require Exporter;
package Math::Trig;
-use 5.006;
+use 5.005;
use strict;
-use Math::Complex 1.35;
-use Math::Complex qw(:trig);
+use Math::Complex 1.51;
+use Math::Complex qw(:trig :pi);
-our($VERSION, $PACKAGE, @ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS);
+use vars qw($VERSION $PACKAGE @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
@ISA = qw(Exporter);
-$VERSION = 1.03;
+$VERSION = 1.15;
my @angcnv = qw(rad2deg rad2grad
deg2rad deg2grad
grad2rad grad2deg);
+my @areal = qw(asin_real acos_real);
+
@EXPORT = (@{$Math::Complex::EXPORT_TAGS{'trig'}},
- @angcnv);
+ @angcnv, @areal);
my @rdlcnv = qw(cartesian_to_cylindrical
cartesian_to_spherical
great_circle_destination
);
-my @pi = qw(pi2 pip2 pip4);
+my @pi = qw(pi pi2 pi4 pip2 pip4);
-@EXPORT_OK = (@rdlcnv, @greatcircle, @pi);
+@EXPORT_OK = (@rdlcnv, @greatcircle, @pi, 'Inf');
# See e.g. the following pages:
# http://www.movable-type.co.uk/scripts/LatLong.html
'great_circle' => [ @greatcircle ],
'pi' => [ @pi ]);
-sub pi2 () { 2 * pi }
-sub pip2 () { pi / 2 }
-sub pip4 () { pi / 4 }
-
-sub DR () { pi2/360 }
-sub RD () { 360/pi2 }
-sub DG () { 400/360 }
-sub GD () { 360/400 }
-sub RG () { 400/pi2 }
-sub GR () { pi2/400 }
+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 ($$) {
+sub _remt ($$) {
# Oh yes, POSIX::fmod() would be faster. Possibly. If it is available.
$_[0] - $_[1] * int($_[0] / $_[1]);
}
# Angle conversions.
#
-sub rad2rad($) { remt($_[0], pi2) }
+sub rad2rad($) { _remt($_[0], pi2) }
+
+sub deg2deg($) { _remt($_[0], 360) }
-sub deg2deg($) { remt($_[0], 360) }
+sub grad2grad($) { _remt($_[0], 400) }
-sub grad2grad($) { remt($_[0], 400) }
+sub rad2deg ($;$) { my $d = _RD * $_[0]; $_[1] ? $d : deg2deg($d) }
-sub rad2deg ($;$) { my $d = RD * $_[0]; $_[1] ? $d : deg2deg($d) }
+sub deg2rad ($;$) { my $d = _DR * $_[0]; $_[1] ? $d : rad2rad($d) }
-sub deg2rad ($;$) { my $d = DR * $_[0]; $_[1] ? $d : rad2rad($d) }
+sub grad2deg ($;$) { my $d = _GD * $_[0]; $_[1] ? $d : deg2deg($d) }
-sub grad2deg ($;$) { my $d = GD * $_[0]; $_[1] ? $d : deg2deg($d) }
+sub deg2grad ($;$) { my $d = _DG * $_[0]; $_[1] ? $d : grad2grad($d) }
-sub deg2grad ($;$) { my $d = DG * $_[0]; $_[1] ? $d : grad2grad($d) }
+sub rad2grad ($;$) { my $d = _RG * $_[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 grad2rad ($;$) { my $d = GR * $_[0]; $_[1] ? $d : rad2rad($d) }
+#
+# acos and asin functions which always return a real number
+#
+
+sub acos_real {
+ return 0 if $_[0] >= 1;
+ return pi if $_[0] <= -1;
+ return acos($_[0]);
+}
+
+sub asin_real {
+ return &pip2 if $_[0] >= 1;
+ return -&pip2 if $_[0] <= -1;
+ return asin($_[0]);
+}
sub cartesian_to_spherical {
my ( $x, $y, $z ) = @_;
return ( $rho,
atan2( $y, $x ),
- $rho ? acos( $z / $rho ) : 0 );
+ $rho ? acos_real( $z / $rho ) : 0 );
}
sub spherical_to_cartesian {
my $lat1 = pip2 - $phi1;
return $rho *
- acos(cos( $lat0 ) * cos( $lat1 ) * cos( $theta0 - $theta1 ) +
- sin( $lat0 ) * sin( $lat1 ) );
+ acos_real( cos( $lat0 ) * cos( $lat1 ) * cos( $theta0 - $theta1 ) +
+ sin( $lat0 ) * sin( $lat1 ) );
}
sub great_circle_direction {
my $lat1 = pip2 - $phi1;
my $direction =
- acos((sin($lat1) - sin($lat0) * cos($distance)) /
- (cos($lat0) * sin($distance)));
-
+ acos_real((sin($lat1) - sin($lat0) * cos($distance)) /
+ (cos($lat0) * sin($distance)));
+
$direction = pi2 - $direction
if sin($theta1 - $theta0) < 0;
my $z = $A * sin($lat0) + $B * sin($lat1);
my $theta = atan2($y, $x);
- my $phi = atan2($z, sqrt($x*$x + $y*$y));
+ my $phi = acos_real($z);
return ($theta, $phi);
}
my $lat0 = pip2 - $phi0;
- my $phi1 = asin(sin($lat0)*cos($dst)+cos($lat0)*sin($dst)*cos($dir0));
+ my $phi1 = asin_real(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));
=head1 SYNOPSIS
- use Math::Trig;
+ use Math::Trig;
- $x = tan(0.9);
- $y = acos(3.7);
- $z = asin(2.4);
+ $x = tan(0.9);
+ $y = acos(3.7);
+ $z = asin(2.4);
- $halfpi = pi/2;
+ $halfpi = pi/2;
- $rad = deg2rad(120);
+ $rad = deg2rad(120);
- # Import constants pi2, pip2, pip4 (2*pi, pi/2, pi/4).
- use Math::Trig ':pi';
+ # 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 conversions between cartesian/spherical/cylindrical.
+ use Math::Trig ':radial';
# Import the great circle formulas.
- use Math::Trig ':great_circle';
+ use Math::Trig ':great_circle';
=head1 DESCRIPTION
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.
B<acsc>, B<acosec>, B<asec>, B<acot>, B<acotan>
B<acsch>, B<acosech>, B<asech>, B<acoth>, B<acotanh>
-The trigonometric constant B<pi> is also defined.
+The trigonometric constant B<pi> and some of handy multiples
+of it are also defined.
-$pi2 = 2 * B<pi>;
+B<pi, pi2, pi4, pip2, pip4>
=head2 ERRORS DUE TO DIVISION BY ZERO
The following functions
- acoth
- acsc
- acsch
- asec
- asech
- atanh
- cot
- coth
- csc
- csch
- sec
- sech
- tan
- tanh
+ 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 ...
+ 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...
+ 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. atan2(0, 0) is undefined.
+pi>, where I<k> is any integer.
+
+Note that atan2(0, 0) is not well-defined.
=head2 SIMPLE (REAL) ARGUMENTS, COMPLEX RESULTS
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 C<1.571>
and the imaginary part of approximately C<-1.317>.
(Plane, 2-dimensional) angles may be converted with the following functions.
- $radians = deg2rad($degrees);
- $radians = grad2rad($gradians);
+=over
+
+=item deg2rad
+
+ $radians = deg2rad($degrees);
+
+=item grad2rad
+
+ $radians = grad2rad($gradians);
+
+=item rad2deg
- $degrees = rad2deg($radians);
- $degrees = grad2deg($gradians);
+ $degrees = rad2deg($radians);
- $gradians = deg2grad($degrees);
- $gradians = rad2grad($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);
+ $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>
=item cartesian_to_cylindrical
- ($rho, $theta, $z) = cartesian_to_cylindrical($x, $y, $z);
+ ($rho, $theta, $z) = cartesian_to_cylindrical($x, $y, $z);
=item cartesian_to_spherical
- ($rho, $theta, $phi) = cartesian_to_spherical($x, $y, $z);
+ ($rho, $theta, $phi) = cartesian_to_spherical($x, $y, $z);
=item cylindrical_to_cartesian
- ($x, $y, $z) = cylindrical_to_cartesian($rho, $theta, $z);
+ ($x, $y, $z) = cylindrical_to_cartesian($rho, $theta, $z);
=item cylindrical_to_spherical
- ($rho_s, $theta, $phi) = cylindrical_to_spherical($rho_c, $theta, $z);
+ ($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);
+ ($x, $y, $z) = spherical_to_cartesian($rho, $theta, $phi);
=item spherical_to_cylindrical
- ($rho_c, $theta, $z) = spherical_to_cylindrical($rho_s, $theta, $phi);
+ ($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>.
=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:
defaults to radians.
If you think geographically the I<theta> are longitudes: zero at the
-Greenwhich meridian, eastward positive, westward negative--and 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
$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:
$direction = great_circle_direction($theta0, $phi0, $theta1, $phi1);
-(Alias 'great_circle_bearing' is also available.)
-The result is in radians, zero indicating straight north, pi or -pi
-straight south, pi/2 straight west, and -pi/2 straight east.
+=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,
or the midpoint if you know the end points:
+=head2 great_circle_midpoint
+
use Math::Trig 'great_circle_midpoint';
($thetam, $phim) =
The great_circle_midpoint() is just a special case of
+=head2 great_circle_waypoint
+
use Math::Trig 'great_circle_waypoint';
($thetai, $phii) =
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
+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.
+Asia do often cross the polar regions. (The common Mercator projection
+does B<not> show great circles as straight lines: straight lines in the
+Mercator projection are lines of constant bearing.)
=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);
+ 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.
+ # 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);
+ use Math::Trig qw(great_circle_direction);
- my $rad = great_circle_direction(@L, @T); # About 0.547 or 0.174 pi.
+ 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);
+ use Math::Trig qw(great_circle_midpoint);
- my @M = great_circle_midpoint(@L, @T);
+ my @M = great_circle_midpoint(@L, @T);
-or about 68.11N 24.74E, in the Finnish Lapland.
+or about 68.93N 89.16E, in the frozen wastes of Siberia.
=head2 CAVEAT FOR GREAT CIRCLE FORMULAS
(slightly aspherical) form of the Earth. The errors are at worst
about 0.55%, but generally below 0.3%.
+=head2 Real-valued asin and acos
+
+For small inputs asin() and acos() may return complex numbers even
+when real numbers would be enough and correct, this happens because of
+floating-point inaccuracies. You can see these inaccuracies for
+example by trying theses:
+
+ print cos(1e-6)**2+sin(1e-6)**2 - 1,"\n";
+ printf "%.20f", cos(1e-6)**2+sin(1e-6)**2,"\n";
+
+which will print something like this
+
+ -1.11022302462516e-16
+ 0.99999999999999988898
+
+even though the expected results are of course exactly zero and one.
+The formulas used to compute asin() and acos() are quite sensitive to
+this, and therefore they might accidentally slip into the complex
+plane even when they should not. To counter this there are two
+interfaces that are guaranteed to return a real-valued output.
+
+=over 4
+
+=item asin_real
+
+ use Math::Trig qw(asin_real);
+
+ $real_angle = asin_real($input_sin);
+
+Return a real-valued arcus sine if the input is between [-1, 1],
+B<inclusive> the endpoints. For inputs greater than one, pi/2
+is returned. For inputs less than minus one, -pi/2 is returned.
+
+=item acos_real
+
+ use Math::Trig qw(acos_real);
+
+ $real_angle = acos_real($input_cos);
+
+Return a real-valued arcus cosine if the input is between [-1, 1],
+B<inclusive> the endpoints. For inputs greater than one, zero
+is returned. For inputs less than minus one, pi is returned.
+
+=back
+
=head1 BUGS
Saying C<use Math::Trig;> exports many mathematical routines in the
Do not attempt navigation using these formulas.
+L<Math::Complex>
+
=head1 AUTHORS
-Jarkko Hietaniemi <F<jhi@iki.fi>> and
-Raphael Manfredi <F<Raphael_Manfredi@pobox.com>>.
+Jarkko Hietaniemi <F<jhi!at!iki.fi>> and
+Raphael Manfredi <F<Raphael_Manfredi!at!pobox.com>>.
+
+=head1 LICENSE
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
=cut