a few typo fixes

[p5sagit/p5-mst-13.2.git] / lib / Math / Complex.pm

diff --git a/lib/Math/Complex.pm b/lib/Math/Complex.pm
index af2b2a0..19d30b0 100644 (file)
--- a/lib/Math/Complex.pm
+++ b/lib/Math/Complex.pm
@@ -7,15 +7,28 @@
 
 package Math::Complex;
 
-$VERSION = "1.30";
-
 our($VERSION, @ISA, @EXPORT, %EXPORT_TAGS, $Inf);
 
+$VERSION = 1.32;
+
 BEGIN {
-    my $e = $!;
-    $Inf = CORE::exp(CORE::exp(30)); # We do want an arithmetic overflow.
-    $! = $e; # Clear ERANGE.
-    undef $Inf unless $Inf =~ /^inf(?:inity)?$/i; # Inf INF inf Infinity
+    unless ($^O eq 'unicosmk') {
+        my $e = $!;
+       # We do want an arithmetic overflow, Inf INF inf Infinity:.
+        undef $Inf unless eval <<'EOE' and $Inf =~ /^inf(?:inity)?$/i;
+         local $SIG{FPE} = sub {die};
+         my $t = CORE::exp 30;
+         $Inf = CORE::exp $t;
+EOE
+       if (!defined $Inf) {            # Try a different method
+         undef $Inf unless eval <<'EOE' and $Inf =~ /^inf(?:inity)?$/i;
+           local $SIG{FPE} = sub {die};
+           my $t = 1;
+           $Inf = $t + "1e99999999999999999999999999999999";
+EOE
+       }
+        $! = $e; # Clear ERANGE.
+    }
     $Inf = "Inf" if !defined $Inf || !($Inf > 0); # Desperation.
 }
 
@@ -661,7 +674,7 @@ sub Re {
 #
 sub Im {
        my ($z, $Im) = @_;
-       return $z unless ref $z;
+       return 0 unless ref $z;
        if (defined $Im) {
            $z->{'cartesian'} = [ ${$z->cartesian}[0], $Im ];
            $z->{c_dirty} = 0;
@@ -1250,23 +1263,15 @@ sub display_format {
                my %obj = %{$self->{display_format}};
                @display_format{keys %obj} = values %obj;
            }
-           if (@_ == 1) {
-               $display_format{style} = shift;
-           } else {
-               my %new = @_;
-               @display_format{keys %new} = values %new;
-           }
-       } else {                                # Called as a class method
-           if (@_ = 1) {
-               $display_format{style} = $self;
-           } else {
-               my %new = @_;
-               @display_format{keys %new} = values %new;
-           }
-           undef $self;
+       }
+       if (@_ == 1) {
+           $display_format{style} = shift;
+       } else {
+           my %new = @_;
+           @display_format{keys %new} = values %new;
        }
 
-       if (defined $self) {
+       if (ref $self) { # Called as an object method
            $self->{display_format} = { %display_format };
            return
                wantarray ?
@@ -1274,6 +1279,7 @@ sub display_format {
                    $self->{display_format}->{style};
        }
 
+        # Called as a class method
        %DISPLAY_FORMAT = %display_format;
        return
            wantarray ?
@@ -1418,6 +1424,8 @@ sub stringify_polar {
 1;
 __END__
 
+=pod
+
 =head1 NAME
 
 Math::Complex - complex numbers and associated mathematical functions
@@ -1553,7 +1561,7 @@ be called an extension, would it?).
 
 A I<new> operation possible on a complex number that is
 the identity for real numbers is called the I<conjugate>, and is noted
-with an horizontal bar above the number, or C<~z> here.
+with a horizontal bar above the number, or C<~z> here.
 
         z = a + bi
        ~z = a - bi
@@ -1652,7 +1660,7 @@ I<arg>, I<abs>, I<log>, I<csc>, I<cot>, I<acsc>, I<acot>, I<csch>,
 I<coth>, I<acosech>, I<acotanh>, have aliases I<rho>, I<theta>, I<ln>,
 I<cosec>, I<cotan>, I<acosec>, I<acotan>, I<cosech>, I<cotanh>,
 I<acosech>, I<acotanh>, respectively.  C<Re>, C<Im>, C<arg>, C<abs>,
-C<rho>, and C<theta> can be used also also mutators.  The C<cbrt>
+C<rho>, and C<theta> can be used also as mutators.  The C<cbrt>
 returns only one of the solutions: if you want all three, use the
 C<root> function.
 
@@ -1828,7 +1836,7 @@ or
        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 the
+C<asech>, C<acsch>, the argument cannot be C<0> (zero).  For the
 logarithmic functions and 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<atan>, C<acot>, the argument cannot be