2 # Complex numbers and associated mathematical functions
3 # -- Raphael Manfredi Since Sep 1996
4 # -- Jarkko Hietaniemi Since Mar 1997
5 # -- Daniel S. Lewart Since Sep 1997
14 our($VERSION, @ISA, @EXPORT, %EXPORT_TAGS);
18 $VERSION = sprintf("%s", q$Id: Complex.pm,v 1.26 1998/11/01 00:00:00 dsl Exp $ =~ /(\d+\.\d+)/);
25 csc cosec sec cot cotan
27 acsc acosec asec acot acotan
29 csch cosech sech coth cotanh
31 acsch acosech asech acoth acotanh
70 my $package = 'Math::Complex'; # Package name
71 my %DISPLAY_FORMAT = ('style' => 'cartesian',
72 'polar_pretty_print' => 1);
73 my $eps = 1e-14; # Epsilon
76 unless ($^O eq 'unicos') { # Unicos gets a fatal runtime error
77 $Inf = CORE::exp(CORE::exp(30));
79 $Inf = "Inf" if !defined $Inf || !$Inf > 0;
82 # Object attributes (internal):
83 # cartesian [real, imaginary] -- cartesian form
84 # polar [rho, theta] -- polar form
85 # c_dirty cartesian form not up-to-date
86 # p_dirty polar form not up-to-date
87 # display display format (package's global when not set)
90 # Die on bad *make() arguments.
93 die "@{[(caller(1))[3]]}: Cannot take $_[0] of $_[1].\n";
99 # Create a new complex number (cartesian form)
102 my $self = bless {}, shift;
106 if ( $rre eq ref $self ) {
109 _cannot_make("real part", $rre);
114 if ( $rim eq ref $self ) {
117 _cannot_make("imaginary part", $rim);
120 $self->{'cartesian'} = [ $re, $im ];
121 $self->{c_dirty} = 0;
122 $self->{p_dirty} = 1;
123 $self->display_format('cartesian');
130 # Create a new complex number (exponential form)
133 my $self = bless {}, shift;
134 my ($rho, $theta) = @_;
137 if ( $rrh eq ref $self ) {
140 _cannot_make("rho", $rrh);
143 my $rth = ref $theta;
145 if ( $rth eq ref $self ) {
146 $theta = theta($theta);
148 _cannot_make("theta", $rth);
153 $theta = ($theta <= 0) ? $theta + pi() : $theta - pi();
155 $self->{'polar'} = [$rho, $theta];
156 $self->{p_dirty} = 0;
157 $self->{c_dirty} = 1;
158 $self->display_format('polar');
162 sub new { &make } # For backward compatibility only.
167 # Creates a complex number from a (re, im) tuple.
168 # This avoids the burden of writing Math::Complex->make(re, im).
172 return __PACKAGE__->make($re, defined $im ? $im : 0);
178 # Creates a complex number from a (rho, theta) tuple.
179 # This avoids the burden of writing Math::Complex->emake(rho, theta).
182 my ($rho, $theta) = @_;
183 return __PACKAGE__->emake($rho, defined $theta ? $theta : 0);
189 # The number defined as pi = 180 degrees
191 sub pi () { 4 * CORE::atan2(1, 1) }
198 sub pit2 () { 2 * pi }
205 sub pip2 () { pi / 2 }
210 # One degree in radians, used in stringify_polar.
213 sub deg1 () { pi / 180 }
220 sub uplog10 () { 1 / CORE::log(10) }
225 # The number defined as i*i = -1;
230 $i->{'cartesian'} = [0, 1];
231 $i->{'polar'} = [1, pip2];
245 # Attribute access/set routines
248 sub cartesian {$_[0]->{c_dirty} ?
249 $_[0]->update_cartesian : $_[0]->{'cartesian'}}
250 sub polar {$_[0]->{p_dirty} ?
251 $_[0]->update_polar : $_[0]->{'polar'}}
253 sub set_cartesian { $_[0]->{p_dirty}++; $_[0]->{'cartesian'} = $_[1] }
254 sub set_polar { $_[0]->{c_dirty}++; $_[0]->{'polar'} = $_[1] }
259 # Recompute and return the cartesian form, given accurate polar form.
261 sub update_cartesian {
263 my ($r, $t) = @{$self->{'polar'}};
264 $self->{c_dirty} = 0;
265 return $self->{'cartesian'} = [$r * CORE::cos($t), $r * CORE::sin($t)];
272 # Recompute and return the polar form, given accurate cartesian form.
276 my ($x, $y) = @{$self->{'cartesian'}};
277 $self->{p_dirty} = 0;
278 return $self->{'polar'} = [0, 0] if $x == 0 && $y == 0;
279 return $self->{'polar'} = [CORE::sqrt($x*$x + $y*$y),
280 CORE::atan2($y, $x)];
289 my ($z1, $z2, $regular) = @_;
290 my ($re1, $im1) = @{$z1->cartesian};
291 $z2 = cplx($z2) unless ref $z2;
292 my ($re2, $im2) = ref $z2 ? @{$z2->cartesian} : ($z2, 0);
293 unless (defined $regular) {
294 $z1->set_cartesian([$re1 + $re2, $im1 + $im2]);
297 return (ref $z1)->make($re1 + $re2, $im1 + $im2);
306 my ($z1, $z2, $inverted) = @_;
307 my ($re1, $im1) = @{$z1->cartesian};
308 $z2 = cplx($z2) unless ref $z2;
309 my ($re2, $im2) = @{$z2->cartesian};
310 unless (defined $inverted) {
311 $z1->set_cartesian([$re1 - $re2, $im1 - $im2]);
315 (ref $z1)->make($re2 - $re1, $im2 - $im1) :
316 (ref $z1)->make($re1 - $re2, $im1 - $im2);
326 my ($z1, $z2, $regular) = @_;
327 if ($z1->{p_dirty} == 0 and ref $z2 and $z2->{p_dirty} == 0) {
328 # if both polar better use polar to avoid rounding errors
329 my ($r1, $t1) = @{$z1->polar};
330 my ($r2, $t2) = @{$z2->polar};
332 if ($t > pi()) { $t -= pit2 }
333 elsif ($t <= -pi()) { $t += pit2 }
334 unless (defined $regular) {
335 $z1->set_polar([$r1 * $r2, $t]);
338 return (ref $z1)->emake($r1 * $r2, $t);
340 my ($x1, $y1) = @{$z1->cartesian};
342 my ($x2, $y2) = @{$z2->cartesian};
343 return (ref $z1)->make($x1*$x2-$y1*$y2, $x1*$y2+$y1*$x2);
345 return (ref $z1)->make($x1*$z2, $y1*$z2);
353 # Die on division by zero.
356 my $mess = "$_[0]: Division by zero.\n";
359 $mess .= "(Because in the definition of $_[0], the divisor ";
360 $mess .= "$_[1] " unless ("$_[1]" eq '0');
366 $mess .= "Died at $up[1] line $up[2].\n";
377 my ($z1, $z2, $inverted) = @_;
378 if ($z1->{p_dirty} == 0 and ref $z2 and $z2->{p_dirty} == 0) {
379 # if both polar better use polar to avoid rounding errors
380 my ($r1, $t1) = @{$z1->polar};
381 my ($r2, $t2) = @{$z2->polar};
384 _divbyzero "$z2/0" if ($r1 == 0);
386 if ($t > pi()) { $t -= pit2 }
387 elsif ($t <= -pi()) { $t += pit2 }
388 return (ref $z1)->emake($r2 / $r1, $t);
390 _divbyzero "$z1/0" if ($r2 == 0);
392 if ($t > pi()) { $t -= pit2 }
393 elsif ($t <= -pi()) { $t += pit2 }
394 return (ref $z1)->emake($r1 / $r2, $t);
399 ($x2, $y2) = @{$z1->cartesian};
400 $d = $x2*$x2 + $y2*$y2;
401 _divbyzero "$z2/0" if $d == 0;
402 return (ref $z1)->make(($x2*$z2)/$d, -($y2*$z2)/$d);
404 my ($x1, $y1) = @{$z1->cartesian};
406 ($x2, $y2) = @{$z2->cartesian};
407 $d = $x2*$x2 + $y2*$y2;
408 _divbyzero "$z1/0" if $d == 0;
409 my $u = ($x1*$x2 + $y1*$y2)/$d;
410 my $v = ($y1*$x2 - $x1*$y2)/$d;
411 return (ref $z1)->make($u, $v);
413 _divbyzero "$z1/0" if $z2 == 0;
414 return (ref $z1)->make($x1/$z2, $y1/$z2);
423 # Computes z1**z2 = exp(z2 * log z1)).
426 my ($z1, $z2, $inverted) = @_;
428 return 1 if $z1 == 0 || $z2 == 1;
429 return 0 if $z2 == 0 && Re($z1) > 0;
431 return 1 if $z2 == 0 || $z1 == 1;
432 return 0 if $z1 == 0 && Re($z2) > 0;
434 my $w = $inverted ? &exp($z1 * &log($z2))
435 : &exp($z2 * &log($z1));
436 # If both arguments cartesian, return cartesian, else polar.
437 return $z1->{c_dirty} == 0 &&
438 (not ref $z2 or $z2->{c_dirty} == 0) ?
439 cplx(@{$w->cartesian}) : $w;
445 # Computes z1 <=> z2.
446 # Sorts on the real part first, then on the imaginary part. Thus 2-4i < 3+8i.
449 my ($z1, $z2, $inverted) = @_;
450 my ($re1, $im1) = ref $z1 ? @{$z1->cartesian} : ($z1, 0);
451 my ($re2, $im2) = ref $z2 ? @{$z2->cartesian} : ($z2, 0);
452 my $sgn = $inverted ? -1 : 1;
453 return $sgn * ($re1 <=> $re2) if $re1 != $re2;
454 return $sgn * ($im1 <=> $im2);
462 # (Required in addition to spaceship() because of NaNs.)
464 my ($z1, $z2, $inverted) = @_;
465 my ($re1, $im1) = ref $z1 ? @{$z1->cartesian} : ($z1, 0);
466 my ($re2, $im2) = ref $z2 ? @{$z2->cartesian} : ($z2, 0);
467 return $re1 == $re2 && $im1 == $im2 ? 1 : 0;
478 my ($r, $t) = @{$z->polar};
479 $t = ($t <= 0) ? $t + pi : $t - pi;
480 return (ref $z)->emake($r, $t);
482 my ($re, $im) = @{$z->cartesian};
483 return (ref $z)->make(-$re, -$im);
489 # Compute complex's conjugate.
494 my ($r, $t) = @{$z->polar};
495 return (ref $z)->emake($r, -$t);
497 my ($re, $im) = @{$z->cartesian};
498 return (ref $z)->make($re, -$im);
504 # Compute or set complex's norm (rho).
512 return CORE::abs($z);
516 $z->{'polar'} = [ $rho, ${$z->polar}[1] ];
521 return ${$z->polar}[0];
528 if ($$theta > pi()) { $$theta -= pit2 }
529 elsif ($$theta <= -pi()) { $$theta += pit2 }
535 # Compute or set complex's argument (theta).
538 my ($z, $theta) = @_;
539 return $z unless ref $z;
540 if (defined $theta) {
542 $z->{'polar'} = [ ${$z->polar}[0], $theta ];
546 $theta = ${$z->polar}[1];
557 # It is quite tempting to use wantarray here so that in list context
558 # sqrt() would return the two solutions. This, however, would
561 # print "sqrt(z) = ", sqrt($z), "\n";
563 # The two values would be printed side by side without no intervening
564 # whitespace, quite confusing.
565 # Therefore if you want the two solutions use the root().
569 my ($re, $im) = ref $z ? @{$z->cartesian} : ($z, 0);
570 return $re < 0 ? cplx(0, CORE::sqrt(-$re)) : CORE::sqrt($re)
572 my ($r, $t) = @{$z->polar};
573 return (ref $z)->emake(CORE::sqrt($r), $t/2);
579 # Compute cbrt(z) (cubic root).
581 # Why are we not returning three values? The same answer as for sqrt().
586 -CORE::exp(CORE::log(-$z)/3) :
587 ($z > 0 ? CORE::exp(CORE::log($z)/3): 0)
589 my ($r, $t) = @{$z->polar};
591 return (ref $z)->emake(CORE::exp(CORE::log($r)/3), $t/3);
600 my $mess = "Root $_[0] illegal, root rank must be positive integer.\n";
604 $mess .= "Died at $up[1] line $up[2].\n";
612 # Computes all nth root for z, returning an array whose size is n.
613 # `n' must be a positive integer.
615 # The roots are given by (for k = 0..n-1):
617 # z^(1/n) = r^(1/n) (cos ((t+2 k pi)/n) + i sin ((t+2 k pi)/n))
621 _rootbad($n) if ($n < 1 or int($n) != $n);
622 my ($r, $t) = ref $z ?
623 @{$z->polar} : (CORE::abs($z), $z >= 0 ? 0 : pi);
626 my $theta_inc = pit2 / $n;
627 my $rho = $r ** (1/$n);
629 my $cartesian = ref $z && $z->{c_dirty} == 0;
630 for ($k = 0, $theta = $t / $n; $k < $n; $k++, $theta += $theta_inc) {
631 my $w = cplxe($rho, $theta);
632 # Yes, $cartesian is loop invariant.
633 push @root, $cartesian ? cplx(@{$w->cartesian}) : $w;
641 # Return or set Re(z).
645 return $z unless ref $z;
647 $z->{'cartesian'} = [ $Re, ${$z->cartesian}[1] ];
651 return ${$z->cartesian}[0];
658 # Return or set Im(z).
662 return $z unless ref $z;
664 $z->{'cartesian'} = [ ${$z->cartesian}[0], $Im ];
668 return ${$z->cartesian}[1];
675 # Return or set rho(w).
678 Math::Complex::abs(@_);
684 # Return or set theta(w).
687 Math::Complex::arg(@_);
697 my ($x, $y) = @{$z->cartesian};
698 return (ref $z)->emake(CORE::exp($x), $y);
704 # Die on logarithm of zero.
707 my $mess = "$_[0]: Logarithm of zero.\n";
710 $mess .= "(Because in the definition of $_[0], the argument ";
711 $mess .= "$_[1] " unless ($_[1] eq '0');
717 $mess .= "Died at $up[1] line $up[2].\n";
730 _logofzero("log") if $z == 0;
731 return $z > 0 ? CORE::log($z) : cplx(CORE::log(-$z), pi);
733 my ($r, $t) = @{$z->polar};
734 _logofzero("log") if $r == 0;
735 if ($t > pi()) { $t -= pit2 }
736 elsif ($t <= -pi()) { $t += pit2 }
737 return (ref $z)->make(CORE::log($r), $t);
745 sub ln { Math::Complex::log(@_) }
754 return Math::Complex::log($_[0]) * uplog10;
760 # Compute logn(z,n) = log(z) / log(n)
764 $z = cplx($z, 0) unless ref $z;
765 my $logn = $logn{$n};
766 $logn = $logn{$n} = CORE::log($n) unless defined $logn; # Cache log(n)
767 return &log($z) / $logn;
773 # Compute cos(z) = (exp(iz) + exp(-iz))/2.
777 return CORE::cos($z) unless ref $z;
778 my ($x, $y) = @{$z->cartesian};
779 my $ey = CORE::exp($y);
780 my $sx = CORE::sin($x);
781 my $cx = CORE::cos($x);
782 my $ey_1 = $ey ? 1 / $ey : $Inf;
783 return (ref $z)->make($cx * ($ey + $ey_1)/2,
784 $sx * ($ey_1 - $ey)/2);
790 # Compute sin(z) = (exp(iz) - exp(-iz))/2.
794 return CORE::sin($z) unless ref $z;
795 my ($x, $y) = @{$z->cartesian};
796 my $ey = CORE::exp($y);
797 my $sx = CORE::sin($x);
798 my $cx = CORE::cos($x);
799 my $ey_1 = $ey ? 1 / $ey : $Inf;
800 return (ref $z)->make($sx * ($ey + $ey_1)/2,
801 $cx * ($ey - $ey_1)/2);
807 # Compute tan(z) = sin(z) / cos(z).
812 _divbyzero "tan($z)", "cos($z)" if $cz == 0;
813 return &sin($z) / $cz;
819 # Computes the secant sec(z) = 1 / cos(z).
824 _divbyzero "sec($z)", "cos($z)" if ($cz == 0);
831 # Computes the cosecant csc(z) = 1 / sin(z).
836 _divbyzero "csc($z)", "sin($z)" if ($sz == 0);
845 sub cosec { Math::Complex::csc(@_) }
850 # Computes cot(z) = cos(z) / sin(z).
855 _divbyzero "cot($z)", "sin($z)" if ($sz == 0);
856 return &cos($z) / $sz;
864 sub cotan { Math::Complex::cot(@_) }
869 # Computes the arc cosine acos(z) = -i log(z + sqrt(z*z-1)).
873 return CORE::atan2(CORE::sqrt(1-$z*$z), $z)
874 if (! ref $z) && CORE::abs($z) <= 1;
875 my ($x, $y) = ref $z ? @{$z->cartesian} : ($z, 0);
876 return 0 if $x == 1 && $y == 0;
877 my $t1 = CORE::sqrt(($x+1)*($x+1) + $y*$y);
878 my $t2 = CORE::sqrt(($x-1)*($x-1) + $y*$y);
879 my $alpha = ($t1 + $t2)/2;
880 my $beta = ($t1 - $t2)/2;
881 $alpha = 1 if $alpha < 1;
882 if ($beta > 1) { $beta = 1 }
883 elsif ($beta < -1) { $beta = -1 }
884 my $u = CORE::atan2(CORE::sqrt(1-$beta*$beta), $beta);
885 my $v = CORE::log($alpha + CORE::sqrt($alpha*$alpha-1));
886 $v = -$v if $y > 0 || ($y == 0 && $x < -1);
887 return __PACKAGE__->make($u, $v);
893 # Computes the arc sine asin(z) = -i log(iz + sqrt(1-z*z)).
897 return CORE::atan2($z, CORE::sqrt(1-$z*$z))
898 if (! ref $z) && CORE::abs($z) <= 1;
899 my ($x, $y) = ref $z ? @{$z->cartesian} : ($z, 0);
900 return 0 if $x == 0 && $y == 0;
901 my $t1 = CORE::sqrt(($x+1)*($x+1) + $y*$y);
902 my $t2 = CORE::sqrt(($x-1)*($x-1) + $y*$y);
903 my $alpha = ($t1 + $t2)/2;
904 my $beta = ($t1 - $t2)/2;
905 $alpha = 1 if $alpha < 1;
906 if ($beta > 1) { $beta = 1 }
907 elsif ($beta < -1) { $beta = -1 }
908 my $u = CORE::atan2($beta, CORE::sqrt(1-$beta*$beta));
909 my $v = -CORE::log($alpha + CORE::sqrt($alpha*$alpha-1));
910 $v = -$v if $y > 0 || ($y == 0 && $x < -1);
911 return __PACKAGE__->make($u, $v);
917 # Computes the arc tangent atan(z) = i/2 log((i+z) / (i-z)).
921 return CORE::atan2($z, 1) unless ref $z;
922 my ($x, $y) = ref $z ? @{$z->cartesian} : ($z, 0);
923 return 0 if $x == 0 && $y == 0;
924 _divbyzero "atan(i)" if ( $z == i);
925 _logofzero "atan(-i)" if (-$z == i); # -i is a bad file test...
926 my $log = &log((i + $z) / (i - $z));
933 # Computes the arc secant asec(z) = acos(1 / z).
937 _divbyzero "asec($z)", $z if ($z == 0);
944 # Computes the arc cosecant acsc(z) = asin(1 / z).
948 _divbyzero "acsc($z)", $z if ($z == 0);
957 sub acosec { Math::Complex::acsc(@_) }
962 # Computes the arc cotangent acot(z) = atan(1 / z)
966 _divbyzero "acot(0)" if $z == 0;
967 return ($z >= 0) ? CORE::atan2(1, $z) : CORE::atan2(-1, -$z)
969 _divbyzero "acot(i)" if ($z - i == 0);
970 _logofzero "acot(-i)" if ($z + i == 0);
979 sub acotan { Math::Complex::acot(@_) }
984 # Computes the hyperbolic cosine cosh(z) = (exp(z) + exp(-z))/2.
991 return $ex ? ($ex + 1/$ex)/2 : $Inf;
993 my ($x, $y) = @{$z->cartesian};
994 my $cy = CORE::cos($y);
995 my $sy = CORE::cos($y);
997 my $ex_1 = $ex ? 1 / $ex : $Inf;
998 return (ref $z)->make(CORE::cos($y) * ($ex + $ex_1)/2,
999 CORE::sin($y) * ($ex - $ex_1)/2);
1005 # Computes the hyperbolic sine sinh(z) = (exp(z) - exp(-z))/2.
1011 return 0 if $z == 0;
1012 $ex = CORE::exp($z);
1013 return $ex ? ($ex - 1/$ex)/2 : "-$Inf";
1015 my ($x, $y) = @{$z->cartesian};
1016 my $cy = CORE::cos($y);
1017 my $sy = CORE::sin($y);
1018 $ex = CORE::exp($x);
1019 my $ex_1 = $ex ? 1 / $ex : $Inf;
1020 return (ref $z)->make($cy * ($ex - $ex_1)/2,
1021 $sy * ($ex + $ex_1)/2);
1027 # Computes the hyperbolic tangent tanh(z) = sinh(z) / cosh(z).
1032 _divbyzero "tanh($z)", "cosh($z)" if ($cz == 0);
1033 return sinh($z) / $cz;
1039 # Computes the hyperbolic secant sech(z) = 1 / cosh(z).
1044 _divbyzero "sech($z)", "cosh($z)" if ($cz == 0);
1051 # Computes the hyperbolic cosecant csch(z) = 1 / sinh(z).
1056 _divbyzero "csch($z)", "sinh($z)" if ($sz == 0);
1065 sub cosech { Math::Complex::csch(@_) }
1070 # Computes the hyperbolic cotangent coth(z) = cosh(z) / sinh(z).
1075 _divbyzero "coth($z)", "sinh($z)" if $sz == 0;
1076 return cosh($z) / $sz;
1084 sub cotanh { Math::Complex::coth(@_) }
1089 # Computes the arc hyperbolic cosine acosh(z) = log(z + sqrt(z*z-1)).
1096 my ($re, $im) = @{$z->cartesian};
1098 return CORE::log($re + CORE::sqrt($re*$re - 1))
1100 return cplx(0, CORE::atan2(CORE::sqrt(1 - $re*$re), $re))
1101 if CORE::abs($re) < 1;
1103 my $s = &sqrt($z*$z - 1);
1105 $t = 1/(2*$s) if $t == 0 || $t && &abs(cosh(&log($t)) - $z) > $eps;
1112 # Computes the arc hyperbolic sine asinh(z) = log(z + sqrt(z*z+1))
1117 my $t = $z + CORE::sqrt($z*$z + 1);
1118 return CORE::log($t) if $t;
1120 my $s = &sqrt($z*$z + 1);
1122 # Try Taylor series if looking bad.
1123 $t = 1/(2*$s) if $t == 0 || $t && &abs(sinh(&log($t)) - $z) > $eps;
1130 # Computes the arc hyperbolic tangent atanh(z) = 1/2 log((1+z) / (1-z)).
1135 return CORE::log((1 + $z)/(1 - $z))/2 if CORE::abs($z) < 1;
1138 _divbyzero 'atanh(1)', "1 - $z" if (1 - $z == 0);
1139 _logofzero 'atanh(-1)' if (1 + $z == 0);
1140 return 0.5 * &log((1 + $z) / (1 - $z));
1146 # Computes the hyperbolic arc secant asech(z) = acosh(1 / z).
1150 _divbyzero 'asech(0)', "$z" if ($z == 0);
1151 return acosh(1 / $z);
1157 # Computes the hyperbolic arc cosecant acsch(z) = asinh(1 / z).
1161 _divbyzero 'acsch(0)', $z if ($z == 0);
1162 return asinh(1 / $z);
1168 # Alias for acosh().
1170 sub acosech { Math::Complex::acsch(@_) }
1175 # Computes the arc hyperbolic cotangent acoth(z) = 1/2 log((1+z) / (z-1)).
1179 _divbyzero 'acoth(0)' if ($z == 0);
1181 return CORE::log(($z + 1)/($z - 1))/2 if CORE::abs($z) > 1;
1184 _divbyzero 'acoth(1)', "$z - 1" if ($z - 1 == 0);
1185 _logofzero 'acoth(-1)', "1 + $z" if (1 + $z == 0);
1186 return &log((1 + $z) / ($z - 1)) / 2;
1194 sub acotanh { Math::Complex::acoth(@_) }
1199 # Compute atan(z1/z2).
1202 my ($z1, $z2, $inverted) = @_;
1203 my ($re1, $im1, $re2, $im2);
1205 ($re1, $im1) = ref $z2 ? @{$z2->cartesian} : ($z2, 0);
1206 ($re2, $im2) = @{$z1->cartesian};
1208 ($re1, $im1) = @{$z1->cartesian};
1209 ($re2, $im2) = ref $z2 ? @{$z2->cartesian} : ($z2, 0);
1212 return CORE::atan2($re1, $re2) if $im1 == 0;
1213 return ($im1<=>0) * pip2 if $re2 == 0;
1215 my $w = atan($z1/$z2);
1216 my ($u, $v) = ref $w ? @{$w->cartesian} : ($w, 0);
1217 $u += pi if $re2 < 0;
1218 $u -= pit2 if $u > pi;
1219 return cplx($u, $v);
1226 # Set (get if no argument) the display format for all complex numbers that
1227 # don't happen to have overridden it via ->display_format
1229 # When called as an object method, this actually sets the display format for
1230 # the current object.
1232 # Valid object formats are 'c' and 'p' for cartesian and polar. The first
1233 # letter is used actually, so the type can be fully spelled out for clarity.
1235 sub display_format {
1237 my %display_format = %DISPLAY_FORMAT;
1239 if (ref $self) { # Called as an object method
1240 if (exists $self->{display_format}) {
1241 my %obj = %{$self->{display_format}};
1242 @display_format{keys %obj} = values %obj;
1245 $display_format{style} = shift;
1248 @display_format{keys %new} = values %new;
1250 } else { # Called as a class method
1252 $display_format{style} = $self;
1255 @display_format{keys %new} = values %new;
1260 if (defined $self) {
1261 $self->{display_format} = { %display_format };
1264 %{$self->{display_format}} :
1265 $self->{display_format}->{style};
1268 %DISPLAY_FORMAT = %display_format;
1272 $DISPLAY_FORMAT{style};
1278 # Show nicely formatted complex number under its cartesian or polar form,
1279 # depending on the current display format:
1281 # . If a specific display format has been recorded for this object, use it.
1282 # . Otherwise, use the generic current default for all complex numbers,
1283 # which is a package global variable.
1288 my $style = $z->display_format;
1290 $style = $DISPLAY_FORMAT{style} unless defined $style;
1292 return $z->stringify_polar if $style =~ /^p/i;
1293 return $z->stringify_cartesian;
1297 # ->stringify_cartesian
1299 # Stringify as a cartesian representation 'a+bi'.
1301 sub stringify_cartesian {
1303 my ($x, $y) = @{$z->cartesian};
1306 my %format = $z->display_format;
1307 my $format = $format{format};
1310 if ($x =~ /^NaN[QS]?$/i) {
1313 if ($x =~ /^-?$Inf$/oi) {
1316 $re = defined $format ? sprintf($format, $x) : $x;
1324 if ($y == 1) { $im = "" }
1325 elsif ($y == -1) { $im = "-" }
1326 elsif ($y =~ /^(NaN[QS]?)$/i) {
1329 if ($y =~ /^-?$Inf$/oi) {
1332 $im = defined $format ? sprintf($format, $y) : $y;
1345 } elsif ($y > 0 || $im =~ /^NaN[QS]?i$/i) {
1346 $str .= "+" if defined $re;
1349 } elsif (!defined $re) {
1360 # Stringify as a polar representation '[r,t]'.
1362 sub stringify_polar {
1364 my ($r, $t) = @{$z->polar};
1367 my %format = $z->display_format;
1368 my $format = $format{format};
1370 if ($t =~ /^NaN[QS]?$/i || $t =~ /^-?$Inf$/oi) {
1372 } elsif ($t == pi) {
1374 } elsif ($r == 0 || $t == 0) {
1375 $theta = defined $format ? sprintf($format, $t) : $t;
1378 return "[$r,$theta]" if defined $theta;
1381 # Try to identify pi/n and friends.
1384 $t -= int(CORE::abs($t) / pit2) * pit2;
1386 if ($format{polar_pretty_print}) {
1388 for $a (2, 3, 4, 6, 8, 12, 16, 24, 30, 32, 36, 48, 60, 64, 72) {
1390 if (int($b) == $b) {
1391 $b = $b < 0 ? "-" : "" if CORE::abs($b) == 1;
1392 $theta = "${b}pi/$a";
1398 if (defined $format) {
1399 $r = sprintf($format, $r);
1400 $theta = sprintf($format, $theta) unless defined $theta;
1402 $theta = $t unless defined $theta;
1405 return "[$r,$theta]";
1414 Math::Complex - complex numbers and associated mathematical functions
1420 $z = Math::Complex->make(5, 6);
1422 $j = cplxe(1, 2*pi/3);
1426 This package lets you create and manipulate complex numbers. By default,
1427 I<Perl> limits itself to real numbers, but an extra C<use> statement brings
1428 full complex support, along with a full set of mathematical functions
1429 typically associated with and/or extended to complex numbers.
1431 If you wonder what complex numbers are, they were invented to be able to solve
1432 the following equation:
1436 and by definition, the solution is noted I<i> (engineers use I<j> instead since
1437 I<i> usually denotes an intensity, but the name does not matter). The number
1438 I<i> is a pure I<imaginary> number.
1440 The arithmetics with pure imaginary numbers works just like you would expect
1441 it with real numbers... you just have to remember that
1447 5i + 7i = i * (5 + 7) = 12i
1448 4i - 3i = i * (4 - 3) = i
1453 Complex numbers are numbers that have both a real part and an imaginary
1454 part, and are usually noted:
1458 where C<a> is the I<real> part and C<b> is the I<imaginary> part. The
1459 arithmetic with complex numbers is straightforward. You have to
1460 keep track of the real and the imaginary parts, but otherwise the
1461 rules used for real numbers just apply:
1463 (4 + 3i) + (5 - 2i) = (4 + 5) + i(3 - 2) = 9 + i
1464 (2 + i) * (4 - i) = 2*4 + 4i -2i -i*i = 8 + 2i + 1 = 9 + 2i
1466 A graphical representation of complex numbers is possible in a plane
1467 (also called the I<complex plane>, but it's really a 2D plane).
1472 is the point whose coordinates are (a, b). Actually, it would
1473 be the vector originating from (0, 0) to (a, b). It follows that the addition
1474 of two complex numbers is a vectorial addition.
1476 Since there is a bijection between a point in the 2D plane and a complex
1477 number (i.e. the mapping is unique and reciprocal), a complex number
1478 can also be uniquely identified with polar coordinates:
1482 where C<rho> is the distance to the origin, and C<theta> the angle between
1483 the vector and the I<x> axis. There is a notation for this using the
1484 exponential form, which is:
1486 rho * exp(i * theta)
1488 where I<i> is the famous imaginary number introduced above. Conversion
1489 between this form and the cartesian form C<a + bi> is immediate:
1491 a = rho * cos(theta)
1492 b = rho * sin(theta)
1494 which is also expressed by this formula:
1496 z = rho * exp(i * theta) = rho * (cos theta + i * sin theta)
1498 In other words, it's the projection of the vector onto the I<x> and I<y>
1499 axes. Mathematicians call I<rho> the I<norm> or I<modulus> and I<theta>
1500 the I<argument> of the complex number. The I<norm> of C<z> will be
1503 The polar notation (also known as the trigonometric
1504 representation) is much more handy for performing multiplications and
1505 divisions of complex numbers, whilst the cartesian notation is better
1506 suited for additions and subtractions. Real numbers are on the I<x>
1507 axis, and therefore I<theta> is zero or I<pi>.
1509 All the common operations that can be performed on a real number have
1510 been defined to work on complex numbers as well, and are merely
1511 I<extensions> of the operations defined on real numbers. This means
1512 they keep their natural meaning when there is no imaginary part, provided
1513 the number is within their definition set.
1515 For instance, the C<sqrt> routine which computes the square root of
1516 its argument is only defined for non-negative real numbers and yields a
1517 non-negative real number (it is an application from B<R+> to B<R+>).
1518 If we allow it to return a complex number, then it can be extended to
1519 negative real numbers to become an application from B<R> to B<C> (the
1520 set of complex numbers):
1522 sqrt(x) = x >= 0 ? sqrt(x) : sqrt(-x)*i
1524 It can also be extended to be an application from B<C> to B<C>,
1525 whilst its restriction to B<R> behaves as defined above by using
1526 the following definition:
1528 sqrt(z = [r,t]) = sqrt(r) * exp(i * t/2)
1530 Indeed, a negative real number can be noted C<[x,pi]> (the modulus
1531 I<x> is always non-negative, so C<[x,pi]> is really C<-x>, a negative
1532 number) and the above definition states that
1534 sqrt([x,pi]) = sqrt(x) * exp(i*pi/2) = [sqrt(x),pi/2] = sqrt(x)*i
1536 which is exactly what we had defined for negative real numbers above.
1537 The C<sqrt> returns only one of the solutions: if you want the both,
1538 use the C<root> function.
1540 All the common mathematical functions defined on real numbers that
1541 are extended to complex numbers share that same property of working
1542 I<as usual> when the imaginary part is zero (otherwise, it would not
1543 be called an extension, would it?).
1545 A I<new> operation possible on a complex number that is
1546 the identity for real numbers is called the I<conjugate>, and is noted
1547 with an horizontal bar above the number, or C<~z> here.
1554 z * ~z = (a + bi) * (a - bi) = a*a + b*b
1556 We saw that the norm of C<z> was noted C<abs(z)> and was defined as the
1557 distance to the origin, also known as:
1559 rho = abs(z) = sqrt(a*a + b*b)
1563 z * ~z = abs(z) ** 2
1565 If z is a pure real number (i.e. C<b == 0>), then the above yields:
1569 which is true (C<abs> has the regular meaning for real number, i.e. stands
1570 for the absolute value). This example explains why the norm of C<z> is
1571 noted C<abs(z)>: it extends the C<abs> function to complex numbers, yet
1572 is the regular C<abs> we know when the complex number actually has no
1573 imaginary part... This justifies I<a posteriori> our use of the C<abs>
1574 notation for the norm.
1578 Given the following notations:
1580 z1 = a + bi = r1 * exp(i * t1)
1581 z2 = c + di = r2 * exp(i * t2)
1582 z = <any complex or real number>
1584 the following (overloaded) operations are supported on complex numbers:
1586 z1 + z2 = (a + c) + i(b + d)
1587 z1 - z2 = (a - c) + i(b - d)
1588 z1 * z2 = (r1 * r2) * exp(i * (t1 + t2))
1589 z1 / z2 = (r1 / r2) * exp(i * (t1 - t2))
1590 z1 ** z2 = exp(z2 * log z1)
1592 abs(z) = r1 = sqrt(a*a + b*b)
1593 sqrt(z) = sqrt(r1) * exp(i * t/2)
1594 exp(z) = exp(a) * exp(i * b)
1595 log(z) = log(r1) + i*t
1596 sin(z) = 1/2i (exp(i * z1) - exp(-i * z))
1597 cos(z) = 1/2 (exp(i * z1) + exp(-i * z))
1598 atan2(z1, z2) = atan(z1/z2)
1600 The following extra operations are supported on both real and complex
1608 cbrt(z) = z ** (1/3)
1609 log10(z) = log(z) / log(10)
1610 logn(z, n) = log(z) / log(n)
1612 tan(z) = sin(z) / cos(z)
1618 asin(z) = -i * log(i*z + sqrt(1-z*z))
1619 acos(z) = -i * log(z + i*sqrt(1-z*z))
1620 atan(z) = i/2 * log((i+z) / (i-z))
1622 acsc(z) = asin(1 / z)
1623 asec(z) = acos(1 / z)
1624 acot(z) = atan(1 / z) = -i/2 * log((i+z) / (z-i))
1626 sinh(z) = 1/2 (exp(z) - exp(-z))
1627 cosh(z) = 1/2 (exp(z) + exp(-z))
1628 tanh(z) = sinh(z) / cosh(z) = (exp(z) - exp(-z)) / (exp(z) + exp(-z))
1630 csch(z) = 1 / sinh(z)
1631 sech(z) = 1 / cosh(z)
1632 coth(z) = 1 / tanh(z)
1634 asinh(z) = log(z + sqrt(z*z+1))
1635 acosh(z) = log(z + sqrt(z*z-1))
1636 atanh(z) = 1/2 * log((1+z) / (1-z))
1638 acsch(z) = asinh(1 / z)
1639 asech(z) = acosh(1 / z)
1640 acoth(z) = atanh(1 / z) = 1/2 * log((1+z) / (z-1))
1642 I<arg>, I<abs>, I<log>, I<csc>, I<cot>, I<acsc>, I<acot>, I<csch>,
1643 I<coth>, I<acosech>, I<acotanh>, have aliases I<rho>, I<theta>, I<ln>,
1644 I<cosec>, I<cotan>, I<acosec>, I<acotan>, I<cosech>, I<cotanh>,
1645 I<acosech>, I<acotanh>, respectively. C<Re>, C<Im>, C<arg>, C<abs>,
1646 C<rho>, and C<theta> can be used also also mutators. The C<cbrt>
1647 returns only one of the solutions: if you want all three, use the
1650 The I<root> function is available to compute all the I<n>
1651 roots of some complex, where I<n> is a strictly positive integer.
1652 There are exactly I<n> such roots, returned as a list. Getting the
1653 number mathematicians call C<j> such that:
1657 is a simple matter of writing:
1659 $j = ((root(1, 3))[1];
1661 The I<k>th root for C<z = [r,t]> is given by:
1663 (root(z, n))[k] = r**(1/n) * exp(i * (t + 2*k*pi)/n)
1665 The I<spaceship> comparison operator, E<lt>=E<gt>, is also defined. In
1666 order to ensure its restriction to real numbers is conform to what you
1667 would expect, the comparison is run on the real part of the complex
1668 number first, and imaginary parts are compared only when the real
1673 To create a complex number, use either:
1675 $z = Math::Complex->make(3, 4);
1678 if you know the cartesian form of the number, or
1682 if you like. To create a number using the polar form, use either:
1684 $z = Math::Complex->emake(5, pi/3);
1685 $x = cplxe(5, pi/3);
1687 instead. The first argument is the modulus, the second is the angle
1688 (in radians, the full circle is 2*pi). (Mnemonic: C<e> is used as a
1689 notation for complex numbers in the polar form).
1691 It is possible to write:
1693 $x = cplxe(-3, pi/4);
1695 but that will be silently converted into C<[3,-3pi/4]>, since the
1696 modulus must be non-negative (it represents the distance to the origin
1697 in the complex plane).
1699 It is also possible to have a complex number as either argument of
1700 either the C<make> or C<emake>: the appropriate component of
1701 the argument will be used.
1706 =head1 STRINGIFICATION
1708 When printed, a complex number is usually shown under its cartesian
1709 style I<a+bi>, but there are legitimate cases where the polar style
1710 I<[r,t]> is more appropriate.
1712 By calling the class method C<Math::Complex::display_format> and
1713 supplying either C<"polar"> or C<"cartesian"> as an argument, you
1714 override the default display style, which is C<"cartesian">. Not
1715 supplying any argument returns the current settings.
1717 This default can be overridden on a per-number basis by calling the
1718 C<display_format> method instead. As before, not supplying any argument
1719 returns the current display style for this number. Otherwise whatever you
1720 specify will be the new display style for I<this> particular number.
1726 Math::Complex::display_format('polar');
1727 $j = (root(1, 3))[1];
1728 print "j = $j\n"; # Prints "j = [1,2pi/3]"
1729 $j->display_format('cartesian');
1730 print "j = $j\n"; # Prints "j = -0.5+0.866025403784439i"
1732 The polar style attempts to emphasize arguments like I<k*pi/n>
1733 (where I<n> is a positive integer and I<k> an integer within [-9,+9]),
1734 this is called I<polar pretty-printing>.
1736 =head2 CHANGED IN PERL 5.6
1738 The C<display_format> class method and the corresponding
1739 C<display_format> object method can now be called using
1740 a parameter hash instead of just a one parameter.
1742 The old display format style, which can have values C<"cartesian"> or
1743 C<"polar">, can be changed using the C<"style"> parameter. (The one
1744 parameter calling convention also still works.)
1746 There are two new display parameters.
1748 The first one is C<"format">, which is a sprintf()-style format
1749 string to be used for both parts of the complex number(s). The
1750 default is C<undef>, which corresponds usually (this is somewhat
1751 system-dependent) to C<"%.15g">. You can revert to the default by
1752 setting the format string to C<undef>.
1754 # the $j from the above example
1756 $j->display_format('format' => '%.5f');
1757 print "j = $j\n"; # Prints "j = -0.50000+0.86603i"
1758 $j->display_format('format' => '%.6f');
1759 print "j = $j\n"; # Prints "j = -0.5+0.86603i"
1761 Notice that this affects also the return values of the
1762 C<display_format> methods: in list context the whole parameter hash
1763 will be returned, as opposed to only the style parameter value. If
1764 you want to know the whole truth for a complex number, you must call
1765 both the class method and the object method:
1767 The second new display parameter is C<"polar_pretty_print">, which can
1768 be set to true or false, the default being true. See the previous
1769 section for what this means.
1773 Thanks to overloading, the handling of arithmetics with complex numbers
1774 is simple and almost transparent.
1776 Here are some examples:
1780 $j = cplxe(1, 2*pi/3); # $j ** 3 == 1
1781 print "j = $j, j**3 = ", $j ** 3, "\n";
1782 print "1 + j + j**2 = ", 1 + $j + $j**2, "\n";
1784 $z = -16 + 0*i; # Force it to be a complex
1785 print "sqrt($z) = ", sqrt($z), "\n";
1787 $k = exp(i * 2*pi/3);
1788 print "$j - $k = ", $j - $k, "\n";
1790 $z->Re(3); # Re, Im, arg, abs,
1791 $j->arg(2); # (the last two aka rho, theta)
1792 # can be used also as mutators.
1794 =head1 ERRORS DUE TO DIVISION BY ZERO OR LOGARITHM OF ZERO
1796 The division (/) and the following functions
1802 atanh asech acsch acoth
1804 cannot be computed for all arguments because that would mean dividing
1805 by zero or taking logarithm of zero. These situations cause fatal
1806 runtime errors looking like this
1808 cot(0): Division by zero.
1809 (Because in the definition of cot(0), the divisor sin(0) is 0)
1814 atanh(-1): Logarithm of zero.
1817 For the C<csc>, C<cot>, C<asec>, C<acsc>, C<acot>, C<csch>, C<coth>,
1818 C<asech>, C<acsch>, the argument cannot be C<0> (zero). For the the
1819 logarithmic functions and the C<atanh>, C<acoth>, the argument cannot
1820 be C<1> (one). For the C<atanh>, C<acoth>, the argument cannot be
1821 C<-1> (minus one). For the C<atan>, C<acot>, the argument cannot be
1822 C<i> (the imaginary unit). For the C<atan>, C<acoth>, the argument
1823 cannot be C<-i> (the negative imaginary unit). For the C<tan>,
1824 C<sec>, C<tanh>, the argument cannot be I<pi/2 + k * pi>, where I<k>
1827 Note that because we are operating on approximations of real numbers,
1828 these errors can happen when merely `too close' to the singularities
1829 listed above. For example C<tan(2*atan2(1,1)+1e-15)> will die of
1832 =head1 ERRORS DUE TO INDIGESTIBLE ARGUMENTS
1834 The C<make> and C<emake> accept both real and complex arguments.
1835 When they cannot recognize the arguments they will die with error
1836 messages like the following
1838 Math::Complex::make: Cannot take real part of ...
1839 Math::Complex::make: Cannot take real part of ...
1840 Math::Complex::emake: Cannot take rho of ...
1841 Math::Complex::emake: Cannot take theta of ...
1845 Saying C<use Math::Complex;> exports many mathematical routines in the
1846 caller environment and even overrides some (C<sqrt>, C<log>).
1847 This is construed as a feature by the Authors, actually... ;-)
1849 All routines expect to be given real or complex numbers. Don't attempt to
1850 use BigFloat, since Perl has currently no rule to disambiguate a '+'
1851 operation (for instance) between two overloaded entities.
1853 In Cray UNICOS there is some strange numerical instability that results
1854 in root(), cos(), sin(), cosh(), sinh(), losing accuracy fast. Beware.
1855 The bug may be in UNICOS math libs, in UNICOS C compiler, in Math::Complex.
1856 Whatever it is, it does not manifest itself anywhere else where Perl runs.
1860 Raphael Manfredi <F<Raphael_Manfredi@pobox.com>> and
1861 Jarkko Hietaniemi <F<jhi@iki.fi>>.
1863 Extensive patches by Daniel S. Lewart <F<d-lewart@uiuc.edu>>.