perl
view release on metacpan or search on metacpan
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
package Math::BigFloat;
#
# Mike grinned. 'Two down, infinity to go' - Mike Nostrus in 'Before and After'
#
# The following hash values are used internally:
#
# sign : "+", "-", "+inf", "-inf", or "NaN"
# _m : absolute value of mantissa ($LIB thingy)
# _es : sign of exponent ("+" or "-")
# _e : absolute value of exponent ($LIB thingy)
# accuracy : accuracy (scalar)
# precision : precision (scalar)
use 5.006001;
use strict;
use warnings;
use Carp qw< carp croak >;
use Scalar::Util qw< blessed >;
use Math::BigInt qw< >;
our $VERSION = '2.005002';
$VERSION =~ tr/_//d;
require Exporter;
our @ISA = qw< Math::BigInt >;
our @EXPORT_OK = qw< bpi >;
use overload
# overload key: with_assign
'+' => sub { $_[0] -> copy() -> badd($_[1]); },
'-' => sub { my $c = $_[0] -> copy();
$_[2] ? $c -> bneg() -> badd($_[1])
: $c -> bsub($_[1]); },
'*' => sub { $_[0] -> copy() -> bmul($_[1]); },
'/' => sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bdiv($_[0])
: $_[0] -> copy() -> bdiv($_[1]); },
'%' => sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bmod($_[0])
: $_[0] -> copy() -> bmod($_[1]); },
'**' => sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bpow($_[0])
: $_[0] -> copy() -> bpow($_[1]); },
'<<' => sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bblsft($_[0])
: $_[0] -> copy() -> bblsft($_[1]); },
'>>' => sub { $_[2] ? ref($_[0]) -> new($_[1]) -> bbrsft($_[0])
: $_[0] -> copy() -> bbrsft($_[1]); },
# overload key: assign
'+=' => sub { $_[0] -> badd($_[1]); },
'-=' => sub { $_[0] -> bsub($_[1]); },
'*=' => sub { $_[0] -> bmul($_[1]); },
'/=' => sub { scalar $_[0] -> bdiv($_[1]); },
'%=' => sub { $_[0] -> bmod($_[1]); },
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
# '!' => sub { },
'~' => sub { $_[0] -> copy() -> bnot(); },
# '~.' => sub { },
# overload key: mutators
'++' => sub { $_[0] -> binc() },
'--' => sub { $_[0] -> bdec() },
# overload key: func
'atan2' => sub { $_[2] ? ref($_[0]) -> new($_[1]) -> batan2($_[0])
: $_[0] -> copy() -> batan2($_[1]); },
'cos' => sub { $_[0] -> copy() -> bcos(); },
'sin' => sub { $_[0] -> copy() -> bsin(); },
'exp' => sub { $_[0] -> copy() -> bexp($_[1]); },
'abs' => sub { $_[0] -> copy() -> babs(); },
'log' => sub { $_[0] -> copy() -> blog(); },
'sqrt' => sub { $_[0] -> copy() -> bsqrt(); },
'int' => sub { $_[0] -> copy() -> bint(); },
# overload key: conversion
'bool' => sub { $_[0] -> is_zero() ? '' : 1; },
'""' => sub { $_[0] -> bstr(); },
'0+' => sub { $_[0] -> numify(); },
'=' => sub { $_[0] -> copy(); },
;
##############################################################################
# global constants, flags and assorted stuff
# the following are public, but their usage is not recommended. Use the
# accessor methods instead.
# class constants, use Class->constant_name() to access
# one of 'even', 'odd', '+inf', '-inf', 'zero', 'trunc' or 'common'
our $accuracy = undef;
our $precision = undef;
our $round_mode = 'even';
our $div_scale = 40;
our $upgrade = undef;
our $downgrade = undef;
our $_trap_nan = 0; # croak on NaNs?
our $_trap_inf = 0; # croak on Infs?
my $nan = 'NaN'; # constant for easier life
my $LIB = Math::BigInt -> config('lib'); # math backend library
# Has import() been called yet? This variable is needed to make "require" work.
my $IMPORT = 0;
# some digits of accuracy for blog(undef, 10); which we use in blog() for speed
my $LOG_10 =
'2.3025850929940456840179914546843642076011014886287729760333279009675726097';
my $LOG_10_A = length($LOG_10)-1;
# ditto for log(2)
my $LOG_2 =
'0.6931471805599453094172321214581765680755001343602552541206800094933936220';
my $LOG_2_A = length($LOG_2)-1;
my $HALF = '0.5'; # made into an object if nec.
##############################################################################
# the old code had $rnd_mode, so we need to support it, too
our $rnd_mode;
our $AUTOLOAD;
sub TIESCALAR {
my ($class) = @_;
bless \$round_mode, $class;
}
sub FETCH {
return $round_mode;
}
sub STORE {
$rnd_mode = (ref $_[0]) -> round_mode($_[1]);
}
BEGIN {
*objectify = \&Math::BigInt::objectify;
# when someone sets $rnd_mode, we catch this and check the value to see
# whether it is valid or not.
$rnd_mode = 'even';
tie $rnd_mode, 'Math::BigFloat';
*as_number = \&as_int;
}
sub DESTROY {
# going through AUTOLOAD for every DESTROY is costly, avoid it by empty sub
}
sub AUTOLOAD {
# Make fxxx() work by mapping fxxx() to Math::BigFloat::bxxx().
my $name = $AUTOLOAD;
$name =~ s/^(.*):://; # strip package name
my $class = $1 || __PACKAGE__;
$class -> import() if $IMPORT == 0;
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
}
# Initialize a new object.
$self = bless {}, $class;
# See if $wanted is an object that is a Math::BigFloat or can convert
# itself to a Math::BigFloat.
if (defined(blessed($wanted)) && $wanted -> can('as_float')) {
my $tmp = $wanted -> as_float(@r);
for my $attr ('sign', '_m', '_es', '_e') {
$self -> {$attr} = $tmp -> {$attr};
}
return $self -> round(@r);
}
# From now on we only work on the stringified version of $wanted, so
# stringify it once and for all.
$wanted = "$wanted";
# Shortcut for simple forms like '123' that have no trailing zeros.
# Trailing zeros would require a non-zero exponent.
if ($wanted =~
/ ^
\s* # optional leading whitespace
( [+-]? ) # optional sign
0* # optional leading zeros
( [1-9] (?: [0-9]* [1-9] )? ) # significand
\s* # optional trailing whitespace
$
/x)
{
my $dng = $class -> downgrade();
return $dng -> new($1 . $2) if $dng && $dng ne $class;
$self->{sign} = $1 || '+';
$self->{_m} = $LIB -> _new($2);
$self->{_es} = '+';
$self->{_e} = $LIB -> _zero();
$self -> round(@r)
unless @r >= 2 && !defined $r[0] && !defined $r[1];
return $self;
}
# Handle Infs.
if ($wanted =~ / ^
\s*
( [+-]? )
inf (?: inity )?
\s*
\z
/ix)
{
my $sgn = $1 || '+';
return $class -> binf($sgn, @r);
}
# Handle explicit NaNs (not the ones returned due to invalid input).
if ($wanted =~ / ^
\s*
( [+-]? )
nan
\s*
\z
/ix)
{
return $class -> bnan(@r);
}
my @parts;
if (
# Handle hexadecimal numbers. We auto-detect hexadecimal numbers if
# they have a "0x", "0X", "x", or "X" prefix, cf. CORE::oct().
$wanted =~ /^\s*[+-]?0?[Xx]/ and
@parts = $class -> _hex_str_to_flt_lib_parts($wanted)
or
# Handle octal numbers. We auto-detect octal numbers if they have a
# "0o", "0O", "o", "O" prefix, cf. CORE::oct().
$wanted =~ /^\s*[+-]?0?[Oo]/ and
@parts = $class -> _oct_str_to_flt_lib_parts($wanted)
or
# Handle binary numbers. We auto-detect binary numbers if they have a
# "0b", "0B", "b", or "B" prefix, cf. CORE::oct().
$wanted =~ /^\s*[+-]?0?[Bb]/ and
@parts = $class -> _bin_str_to_flt_lib_parts($wanted)
or
# At this point, what is left are decimal numbers that aren't handled
# above and octal floating point numbers that don't have any of the
# "0o", "0O", "o", or "O" prefixes. First see if it is a decimal
# number.
@parts = $class -> _dec_str_to_flt_lib_parts($wanted)
or
# See if it is an octal floating point number. The extra check is
# included because _oct_str_to_flt_lib_parts() accepts octal numbers
# that don't have a prefix (this is needed to make it work with, e.g.,
# from_oct() that don't require a prefix). However, Perl requires a
# prefix for octal floating point literals. For example, "1p+0" is not
# valid, but "01p+0" and "0__1p+0" are.
$wanted =~ /^\s*[+-]?0_*\d/ and
@parts = $class -> _oct_str_to_flt_lib_parts($wanted))
{
($self->{sign}, $self->{_m}, $self->{_es}, $self->{_e}) = @parts;
$self -> round(@r)
unless @r >= 2 && !defined($r[0]) && !defined($r[1]);
$self -> _dng() if ($self -> is_int() ||
$self -> is_inf() ||
$self -> is_nan());
return $self;
}
# If we get here, the value is neither a valid decimal, binary, octal, or
# hexadecimal number. It is not an explicit Inf or a NaN either.
return $class -> bnan(@r);
}
sub from_dec {
my $self = shift;
my $selfref = ref $self;
my $class = $selfref || $self;
# Make "require" work.
$class -> import() if $IMPORT == 0;
# Don't modify constant (read-only) objects.
return $self if $selfref && $self -> modify('from_dec');
my $str = shift;
my @r = @_;
if (my @parts = $class -> _dec_str_to_flt_lib_parts($str)) {
# If called as a class method, initialize a new object.
unless ($selfref) {
$self = bless {}, $class;
#$self -> _init();
}
($self->{sign}, $self->{_m}, $self->{_es}, $self->{_e}) = @parts;
$self -> round(@r)
unless @r >= 2 && !defined($r[0]) && !defined($r[1]);
$self -> _dng() if ($self -> is_int() ||
$self -> is_inf() ||
$self -> is_nan());
return $self;
}
return $self -> bnan(@r);
}
sub from_hex {
my $self = shift;
my $selfref = ref $self;
my $class = $selfref || $self;
# Make "require" work.
$class -> import() if $IMPORT == 0;
# Don't modify constant (read-only) objects.
return $self if $selfref && $self -> modify('from_hex');
my $str = shift;
my @r = @_;
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
$class -> import() if $IMPORT == 0;
# Don't modify constant (read-only) objects.
return $self if $selfref && $self -> modify('binf');
# Get the sign.
my $sign = '+'; # default is to return positive infinity
if (defined($_[0]) && $_[0] =~ /^\s*([+-])(inf|$)/i) {
$sign = $1;
shift;
}
# Get the rounding parameters, if any.
my @r = @_;
# Downgrade?
my $dng = $class -> downgrade();
if ($dng && $dng ne $class) {
return $self -> _dng() -> binf($sign, @r) if $selfref;
return $dng -> binf($sign, @r);
}
# If called as a class method, initialize a new object.
$self = bless {}, $class unless $selfref;
$self -> {sign} = $sign . 'inf';
$self -> {_m} = $LIB -> _zero();
$self -> {_es} = '+';
$self -> {_e} = $LIB -> _zero();
# If rounding parameters are given as arguments, use them. If no rounding
# parameters are given, and if called as a class method initialize the new
# instance with the class variables.
#return $self -> round(@r); # this should work, but doesnt; fixme!
if (@r) {
if (@r >= 2 && defined($r[0]) && defined($r[1])) {
carp "can't specify both accuracy and precision";
return $self -> bnan();
}
$self->{accuracy} = $r[0];
$self->{precision} = $r[1];
} else {
unless($selfref) {
$self->{accuracy} = $class -> accuracy();
$self->{precision} = $class -> precision();
}
}
return $self;
}
sub bnan {
# create/assign a 'NaN'
# Class::method(...) -> Class->method(...)
unless (@_ && (defined(blessed($_[0])) && $_[0] -> isa(__PACKAGE__) ||
$_[0] =~ /^[a-z]\w*(?:::[a-z]\w*)*$/i))
{
#carp "Using ", (caller(0))[3], "() as a function is deprecated;",
# " use is as a method instead";
unshift @_, __PACKAGE__;
}
my $self = shift;
my $selfref = ref $self;
my $class = $selfref || $self;
{
no strict 'refs';
if (${"${class}::_trap_nan"}) {
croak("Tried to create NaN in $class->bnan()");
}
}
# Make "require" work.
$class -> import() if $IMPORT == 0;
# Don't modify constant (read-only) objects.
return $self if $selfref && $self -> modify('bnan');
my $dng = $class -> downgrade();
if ($dng && $dng ne $class) {
return $self -> _dng() -> bnan(@_) if $selfref;
return $dng -> bnan(@_);
}
# Get the rounding parameters, if any.
my @r = @_;
# If called as a class method, initialize a new object.
$self = bless {}, $class unless $selfref;
$self -> {sign} = $nan;
$self -> {_m} = $LIB -> _zero();
$self -> {_es} = '+';
$self -> {_e} = $LIB -> _zero();
# If rounding parameters are given as arguments, use them. If no rounding
# parameters are given, and if called as a class method initialize the new
# instance with the class variables.
#return $self -> round(@r); # this should work, but doesnt; fixme!
if (@r) {
if (@r >= 2 && defined($r[0]) && defined($r[1])) {
carp "can't specify both accuracy and precision";
return $self -> bnan();
}
$self->{accuracy} = $r[0];
$self->{precision} = $r[1];
} else {
unless($selfref) {
$self->{accuracy} = $class -> accuracy();
$self->{precision} = $class -> precision();
}
}
return $self;
}
sub bpi {
# Class::method(...) -> Class->method(...)
unless (@_ && (defined(blessed($_[0])) && $_[0] -> isa(__PACKAGE__) ||
$_[0] =~ /^[a-z]\w*(?:::[a-z]\w*)*$/i))
{
#carp "Using ", (caller(0))[3], "() as a function is deprecated;",
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
# If the exponent of x is < 0 and the exponent of y is >= 0, add the
# absolute value of the exponent of x to both.
if ($y->{_es} eq '+') {
$ex = $LIB->_zero(); # -ex + |ex| = 0
$ey = $LIB->_copy($y->{_e});
$ey = $LIB->_add($ey, $x->{_e}); # ey + |ex|
}
# If the exponent of x is < 0 and the exponent of y is < 0, add the
# absolute values of both exponents to both exponents.
else {
$ex = $LIB->_copy($y->{_e}); # -ex + |ey| + |ex| = |ey|
$ey = $LIB->_copy($x->{_e}); # -ey + |ex| + |ey| = |ex|
}
}
# Now we can normalize the exponents by adding lengths of the mantissas.
$ex = $LIB->_add($ex, $LIB->_new($mxl));
$ey = $LIB->_add($ey, $LIB->_new($myl));
# We're done if the exponents are different.
$cmp = $LIB->_acmp($ex, $ey);
$cmp = -$cmp if $x->{sign} eq '-'; # 124 > 123, but -124 < -123
return $cmp if $cmp;
# Compare the mantissas, but first normalize them by padding the shorter
# mantissa with zeros (shift left) until it has the same length as the
# longer mantissa.
my $mx = $x->{_m};
my $my = $y->{_m};
if ($mxl > $myl) {
$my = $LIB->_lsft($LIB->_copy($my), $LIB->_new($mxl - $myl), 10);
} elsif ($mxl < $myl) {
$mx = $LIB->_lsft($LIB->_copy($mx), $LIB->_new($myl - $mxl), 10);
}
$cmp = $LIB->_acmp($mx, $my);
$cmp = -$cmp if $x->{sign} eq '-'; # 124 > 123, but -124 < -123
return $cmp;
}
sub bacmp {
# Compares 2 values, ignoring their signs.
# Returns one of undef, <0, =0, >0. (suitable for sort)
# set up parameters
my ($class, $x, $y, @r) = ref($_[0]) && ref($_[0]) eq ref($_[1])
? (ref($_[0]), @_)
: objectify(2, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
# handle +-inf and NaN
if ($x->{sign} !~ /^[+-]$/ || $y->{sign} !~ /^[+-]$/) {
return if ($x -> is_nan() || $y -> is_nan());
return 0 if ($x -> is_inf() && $y -> is_inf());
return 1 if ($x -> is_inf() && !$y -> is_inf());
return -1;
}
# shortcut
my $xz = $x -> is_zero();
my $yz = $y -> is_zero();
return 0 if $xz && $yz; # 0 <=> 0
return -1 if $xz && !$yz; # 0 <=> +y
return 1 if $yz && !$xz; # +x <=> 0
# adjust so that exponents are equal
my $lxm = $LIB->_len($x->{_m});
my $lym = $LIB->_len($y->{_m});
my ($xes, $yes) = (1, 1);
$xes = -1 if $x->{_es} ne '+';
$yes = -1 if $y->{_es} ne '+';
# the numify somewhat limits our length, but makes it much faster
my $lx = $lxm + $xes * $LIB->_num($x->{_e});
my $ly = $lym + $yes * $LIB->_num($y->{_e});
my $l = $lx - $ly;
return $l <=> 0 if $l != 0;
# lengths (corrected by exponent) are equal
# so make mantissa equal-length by padding with zero (shift left)
my $diff = $lxm - $lym;
my $xm = $x->{_m}; # not yet copy it
my $ym = $y->{_m};
if ($diff > 0) {
$ym = $LIB->_copy($y->{_m});
$ym = $LIB->_lsft($ym, $LIB->_new($diff), 10);
} elsif ($diff < 0) {
$xm = $LIB->_copy($x->{_m});
$xm = $LIB->_lsft($xm, $LIB->_new(-$diff), 10);
}
$LIB->_acmp($xm, $ym);
}
###############################################################################
# Arithmetic methods
###############################################################################
sub bneg {
# (BINT or num_str) return BINT
# negate number or make a negated number from string
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
# Don't modify constant (read-only) objects.
return $x if $x -> modify('bneg');
# For +0 do not negate (to have always normalized +0).
$x->{sign} =~ tr/+-/-+/
unless $x->{sign} eq '+' && $LIB->_is_zero($x->{_m});
$x -> round(@r);
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
sub bnorm {
# bnorm() can't support rounding, because bround() and bfround() call
# bnorm(), which would recurse indefinitely.
# adjust m and e so that m is smallest possible
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
# inf and nan
if ($x->{sign} !~ /^[+-]$/) {
$x -> round(@r);
$x -> _dng();
return $x;
}
my $zeros = $LIB->_zeros($x->{_m}); # correct for trailing zeros
if ($zeros != 0) {
my $z = $LIB->_new($zeros);
$x->{_m} = $LIB->_rsft($x->{_m}, $z, 10);
if ($x->{_es} eq '-') {
if ($LIB->_acmp($x->{_e}, $z) >= 0) {
$x->{_e} = $LIB->_sub($x->{_e}, $z);
$x->{_es} = '+' if $LIB->_is_zero($x->{_e});
} else {
$x->{_e} = $LIB->_sub($LIB->_copy($z), $x->{_e});
$x->{_es} = '+';
}
} else {
$x->{_e} = $LIB->_add($x->{_e}, $z);
}
} else {
# $x can only be 0Ey if there are no trailing zeros ('0' has 0 trailing
# zeros). So, for something like 0Ey, set y to 0, and -0 => +0
if ($LIB->_is_zero($x->{_m})) {
$x->{sign} = '+';
$x->{_es} = '+';
$x->{_e} = $LIB->_zero();
}
}
# Inf and NaN was handled above, so no need to check for this.
$x -> _dng() if $x -> is_int();
return $x;
}
sub binc {
# increment arg by one
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
# Don't modify constant (read-only) objects.
return $x if $x -> modify('binc');
# Inf and NaN
if ($x -> is_inf() || $x -> is_nan()) {
$x -> round(@r);
$x -> _dng();
return $x
}
# Non-integer
if ($x->{_es} eq '-') {
return $x -> badd($class -> bone(), @r);
}
# If the exponent is non-zero, convert the internal representation, so
# that, e.g., 12e+3 becomes 12000e+0 and we can easily increment the
# mantissa.
if (!$LIB->_is_zero($x->{_e})) {
$x->{_m} = $LIB->_lsft($x->{_m}, $x->{_e}, 10); # 1e2 => 100
$x->{_e} = $LIB->_zero(); # normalize
$x->{_es} = '+';
# we know that the last digit of $x will be '1' or '9', depending on
# the sign
}
# now $x->{_e} == 0
if ($x->{sign} eq '+') {
$x->{_m} = $LIB->_inc($x->{_m});
return $x -> bnorm() -> bround(@r);
} elsif ($x->{sign} eq '-') {
$x->{_m} = $LIB->_dec($x->{_m});
$x->{sign} = '+' if $LIB->_is_zero($x->{_m}); # -1 +1 => -0 => +0
return $x -> bnorm() -> bround(@r);
}
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
sub bdec {
# decrement arg by one
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
# Don't modify constant (read-only) objects.
return $x if $x -> modify('bdec');
# Inf and NaN
if ($x -> is_inf() || $x -> is_nan()) {
$x -> round(@r);
$x -> _dng();
return $x
}
# Non-integer
if ($x->{_es} eq '-') {
return $x -> badd($class -> bone('-'), @r);
}
# If the exponent is non-zero, convert the internal representation, so
# that, e.g., 12e+3 becomes 12000e+0 and we can easily increment the
# mantissa.
if (!$LIB->_is_zero($x->{_e})) {
$x->{_m} = $LIB->_lsft($x->{_m}, $x->{_e}, 10); # 1e2 => 100
$x->{_e} = $LIB->_zero(); # normalize
$x->{_es} = '+';
}
# now $x->{_e} == 0
my $zero = $x -> is_zero();
if (($x->{sign} eq '-') || $zero) { # x <= 0
$x->{_m} = $LIB->_inc($x->{_m});
$x->{sign} = '-' if $zero; # 0 => 1 => -1
$x->{sign} = '+' if $LIB->_is_zero($x->{_m}); # -1 +1 => -0 => +0
$x -> bnorm();
}
elsif ($x->{sign} eq '+') { # x > 0
$x->{_m} = $LIB->_dec($x->{_m});
$x -> bnorm();
}
$x -> round(@r);
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
sub badd {
# set up parameters
my ($class, $x, $y, @r) = ref($_[0]) && ref($_[0]) eq ref($_[1])
? (ref($_[0]), @_)
: objectify(2, @_);
# Don't modify constant (read-only) objects.
return $x if $x -> modify('badd');
unless ($x -> is_finite() && $y -> is_finite()) {
return $x -> bnan(@r) if $x -> is_nan() || $y -> is_nan();
return $x -> is_inf("+") ? ($y -> is_inf("-") ? $x -> bnan(@r)
: $x -> binf("+", @r))
: $x -> is_inf("-") ? ($y -> is_inf("+") ? $x -> bnan(@r)
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
return $x if $x -> modify('bmul');
return $x -> bnan(@r) if $x -> is_nan() || $y -> is_nan();
# inf handling
if (($x->{sign} =~ /^[+-]inf$/) || ($y->{sign} =~ /^[+-]inf$/)) {
return $x -> bnan(@r) if $x -> is_zero() || $y -> is_zero();
# result will always be +-inf:
# +inf * +/+inf => +inf, -inf * -/-inf => +inf
# +inf * -/-inf => -inf, -inf * +/+inf => -inf
return $x -> binf(@r) if ($x->{sign} =~ /^\+/ && $y->{sign} =~ /^\+/);
return $x -> binf(@r) if ($x->{sign} =~ /^-/ && $y->{sign} =~ /^-/);
return $x -> binf('-', @r);
}
return $x -> _upg() -> bmul($y, @r) if $class -> upgrade();
# aEb * cEd = (a*c)E(b+d)
$x->{_m} = $LIB->_mul($x->{_m}, $y->{_m});
($x->{_e}, $x->{_es})
= $LIB -> _sadd($x->{_e}, $x->{_es}, $y->{_e}, $y->{_es});
$r[3] = $y; # no push!
# adjust sign:
$x->{sign} = $x->{sign} ne $y->{sign} ? '-' : '+';
$x -> bnorm -> round(@r);
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
*bdiv = \&bfdiv;
*bmod = \&bfmod;
sub bfdiv {
# This does floored division (or floor division) where the quotient is
# rounded towards minus infinity.
#
# ($q, $r) = $x -> btdiv($y) returns $q and $r so that $q is floor($x / $y)
# and $q * $y + $r = $x.
# Set up parameters.
my ($class, $x, $y, @r) = ref($_[0]) && ref($_[0]) eq ref($_[1])
? (ref($_[0]), @_)
: objectify(2, @_);
###########################################################################
# Code for all classes that share the common interface.
###########################################################################
# Don't modify constant (read-only) objects.
return $x if $x -> modify('bfdiv');
my $wantarray = wantarray; # call only once
# At least one argument is NaN. This is handled the same way as in
# Math::BigInt -> bdiv(). See the comment in the code for Math::BigInt ->
# bdiv() for further details.
if ($x -> is_nan() || $y -> is_nan()) {
return $wantarray ? ($x -> bnan(@r), $class -> bnan(@r))
: $x -> bnan(@r);
}
# Divide by zero and modulo zero. This is handled the same way as in
# Math::BigInt -> bdiv(). See the comment in the code for Math::BigInt ->
# bdiv() for further details.
if ($y -> is_zero()) {
my $rem;
if ($wantarray) {
$rem = $x -> copy() -> round(@r);
$rem -> _dng() if $rem -> is_int();
}
if ($x -> is_zero()) {
$x -> bnan(@r);
} else {
$x -> binf($x->{sign}, @r);
}
return $wantarray ? ($x, $rem) : $x;
}
# Numerator (dividend) is +/-inf. This is handled the same way as in
# Math::BigInt -> bdiv(). See the comment in the code for Math::BigInt ->
# bdiv() for further details.
if ($x -> is_inf()) {
my $rem;
$rem = $class -> bnan(@r) if $wantarray;
if ($y -> is_inf()) {
$x -> bnan(@r);
} else {
my $sign = $x -> bcmp(0) == $y -> bcmp(0) ? '+' : '-';
$x -> binf($sign, @r);
}
return $wantarray ? ($x, $rem) : $x;
}
# Denominator (divisor) is +/-inf. This is handled the same way as in
# Math::BigInt -> bdiv(), with one exception: In scalar context,
# Math::BigFloat does true division (although rounded), not floored
# division (F-division), so a finite number divided by +/-inf is always
# zero. See the comment in the code for Math::BigInt -> bdiv() for further
# details.
if ($y -> is_inf()) {
my $rem;
if ($wantarray) {
if ($x -> is_zero() || $x -> bcmp(0) == $y -> bcmp(0)) {
$rem = $x -> copy() -> round(@r);
$rem -> _dng() if $rem -> is_int();
$x -> bzero(@r);
} else {
$rem = $class -> binf($y -> {sign}, @r);
$x -> bone('-', @r);
}
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
# correct exponent of $x
($x->{_e}, $x->{_es})
= $LIB -> _ssub($x->{_e}, $x->{_es}, $y->{_e}, $y->{_es});
# correct for 10**scale
($x->{_e}, $x->{_es})
= $LIB -> _ssub($x->{_e}, $x->{_es}, $LIB->_new($scale), '+');
$x -> bnorm(); # remove trailing zeros
}
# shortcut to not run through _find_round_parameters again
if (defined $params[0]) {
$x->{accuracy} = undef; # clear before round
$x -> bround($params[0], $params[2]); # then round accordingly
} else {
$x->{precision} = undef; # clear before round
$x -> bfround($params[1], $params[2]); # then round accordingly
}
if ($fallback) {
# clear a/p after round, since user did not request it
$x->{accuracy} = undef;
$x->{precision} = undef;
}
# Restore downgrading
Math::BigFloat -> downgrade($dng);
if ($wantarray) {
$x -> bfloor();
$rem -> bfmod($y, @params); # copy already done
if ($fallback) {
# clear a/p after round, since user did not request it
$rem->{accuracy} = undef;
$rem->{precision} = undef;
}
$x -> _dng() if $x -> is_int();
$rem -> _dng() if $rem -> is_int();
return $x, $rem;
}
$x -> _dng() if $x -> is_int();
$x; # rounding already done above
}
sub bfmod {
# (dividend: BFLOAT or num_str, divisor: BFLOAT or num_str) return
# remainder
# set up parameters
my ($class, $x, $y, @r) = ref($_[0]) && ref($_[0]) eq ref($_[1])
? (ref($_[0]), @_)
: objectify(2, @_);
# Don't modify constant (read-only) objects.
return $x if $x -> modify('bfmod');
# At least one argument is NaN. This is handled the same way as in
# Math::BigInt -> bfmod().
return $x -> bnan(@r) if $x -> is_nan() || $y -> is_nan();
# Modulo zero. This is handled the same way as in Math::BigInt -> bfmod().
if ($y -> is_zero()) {
return $x -> round(@r);
}
# Numerator (dividend) is +/-inf. This is handled the same way as in
# Math::BigInt -> bfmod().
if ($x -> is_inf()) {
return $x -> bnan(@r);
}
# Denominator (divisor) is +/-inf. This is handled the same way as in
# Math::BigInt -> bfmod().
if ($y -> is_inf()) {
if ($x -> is_zero() || $x -> bcmp(0) == $y -> bcmp(0)) {
return $x -> round(@r);
} else {
return $x -> binf($y -> sign(), @r);
}
}
# Modulo is zero if $x is zero or if $x is an integer and $y is +/-1.
return $x -> bzero(@r) if $x -> is_zero()
|| ($x -> is_int() &&
# check that $y == +1 or $y == -1:
($LIB->_is_zero($y->{_e}) && $LIB->_is_one($y->{_m})));
# Numerator (dividend) and denominator (divisor) are identical. Return
# zero.
my $cmp = $x -> bacmp($y); # $x <=> $y
if ($cmp == 0) { # $x == $y => result 0
return $x -> bzero(@r);
}
# Compare the exponents of $x and $y.
my $ecmp = $LIB->_scmp($x->{_e}, $x->{_es}, $y->{_e}, $y->{_es});
my $ym = $y->{_m}; # mantissa of y, scaled if necessary
if ($ecmp > 0) {
# $x has a larger exponent than $y, so shift the mantissa of $x by the
# difference between the exponents of $x and $y.
#
# 123e+2 % 456e+1 => 1230 % 456 (+2 - +1 = 1)
# 123e+2 % 456e-1 => 123000 % 456 (+2 - -1 = 3)
# 456e-1 % 123e-3 => 12300 % 456 (-1 - -3 = 2)
# get the difference between exponents; $ds is always "+" here
my ($de, $ds) = $LIB->_ssub($LIB->_copy($x->{_e}), $x->{_es},
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
# difference between the exponents of $x and $y.
#
# 123456e+1 % 78e+2 => 123456 % 780 (+2 - +1 = 1)
# 123456e-2 % 78e+1 => 123456 % 78000 (+1 - -2 = 3)
# get the difference between exponents; $ds is always "+" here
my ($de, $ds) = $LIB->_ssub($LIB->_copy($y->{_e}), $y->{_es},
$x->{_e}, $x->{_es});
# adjust the mantissa of y by the difference between exponents
$ym = $LIB->_lsft($LIB->_copy($ym), $de, 10);
# compute the modulus
$x->{_m} = $LIB->_mod($x->{_m}, $ym);
} else {
# $x has the same exponent as $y, so compute the modulus directly
# compute the modulus
$x->{_m} = $LIB->_mod($x->{_m}, $ym);
}
if ($LIB->_is_zero($x->{_m})) {
$x->{sign} = '+';
} else {
# adjust for floored division/modulus
$x->{_m} = $LIB->_sub($ym, $x->{_m}, 1)
if $x->{sign} ne $y->{sign};
$x->{sign} = $y->{sign};
}
$x -> bnorm();
$x -> round($r[0], $r[1], $r[2], $y);
$x -> _dng() if $x -> is_int();
return $x;
}
sub btdiv {
# This does truncated division, where the quotient is truncted, i.e.,
# rounded towards zero.
#
# ($q, $r) = $x -> btdiv($y) returns $q and $r so that $q is int($x / $y)
# and $q * $y + $r = $x.
# Set up parameters
my ($class, $x, $y, @r) = ref($_[0]) && ref($_[0]) eq ref($_[1])
? (ref($_[0]), @_)
: objectify(2, @_);
###########################################################################
# Code for all classes that share the common interface.
###########################################################################
# Don't modify constant (read-only) objects.
return $x if $x -> modify('btdiv');
my $wantarray = wantarray; # call only once
# At least one argument is NaN. Return NaN for both quotient and the
# modulo/remainder.
if ($x -> is_nan() || $y -> is_nan()) {
return $wantarray ? ($x -> bnan(@r), $class -> bnan(@r))
: $x -> bnan(@r);
}
# Divide by zero and modulo zero.
#
# Division: Use the common convention that x / 0 is inf with the same sign
# as x, except when x = 0, where we return NaN. This is also what earlier
# versions did.
#
# Modulo: In modular arithmetic, the congruence relation z = x (mod y)
# means that there is some integer k such that z - x = k y. If y = 0, we
# get z - x = 0 or z = x. This is also what earlier versions did, except
# that 0 % 0 returned NaN.
#
# inf / 0 = inf inf % 0 = inf
# 5 / 0 = inf 5 % 0 = 5
# 0 / 0 = NaN 0 % 0 = 0
# -5 / 0 = -inf -5 % 0 = -5
# -inf / 0 = -inf -inf % 0 = -inf
if ($y -> is_zero()) {
my $rem;
if ($wantarray) {
$rem = $x -> copy(@r);
}
if ($x -> is_zero()) {
$x -> bnan(@r);
} else {
$x -> binf($x -> {sign}, @r);
}
return $wantarray ? ($x, $rem) : $x;
}
# Numerator (dividend) is +/-inf, and denominator is finite and non-zero.
# The divide by zero cases are covered above. In all of the cases listed
# below we return the same as core Perl.
#
# inf / -inf = NaN inf % -inf = NaN
# inf / -5 = -inf inf % -5 = NaN
# inf / 5 = inf inf % 5 = NaN
# inf / inf = NaN inf % inf = NaN
#
# -inf / -inf = NaN -inf % -inf = NaN
# -inf / -5 = inf -inf % -5 = NaN
# -inf / 5 = -inf -inf % 5 = NaN
# -inf / inf = NaN -inf % inf = NaN
if ($x -> is_inf()) {
my $rem;
$rem = $class -> bnan(@r) if $wantarray;
if ($y -> is_inf()) {
$x -> bnan(@r);
} else {
my $sign = $x -> bcmp(0) == $y -> bcmp(0) ? '+' : '-';
$x -> binf($sign,@r );
}
return $wantarray ? ($x, $rem) : $x;
}
# Denominator (divisor) is +/-inf. The cases when the numerator is +/-inf
# are covered above. In the modulo cases (in the right column) we return
# the same as core Perl, which does floored division, so for consistency we
# also do floored division in the division cases (in the left column).
#
# -5 / inf = 0 -5 % inf = -5
# 0 / inf = 0 0 % inf = 0
# 5 / inf = 0 5 % inf = 5
#
# -5 / -inf = 0 -5 % -inf = -5
# 0 / -inf = 0 0 % -inf = 0
# 5 / -inf = 0 5 % -inf = 5
if ($y -> is_inf()) {
my $rem;
if ($wantarray) {
$rem = $x -> copy() -> round(@r);
$rem -> _dng() if $rem -> is_int();
}
$x -> bzero(@r);
return $wantarray ? ($x, $rem) : $x;
}
# At this point, both the numerator and denominator are finite, non-zero
# numbers.
# we need to limit the accuracy to protect against overflow
my $fallback = 0;
my (@params, $scale);
($x, @params) = $x->_find_round_parameters($r[0], $r[1], $r[2], $y);
if ($x -> is_nan()) { # error in _find_round_parameters?
$x -> round(@r);
return $wantarray ? ($x, $class -> bnan(@r)) : $x;
}
# no rounding at all, so must use fallback
if (scalar @params == 0) {
# simulate old behaviour
$params[0] = $class -> div_scale(); # and round to it as accuracy
$scale = $params[0]+4; # at least four more for proper round
$params[2] = $r[2]; # round mode by caller or undef
$fallback = 1; # to clear a/p afterwards
} else {
# the 4 below is empirical, and there might be cases where it is not
# enough...
$scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
# correct exponent of $x
($x->{_e}, $x->{_es})
= $LIB -> _ssub($x->{_e}, $x->{_es}, $y->{_e}, $y->{_es});
# correct for 10**scale
($x->{_e}, $x->{_es})
= $LIB -> _ssub($x->{_e}, $x->{_es}, $LIB->_new($scale), '+');
$x -> bnorm(); # remove trailing zeros in mantissa
}
# shortcut to not run through _find_round_parameters again
if (defined $params[0]) {
$x->{accuracy} = undef; # clear before round
$x -> bround($params[0], $params[2]); # then round accordingly
} else {
$x->{precision} = undef; # clear before round
$x -> bfround($params[1], $params[2]); # then round accordingly
}
if ($fallback) {
# clear a/p after round, since user did not request it
$x->{accuracy} = undef;
$x->{precision} = undef;
}
# Restore downgrading
Math::BigFloat -> downgrade($dng);
if ($wantarray) {
$x -> bint();
$rem -> btmod($y, @params); # copy already done
if ($fallback) {
# clear a/p after round, since user did not request it
$rem->{accuracy} = undef;
$rem->{precision} = undef;
}
$x -> _dng() if $x -> is_int();
$rem -> _dng() if $rem -> is_int();
return $x, $rem;
}
$x -> _dng() if $x -> is_int();
$x; # rounding already done above
}
sub btmod {
# (dividend: BFLOAT or num_str, divisor: BFLOAT or num_str) return
# remainder
# set up parameters
my ($class, $x, $y, @r) = ref($_[0]) && ref($_[0]) eq ref($_[1])
? (ref($_[0]), @_)
: objectify(2, @_);
# Don't modify constant (read-only) objects.
return $x if $x -> modify('btmod');
# At least one argument is NaN. This is handled the same way as in
# Math::BigInt -> btmod().
return $x -> bnan(@r) if $x -> is_nan() || $y -> is_nan();
# Modulo zero. This is handled the same way as in Math::BigInt -> btmod().
if ($y -> is_zero()) {
return $x -> round(@r);
}
# Numerator (dividend) is +/-inf. This is handled the same way as in
# Math::BigInt -> btmod().
if ($x -> is_inf()) {
return $x -> bnan(@r);
}
# Denominator (divisor) is +/-inf. This is handled the same way as in
# Math::BigInt -> btmod().
if ($y -> is_inf()) {
return $x -> round(@r);
}
# Modulo is zero if $x is zero or if $x is an integer and $y is +/-1.
return $x -> bzero(@r) if $x -> is_zero()
|| ($x -> is_int() &&
# check that $y == +1 or $y == -1:
($LIB->_is_zero($y->{_e}) && $LIB->_is_one($y->{_m})));
# Numerator (dividend) and denominator (divisor) are identical. Return
# zero.
my $cmp = $x -> bacmp($y); # $x <=> $y
if ($cmp == 0) { # $x == $y => result 0
return $x -> bzero(@r);
}
# Compare the exponents of $x and $y.
my $ecmp = $LIB->_scmp($x->{_e}, $x->{_es}, $y->{_e}, $y->{_es});
if ($ecmp > 0) {
# $x has a larger exponent than $y, so shift the mantissa of $x by the
# difference between the exponents of $x and $y.
#
# 123e+2 % 456e+1 => 1230 % 456 (+2 - +1 = 1)
# 123e+2 % 456e-1 => 123000 % 456 (+2 - -1 = 3)
# 456e-1 % 123e-3 => 12300 % 456 (-1 - -3 = 2)
# get the difference between exponents; $ds is always "+" here
my ($de, $ds) = $LIB->_ssub($LIB->_copy($x->{_e}), $x->{_es},
$y->{_e}, $y->{_es});
# adjust the mantissa of x by the difference between exponents
$x->{_m} = $LIB->_lsft($x->{_m}, $de, 10);
# compute the modulus
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
# Shift the significand left or right to get the desired number of digits,
# which is 2*$scale with possibly one extra digit to ensure that the
# exponent is an even number.
my $l = $LIB -> _len($x->{_m});
my $n = 2 * $scale - $l; # how much should we shift?
$n++ if ($l % 2 xor $LIB -> _is_odd($x->{_e}));
my ($na, $ns) = $n < 0 ? (abs($n), "-") : ($n, "+");
$na = $LIB -> _new($na);
$x->{_m} = $ns eq "+" ? $LIB -> _lsft($x->{_m}, $na, 10)
: $LIB -> _rsft($x->{_m}, $na, 10);
$x->{_m} = $LIB -> _sqrt($x->{_m});
# Adjust the exponent by the amount that we shifted the significand. The
# square root of the exponent is simply half of it: sqrt(10^(2*a)) = 10^a.
($x->{_e}, $x->{_es}) = $LIB -> _ssub($x->{_e}, $x->{_es}, $na, $ns);
$x->{_e} = $LIB -> _div($x->{_e}, $LIB -> _new("2"));
# Normalize to get rid of any trailing zeros in the significand.
$x -> bnorm();
# shortcut to not run through _find_round_parameters again
if (defined $params[0]) {
$x -> bround($params[0], $params[2]); # then round accordingly
} else {
$x -> bfround($params[1], $params[2]); # then round accordingly
}
if ($fallback) {
# clear a/p after round, since user did not request it
$x->{accuracy} = undef;
$x->{precision} = undef;
}
$x -> round(@r);
$x -> _dng() if $x -> is_int();
$x;
}
sub bpow {
# (BFLOAT or num_str, BFLOAT or num_str) return BFLOAT
# compute power of two numbers, second arg is used as integer
# modifies first argument
# set up parameters
my ($class, $x, $y, $a, $p, $r) = (ref($_[0]), @_);
# objectify is costly, so avoid it
if ((!ref($_[0])) || (ref($_[0]) ne ref($_[1]))) {
($class, $x, $y, $a, $p, $r) = objectify(2, @_);
}
# Don't modify constant (read-only) objects.
return $x if $x -> modify('bpow');
# $x and/or $y is a NaN
return $x -> bnan() if $x -> is_nan() || $y -> is_nan();
# $x and/or $y is a +/-Inf
if ($x -> is_inf("-")) {
return $x -> bzero() if $y -> is_negative();
return $x -> bnan() if $y -> is_zero();
return $x if $y -> is_odd();
return $x -> bneg();
} elsif ($x -> is_inf("+")) {
return $x -> bzero() if $y -> is_negative();
return $x -> bnan() if $y -> is_zero();
return $x;
} elsif ($y -> is_inf("-")) {
return $x -> bnan() if $x -> is_one("-");
return $x -> binf("+") if $x > -1 && $x < 1;
return $x -> bone() if $x -> is_one("+");
return $x -> bzero();
} elsif ($y -> is_inf("+")) {
return $x -> bnan() if $x -> is_one("-");
return $x -> bzero() if $x > -1 && $x < 1;
return $x -> bone() if $x -> is_one("+");
return $x -> binf("+");
}
if ($x -> is_zero()) {
return $x -> bone() if $y -> is_zero();
return $x -> binf() if $y -> is_negative();
return $x;
}
# We don't support complex numbers, so upgrade or return NaN.
if ($x -> is_negative() && !$y -> is_int()) {
return $x -> _upg() -> bpow($y, $a, $p, $r) if $class -> upgrade();
return $x -> bnan();
}
if ($x -> is_one("+") || $y -> is_one()) {
return $x;
}
if ($x -> is_one("-")) {
return $x if $y -> is_odd();
return $x -> bneg();
}
return $x -> _pow($y, $a, $p, $r) if !$y -> is_int();
# We should NOT be looking at private variables of other objects. Fixme XXX
my $y1 = $y -> as_int()->{value}; # make MBI part
my $new_sign = '+';
$new_sign = $LIB -> _is_odd($y1) ? '-' : '+' if $x->{sign} ne '+';
# calculate $x->{_m} ** $y and $x->{_e} * $y separately (faster)
$x->{_m} = $LIB -> _pow($x->{_m}, $y1);
$x->{_e} = $LIB -> _mul($x->{_e}, $y1);
$x->{sign} = $new_sign;
$x -> bnorm();
# x ** (-y) = 1 / (x ** y)
if ($y->{sign} eq '-') {
# modify $x in place!
my $z = $x -> copy();
$x -> bone();
# round in one go (might ignore y's A!)
return scalar $x -> bdiv($z, $a, $p, $r);
}
$x -> round($a, $p, $r, $y);
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
sub broot {
# calculate $y'th root of $x
# set up parameters
my ($class, $x, $y, @r) = ref($_[0]) && ref($_[0]) eq ref($_[1])
? (ref($_[0]), @_)
: objectify(2, @_);
# Don't modify constant (read-only) objects.
return $x if $x -> modify('broot');
# Handle trivial cases.
return $x -> bnan(@r) if $x -> is_nan() || $y -> is_nan();
if ($x -> is_neg()) {
# -27 ** (1/3) = -(27 ** (1/3)) = -3
return $x -> broot($y -> copy() -> bneg(), @r) -> bneg()
if ($x -> is_int() && $y -> is_int() &&
$y -> is_neg() && $y -> is_odd());
return $x -> _upg -> broot($y, @r) if $class -> upgrade();
return $x -> bnan(@r);
}
# NaN handling: $x ** 1/0, x or y NaN, or y inf/-inf or y == 0
return $x -> bnan(@r) if ($x->{sign} !~ /^\+/ || $y -> is_zero() ||
$y->{sign} !~ /^\+$/);
# Trivial cases.
return $x if ($x -> is_zero() || $x -> is_one() ||
$x -> is_inf() || $y -> is_one());
# we need to limit the accuracy to protect against overflow
my $fallback = 0;
my (@params, $scale);
($x, @params) = $x->_find_round_parameters(@r);
return $x if $x -> is_nan(); # error in _find_round_parameters?
# no rounding at all, so must use fallback
if (scalar @params == 0) {
# simulate old behaviour
$params[0] = $class -> div_scale(); # and round to it as accuracy
$scale = $params[0]+4; # at least four more for proper round
$params[2] = $r[2]; # round mode by caller or undef
$fallback = 1; # to clear a/p afterwards
} else {
# the 4 below is empirical, and there might be cases where it is not
# enough...
$scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
}
# When user set globals, they would interfere with our calculation, so
# disable them and later re-enable them.
my $ab = $class -> accuracy();
my $pb = $class -> precision();
$class -> accuracy(undef);
$class -> precision(undef);
# Disabling upgrading and downgrading is no longer necessary to avoid an
# infinite recursion, but it avoids unnecessary upgrading and downgrading
# in the intermediate computations.
my $upg = $class -> upgrade();
my $dng = $class -> downgrade();
$class -> upgrade(undef);
$class -> downgrade(undef);
# We also need to disable any set A or P on $x (_find_round_parameters took
# them already into account), since these would interfere, too.
$x->{accuracy} = undef;
$x->{precision} = undef;
# remember sign and make $x positive, since -4 ** (1/2) => -2
my $sign = 0;
$sign = 1 if $x->{sign} eq '-';
$x->{sign} = '+';
my $is_two = 0;
if ($y -> isa('Math::BigFloat')) {
$is_two = $y->{sign} eq '+' && $LIB->_is_two($y->{_m})
&& $LIB->_is_zero($y->{_e});
} else {
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
$done = 1;
}
}
if ($done == 0) {
my $u = $class -> bone() -> bdiv($y, $scale+4);
$u->{accuracy} = undef;
$u->{precision} = undef;
$x -> bpow($u, $scale+4); # el cheapo
}
Math::BigInt -> upgrade($mbi_upg);
}
$x -> bneg() if $sign == 1;
# shortcut to not run through _find_round_parameters again
if (defined $params[0]) {
$x -> bround($params[0], $params[2]); # then round accordingly
} else {
$x -> bfround($params[1], $params[2]); # then round accordingly
}
if ($fallback) {
# clear a/p after round, since user did not request it
$x->{accuracy} = undef;
$x->{precision} = undef;
}
# Restore globals. We need to do it like this, because setting one
# undefines the other.
if (defined $ab) {
$class -> accuracy($ab);
} else {
$class -> precision($pb);
}
$class -> upgrade($upg);
$class -> downgrade($dng);
$x -> round(@r);
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
sub bmuladd {
# multiply two numbers and add the third to the result
# set up parameters
my ($class, $x, $y, $z, @r)
= ref($_[0]) && ref($_[0]) eq ref($_[1]) && ref($_[1]) eq ref($_[2])
? (ref($_[0]), @_)
: objectify(3, @_);
# Don't modify constant (read-only) objects.
return $x if $x -> modify('bmuladd');
# At least one of x, y, and z is a NaN
return $x -> bnan(@r) if ($x -> is_nan() ||
$y -> is_nan() ||
$z -> is_nan());
# At least one of x, y, and z is an Inf
if ($x -> is_inf("-")) {
if ($y -> is_neg()) { # x = -inf, y < 0
if ($z -> is_inf("-")) {
return $x -> bnan(@r);
} else {
return $x -> binf("+", @r);
}
} elsif ($y -> is_zero()) { # x = -inf, y = 0
return $x -> bnan(@r);
} else { # x = -inf, y > 0
if ($z->{sign} eq "+inf") {
return $x -> bnan(@r);
} else {
return $x -> binf("-", @r);
}
}
} elsif ($x->{sign} eq "+inf") {
if ($y -> is_neg()) { # x = +inf, y < 0
if ($z->{sign} eq "+inf") {
return $x -> bnan(@r);
} else {
return $x -> binf("-", @r);
}
} elsif ($y -> is_zero()) { # x = +inf, y = 0
return $x -> bnan(@r);
} else { # x = +inf, y > 0
if ($z -> is_inf("-")) {
return $x -> bnan(@r);
} else {
return $x -> binf("+", @r);
}
}
} elsif ($x -> is_neg()) {
if ($y -> is_inf("-")) { # -inf < x < 0, y = -inf
if ($z -> is_inf("-")) {
return $x -> bnan(@r);
} else {
return $x -> binf("+", @r);
}
} elsif ($y->{sign} eq "+inf") { # -inf < x < 0, y = +inf
if ($z->{sign} eq "+inf") {
return $x -> bnan(@r);
} else {
return $x -> binf("-", @r);
}
} else { # -inf < x < 0, -inf < y < +inf
if ($z -> is_inf("-")) {
return $x -> binf("-", @r);
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
# take lower of the two e's and adapt m1 to it to match m2
my $e = $z->{_e};
$e = $LIB->_zero() if !defined $e; # if no BFLOAT?
$e = $LIB->_copy($e); # make copy (didn't do it yet)
my $es;
($e, $es) = $LIB -> _ssub($e, $z->{_es} || '+', $x->{_e}, $x->{_es});
my $add = $LIB->_copy($z->{_m});
if ($es eq '-') # < 0
{
$x->{_m} = $LIB->_lsft($x->{_m}, $e, 10);
($x->{_e}, $x->{_es}) = $LIB -> _sadd($x->{_e}, $x->{_es}, $e, $es);
} elsif (!$LIB->_is_zero($e)) # > 0
{
$add = $LIB->_lsft($add, $e, 10);
}
# else: both e are the same, so just leave them
if ($x->{sign} eq $z->{sign}) {
# add
$x->{_m} = $LIB->_add($x->{_m}, $add);
} else {
($x->{_m}, $x->{sign}) =
$LIB -> _sadd($x->{_m}, $x->{sign}, $add, $z->{sign});
}
# delete trailing zeros, then round
$x -> bnorm() -> round(@r);
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
sub bmodpow {
# takes a very large number to a very large exponent in a given very
# large modulus, quickly, thanks to binary exponentiation. Supports
# negative exponents.
my ($class, $num, $exp, $mod, @r)
= ref($_[0]) && ref($_[0]) eq ref($_[1]) && ref($_[1]) eq ref($_[2])
? (ref($_[0]), @_)
: objectify(3, @_);
# Don't modify constant (read-only) objects.
return $num if $num -> modify('bmodpow');
return $num -> bnan(@r)
if $mod -> is_nan() || $exp -> is_nan() || $mod -> is_nan();
# check modulus for valid values
return $num -> bnan(@r) if $mod->{sign} ne '+' || $mod -> is_zero();
# check exponent for valid values
if ($exp->{sign} =~ /\w/) {
# i.e., if it's NaN, +inf, or -inf...
return $num -> bnan(@r);
}
$num -> bmodinv($mod, @r) if $exp->{sign} eq '-';
# check num for valid values (also NaN if there was no inverse but $exp < 0)
return $num -> bnan(@r) if $num->{sign} !~ /^[+-]$/;
# $mod is positive, sign on $exp is ignored, result also positive
# XXX TODO: speed it up when all three numbers are integers
$num -> bpow($exp) -> bmod($mod);
$num -> round(@r);
$num -> _dng() if ($num -> is_int() ||
$num -> is_inf() ||
$num -> is_nan());
return $num;
}
sub blog {
# Return the logarithm of the operand. If a second operand is defined, that
# value is used as the base, otherwise the base is assumed to be Euler's
# constant.
my ($class, $x, $base, @r);
# Only objectify the base if it is defined, since an undefined base, as in
# $x->blog() or $x->blog(undef) signals that the base is Euler's number =
# 2.718281828...
if (!ref($_[0]) && $_[0] =~ /^[A-Za-z]|::/) {
# E.g., Math::BigFloat->blog(256, 2)
($class, $x, $base, @r) =
defined $_[2] ? objectify(2, @_) : objectify(1, @_);
} else {
# E.g., $x->blog(2) or the deprecated Math::BigFloat::blog(256, 2)
($class, $x, $base, @r) =
defined $_[1] ? objectify(2, @_) : objectify(1, @_);
}
# Don't modify constant (read-only) objects.
return $x if $x -> modify('blog');
# Handle all exception cases and all trivial cases. I have used Wolfram
# Alpha (http://www.wolframalpha.com) as the reference for these cases.
return $x -> bnan(@r) if $x -> is_nan();
if (defined $base) {
$base = $class -> new($base)
unless defined(blessed($base)) && $base -> isa(__PACKAGE__);
if ($base -> is_nan() || $base -> is_one()) {
return $x -> bnan(@r);
} elsif ($base -> is_inf() || $base -> is_zero()) {
return $x -> bnan(@r) if $x -> is_inf() || $x -> is_zero();
return $x -> bzero(@r);
} elsif ($base -> is_negative()) { # -inf < base < 0
return $x -> bzero(@r) if $x -> is_one(); # x = 1
return $x -> bone('+', @r) if $x == $base; # x = base
# we can't handle these cases, so upgrade, if we can
return $x -> _upg() -> blog($base, @r) if $class -> upgrade();
return $x -> bnan(@r);
}
return $x -> bone(@r) if $x == $base; # 0 < base && 0 < x < inf
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
$x -> bsub($next);
}
$sign = 1 - $sign; # alternatex
# calculate things for the next term
$over -> bmul($x2); # $x*$x
$below -> badd($two); # n += 2
}
$x -> bmul($fmul);
if (defined $pi) {
my $x_copy = $x -> copy();
# modify $x in place
$x->{_m} = $pi->{_m};
$x->{_e} = $pi->{_e};
$x->{_es} = $pi->{_es};
# PI/2 - $x
$x -> bsub($x_copy);
}
# Shortcut to not run through _find_round_parameters again.
if (defined $params[0]) {
$x -> bround($params[0], $params[2]); # then round accordingly
} else {
$x -> bfround($params[1], $params[2]); # then round accordingly
}
if ($fallback) {
# Clear a/p after round, since user did not request it.
$x->{accuracy} = undef;
$x->{precision} = undef;
}
# Restore globals. We need to do it like this, because setting one
# undefines the other.
if (defined $ab) {
$class -> accuracy($ab);
} else {
$class -> precision($pb);
}
$class -> upgrade($upg);
$class -> downgrade($dng);
return $x -> _dng() if ($x -> is_int() ||
$x -> is_inf());
$x;
}
sub batan2 {
# $y -> batan2($x) returns the arcus tangens of $y / $x.
# Set up parameters.
my ($class, $y, $x, @r) = ref($_[0]) && ref($_[0]) eq ref($_[1])
? (ref($_[0]), @_)
: objectify(2, @_);
# Don't modify constant (read-only) objects.
return $y if $y -> modify('batan2');
# Handle all NaN cases.
return $y -> bnan() if $x -> is_nan() || $y -> is_nan();
# We need to limit the accuracy to protect against overflow.
my $fallback = 0;
my ($scale, @params);
($y, @params) = $y -> _find_round_parameters(@r);
# Error in _find_round_parameters?
return $y if $y -> is_nan();
# No rounding at all, so must use fallback.
if (scalar @params == 0) {
# Simulate old behaviour
$params[0] = $class -> div_scale(); # and round to it as accuracy
$params[1] = undef; # disable P
$scale = $params[0] + 4; # at least four more for proper round
$params[2] = $r[2]; # round mode by caller or undef
$fallback = 1; # to clear a/p afterwards
} else {
# The 4 below is empirical, and there might be cases where it is not
# enough ...
$scale = abs($params[0] || $params[1]) + 4; # take whatever is defined
}
if ($x -> is_inf("+")) { # x = inf
if ($y -> is_inf("+")) { # y = inf
$y -> bpi($scale) -> bmul("0.25"); # pi/4
} elsif ($y -> is_inf("-")) { # y = -inf
$y -> bpi($scale) -> bmul("-0.25"); # -pi/4
} else { # -inf < y < inf
return $y -> bzero(@r); # 0
}
} elsif ($x -> is_inf("-")) { # x = -inf
if ($y -> is_inf("+")) { # y = inf
$y -> bpi($scale) -> bmul("0.75"); # 3/4 pi
} elsif ($y -> is_inf("-")) { # y = -inf
$y -> bpi($scale) -> bmul("-0.75"); # -3/4 pi
} elsif ($y >= 0) { # y >= 0
$y -> bpi($scale); # pi
} else { # y < 0
$y -> bpi($scale) -> bneg(); # -pi
}
} elsif ($x > 0) { # 0 < x < inf
if ($y -> is_inf("+")) { # y = inf
$y -> bpi($scale) -> bmul("0.5"); # pi/2
} elsif ($y -> is_inf("-")) { # y = -inf
$y -> bpi($scale) -> bmul("-0.5"); # -pi/2
} else { # -inf < y < inf
$y -> bdiv($x, $scale) -> batan($scale); # atan(y/x)
}
} elsif ($x < 0) { # -inf < x < 0
my $pi = $class -> bpi($scale);
if ($y >= 0) { # y >= 0
$y -> bdiv($x, $scale) -> batan() # atan(y/x) + pi
-> badd($pi);
} else { # y < 0
$y -> bdiv($x, $scale) -> batan() # atan(y/x) - pi
-> bsub($pi);
}
} else { # x = 0
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
return $x;
}
# Bitwise right shift.
sub bbrsft {
# We don't call objectify(), because the bitwise methods should not
# upgrade, even when upgrading is enabled.
my ($class, $x, $y, @r) = ref($_[0]) ? (ref($_[0]), @_) : @_;
# Don't modify constant (read-only) objects.
return $x if $x -> modify('bbrsft');
# Let Math::BigInt do the job.
my $xint = Math::BigInt -> bbrsft($x, $y, @r);
# Temporarily disable downgrading.
my $dng = $class -> downgrade();
$class -> downgrade(undef);
# Convert to our class without downgrading.
my $xflt = $class -> new($xint);
# Reset downgrading.
$class -> downgrade($dng);
# If we are called as a class method, the first operand might not be an
# object of this class, so check.
if (defined(blessed($x)) && $x -> isa(__PACKAGE__)) {
$x -> {sign} = $xflt -> {sign};
$x -> {_m} = $xflt -> {_m};
$x -> {_es} = $xflt -> {_es};
$x -> {_e} = $xflt -> {_e};
} else {
$x = $xflt;
}
# Now we might downgrade.
$x -> round(@r);
$x -> _dng();
return $x;
}
sub band {
my ($class, $x, $y, @r) = ref($_[0]) && ref($_[0]) eq ref($_[1])
? (ref($_[0]), @_)
: objectify(2, @_);
# Don't modify constant (read-only) objects.
return if $x -> modify('band');
# If $x and/or $y is Inf or NaN, return NaN.
return $x -> bnan(@r) if ($x -> is_nan() || $x -> is_inf() ||
$y -> is_nan() || $y -> is_inf());
# This should be implemented without converting to Math::BigInt. XXX
my $xint = $x -> as_int(); # to Math::BigInt
my $yint = $y -> as_int(); # to Math::BigInt
$xint -> band($yint);
$xint -> round(@r);
my $xflt = $xint -> as_float();
$x -> {sign} = $xflt -> {sign};
$x -> {_m} = $xflt -> {_m};
$x -> {_es} = $xflt -> {_es};
$x -> {_e} = $xflt -> {_e};
return $x -> _dng();
return $x;
}
sub bior {
my ($class, $x, $y, @r) = ref($_[0]) && ref($_[0]) eq ref($_[1])
? (ref($_[0]), @_)
: objectify(2, @_);
# Don't modify constant (read-only) objects.
return if $x -> modify('bior');
# If $x and/or $y is Inf or NaN, return NaN.
return $x -> bnan(@r) if ($x -> is_nan() || $x -> is_inf() ||
$y -> is_nan() || $y -> is_inf());
# This should be implemented without converting to Math::BigInt. XXX
my $xint = $x -> as_int(); # to Math::BigInt
my $yint = $y -> as_int(); # to Math::BigInt
$xint -> bior($yint);
$xint -> round(@r);
my $xflt = $xint -> as_float();
$x -> {sign} = $xflt -> {sign};
$x -> {_m} = $xflt -> {_m};
$x -> {_es} = $xflt -> {_es};
$x -> {_e} = $xflt -> {_e};
return $x -> _dng();
return $x;
}
sub bxor {
my ($class, $x, $y, @r) = ref($_[0]) && ref($_[0]) eq ref($_[1])
? (ref($_[0]), @_)
: objectify(2, @_);
# Don't modify constant (read-only) objects.
return if $x -> modify('bxor');
# If $x and/or $y is Inf or NaN, return NaN.
return $x -> bnan(@r) if ($x -> is_nan() || $x -> is_inf() ||
$y -> is_nan() || $y -> is_inf());
# This should be implemented without converting to Math::BigInt. XXX
my $xint = $x -> as_int(); # to Math::BigInt
my $yint = $y -> as_int(); # to Math::BigInt
$xint -> bxor($yint);
$xint -> round(@r);
my $xflt = $xint -> as_float();
$x -> {sign} = $xflt -> {sign};
$x -> {_m} = $xflt -> {_m};
$x -> {_es} = $xflt -> {_es};
$x -> {_e} = $xflt -> {_e};
return $x -> _dng();
return $x;
}
sub bnot {
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
# Don't modify constant (read-only) objects.
return if $x -> modify('bnot');
return $x -> bnan(@r) if $x -> is_nan();
# This should be implemented without converting to Math::BigInt. XXX
my $xint = $x -> as_int(); # to Math::BigInt
$xint -> bnot();
$xint -> round(@r);
my $xflt = $xint -> as_float();
$x -> {sign} = $xflt -> {sign};
$x -> {_m} = $xflt -> {_m};
$x -> {_es} = $xflt -> {_es};
$x -> {_e} = $xflt -> {_e};
return $x -> _dng();
return $x;
}
###############################################################################
# Rounding methods
###############################################################################
sub bround {
# accuracy: preserve $N digits, and overwrite the rest with 0's
my ($class, $x, @a) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
if (($a[0] || 0) < 0) {
croak('bround() needs positive accuracy');
}
# Don't modify constant (read-only) objects.
return $x if $x -> modify('bround');
my ($scale, $mode) = $x->_scale_a(@a);
if (!defined $scale) { # no-op
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
# Scale is now either $x->{accuracy}, $accuracy, or the input argument.
# Test whether $x already has lower accuracy, do nothing in this case but
# do round if the accuracy is the same, since a math operation might want
# to round a number with A=5 to 5 digits afterwards again
if (defined $x->{accuracy} && $x->{accuracy} < $scale) {
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
# scale < 0 makes no sense
# scale == 0 => keep all digits
# never round a +-inf, NaN
if ($scale <= 0 || $x->{sign} !~ /^[+-]$/) {
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
# 1: never round a 0
# 2: if we should keep more digits than the mantissa has, do nothing
if ($x -> is_zero() || $LIB->_len($x->{_m}) <= $scale) {
$x->{accuracy} = $scale if !defined $x->{accuracy} || $x->{accuracy} > $scale;
$x -> _dng() if $x -> is_int();
return $x;
}
# pass sign to bround for '+inf' and '-inf' rounding modes
my $m = bless { sign => $x->{sign}, value => $x->{_m} }, 'Math::BigInt';
$m = $m -> bround($scale, $mode); # round mantissa
$x->{_m} = $m->{value}; # get our mantissa back
$x->{accuracy} = $scale; # remember rounding
$x->{precision} = undef; # and clear P
# bnorm() downgrades if necessary, so no need to check whether to
# downgrade.
$x -> bnorm(); # del trailing zeros gen. by bround()
}
sub bfround {
# precision: round to the $Nth digit left (+$n) or right (-$n) from the '.'
# $n == 0 means round to integer
# expects and returns normalized numbers!
my ($class, $x, @p) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
# Don't modify constant (read-only) objects.
return $x if $x -> modify('bfround'); # no-op
my ($scale, $mode) = $x->_scale_p(@p);
if (!defined $scale) {
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
# never round a 0, +-inf, NaN
if ($x -> is_zero()) {
$x->{precision} = $scale if !defined $x->{precision} || $x->{precision} < $scale; # -3 < -2
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
if ($x->{sign} !~ /^[+-]$/) {
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
# don't round if x already has lower precision
if (defined $x->{precision} && $x->{precision} < 0 && $scale < $x->{precision}) {
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
$x->{precision} = $scale; # remember round in any case
$x->{accuracy} = undef; # and clear A
if ($scale < 0) {
# round right from the '.'
if ($x->{_es} eq '+') { # e >= 0 => nothing to round
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
}
$scale = -$scale; # positive for simplicity
my $len = $LIB->_len($x->{_m}); # length of mantissa
# the following poses a restriction on _e, but if _e is bigger than a
# scalar, you got other problems (memory etc) anyway
my $dad = -(0+ ($x->{_es}.$LIB->_num($x->{_e}))); # digits after dot
my $zad = 0; # zeros after dot
$zad = $dad - $len if (-$dad < -$len); # for 0.00..00xxx style
# print "scale $scale dad $dad zad $zad len $len\n";
# number bsstr len zad dad
# 0.123 123e-3 3 0 3
# 0.0123 123e-4 3 1 4
# 0.001 1e-3 1 2 3
# 1.23 123e-2 3 0 2
# 1.2345 12345e-4 5 0 4
# do not round after/right of the $dad
if ($scale > $dad) { # 0.123, scale >= 3 => exit
$x -> _dng() if ($x -> is_int() ||
$x -> is_inf() ||
$x -> is_nan());
return $x;
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
return $x -> sparts() if $x -> is_nan() || $x -> is_inf();
# Finite number.
my ($mant, $expo) = $x -> sparts();
if ($mant -> bcmp(0)) {
my ($ndigtot, $ndigfrac) = $mant -> length();
my $expo10adj = $ndigtot - $ndigfrac - 1;
if ($expo10adj > 0) { # if mantissa is not an integer
$mant = $mant -> brsft($expo10adj, 10);
return $mant unless wantarray;
$expo = $expo -> badd($expo10adj);
return $mant, $expo;
}
}
return $mant unless wantarray;
return $mant, $expo;
}
# Parts used for engineering notation with significand/mantissa as either 0 or
# a number in the semi-open interval [1,1000) and the exponent is a multiple of
# 3. E.g., "12345.6789" is returned as "12.3456789" and "3".
sub eparts {
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
# Not-a-number and Infinity.
return $x -> sparts() if $x -> is_nan() || $x -> is_inf();
# Finite number.
my ($mant, $expo) = $x -> nparts();
my $c = $expo -> copy() -> bmod(3);
$mant = $mant -> blsft($c, 10);
return $mant unless wantarray;
$expo = $expo -> bsub($c);
return $mant, $expo;
}
# Parts used for decimal notation, e.g., "12345.6789" is returned as "12345"
# (integer part) and "0.6789" (fraction part).
sub dparts {
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
# Not-a-number.
if ($x -> is_nan()) {
my $int = $class -> bnan();
return $int unless wantarray;
my $frc = $class -> bzero(); # or NaN?
return $int, $frc;
}
# Infinity.
if ($x -> is_inf()) {
my $int = $class -> binf($x->{sign});
return $int unless wantarray;
my $frc = $class -> bzero();
return $int, $frc;
}
# Finite number.
my $int = $x -> copy();
my $frc;
# If the input is an integer.
if ($int->{_es} eq '+') {
$frc = $class -> bzero();
}
# If the input has a fraction part
else {
$int->{_m} = $LIB -> _rsft($int->{_m}, $int->{_e}, 10);
$int->{_e} = $LIB -> _zero();
$int->{_es} = '+';
$int->{sign} = '+' if $LIB->_is_zero($int->{_m}); # avoid -0
return $int unless wantarray;
$frc = $x -> copy() -> bsub($int);
return $int, $frc;
}
$int -> _dng();
return $int unless wantarray;
return $int, $frc;
}
# Fractional parts with the numerator and denominator as integers. E.g.,
# "123.4375" is returned as "1975" and "16".
sub fparts {
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
# NaN => NaN/NaN
if ($x -> is_nan()) {
return $class -> bnan() unless wantarray;
return $class -> bnan(), $class -> bnan();
}
# ±Inf => ±Inf/1
if ($x -> is_inf()) {
my $numer = $class -> binf($x->{sign});
return $numer unless wantarray;
my $denom = $class -> bone();
return $numer, $denom;
}
# Finite number.
# If we get here, we know that the output is an integer.
$class = $downgrade if $class -> downgrade();
my @flt_parts = ($x->{sign}, $x->{_m}, $x->{_es}, $x->{_e});
my @rat_parts = $class -> _flt_lib_parts_to_rat_lib_parts(@flt_parts);
my $num = $class -> new($LIB -> _str($rat_parts[1]));
my $den = $class -> new($LIB -> _str($rat_parts[2]));
$num = $num -> bneg() if $rat_parts[0] eq "-";
return $num unless wantarray;
return $num, $den;
}
# Given "123.4375", returns "1975", since "123.4375" is "1975/16".
sub numerator {
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
return $class -> bnan() if $x -> is_nan();
return $class -> binf($x -> sign()) if $x -> is_inf();
return $class -> bzero() if $x -> is_zero();
# If we get here, we know that the output is an integer.
$class = $downgrade if $class -> downgrade();
if ($x -> {_es} eq '-') { # exponent < 0
my $numer_lib = $LIB -> _copy($x -> {_m});
my $denom_lib = $LIB -> _1ex($x -> {_e});
my $gcd_lib = $LIB -> _gcd($LIB -> _copy($numer_lib), $denom_lib);
$numer_lib = $LIB -> _div($numer_lib, $gcd_lib);
return $class -> new($x -> {sign} . $LIB -> _str($numer_lib));
}
elsif (! $LIB -> _is_zero($x -> {_e})) { # exponent > 0
my $numer_lib = $LIB -> _copy($x -> {_m});
$numer_lib = $LIB -> _lsft($numer_lib, $x -> {_e}, 10);
return $class -> new($x -> {sign} . $LIB -> _str($numer_lib));
}
else { # exponent = 0
return $class -> new($x -> {sign} . $LIB -> _str($x -> {_m}));
}
}
# Given "123.4375", returns "16", since "123.4375" is "1975/16".
sub denominator {
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
return $class -> bnan() if $x -> is_nan();
# If we get here, we know that the output is an integer.
$class = $downgrade if $class -> downgrade();
if ($x -> {_es} eq '-') { # exponent < 0
my $numer_lib = $LIB -> _copy($x -> {_m});
my $denom_lib = $LIB -> _1ex($x -> {_e});
my $gcd_lib = $LIB -> _gcd($LIB -> _copy($numer_lib), $denom_lib);
$denom_lib = $LIB -> _div($denom_lib, $gcd_lib);
return $class -> new($LIB -> _str($denom_lib));
}
else { # exponent >= 0
return $class -> bone();
}
}
###############################################################################
# String conversion methods
###############################################################################
sub bstr {
# (ref to BFLOAT or num_str) return num_str
# Convert number from internal format to (non-scientific) string format.
# internal format is always normalized (no leading zeros, "-0" => "+0")
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
# Inf and NaN
if ($x->{sign} ne '+' && $x->{sign} ne '-') {
return $x->{sign} unless $x -> is_inf("+"); # -inf, NaN
return 'inf'; # +inf
}
# Finite number
my $es = '0';
my $len = 1;
my $cad = 0;
my $dot = '.';
# $x is zero?
my $not_zero = !($x->{sign} eq '+' && $LIB->_is_zero($x->{_m}));
if ($not_zero) {
$es = $LIB->_str($x->{_m});
$len = CORE::length($es);
my $e = $LIB->_num($x->{_e});
$e = -$e if $x->{_es} eq '-';
if ($e < 0) {
$dot = '';
# if _e is bigger than a scalar, the following will blow your memory
if ($e <= -$len) {
my $r = abs($e) - $len;
$es = '0.'. ('0' x $r) . $es;
$cad = -($len+$r);
} else {
substr($es, $e, 0) = '.';
$cad = $LIB->_num($x->{_e});
$cad = -$cad if $x->{_es} eq '-';
}
} elsif ($e > 0) {
# expand with zeros
$es .= '0' x $e;
$len += $e;
$cad = 0;
}
} # if not zero
$es = '-'.$es if $x->{sign} eq '-';
# if set accuracy or precision, pad with zeros on the right side
if ((defined $x->{accuracy}) && ($not_zero)) {
# 123400 => 6, 0.1234 => 4, 0.001234 => 4
my $zeros = $x->{accuracy} - $cad; # cad == 0 => 12340
$zeros = $x->{accuracy} - $len if $cad != $len;
$es .= $dot.'0' x $zeros if $zeros > 0;
} elsif ((($x->{precision} || 0) < 0)) {
# 123400 => 6, 0.1234 => 4, 0.001234 => 6
my $zeros = -$x->{precision} + $cad;
$es .= $dot.'0' x $zeros if $zeros > 0;
}
$es;
}
# Scientific notation with significand/mantissa and exponent as integers, e.g.,
# "12345.6789" is written as "123456789e-4".
sub bsstr {
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
# Inf and NaN
if ($x->{sign} ne '+' && $x->{sign} ne '-') {
return $x->{sign} unless $x -> is_inf("+"); # -inf, NaN
return 'inf'; # +inf
}
# Upgrade?
return $x -> _upg() -> bsstr(@r)
if $class -> upgrade() && !$x -> isa(__PACKAGE__);
# Round according to arguments or global settings, if any.
$x = $x -> copy() -> round(@r);
# Finite number
($x->{sign} eq '-' ? '-' : '') . $LIB->_str($x->{_m})
. 'e' . $x->{_es} . $LIB->_str($x->{_e});
}
# Normalized notation, e.g., "12345.6789" is written as "1.23456789e+4".
sub bnstr {
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
# Inf and NaN
if ($x->{sign} ne '+' && $x->{sign} ne '-') {
return $x->{sign} unless $x -> is_inf("+"); # -inf, NaN
return 'inf'; # +inf
}
# Upgrade?
return $x -> _upg() -> bnstr(@r)
if $class -> upgrade() && !$x -> isa(__PACKAGE__);
# Finite number
my $str = $x->{sign} eq '-' ? '-' : '';
# Round according to arguments or global settings, if any.
$x = $x -> copy() -> round(@r);
# Get the mantissa and the length of the mantissa.
my $mant = $LIB->_str($x->{_m});
my $mantlen = CORE::length($mant);
if ($mantlen == 1) {
# Not decimal point when the mantissa has length one, i.e., return the
# number 2 as the string "2", not "2.".
$str .= $mant . 'e' . $x->{_es} . $LIB->_str($x->{_e});
} else {
# Compute new exponent where the original exponent is adjusted by the
# length of the mantissa minus one (because the decimal point is after
# one digit).
my ($eabs, $esgn) = $LIB -> _sadd($LIB -> _copy($x->{_e}), $x->{_es},
$LIB -> _new($mantlen - 1), "+");
substr $mant, 1, 0, ".";
$str .= $mant . 'e' . $esgn . $LIB->_str($eabs);
}
return $str;
}
# Engineering notation, e.g., "12345.6789" is written as "12.3456789e+3".
sub bestr {
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
# Inf and NaN
if ($x->{sign} ne '+' && $x->{sign} ne '-') {
return $x->{sign} unless $x -> is_inf("+"); # -inf, NaN
return 'inf'; # +inf
}
# Upgrade?
return $x -> _upg() -> bestr(@r)
if $class -> upgrade() && !$x -> isa(__PACKAGE__);
# Round according to arguments or global settings, if any.
$x = $x -> copy() -> round(@r);
# Finite number
my $str = $x->{sign} eq '-' ? '-' : '';
# Get the mantissa, the length of the mantissa, and adjust the exponent by
# the length of the mantissa minus 1 (because the dot is after one digit).
my $mant = $LIB->_str($x->{_m});
my $mantlen = CORE::length($mant);
my ($eabs, $esgn) = $LIB -> _sadd($LIB -> _copy($x->{_e}), $x->{_es},
$LIB -> _new($mantlen - 1), "+");
my $dotpos = 1;
my $mod = $LIB -> _mod($LIB -> _copy($eabs), $LIB -> _new("3"));
unless ($LIB -> _is_zero($mod)) {
if ($esgn eq '+') {
$eabs = $LIB -> _sub($eabs, $mod);
$dotpos += $LIB -> _num($mod);
} else {
my $delta = $LIB -> _sub($LIB -> _new("3"), $mod);
$eabs = $LIB -> _add($eabs, $delta);
$dotpos += $LIB -> _num($delta);
}
}
if ($dotpos < $mantlen) {
substr $mant, $dotpos, 0, ".";
} elsif ($dotpos > $mantlen) {
$mant .= "0" x ($dotpos - $mantlen);
}
$str .= $mant . 'e' . $esgn . $LIB->_str($eabs);
return $str;
}
# Decimal notation, e.g., "12345.6789" (no exponent).
sub bdstr {
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
# Inf and NaN
if ($x->{sign} ne '+' && $x->{sign} ne '-') {
return $x->{sign} unless $x -> is_inf("+"); # -inf, NaN
return 'inf'; # +inf
}
# Upgrade?
return $x -> _upg() -> bdstr(@r)
if $class -> upgrade() && !$x -> isa(__PACKAGE__);
# Round according to arguments or global settings, if any.
$x = $x -> copy() -> round(@r);
# Finite number
my $mant = $LIB->_str($x->{_m});
my $esgn = $x->{_es};
my $eabs = $LIB -> _num($x->{_e});
my $uintmax = ~0;
my $str = $mant;
if ($esgn eq '+') {
croak("The absolute value of the exponent is too large")
if $eabs > $uintmax;
$str .= "0" x $eabs;
} else {
my $mlen = CORE::length($mant);
my $c = $mlen - $eabs;
my $intmax = ($uintmax - 1) / 2;
croak("The absolute value of the exponent is too large")
if (1 - $c) > $intmax;
$str = "0" x (1 - $c) . $str if $c <= 0;
substr($str, -$eabs, 0) = '.';
}
return $x->{sign} eq '-' ? '-' . $str : $str;
}
# Fractional notation, e.g., "123.4375" is written as "1975/16".
sub bfstr {
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
# Inf and NaN
if ($x->{sign} ne '+' && $x->{sign} ne '-') {
return $x->{sign} unless $x -> is_inf("+"); # -inf, NaN
return 'inf'; # +inf
}
# Upgrade?
return $x -> _upg() -> bfstr(@r)
if $class -> upgrade() && !$x -> isa(__PACKAGE__);
# Finite number
my $str = $x->{sign} eq '-' ? '-' : '';
if ($x->{_es} eq '+') {
$str .= $LIB -> _str($x->{_m}) . ("0" x $LIB -> _num($x->{_e}));
} else {
my @flt_parts = ($x->{sign}, $x->{_m}, $x->{_es}, $x->{_e});
my @rat_parts = $class -> _flt_lib_parts_to_rat_lib_parts(@flt_parts);
$str = $LIB -> _str($rat_parts[1]) . "/" . $LIB -> _str($rat_parts[2]);
$str = "-" . $str if $rat_parts[0] eq "-";
}
return $str;
}
sub to_hex {
# return number as hexadecimal string (only for integers defined)
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
# Inf and NaN
if ($x->{sign} ne '+' && $x->{sign} ne '-') {
return $x->{sign} unless $x -> is_inf("+"); # -inf, NaN
return 'inf'; # +inf
}
# Upgrade?
return $x -> _upg() -> to_hex(@r)
if $class -> upgrade() && !$x -> isa(__PACKAGE__);
# Finite number
return '0' if $x -> is_zero();
return $nan if $x->{_es} ne '+'; # how to do 1e-1 in hex?
my $z = $LIB->_copy($x->{_m});
if (! $LIB->_is_zero($x->{_e})) { # > 0
$z = $LIB->_lsft($z, $x->{_e}, 10);
}
my $str = $LIB->_to_hex($z);
return $x->{sign} eq '-' ? "-$str" : $str;
}
sub to_oct {
# return number as octal digit string (only for integers defined)
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
# Inf and NaN
if ($x->{sign} ne '+' && $x->{sign} ne '-') {
return $x->{sign} unless $x -> is_inf("+"); # -inf, NaN
return 'inf'; # +inf
}
# Upgrade?
return $x -> _upg() -> to_oct(@r)
if $class -> upgrade() && !$x -> isa(__PACKAGE__);
# Finite number
return '0' if $x -> is_zero();
return $nan if $x->{_es} ne '+'; # how to do 1e-1 in octal?
my $z = $LIB->_copy($x->{_m});
if (! $LIB->_is_zero($x->{_e})) { # > 0
$z = $LIB->_lsft($z, $x->{_e}, 10);
}
my $str = $LIB->_to_oct($z);
return $x->{sign} eq '-' ? "-$str" : $str;
}
sub to_bin {
# return number as binary digit string (only for integers defined)
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), $_[0]) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
# Inf and NaN
if ($x->{sign} ne '+' && $x->{sign} ne '-') {
return $x->{sign} unless $x -> is_inf("+"); # -inf, NaN
return 'inf'; # +inf
}
# Upgrade?
return $x -> _upg() -> to_bin(@r)
if $class -> upgrade() && !$x -> isa(__PACKAGE__);
# Finite number
return '0' if $x -> is_zero();
return $nan if $x->{_es} ne '+'; # how to do 1e-1 in binary?
my $z = $LIB->_copy($x->{_m});
if (! $LIB->_is_zero($x->{_e})) { # > 0
$z = $LIB->_lsft($z, $x->{_e}, 10);
}
my $str = $LIB->_to_bin($z);
return $x->{sign} eq '-' ? "-$str" : $str;
}
sub to_bytes {
# return a byte string
my ($class, $x, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
croak("to_bytes() requires a finite, non-negative integer")
if $x -> is_neg() || ! $x -> is_int();
return $x -> _upg() -> to_bytes(@r)
if $class -> upgrade() && !$x -> isa(__PACKAGE__);
croak("to_bytes() requires a newer version of the $LIB library.")
unless $LIB -> can('_to_bytes');
return $LIB->_to_bytes($LIB -> _lsft($x->{_m}, $x->{_e}, 10));
}
sub to_ieee754 {
my ($class, $x, $format, @r) = ref($_[0]) ? (ref($_[0]), @_) : objectify(1, @_);
carp "Rounding is not supported for ", (caller(0))[3], "()" if @r;
my $enc; # significand encoding (applies only to decimal)
my $k; # storage width in bits
my $b; # base
if ($format =~ /^binary(\d+)\z/) {
$k = $1;
$b = 2;
} elsif ($format =~ /^decimal(\d+)(dpd|bcd)?\z/) {
$k = $1;
$b = 10;
$enc = $2 || 'dpd'; # default is dencely-packed decimals (DPD)
} elsif ($format eq 'half') {
$k = 16;
$b = 2;
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
$x->{accuracy} = undef;
$x->{precision} = undef;
}
# Restore globals. We need to do it like this, because setting one
# undefines the other.
if (defined $ab) {
$class -> accuracy($ab);
} else {
$class -> precision($pb);
}
$class -> upgrade($upg);
$class -> downgrade($dng);
$x;
}
# These functions are only provided for backwards compabibility so that old
# version of Math::BigRat etc. don't complain about missing them.
sub _e_add {
my ($x, $y, $xs, $ys) = @_;
return $LIB -> _sadd($x, $xs, $y, $ys);
}
sub _e_sub {
my ($x, $y, $xs, $ys) = @_;
return $LIB -> _ssub($x, $xs, $y, $ys);
}
1;
__END__
=pod
=head1 NAME
Math::BigFloat - arbitrary size floating point math package
=head1 SYNOPSIS
use Math::BigFloat;
# Configuration methods (may be used as class methods and instance methods)
Math::BigFloat->accuracy($n); # set accuracy
Math::BigFloat->accuracy(); # get accuracy
Math::BigFloat->precision($n); # set precision
Math::BigFloat->precision(); # get precision
Math::BigFloat->round_mode($m); # set rounding mode, must be
# 'even', 'odd', '+inf', '-inf',
# 'zero', 'trunc', or 'common'
Math::BigFloat->round_mode(); # get class rounding mode
Math::BigFloat->div_scale($n); # set fallback accuracy
Math::BigFloat->div_scale(); # get fallback accuracy
Math::BigFloat->trap_inf($b); # trap infinities or not
Math::BigFloat->trap_inf(); # get trap infinities status
Math::BigFloat->trap_nan($b); # trap NaNs or not
Math::BigFloat->trap_nan(); # get trap NaNs status
Math::BigFloat->config($par, $val); # set configuration parameter
Math::BigFloat->config($par); # get configuration parameter
Math::BigFloat->config(); # get hash with configuration
Math::BigFloat->config("lib"); # get name of backend library
# Generic constructor method (always returns a new object)
$x = Math::BigFloat->new($str); # defaults to 0
$x = Math::BigFloat->new('256'); # from decimal
$x = Math::BigFloat->new('0256'); # from decimal
$x = Math::BigFloat->new('0xcafe'); # from hexadecimal
$x = Math::BigFloat->new('0x1.cafep+7'); # from hexadecimal
$x = Math::BigFloat->new('0o377'); # from octal
$x = Math::BigFloat->new('0o1.3571p+6'); # from octal
$x = Math::BigFloat->new('0b101'); # from binary
$x = Math::BigFloat->new('0b1.101p+3'); # from binary
# Specific constructor methods (no prefix needed; when used as
# instance method, the value is assigned to the invocand)
$x = Math::BigFloat->from_dec('234'); # from decimal
$x = Math::BigFloat->from_hex('c.afep+3'); # from hexadecimal
$x = Math::BigFloat->from_hex('cafe'); # from hexadecimal
$x = Math::BigFloat->from_oct('1.3267p-4'); # from octal
$x = Math::BigFloat->from_oct('377'); # from octal
$x = Math::BigFloat->from_bin('0b1.1001p-4'); # from binary
$x = Math::BigFloat->from_bin('0101'); # from binary
$x = Math::BigFloat->from_bytes($bytes); # from byte string
$x = Math::BigFloat->from_base('why', 36); # from any base
$x = Math::BigFloat->from_ieee754($b, $fmt); # from IEEE-754 bytes
$x = Math::BigFloat->bzero(); # create a +0
$x = Math::BigFloat->bone(); # create a +1
$x = Math::BigFloat->bone('-'); # create a -1
$x = Math::BigFloat->binf(); # create a +inf
$x = Math::BigFloat->binf('-'); # create a -inf
$x = Math::BigFloat->bnan(); # create a Not-A-Number
$x = Math::BigFloat->bpi(); # returns pi
$y = $x->copy(); # make a copy (unlike $y = $x)
$y = $x->as_int(); # return as BigInt
$y = $x->as_float(); # return as a Math::BigFloat
$y = $x->as_rat(); # return as a Math::BigRat
# Boolean methods (these don't modify the invocand)
$x->is_zero(); # true if $x is 0
$x->is_one(); # true if $x is +1
$x->is_one("+"); # true if $x is +1
$x->is_one("-"); # true if $x is -1
$x->is_inf(); # true if $x is +inf or -inf
$x->is_inf("+"); # true if $x is +inf
$x->is_inf("-"); # true if $x is -inf
$x->is_nan(); # true if $x is NaN
$x->is_finite(); # true if -inf < $x < inf
$x->is_positive(); # true if $x > 0
$x->is_pos(); # true if $x > 0
$x->is_negative(); # true if $x < 0
$x->is_neg(); # true if $x < 0
$x->is_non_positive() # true if $x <= 0
$x->is_non_negative() # true if $x >= 0
$x->is_odd(); # true if $x is odd
$x->is_even(); # true if $x is even
$x->is_int(); # true if $x is an integer
# Comparison methods (these don't modify the invocand)
$x->bcmp($y); # compare numbers (undef, < 0, == 0, > 0)
$x->bacmp($y); # compare abs values (undef, < 0, == 0, > 0)
$x->beq($y); # true if $x == $y
$x->bne($y); # true if $x != $y
$x->blt($y); # true if $x < $y
$x->ble($y); # true if $x <= $y
$x->bgt($y); # true if $x > $y
$x->bge($y); # true if $x >= $y
# Arithmetic methods (these modify the invocand)
$x->bneg(); # negation
$x->babs(); # absolute value
$x->bsgn(); # sign function (-1, 0, 1, or NaN)
$x->binc(); # increment $x by 1
$x->bdec(); # decrement $x by 1
$x->badd($y); # addition (add $y to $x)
$x->bsub($y); # subtraction (subtract $y from $x)
$x->bmul($y); # multiplication (multiply $x by $y)
$x->bmuladd($y, $z); # $x = $x * $y + $z
$x->bdiv($y); # division (floored), set $x to quotient
$x->bmod($y); # modulus (x % y)
$x->bmodinv($mod); # modular multiplicative inverse
$x->bmodpow($y, $mod); # modular exponentiation (($x ** $y) % $mod)
$x->btdiv($y); # division (truncated), set $x to quotient
$x->btmod($y); # modulus (truncated)
$x->binv() # inverse (1/$x)
$x->bpow($y); # power of arguments (x ** y)
$x->blog(); # logarithm of $x to base e (Euler's number)
$x->blog($base); # logarithm of $x to base $base (e.g., base 2)
$x->bexp(); # calculate e ** $x where e is Euler's number
$x->bilog2(); # log2($x) rounded down to nearest int
$x->bilog10(); # log10($x) rounded down to nearest int
$x->bclog2(); # log2($x) rounded up to nearest int
$x->bclog10(); # log10($x) rounded up to nearest int
$x->bnok($y); # combinations (binomial coefficient n over k)
$x->bperm($y); # permutations
$x->bsin(); # sine
$x->bcos(); # cosine
$x->batan(); # inverse tangent
$x->batan2($y); # two-argument inverse tangent
$x->bsqrt(); # calculate square root
$x->broot($y); # $y'th root of $x (e.g. $y == 3 => cubic root)
$x->bfac(); # factorial of $x (1*2*3*4*..$x)
$x->bdfac(); # double factorial of $x ($x*($x-2)*($x-4)*...)
$x->btfac(); # triple factorial of $x ($x*($x-3)*($x-6)*...)
$x->bmfac($k); # $k'th multi-factorial of $x ($x*($x-$k)*...)
$x->bfib($k); # $k'th Fibonacci number
$x->blucas($k); # $k'th Lucas number
$x->blsft($n); # left shift $n places in base 2
$x->blsft($n, $b); # left shift $n places in base $b
$x->brsft($n); # right shift $n places in base 2
$x->brsft($n, $b); # right shift $n places in base $b
# Bitwise methods (these modify the invocand)
$x->bblsft($y); # bitwise left shift
$x->bbrsft($y); # bitwise right shift
$x->band($y); # bitwise and
$x->bior($y); # bitwise inclusive or
$x->bxor($y); # bitwise exclusive or
$x->bnot(); # bitwise not (two's complement)
# Rounding methods (these modify the invocand)
$x->round($A, $P, $R); # round to accuracy or precision using
# rounding mode $R
$x->bround($n); # accuracy: preserve $n digits
$x->bfround($n); # $n > 0: round to $nth digit left of dec. point
# $n < 0: round to $nth digit right of dec. point
$x->bfloor(); # round towards minus infinity
$x->bceil(); # round towards plus infinity
$x->bint(); # round towards zero
# Other mathematical methods (these don't modify the invocand)
$x->bgcd($y); # greatest common divisor
$x->blcm($y); # least common multiple
# Object property methods (these don't modify the invocand)
$x->sign(); # the sign, either +, - or NaN
$x->digit($n); # the nth digit, counting from the right
$x->digit(-$n); # the nth digit, counting from the left
$x->length(); # return number of digits in number
$x->mantissa(); # return (signed) mantissa as BigInt
$x->exponent(); # return exponent as BigInt
$x->parts(); # return (mantissa,exponent) as BigInt
$x->sparts(); # mantissa and exponent (as integers)
$x->nparts(); # mantissa and exponent (normalised)
$x->eparts(); # mantissa and exponent (engineering notation)
$x->dparts(); # integer and fraction part
$x->fparts(); # numerator and denominator
$x->numerator(); # numerator
$x->denominator(); # denominator
# Conversion methods (these don't modify the invocand)
$x->bstr(); # decimal notation (possibly zero padded)
$x->bsstr(); # string in scientific notation with integers
$x->bnstr(); # string in normalized notation
$x->bestr(); # string in engineering notation
$x->bdstr(); # string in decimal notation (no padding)
$x->bfstr(); # string in fractional notation
$x->to_hex(); # as signed hexadecimal string
$x->to_bin(); # as signed binary string
$x->to_oct(); # as signed octal string
$x->to_bytes(); # as byte string
$x->to_ieee754($fmt); # to bytes encoded according to IEEE 754-2008
$x->as_hex(); # as signed hexadecimal string with "0x" prefix
$x->as_bin(); # as signed binary string with "0b" prefix
$x->as_oct(); # as signed octal string with "0" prefix
# Other conversion methods (these don't modify the invocand)
$x->numify(); # return as scalar (might overflow or underflow)
=head1 DESCRIPTION
Math::BigFloat provides support for arbitrary precision floating point.
Overloading is also provided for Perl operators.
All operators (including basic math operations) are overloaded if you
declare your big floating point numbers as
$x = Math::BigFloat -> new('12_3.456_789_123_456_789E-2');
Operations with overloaded operators preserve the arguments, which is
exactly what you expect.
=head2 Input
Input values to these routines may be any scalar number or string that looks
like a number. Anything that is accepted by Perl as a literal numeric constant
should be accepted by this module.
=over
=item *
Leading and trailing whitespace is ignored.
=item *
Leading zeros are ignored, except for floating point numbers with a binary
exponent, in which case the number is interpreted as an octal floating point
number. For example, "01.4p+0" gives 1.5, "00.4p+0" gives 0.5, but "0.4p+0"
gives a NaN. And while "0377" gives 255, "0377p0" gives 255.
=item *
If the string has a "0x" or "0X" prefix, it is interpreted as a hexadecimal
number.
=item *
If the string has a "0o" or "0O" prefix, it is interpreted as an octal number.
A floating point literal with a "0" prefix is also interpreted as an octal
number.
=item *
If the string has a "0b" or "0B" prefix, it is interpreted as a binary number.
=item *
Underline characters are allowed in the same way as they are allowed in literal
numerical constants.
=item *
If the string can not be interpreted, NaN is returned.
=item *
For hexadecimal, octal, and binary floating point numbers, the exponent must be
separated from the significand (mantissa) by the letter "p" or "P", not "e" or
"E" as with decimal numbers.
=back
Some examples of valid string input
Input string Resulting value
123 123
1.23e2 123
12300e-2 123
67_538_754 67538754
-4_5_6.7_8_9e+0_1_0 -4567890000000
0x13a 314
0x13ap0 314
0x1.3ap+8 314
0x0.00013ap+24 314
0x13a000p-12 314
0o472 314
0o1.164p+8 314
0o0.0001164p+20 314
0o1164000p-10 314
0472 472 Note!
01.164p+8 314
00.0001164p+20 314
01164000p-10 314
0b100111010 314
0b1.0011101p+8 314
0b0.00010011101p+12 314
0b100111010000p-3 314
0x1.921fb5p+1 3.14159262180328369140625e+0
0o1.2677025p1 2.71828174591064453125
01.2677025p1 2.71828174591064453125
0b1.1001p-4 9.765625e-2
=head2 Output
Output values are usually Math::BigFloat objects.
Boolean operators L<is_zero()|Math::BigInt/is_zero()>,
L<is_one()|Math::BigInt/is_one()>, L<is_inf()|Math::BigInt/is_inf()>, etc.
return true or false.
Comparison operators L<bcmp()|Math::BigInt/bcmp()> and
L<bacmp()|Math::BigInt/bacmp()>) return -1, 0, 1, or undef.
=head1 METHODS
Math::BigFloat supports all methods that Math::BigInt supports, except it
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
$A = $x->accuracy(); # read out accuracy that affects $x
$A = CLASS->accuracy(); # read out global accuracy
Set or get the global or local accuracy, aka how many significant digits the
results have. If you set a global accuracy, then this also applies to new()!
Warning! The accuracy I<sticks>, e.g. once you created a number under the
influence of C<< CLASS->accuracy($A) >>, all results from math operations with
that number will also be rounded.
In most cases, you should probably round the results explicitly using one of
L<Math::BigInt/round()>, L<Math::BigInt/bround()> or L<Math::BigInt/bfround()>
or by passing the desired accuracy to the math operation as additional
parameter:
my $x = Math::BigInt->new(30000);
my $y = Math::BigInt->new(7);
print scalar $x->copy()->bdiv($y, 2); # print 4300
print scalar $x->copy()->bdiv($y)->bround(2); # print 4300
=item precision()
$x->precision(-2); # local for $x, round at the second
# digit right of the dot
$x->precision(2); # ditto, round at the second digit
# left of the dot
CLASS->precision(5); # Global for all members of CLASS
# This also applies to new()!
CLASS->precision(-5); # ditto
$P = CLASS->precision(); # read out global precision
$P = $x->precision(); # read out precision that affects $x
Note: You probably want to use L</accuracy()> instead. With L</accuracy()> you
set the number of digits each result should have, with L</precision()> you
set the place where to round!
=back
=head2 Constructor methods
=over
=item from_dec()
$x -> from_hex("314159");
$x = Math::BigInt -> from_hex("314159");
Interpret input as a decimal. It is equivalent to new(), but does not accept
anything but strings representing finite, decimal numbers.
=item from_hex()
$x -> from_hex("0x1.921fb54442d18p+1");
$x = Math::BigFloat -> from_hex("0x1.921fb54442d18p+1");
Interpret input as a hexadecimal string.A prefix ("0x", "x", ignoring case) is
optional. A single underscore character ("_") may be placed between any two
digits. If the input is invalid, a NaN is returned. The exponent is in base 2
using decimal digits.
If called as an instance method, the value is assigned to the invocand.
=item from_oct()
$x -> from_oct("1.3267p-4");
$x = Math::BigFloat -> from_oct("1.3267p-4");
Interpret input as an octal string. A single underscore character ("_") may be
placed between any two digits. If the input is invalid, a NaN is returned. The
exponent is in base 2 using decimal digits.
If called as an instance method, the value is assigned to the invocand.
=item from_bin()
$x -> from_bin("0b1.1001p-4");
$x = Math::BigFloat -> from_bin("0b1.1001p-4");
Interpret input as a hexadecimal string. A prefix ("0b" or "b", ignoring case)
is optional. A single underscore character ("_") may be placed between any two
digits. If the input is invalid, a NaN is returned. The exponent is in base 2
using decimal digits.
If called as an instance method, the value is assigned to the invocand.
=item from_bytes()
$x = Math::BigFloat->from_bytes("\xf3\x6b"); # $x = 62315
Interpret the input as a byte string, assuming big endian byte order. The
output is always a non-negative, finite integer.
See L<Math::BigInt/from_bytes()>.
=item from_ieee754()
Interpret the input as a value encoded as described in IEEE754-2008. The input
can be given as a byte string, hex string, or binary string. The input is
assumed to be in big-endian byte-order.
# Both $dbl, $xr, $xh, and $xb below are 3.141592...
$dbl = unpack "d>", "\x40\x09\x21\xfb\x54\x44\x2d\x18";
$raw = "\x40\x09\x21\xfb\x54\x44\x2d\x18"; # raw bytes
$xr = Math::BigFloat -> from_ieee754($raw, "binary64");
$hex = "400921fb54442d18";
$xh = Math::BigFloat -> from_ieee754($hex, "binary64");
$bin = "0100000000001001001000011111101101010100010001000010110100011000";
$xb = Math::BigFloat -> from_ieee754($bin, "binary64");
Supported formats are all IEEE 754 binary formats: "binary16", "binary32",
"binary64", "binary128", "binary160", "binary192", "binary224", "binary256",
etc. where the number of bits is a multiple of 32 for all formats larger than
"binary128". Aliases are "half" ("binary16"), "single" ("binary32"), "double"
("binary64"), "quadruple" ("binary128"), "octuple" ("binary256"), and
"sexdecuple" ("binary512").
See also L</to_ieee754()>.
=item from_base()
See L<Math::BigInt/from_base()>.
=item bpi()
print Math::BigFloat->bpi(100), "\n";
Calculate PI to N digits (including the 3 before the dot). The result is
rounded according to the current rounding mode, which defaults to "even".
This method was added in v1.87 of Math::BigInt (June 2007).
=item as_int()
$y = $x -> as_int(); # $y is a Math::BigInt
Returns $x as a Math::BigInt object regardless of upgrading and downgrading. If
$x is finite, but not an integer, $x is truncated.
cpan/Math-BigInt/lib/Math/BigFloat.pm view on Meta::CPAN
B<Note>: General purpose packages should not be explicit about the library to
use; let the script author decide which is best.
Note: The keyword 'lib' will warn when the requested library could not be
loaded. To suppress the warning use 'try' instead:
use Math::BigFloat try => "GMP";
If your script works with huge numbers and Calc is too slow for them, you can
also for the loading of one of these libraries and if none of them can be used,
the code will die:
use Math::BigFloat only => "GMP,Pari";
The following would first try to find Math::BigInt::Foo, then
Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc:
use Math::BigFloat lib => "Foo,Math::BigInt::Bar";
See the respective low-level library documentation for further details.
See L<Math::BigInt> for more details about using a different low-level library.
=head1 EXPORTS
C<Math::BigFloat> exports nothing by default, but can export the L</bpi()>
method:
use Math::BigFloat qw/bpi/;
print bpi(10), "\n";
=over
=item Modifying and =
Beware of:
$x = Math::BigFloat->new(5);
$y = $x;
It will not do what you think, e.g. making a copy of $x. Instead it just makes
a second reference to the B<same> object and stores it in $y. Thus anything
that modifies $x will modify $y (except overloaded math operators), and vice
versa. See L<Math::BigInt> for details and how to avoid that.
=item precision() vs. accuracy()
A common pitfall is to use L</precision()> when you want to round a result to
a certain number of digits:
use Math::BigFloat;
Math::BigFloat->precision(4); # does not do what you
# think it does
my $x = Math::BigFloat->new(12345); # rounds $x to "12000"!
print "$x\n"; # print "12000"
my $y = Math::BigFloat->new(3); # rounds $y to "0"!
print "$y\n"; # print "0"
$z = $x / $y; # 12000 / 0 => NaN!
print "$z\n";
print $z->precision(),"\n"; # 4
Replacing L</precision()> with L</accuracy()> is probably not what you want,
either:
use Math::BigFloat;
Math::BigFloat->accuracy(4); # enables global rounding:
my $x = Math::BigFloat->new(123456); # rounded immediately
# to "12350"
print "$x\n"; # print "123500"
my $y = Math::BigFloat->new(3); # rounded to "3
print "$y\n"; # print "3"
print $z = $x->copy()->bdiv($y),"\n"; # 41170
print $z->accuracy(),"\n"; # 4
What you want to use instead is:
use Math::BigFloat;
my $x = Math::BigFloat->new(123456); # no rounding
print "$x\n"; # print "123456"
my $y = Math::BigFloat->new(3); # no rounding
print "$y\n"; # print "3"
print $z = $x->copy()->bdiv($y,4),"\n"; # 41150
print $z->accuracy(),"\n"; # undef
In addition to computing what you expected, the last example also does B<not>
"taint" the result with an accuracy or precision setting, which would
influence any further operation.
=back
=head1 BUGS
Please report any bugs or feature requests to
C<bug-math-bigint at rt.cpan.org>, or through the web interface at
L<https://rt.cpan.org/Ticket/Create.html?Queue=Math-BigInt> (requires login).
We will be notified, and then you'll automatically be notified of progress on
your bug as I make changes.
=head1 SUPPORT
You can find documentation for this module with the perldoc command.
perldoc Math::BigFloat
You can also look for information at:
=over 4
=item * GitHub
L<https://github.com/pjacklam/p5-Math-BigInt>
=item * RT: CPAN's request tracker
L<https://rt.cpan.org/Dist/Display.html?Name=Math-BigInt>
( run in 0.400 second using v1.01-cache-2.11-cpan-1dc43b0fbd2 )