turnstep / math-gmp Goto Github PK

my $LONG = 300; # approximate

package Math::GMP {
    sub log10 {
        my($self) = @_;
        my $s = "$self";
        my $len = length($s);
        return log($s) / log(10) if $len < $LONG;
        $s =~ s/^(.)/$1./;
        return log($s) / log(10) + $len - 1;
    }
    sub log {
        my($self) = @_;
        return log10($self) * log(10);
    }
    sub bfdiv {
        my($self, $other) = @_;
        my $sself = "$self";
        # corrected from:
        # return $self / "$other" if length($sself) < $LONG;
        return $sself / "$other" if length($sself) < $LONG;
        my $lother = ref($other) ? $other->log : CORE::log($other);
        return exp($self->log - $lother);
    }
}

sub long_sprintf {
    # $format is expected to have a single %g or similar format specifier
    my($format, $large) = @_;
    my $s = sprintf $format, "$large";
    if ($s =~ /inf/i) {
        my $log = $large->log10;
        my $exp = int($log);
        my $rem = $log - $exp;
        $s = sprintf $format, 10 ** $rem;
        $s =~ s{e\d+|$}{e$exp};
    }
    return $s;
}

=head1 SYNOPSIS

  my $large = Math::GMP->new(10) ** 1000;
  my $smaller = $large * 2 / 3;
  say $large->log10;  # 1000
  say $large->log;    # 2302.58509299405
  say $large->bfdiv($smaller);  # 1.5-ish
  say long_sprintf("%.2g", $large);  # 1.00e1000

=head1 METHODS

=over 4

=head2 log10( )

Returns the base-10 logarithm of the invocant as a Perl float.

=head2 log( )

Returns the natural logarithm of the invocant as a Perl float.

=head2 bdfiv($n)

Returns the invocant divided by C<$n> as a Perl float. C<$n> may be a
C<Math::GMP> object or a standard Perl scalar value. Note that this
will use logarithms/exponentiation for large values, which will limit
its accuracy - use bigfloats instead if you need greater precision.

=back

=head1 FUNCTIONS

=over 4

=head2 long_sprintf($format, $value)

Given a sprintf-style format C<$format> with a single format specification
requesting a value in exponential notation, and a C<Math::GMP> object
C<$value>, returns a string displaying C<$value> in the requested manner.

=back

--- a/lib/Math/GMP.pm 2020-02-09 19:08:42.000000000 +0000
+++ b/lib/Math/GMP.pm 2021-09-08 15:23:54.139606957 +0100
@@ -536,6 +536,31 @@
 
 For internal use. B<Do not use directly>.
 
+=head1 DIVISION BY ZERO
+
+Whereas perl normally catches division by zero to provide a standard
+perl-level error message, C<libgmp> does not; the result is usually
+a SIGFPE (floating point exception) giving a core dump if you ever
+attempt to divide a C<Math::GMP> object by anything that evaluates
+to zero. This can make it hard to diagnose where the error has occurred
+in your perl code.
+
+As of perl-5.36.0, SIGFPE is delivered in a way that can be caught
+by a C<%SIG> handler. So you can get a stack trace with code like:
+
+  use Carp;  # load it up front
+  local $SIG{FPE} = sub { confess(@_) };
+
+Before perl-5.36.0 this approach won't work: you'll need to use
+L<POSIX/sigaction> instead:
+
+  use Carp;
+  use POSIX qw{ sigaction SIGFPE };
+  sigaction(SIGFPE, POSIX::SigAction->new(sub { confess(@_) }));
+
+In either case, you should not attempt to return from the signal
+handler, since the signal will just be thrown again.
+
 =head1 BUGS
 
 As of version 1.0, Math::GMP is mostly compatible with the old