#
# Trigonometric functions, mostly inherited from Math::Complex.
-# -- Jarkko Hietaniemi, April 1997
+# -- Jarkko Hietaniemi, since April 1997
+# -- Raphael Manfredi, September 1996 (indirectly: because of Math::Complex)
#
require Exporter;
package Math::Trig;
+use 5.005;
use strict;
-use Math::Complex qw(:trig);
+use Math::Complex 1.36;
+use Math::Complex qw(:trig :pi);
-use vars qw($VERSION $PACKAGE
- @ISA
- @EXPORT
- $pi2 $DR $RD $DG $GD $RG $GR);
+use vars qw($VERSION $PACKAGE @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
@ISA = qw(Exporter);
-$VERSION = 1.00;
+$VERSION = 1.04;
-my @angcnv = qw(rad_to_deg rad_to_grad
- deg_to_rad deg_to_grad
- grad_to_rad grad_to_dec);
+my @angcnv = qw(rad2deg rad2grad
+ deg2rad deg2grad
+ grad2rad grad2deg);
@EXPORT = (@{$Math::Complex::EXPORT_TAGS{'trig'}},
@angcnv);
-sub pi2 () {
- $pi2 = 2 * pi unless ($pi2);
- $pi2;
+my @rdlcnv = qw(cartesian_to_cylindrical
+ cartesian_to_spherical
+ cylindrical_to_cartesian
+ cylindrical_to_spherical
+ spherical_to_cartesian
+ spherical_to_cylindrical);
+
+my @greatcircle = qw(
+ great_circle_distance
+ great_circle_direction
+ great_circle_bearing
+ great_circle_waypoint
+ great_circle_midpoint
+ great_circle_destination
+ );
+
+my @pi = qw(pi pi2 pi4 pip2 pip4);
+
+@EXPORT_OK = (@rdlcnv, @greatcircle, @pi);
+
+# See e.g. the following pages:
+# http://www.movable-type.co.uk/scripts/LatLong.html
+# http://williams.best.vwh.net/avform.htm
+
+%EXPORT_TAGS = ('radial' => [ @rdlcnv ],
+ 'great_circle' => [ @greatcircle ],
+ 'pi' => [ @pi ]);
+
+sub _DR () { pi2/360 }
+sub _RD () { 360/pi2 }
+sub _DG () { 400/360 }
+sub _GD () { 360/400 }
+sub _RG () { 400/pi2 }
+sub _GR () { pi2/400 }
+
+#
+# Truncating remainder.
+#
+
+sub _remt ($$) {
+ # Oh yes, POSIX::fmod() would be faster. Possibly. If it is available.
+ $_[0] - $_[1] * int($_[0] / $_[1]);
}
-sub DR () {
- $DR = pi2/360 unless ($DR);
- $DR;
+#
+# Angle conversions.
+#
+
+sub rad2rad($) { _remt($_[0], pi2) }
+
+sub deg2deg($) { _remt($_[0], 360) }
+
+sub grad2grad($) { _remt($_[0], 400) }
+
+sub rad2deg ($;$) { my $d = _RD * $_[0]; $_[1] ? $d : deg2deg($d) }
+
+sub deg2rad ($;$) { my $d = _DR * $_[0]; $_[1] ? $d : rad2rad($d) }
+
+sub grad2deg ($;$) { my $d = _GD * $_[0]; $_[1] ? $d : deg2deg($d) }
+
+sub deg2grad ($;$) { my $d = _DG * $_[0]; $_[1] ? $d : grad2grad($d) }
+
+sub rad2grad ($;$) { my $d = _RG * $_[0]; $_[1] ? $d : grad2grad($d) }
+
+sub grad2rad ($;$) { my $d = _GR * $_[0]; $_[1] ? $d : rad2rad($d) }
+
+sub cartesian_to_spherical {
+ my ( $x, $y, $z ) = @_;
+
+ my $rho = sqrt( $x * $x + $y * $y + $z * $z );
+
+ return ( $rho,
+ atan2( $y, $x ),
+ $rho ? acos( $z / $rho ) : 0 );
}
-sub RD () {
- $RD = 360/pi2 unless ($RD);
- $RD;
+sub spherical_to_cartesian {
+ my ( $rho, $theta, $phi ) = @_;
+
+ return ( $rho * cos( $theta ) * sin( $phi ),
+ $rho * sin( $theta ) * sin( $phi ),
+ $rho * cos( $phi ) );
}
-sub DG () {
- $DG = 400/360 unless ($DG);
- $DG;
+sub spherical_to_cylindrical {
+ my ( $x, $y, $z ) = spherical_to_cartesian( @_ );
+
+ return ( sqrt( $x * $x + $y * $y ), $_[1], $z );
}
-sub GD () {
- $GD = 360/400 unless ($GD);
- $GD;
+sub cartesian_to_cylindrical {
+ my ( $x, $y, $z ) = @_;
+
+ return ( sqrt( $x * $x + $y * $y ), atan2( $y, $x ), $z );
}
-sub RG () {
- $RG = 400/pi2 unless ($RG);
- $RG;
+sub cylindrical_to_cartesian {
+ my ( $rho, $theta, $z ) = @_;
+
+ return ( $rho * cos( $theta ), $rho * sin( $theta ), $z );
}
-sub GR () {
- $GR = pi2/400 unless ($GR);
- $GR;
+sub cylindrical_to_spherical {
+ return ( cartesian_to_spherical( cylindrical_to_cartesian( @_ ) ) );
}
-#
-# Truncating remainder.
-#
+sub great_circle_distance {
+ my ( $theta0, $phi0, $theta1, $phi1, $rho ) = @_;
-sub remt ($$) {
- # Oh yes, POSIX::fmod() would be faster. Possibly. If it is available.
- $_[0] - $_[1] * int($_[0] / $_[1]);
-}
+ $rho = 1 unless defined $rho; # Default to the unit sphere.
-#
-# Angle conversions.
-#
+ my $lat0 = pip2 - $phi0;
+ my $lat1 = pip2 - $phi1;
-sub rad_to_deg ($) {
- remt(RD * $_[0], 360);
+ return $rho *
+ acos(cos( $lat0 ) * cos( $lat1 ) * cos( $theta0 - $theta1 ) +
+ sin( $lat0 ) * sin( $lat1 ) );
}
-sub deg_to_rad ($) {
- remt(DR * $_[0], pi2);
-}
+sub great_circle_direction {
+ my ( $theta0, $phi0, $theta1, $phi1 ) = @_;
+
+ my $distance = &great_circle_distance;
+
+ my $lat0 = pip2 - $phi0;
+ my $lat1 = pip2 - $phi1;
-sub grad_to_deg ($) {
- remt(GD * $_[0], 360);
+ my $direction =
+ acos((sin($lat1) - sin($lat0) * cos($distance)) /
+ (cos($lat0) * sin($distance)));
+
+ $direction = pi2 - $direction
+ if sin($theta1 - $theta0) < 0;
+
+ return rad2rad($direction);
}
-sub deg_to_grad ($) {
- remt(DG * $_[0], 400);
+*great_circle_bearing = \&great_circle_direction;
+
+sub great_circle_waypoint {
+ my ( $theta0, $phi0, $theta1, $phi1, $point ) = @_;
+
+ $point = 0.5 unless defined $point;
+
+ my $d = great_circle_distance( $theta0, $phi0, $theta1, $phi1 );
+
+ return undef if $d == pi;
+
+ my $sd = sin($d);
+
+ return ($theta0, $phi0) if $sd == 0;
+
+ my $A = sin((1 - $point) * $d) / $sd;
+ my $B = sin( $point * $d) / $sd;
+
+ my $lat0 = pip2 - $phi0;
+ my $lat1 = pip2 - $phi1;
+
+ my $x = $A * cos($lat0) * cos($theta0) + $B * cos($lat1) * cos($theta1);
+ my $y = $A * cos($lat0) * sin($theta0) + $B * cos($lat1) * sin($theta1);
+ my $z = $A * sin($lat0) + $B * sin($lat1);
+
+ my $theta = atan2($y, $x);
+ my $phi = acos($z);
+
+ return ($theta, $phi);
}
-sub rad_to_grad ($) {
- remt(RG * $_[0], 400);
+sub great_circle_midpoint {
+ great_circle_waypoint(@_[0..3], 0.5);
}
-sub grad_to_rad ($) {
- remt(GR * $_[0], pi2);
+sub great_circle_destination {
+ my ( $theta0, $phi0, $dir0, $dst ) = @_;
+
+ my $lat0 = pip2 - $phi0;
+
+ my $phi1 = asin(sin($lat0)*cos($dst)+cos($lat0)*sin($dst)*cos($dir0));
+ my $theta1 = $theta0 + atan2(sin($dir0)*sin($dst)*cos($lat0),
+ cos($dst)-sin($lat0)*sin($phi1));
+
+ my $dir1 = great_circle_bearing($theta1, $phi1, $theta0, $phi0) + pi;
+
+ $dir1 -= pi2 if $dir1 > pi2;
+
+ return ($theta1, $phi1, $dir1);
}
+1;
+
+__END__
+=pod
+
=head1 NAME
Math::Trig - trigonometric functions
=head1 SYNOPSIS
- use Math::Trig;
-
- $x = tan(0.9);
- $y = acos(3.7);
- $z = asin(2.4);
-
- $halfpi = pi/2;
+ use Math::Trig;
- $rad = deg_to_rad(120);
+ $x = tan(0.9);
+ $y = acos(3.7);
+ $z = asin(2.4);
+
+ $halfpi = pi/2;
+
+ $rad = deg2rad(120);
+
+ # Import constants pi2, pip2, pip4 (2*pi, pi/2, pi/4).
+ use Math::Trig ':pi';
+
+ # Import the conversions between cartesian/spherical/cylindrical.
+ use Math::Trig ':radial';
+
+ # Import the great circle formulas.
+ use Math::Trig ':great_circle';
=head1 DESCRIPTION
C<Math::Trig> defines many trigonometric functions not defined by the
-core Perl (which defines only the C<sin()> and C<cos()>. The constant
+core Perl which defines only the C<sin()> and C<cos()>. The constant
B<pi> is also defined as are a few convenience functions for angle
-conversions.
+conversions, and I<great circle formulas> for spherical movement.
=head1 TRIGONOMETRIC FUNCTIONS
The tangent
- tan
+=over 4
+
+=item B<tan>
+
+=back
The cofunctions of the sine, cosine, and tangent (cosec/csc and cotan/cot
are aliases)
- csc cosec sec cot cotan
+B<csc>, B<cosec>, B<sec>, B<sec>, B<cot>, B<cotan>
The arcus (also known as the inverse) functions of the sine, cosine,
and tangent
- asin acos atan
+B<asin>, B<acos>, B<atan>
The principal value of the arc tangent of y/x
- atan2(y, x)
+B<atan2>(y, x)
The arcus cofunctions of the sine, cosine, and tangent (acosec/acsc
-and acotan/acot are aliases)
+and acotan/acot are aliases). Note that atan2(0, 0) is not well-defined.
- acsc acosec asec acot acotan
+B<acsc>, B<acosec>, B<asec>, B<acot>, B<acotan>
The hyperbolic sine, cosine, and tangent
- sinh cosh tanh
+B<sinh>, B<cosh>, B<tanh>
The cofunctions of the hyperbolic sine, cosine, and tangent (cosech/csch
and cotanh/coth are aliases)
- csch cosech sech coth cotanh
+B<csch>, B<cosech>, B<sech>, B<coth>, B<cotanh>
The arcus (also known as the inverse) functions of the hyperbolic
sine, cosine, and tangent
- asinh acosh atanh
+B<asinh>, B<acosh>, B<atanh>
The arcus cofunctions of the hyperbolic sine, cosine, and tangent
(acsch/acosech and acoth/acotanh are aliases)
- acsch acosech asech acoth acotanh
+B<acsch>, B<acosech>, B<asech>, B<acoth>, B<acotanh>
+
+The trigonometric constant B<pi> and some of handy multiples
+of it are also defined.
-The trigonometric constant B<pi> is also defined.
+B<pi, pi2, pi4, pip2, pip4>
- $pi2 = 2 * pi;
+=head2 ERRORS DUE TO DIVISION BY ZERO
-=head2 SIMPLE ARGUMENTS, COMPLEX RESULTS
+The following functions
+
+ acoth
+ acsc
+ acsch
+ asec
+ asech
+ atanh
+ cot
+ coth
+ csc
+ csch
+ sec
+ sech
+ tan
+ tanh
+
+cannot be computed for all arguments because that would mean dividing
+by zero or taking logarithm of zero. These situations cause fatal
+runtime errors looking like this
+
+ cot(0): Division by zero.
+ (Because in the definition of cot(0), the divisor sin(0) is 0)
+ Died at ...
+
+or
+
+ atanh(-1): Logarithm of zero.
+ Died at...
+
+For the C<csc>, C<cot>, C<asec>, C<acsc>, C<acot>, C<csch>, C<coth>,
+C<asech>, C<acsch>, the argument cannot be C<0> (zero). For the
+C<atanh>, C<acoth>, the argument cannot be C<1> (one). For the
+C<atanh>, C<acoth>, the argument cannot be C<-1> (minus one). For the
+C<tan>, C<sec>, C<tanh>, C<sech>, the argument cannot be I<pi/2 + k *
+pi>, where I<k> is any integer.
+
+Note that atan2(0, 0) is not well-defined.
+
+=head2 SIMPLE (REAL) ARGUMENTS, COMPLEX RESULTS
Please note that some of the trigonometric functions can break out
from the B<real axis> into the B<complex plane>. For example
complex numbers as results because the C<Math::Complex> takes care of
details like for example how to display complex numbers. For example:
- print asin(2), "\n";
-
+ print asin(2), "\n";
+
should produce something like this (take or leave few last decimals):
- 1.5707963267949-1.31695789692482i
+ 1.5707963267949-1.31695789692482i
-That is, a complex number with the real part of approximately E<1.571>
-and the imaginary part of approximately E<-1.317>.
+That is, a complex number with the real part of approximately C<1.571>
+and the imaginary part of approximately C<-1.317>.
-=head1 ANGLE CONVERSIONS
+=head1 PLANE ANGLE CONVERSIONS
(Plane, 2-dimensional) angles may be converted with the following functions.
- $radians = deg_to_rad($degrees);
- $radians = grad_to_rad($gradians);
-
- $degrees = rad_to_deg($radians);
- $degrees = grad_to_deg($gradians);
-
- $gradians = deg_to_grad($degrees);
- $gradians = rad_to_grad($radians);
+=over
-The full circle is 2 B<pi> radians or E<360> degrees or E<400> gradians.
+=item deg2rad
-=head1
+ $radians = deg2rad($degrees);
-The following functions
+=item grad2rad
- tan
- sec
- csc
- cot
- atan
- acot
- tanh
- sech
- csch
- coth
- atanh
- asech
- acsch
- acoth
+ $radians = grad2rad($gradians);
-cannot be computed for all arguments because that would mean dividing
-by zero. These situations cause fatal runtime errors looking like this
+=item rad2deg
+
+ $degrees = rad2deg($radians);
+
+=item grad2deg
+
+ $degrees = grad2deg($gradians);
+
+=item deg2grad
+
+ $gradians = deg2grad($degrees);
+
+=item rad2grad
+
+ $gradians = rad2grad($radians);
+
+=back
+
+The full circle is 2 I<pi> radians or I<360> degrees or I<400> gradians.
+The result is by default wrapped to be inside the [0, {2pi,360,400}[ circle.
+If you don't want this, supply a true second argument:
+
+ $zillions_of_radians = deg2rad($zillions_of_degrees, 1);
+ $negative_degrees = rad2deg($negative_radians, 1);
+
+You can also do the wrapping explicitly by rad2rad(), deg2deg(), and
+grad2grad().
+
+=over 4
+
+=item rad2rad
+
+ $radians_wrapped_by_2pi = rad2rad($radians);
+
+=item deg2deg
+
+ $degrees_wrapped_by_360 = deg2deg($degrees);
+
+=item grad2grad
+
+ $gradians_wrapped_by_400 = grad2grad($gradians);
+
+=back
+
+=head1 RADIAL COORDINATE CONVERSIONS
+
+B<Radial coordinate systems> are the B<spherical> and the B<cylindrical>
+systems, explained shortly in more detail.
+
+You can import radial coordinate conversion functions by using the
+C<:radial> tag:
+
+ use Math::Trig ':radial';
+
+ ($rho, $theta, $z) = cartesian_to_cylindrical($x, $y, $z);
+ ($rho, $theta, $phi) = cartesian_to_spherical($x, $y, $z);
+ ($x, $y, $z) = cylindrical_to_cartesian($rho, $theta, $z);
+ ($rho_s, $theta, $phi) = cylindrical_to_spherical($rho_c, $theta, $z);
+ ($x, $y, $z) = spherical_to_cartesian($rho, $theta, $phi);
+ ($rho_c, $theta, $z) = spherical_to_cylindrical($rho_s, $theta, $phi);
+
+B<All angles are in radians>.
+
+=head2 COORDINATE SYSTEMS
+
+B<Cartesian> coordinates are the usual rectangular I<(x, y, z)>-coordinates.
+
+Spherical coordinates, I<(rho, theta, pi)>, are three-dimensional
+coordinates which define a point in three-dimensional space. They are
+based on a sphere surface. The radius of the sphere is B<rho>, also
+known as the I<radial> coordinate. The angle in the I<xy>-plane
+(around the I<z>-axis) is B<theta>, also known as the I<azimuthal>
+coordinate. The angle from the I<z>-axis is B<phi>, also known as the
+I<polar> coordinate. The North Pole is therefore I<0, 0, rho>, and
+the Gulf of Guinea (think of the missing big chunk of Africa) I<0,
+pi/2, rho>. In geographical terms I<phi> is latitude (northward
+positive, southward negative) and I<theta> is longitude (eastward
+positive, westward negative).
+
+B<BEWARE>: some texts define I<theta> and I<phi> the other way round,
+some texts define the I<phi> to start from the horizontal plane, some
+texts use I<r> in place of I<rho>.
+
+Cylindrical coordinates, I<(rho, theta, z)>, are three-dimensional
+coordinates which define a point in three-dimensional space. They are
+based on a cylinder surface. The radius of the cylinder is B<rho>,
+also known as the I<radial> coordinate. The angle in the I<xy>-plane
+(around the I<z>-axis) is B<theta>, also known as the I<azimuthal>
+coordinate. The third coordinate is the I<z>, pointing up from the
+B<theta>-plane.
+
+=head2 3-D ANGLE CONVERSIONS
+
+Conversions to and from spherical and cylindrical coordinates are
+available. Please notice that the conversions are not necessarily
+reversible because of the equalities like I<pi> angles being equal to
+I<-pi> angles.
+
+=over 4
+
+=item cartesian_to_cylindrical
+
+ ($rho, $theta, $z) = cartesian_to_cylindrical($x, $y, $z);
+
+=item cartesian_to_spherical
+
+ ($rho, $theta, $phi) = cartesian_to_spherical($x, $y, $z);
+
+=item cylindrical_to_cartesian
+
+ ($x, $y, $z) = cylindrical_to_cartesian($rho, $theta, $z);
+
+=item cylindrical_to_spherical
+
+ ($rho_s, $theta, $phi) = cylindrical_to_spherical($rho_c, $theta, $z);
+
+Notice that when C<$z> is not 0 C<$rho_s> is not equal to C<$rho_c>.
+
+=item spherical_to_cartesian
+
+ ($x, $y, $z) = spherical_to_cartesian($rho, $theta, $phi);
+
+=item spherical_to_cylindrical
+
+ ($rho_c, $theta, $z) = spherical_to_cylindrical($rho_s, $theta, $phi);
+
+Notice that when C<$z> is not 0 C<$rho_c> is not equal to C<$rho_s>.
+
+=back
+
+=head1 GREAT CIRCLE DISTANCES AND DIRECTIONS
+
+A great circle is section of a circle that contains the circle
+diameter: the shortest distance between two (non-antipodal) points on
+the spherical surface goes along the great circle connecting those two
+points.
+
+=head2 great_circle_distance
+
+You can compute spherical distances, called B<great circle distances>,
+by importing the great_circle_distance() function:
+
+ use Math::Trig 'great_circle_distance';
+
+ $distance = great_circle_distance($theta0, $phi0, $theta1, $phi1, [, $rho]);
+
+The I<great circle distance> is the shortest distance between two
+points on a sphere. The distance is in C<$rho> units. The C<$rho> is
+optional, it defaults to 1 (the unit sphere), therefore the distance
+defaults to radians.
+
+If you think geographically the I<theta> are longitudes: zero at the
+Greenwhich meridian, eastward positive, westward negative--and the
+I<phi> are latitudes: zero at the North Pole, northward positive,
+southward negative. B<NOTE>: this formula thinks in mathematics, not
+geographically: the I<phi> zero is at the North Pole, not at the
+Equator on the west coast of Africa (Bay of Guinea). You need to
+subtract your geographical coordinates from I<pi/2> (also known as 90
+degrees).
+
+ $distance = great_circle_distance($lon0, pi/2 - $lat0,
+ $lon1, pi/2 - $lat1, $rho);
+
+=head2 great_circle_direction
+
+The direction you must follow the great circle (also known as I<bearing>)
+can be computed by the great_circle_direction() function:
+
+ use Math::Trig 'great_circle_direction';
+
+ $direction = great_circle_direction($theta0, $phi0, $theta1, $phi1);
+
+=head2 great_circle_bearing
+
+Alias 'great_circle_bearing' for 'great_circle_direction' is also available.
+
+ use Math::Trig 'great_circle_bearing';
+
+ $direction = great_circle_bearing($theta0, $phi0, $theta1, $phi1);
+
+The result of great_circle_direction is in radians, zero indicating
+straight north, pi or -pi straight south, pi/2 straight west, and
+-pi/2 straight east.
+
+You can inversely compute the destination if you know the
+starting point, direction, and distance:
+
+=head2 great_circle_destination
+
+ use Math::Trig 'great_circle_destination';
+
+ # thetad and phid are the destination coordinates,
+ # dird is the final direction at the destination.
+
+ ($thetad, $phid, $dird) =
+ great_circle_destination($theta, $phi, $direction, $distance);
+
+or the midpoint if you know the end points:
+
+=head2 great_circle_midpoint
+
+ use Math::Trig 'great_circle_midpoint';
+
+ ($thetam, $phim) =
+ great_circle_midpoint($theta0, $phi0, $theta1, $phi1);
+
+The great_circle_midpoint() is just a special case of
+
+=head2 great_circle_waypoint
+
+ use Math::Trig 'great_circle_waypoint';
+
+ ($thetai, $phii) =
+ great_circle_waypoint($theta0, $phi0, $theta1, $phi1, $way);
+
+Where the $way is a value from zero ($theta0, $phi0) to one ($theta1,
+$phi1). Note that antipodal points (where their distance is I<pi>
+radians) do not have waypoints between them (they would have an an
+"equator" between them), and therefore C<undef> is returned for
+antipodal points. If the points are the same and the distance
+therefore zero and all waypoints therefore identical, the first point
+(either point) is returned.
+
+The thetas, phis, direction, and distance in the above are all in radians.
+
+You can import all the great circle formulas by
+
+ use Math::Trig ':great_circle';
+
+Notice that the resulting directions might be somewhat surprising if
+you are looking at a flat worldmap: in such map projections the great
+circles quite often do not look like the shortest routes-- but for
+example the shortest possible routes from Europe or North America to
+Asia do often cross the polar regions.
+
+=head1 EXAMPLES
+
+To calculate the distance between London (51.3N 0.5W) and Tokyo
+(35.7N 139.8E) in kilometers:
+
+ use Math::Trig qw(great_circle_distance deg2rad);
+
+ # Notice the 90 - latitude: phi zero is at the North Pole.
+ sub NESW { deg2rad($_[0]), deg2rad(90 - $_[1]) }
+ my @L = NESW( -0.5, 51.3);
+ my @T = NESW(139.8, 35.7);
+ my $km = great_circle_distance(@L, @T, 6378); # About 9600 km.
+
+The direction you would have to go from London to Tokyo (in radians,
+straight north being zero, straight east being pi/2).
+
+ use Math::Trig qw(great_circle_direction);
+
+ my $rad = great_circle_direction(@L, @T); # About 0.547 or 0.174 pi.
+
+The midpoint between London and Tokyo being
+
+ use Math::Trig qw(great_circle_midpoint);
+
+ my @M = great_circle_midpoint(@L, @T);
+
+or about 89.16N 68.93E, practically at the North Pole.
+
+=head2 CAVEAT FOR GREAT CIRCLE FORMULAS
+
+The answers may be off by few percentages because of the irregular
+(slightly aspherical) form of the Earth. The errors are at worst
+about 0.55%, but generally below 0.3%.
+
+=head1 BUGS
+
+Saying C<use Math::Trig;> exports many mathematical routines in the
+caller environment and even overrides some (C<sin>, C<cos>). This is
+construed as a feature by the Authors, actually... ;-)
+
+The code is not optimized for speed, especially because we use
+C<Math::Complex> and thus go quite near complex numbers while doing
+the computations even when the arguments are not. This, however,
+cannot be completely avoided if we want things like C<asin(2)> to give
+an answer instead of giving a fatal runtime error.
+
+Do not attempt navigation using these formulas.
+
+=head1 AUTHORS
- cot(0): Division by zero.
- (Because in the definition of cot(0), sin(0) is 0)
- Died at ...
+Jarkko Hietaniemi <F<jhi!at!iki.fi>> and
+Raphael Manfredi <F<Raphael_Manfredi!at!pobox.com>>.
=cut
projects / p5sagit/p5-mst-13.2.git / blobdiff