1N/A# Mike grinned. 'Two down, infinity to go' - Mike Nostrus in 'Before and After' 1N/A# The following hash values are internally used: 1N/A# _e : exponent (ref to $CALC object) 1N/A# _m : mantissa (ref to $CALC object) 1N/A# sign : +,-,+inf,-inf, or "NaN" if not a number 1N/A# $_trap_inf and $_trap_nan are internal and should never be accessed from the outside 1N/A'<=>' =>
sub { $_[
2] ?
1N/A############################################################################## 1N/A# global constants, flags and assorted stuff 1N/A# the following are public, but their usage is not recommended. Use the 1N/A# accessor methods instead. 1N/A# class constants, use Class->constant_name() to access 1N/A$
round_mode =
'even';
# one of 'even', 'odd', '+inf', '-inf', 'zero' or 'trunc' 1N/A# the package we are using for our private parts, defaults to: 1N/A# Math::BigInt->config()->{lib} 1N/Amy $
MBI =
'Math::BigInt::Calc';
1N/A# are NaNs ok? (otherwise it dies when encountering an NaN) set w/ config() 1N/A# the same for infinity 1N/A# constant for easier life 1N/Amy $
IMPORT =
0;
# was import() called yet? used to make require work 1N/A# some digits of accuracy for blog(undef,10); which we use in blog() for speed 1N/A '2.3025850929940456840179914546843642076011014886287729760333279009675726097';
1N/A '0.6931471805599453094172321214581765680755001343602552541206800094933936220';
1N/Amy $
HALF =
'0.5';
# made into an object if necc. 1N/A############################################################################## 1N/A# the old code had $rnd_mode, so we need to support it, too 1N/A # when someone set's $rnd_mode, we catch this and check the value to see 1N/A # whether it is valid or not. 1N/A############################################################################## 1N/A # valid method aliases for AUTOLOAD 1N/A # valid method's that can be hand-ed up (for AUTOLOAD) 1N/A############################################################################## 1N/A # create a new BigFloat object from a string or another bigfloat object. 1N/A # sign => sign (+/-), or "NaN" 1N/A # avoid numify-calls by not using || on $wanted! 1N/A # shortcut for bigints and its subclasses 1N/A # handle '+inf', '-inf' first 1N/A Carp::
croak (
"$wanted is not a number initialized to $class");
1N/A # make integer from mantissa by adjusting exp, then convert to int 1N/A # 3.123E0 = 3123E-3, and 3.123E-2 => 3123E-5 1N/A # we can only have trailing zeros on the mantissa of $$mfv eq '' 1N/A # for something like 0Ey, set y to 1, and -0 => +0 1N/A # if downgrade, inf, NaN or integers go down 1N/A # if two arguments, the first one is the class to "swallow" subclasses 1N/A return unless ref($x);
# only for objects 1N/A # used by parent class bone() to initialize number to NaN 1N/A Carp::
croak (
"Tried to set $self to NaN in $class\::_bnan()");
1N/A # used by parent class bone() to initialize number to +-inf 1N/A Carp::
croak (
"Tried to set $self to +-inf in $class\::_binf()");
1N/A # used by parent class bone() to initialize number to 1 1N/A # used by parent class bone() to initialize number to 0 1N/A # return (later set?) configuration data as hash ref 1N/A # now we need only to override the ones that are different from our parent 1N/A############################################################################## 1N/A# string conversation 1N/A # (ref to BFLOAT or num_str ) return num_str 1N/A # Convert number from internal format to (non-scientific) string format. 1N/A # internal format is always normalized (no leading zeros, "-0" => "+0") 1N/A return $x->{
sign}
unless $x->{
sign}
eq '+inf';
# -inf, NaN 1N/A return 'inf';
# +inf 1N/A # if _e is bigger than a scalar, the following will blow your memory 1N/A # if set accuracy or precision, pad with zeros on the right side 1N/A # 123400 => 6, 0.1234 => 4, 0.001234 => 4 1N/A elsif ((($x->{
_p} ||
0) <
0))
1N/A # 123400 => 6, 0.1234 => 4, 0.001234 => 6 1N/A # (ref to BFLOAT or num_str ) return num_str 1N/A # Convert number from internal format to scientific string format. 1N/A # internal format is always normalized (no leading zeros, "-0E0" => "+0E0") 1N/A return $x->{
sign}
unless $x->{
sign}
eq '+inf';
# -inf, NaN 1N/A return 'inf';
# +inf 1N/A # Make a number from a BigFloat object 1N/A # simple return a string and let Perl's atoi()/atof() handle the rest 1N/A############################################################################## 1N/A# public stuff (usually prefixed with "b") 1N/A# XXX TODO this must be overwritten and return NaN for non-integer values 1N/A# band(), bior(), bxor(), too 1N/A# $class->SUPER::bnot($class,@_); 1N/A # Compares 2 values. Returns one of undef, <0, =0, >0. (suitable for sort) 1N/A my ($
self,$x,$y) = (
ref($_[
0]),@_);
1N/A # objectify is costly, so avoid it 1N/A if ((!
ref($_[
0])) || (
ref($_[
0])
ne ref($_[
1])))
1N/A if (($x->{
sign} !~ /^[+-]$/) || ($y->{
sign} !~ /^[+-]$/))
1N/A # handle +-inf and NaN 1N/A # check sign for speed first 1N/A return 1 if $x->{
sign}
eq '+' && $y->{
sign}
eq '-';
# does also 0 <=> -y 1N/A return -
1 if $x->{
sign}
eq '-' && $y->{
sign}
eq '+';
# does also -x <=> 0 1N/A return -
1 if $
xz && $y->{
sign}
eq '+';
# 0 <=> +y 1N/A return 1 if $
yz && $x->{
sign}
eq '+';
# +x <=> 0 1N/A # adjust so that exponents are equal 1N/A # the numify somewhat limits our length, but makes it much faster 1N/A return $l <=>
0 if $l !=
0;
1N/A # lengths (corrected by exponent) are equal 1N/A # so make mantissa equal length by padding with zero (shift left) 1N/A my $
xm = $x->{
_m};
# not yet copy it 1N/A # Compares 2 values, ignoring their signs. 1N/A # Returns one of undef, <0, =0, >0. (suitable for sort) 1N/A my ($
self,$x,$y) = (
ref($_[
0]),@_);
1N/A # objectify is costly, so avoid it 1N/A if ((!
ref($_[
0])) || (
ref($_[
0])
ne ref($_[
1])))
1N/A # handle +-inf and NaN's 1N/A return -
1 if $
xz && !$
yz;
# 0 <=> +y 1N/A return 1 if $
yz && !$
xz;
# +x <=> 0 1N/A # adjust so that exponents are equal 1N/A # the numify somewhat limits our length, but makes it much faster 1N/A return $l <=>
0 if $l !=
0;
1N/A # lengths (corrected by exponent) are equal 1N/A # so make mantissa equal-length by padding with zero (shift left) 1N/A my $
xm = $x->{
_m};
# not yet copy it 1N/A # add second arg (BFLOAT or string) to first (BFLOAT) (modifies first) 1N/A # return result as BFLOAT 1N/A my ($
self,$x,$y,$a,$p,$r) = (
ref($_[
0]),@_);
1N/A # objectify is costly, so avoid it 1N/A if ((!
ref($_[
0])) || (
ref($_[
0])
ne ref($_[
1])))
1N/A # inf and NaN handling 1N/A if (($x->{
sign} !~ /^[+-]$/) || ($y->{
sign} !~ /^[+-]$/))
1N/A # +inf++inf or -inf+-inf => same, rest is NaN 1N/A # +-inf + something => +inf; something +-inf => +-inf 1N/A # speed: no add for 0+y or x+0 1N/A # make copy, clobbering up x (modify in place!) 1N/A # take lower of the two e's and adapt m1 to it to match m2 1N/A # else: both e are the same, so just leave them 1N/A # delete trailing zeros, then round 1N/A # (BigFloat or num_str, BigFloat or num_str) return BigFloat 1N/A # subtract second arg from first, modify first 1N/A my ($
self,$x,$y,$a,$p,$r) = (
ref($_[
0]),@_);
1N/A # objectify is costly, so avoid it 1N/A if ((!
ref($_[
0])) || (
ref($_[
0])
ne ref($_[
1])))
1N/A if ($y->
is_zero())
# still round for not adding zero 1N/A # $x - $y = -$x + $y 1N/A $y->{
sign} =~
tr/+-/-+/;
# does nothing for NaN 1N/A $x->
badd($y,$a,$p,$r);
# badd does not leave internal zeros 1N/A $y->{
sign} =~
tr/+-/-+/;
# refix $y (does nothing for NaN) 1N/A $x;
# already rounded by badd() 1N/A # increment arg by one 1N/A # 1e2 => 100, so after the shift below _m has a '0' as last digit 1N/A # we know that the last digit of $x will be '1' or '9', depending on the 1N/A # inf, nan handling etc 1N/A # decrement arg by one 1N/A # inf, nan handling etc 1N/A # $base > 0, $base != 1; if $base == undef default to $base == e 1N/A # we need to limit the accuracy to protect against overflow 1N/A # also takes care of the "error in _find_round_parameters?" case 1N/A # no rounding at all, so must use fallback 1N/A # simulate old behaviour 1N/A $
params[
2] = $r;
# round mode by caller or undef 1N/A # the 4 below is empirical, and there might be cases where it is not 1N/A # base not defined => base == Euler's constant e 1N/A # make object, since we don't feed it through objectify() to still get the 1N/A # case of $base == undef 1N/A # $base > 0; $base != 1 1N/A # if $x == $base, we know the result must be 1.0 1N/A # when user set globals, they would interfere with our calculation, so 1N/A # disable them and later re-enable them 1N/A # we also need to disable any set A or P on $x (_find_round_parameters took 1N/A # them already into account), since these would interfere, too 1N/A # need to disable $upgrade in BigInt, to avoid deep recursion 1N/A # upgrade $x if $x is not a BigFloat (handle BigInt input) 1N/A if (!$x->
isa(
'Math::BigFloat'))
1N/A # If the base is defined and an integer, try to calculate integer result 1N/A # first. This is very fast, and in case the real result was found, we can 1N/A # found result, return it 1N/A # first calculate the log to base e (using reduction by 10 (and probably 2)) 1N/A # and if a different base was requested, convert it 1N/A # not ln, but some other base (don't modify $base) 1N/A # shortcut to not run through _find_round_parameters again 1N/A # clear a/p after round, since user did not request it 1N/A # internal log function to calculate ln() based on Taylor series. 1N/A # Modifies $x in place. 1N/A # in case of $x == 1, result is 0 1N/A # Taylor: | u 1 u^3 1 u^5 | 1N/A # ln (x) = 2 | --- + - * --- + - * --- + ... | x > 0 1N/A # |_ v 3 v^3 5 v^5 _| 1N/A # This takes much more steps to calculate the result and is thus not used 1N/A # Taylor: | u 1 u^2 1 u^3 | 1N/A # ln (x) = 2 | --- + - * --- + - * --- + ... | x > 1/2 1N/A # |_ x 2 x^2 3 x^3 _| 1N/A $u *= $u; $v *= $v;
# u^2, v^2 1N/A # we calculate the next term, and add it to the last 1N/A # when the next term is below our limit, it won't affect the outcome 1N/A # anymore, so we stop 1N/A # calculating the next term simple from over/below will result in quite 1N/A # a time hog if the input has many digits, since over and below will 1N/A # accumulate more and more digits, and the result will also have many 1N/A # digits, but in the end it is rounded to $scale digits anyway. So if we 1N/A # round $over and $below first, we save a lot of time for the division 1N/A # (not with log(1.2345), but try log (123**123) to see what I mean. This 1N/A # can introduce a rounding error if the division result would be f.i. 1N/A # 0.1234500000001 and we round it to 5 digits it would become 0.12346, but 1N/A # if we truncated $over and $below we might get 0.12345. Does this matter 1N/A # for the end result? So we give $over and $below 4 more digits to be 1N/A # on the safe side (unscientific error handling as usual... :+D 1N/A## $next = $over->copy()->bdiv($below->copy()->bmul($factor),$scale); 1N/A # calculate things for the next term 1N/A # Internal log function based on reducing input to the range of 0.1 .. 9.99 1N/A # and then "correcting" the result to the proper one. Modifies $x in place. 1N/A # taking blog() from numbers greater than 10 takes a *very long* time, so we 1N/A # break the computation down into parts based on the observation that: 1N/A # blog(x*y) = blog(x) + blog(y) 1N/A # We set $y here to multiples of 10 so that $x is below 1 (the smaller $x is 1N/A # the faster it get's, especially because 2*$x takes about 10 times as long, 1N/A # so by dividing $x by 10 we make it at least factor 100 faster...) 1N/A # The same observation is valid for numbers smaller than 0.1 (e.g. computing 1N/A # log(1) is fastest, and the farther away we get from 1, the longer it takes) 1N/A # so we also 'break' this down by multiplying $x with 10 and subtract the 1N/A # log(10) afterwards to get the correct result. 1N/A # calculate nr of digits before dot 1N/A # more than one digit (e.g. at least 10), but *not* exactly 10 to avoid 1N/A # infinite recursion 1N/A my $
calc =
1;
# do some calculation? 1N/A # disable the shortcut for 10, since we need log(10) and this would recurse 1N/A # we can use the cached value in these cases 1N/A $
calc =
0;
# no need to calc, but round 1N/A # disable the shortcut for 2, since we maybe have it cached 1N/A # we can use the cached value in these cases 1N/A $
calc =
0;
# no need to calc, but round 1N/A # if $x = 0.1, we know the result must be 0-log(10) 1N/A # we can use the cached value in these cases 1N/A $
calc =
0;
# no need to calc, but round 1N/A return if $
calc ==
0;
# already have the result 1N/A # default: these correction factors are undef and thus not used 1N/A my $
l_10;
# value of ln(10) to A of $scale 1N/A my $
l_2;
# value of ln(2) to A of $scale 1N/A # $x == 2 => 1, $x == 13 => 2, $x == 0.1 => 0, $x == 0.01 => -1 1N/A # so don't do this shortcut for 1 or 0 1N/A # convert our cached value to an object if not already (avoid doing this 1N/A # at import() time, since not everybody needs this) 1N/A #print "x = $x, dbd = $dbd, calc = $calc\n"; 1N/A # got more than one digit before the dot, or more than one zero after the 1N/A # log(123) == log(1.23) + log(10) * 2 1N/A # log(0.0123) == log(1.23) - log(10) * 2 1N/A # else: slower, compute it (but don't cache it, because it could be big) 1N/A # also disable downgrade for this code path 1N/A $
dbd--
if ($
dbd >
1);
# 20 => dbd=2, so make it dbd=1 1N/A # Now: 0.1 <= $x < 10 (and possible correction in l_10) 1N/A ### Since $x in the range 0.5 .. 1.5 is MUCH faster, we do a repeated div 1N/A ### or mul by 2 (maximum times 3, since x < 10 and x > 0.1) 1N/A my $
twos =
0;
# default: none (0 times) 1N/A # $twos > 0 => did mul 2, < 0 => did div 2 (never both) 1N/A # calculate correction factor based on ln(2) 1N/A # else: slower, compute it (but don't cache it, because it could be big) 1N/A # also disable downgrade for this code path 1N/A # all done, $x contains now the result 1N/A # (BFLOAT or num_str, BFLOAT or num_str) return BFLOAT 1N/A # does not modify arguments, but returns new object 1N/A # Lowest Common Multiplicator 1N/A # (BFLOAT or num_str, BFLOAT or num_str) return BINT 1N/A # does not modify arguments, but returns new object 1N/A # GCD -- Euclids algorithm Knuth Vol 2 pg 296 1N/A############################################################################## 1N/A # Internal helper sub to take two positive integers and their signs and 1N/A # then add them. Input ($CALC,$CALC,('+'|'-'),('+'|'-')), 1N/A # output ($CALC,('+'|'-')) 1N/A # if the signs are equal we can add them (-5 + -3 => -(5 + 3) => -8) 1N/A # the sign follows $xs 1N/A # Internal helper sub to take two positive integers and their signs and 1N/A # then subtract them. Input ($CALC,$CALC,('+'|'-'),('+'|'-')), 1N/A # output ($CALC,('+'|'-')) 1N/A############################################################################### 1N/A# is_foo methods (is_negative, is_positive are inherited from BigInt) 1N/A # return true if arg (BFLOAT or num_str) is an integer 1N/A return 1 if ($x->{
sign} =~ /^[+-]$/) &&
# NaN and +-inf aren't 1N/A $x->{
_es}
eq '+';
# 1e-1 => no integer 1N/A # return true if arg (BFLOAT or num_str) is zero 1N/A # return true if arg (BFLOAT or num_str) is +1 or -1 if signis given 1N/A # return true if arg (BFLOAT or num_str) is odd or false if even 1N/A return 1 if ($x->{
sign} =~ /^[+-]$/) &&
# NaN & +-inf aren't 1N/A # return true if arg (BINT or num_str) is even or false if odd 1N/A return 0 if $x->{
sign} !~ /^[+-]$/;
# NaN & +-inf aren't 1N/A return 1 if ($x->{
_es}
eq '+' # 123.45 is never 1N/A # multiply two numbers -- stolen from Knuth Vol 2 pg 233 1N/A # (BINT or num_str, BINT or num_str) return BINT 1N/A my ($
self,$x,$y,$a,$p,$r) = (
ref($_[
0]),@_);
1N/A # objectify is costly, so avoid it 1N/A if ((!
ref($_[
0])) || (
ref($_[
0])
ne ref($_[
1])))
1N/A # result will always be +-inf: 1N/A # +inf * +/+inf => +inf, -inf * -/-inf => +inf 1N/A # +inf * -/-inf => -inf, -inf * +/+inf => -inf 1N/A # aEb * cEd = (a*c)E(b+d) 1N/A # (dividend: BFLOAT or num_str, divisor: BFLOAT or num_str) return 1N/A # (BFLOAT,BFLOAT) (quo,rem) or BFLOAT (only rem) 1N/A my ($
self,$x,$y,$a,$p,$r) = (
ref($_[
0]),@_);
1N/A # objectify is costly, so avoid it 1N/A if ((!
ref($_[
0])) || (
ref($_[
0])
ne ref($_[
1])))
1N/A # x== 0 # also: or y == 1 or y == -1 1N/A # we need to limit the accuracy to protect against overflow 1N/A return $x
if $x->
is_nan();
# error in _find_round_parameters? 1N/A # no rounding at all, so must use fallback 1N/A # simulate old behaviour 1N/A $
params[
2] = $r;
# round mode by caller or undef 1N/A # the 4 below is empirical, and there might be cases where it is not 1N/A # make copy of $x in case of list context for later reminder calculation 1N/A # check for / +-1 ( +/- 1E0) 1N/A # promote BigInts and it's subclasses (except when already a BigFloat) 1N/A $y = $
self->
new($y)
unless $y->
isa(
'Math::BigFloat');
1N/A # calculate the result to $scale digits and then round it 1N/A # a * 10 ** b / c * 10 ** d => a/c * 10 ** (b-d) 1N/A # correct for 10**scale 1N/A # shortcut to not run through _find_round_parameters again 1N/A delete $x->{
_a};
# clear before round 1N/A delete $x->{
_p};
# clear before round 1N/A # clear a/p after round, since user did not request it 1N/A # clear a/p after round, since user did not request it 1N/A # (dividend: BFLOAT or num_str, divisor: BFLOAT or num_str) return reminder 1N/A my ($
self,$x,$y,$a,$p,$r) = (
ref($_[
0]),@_);
1N/A # objectify is costly, so avoid it 1N/A if ((!
ref($_[
0])) || (
ref($_[
0])
ne ref($_[
1])))
1N/A # handle NaN, inf, -inf 1N/A if (($x->{
sign} !~ /^[+-]$/) || ($y->{
sign} !~ /^[+-]$/))
1N/A return $x->
bzero($a,$p)
if $
cmp ==
0;
# $x == $y => result 0 1N/A # only $y of the operands negative? 1N/A return $x->
round($a,$p,$r)
if $
cmp <
0 && $
neg ==
0;
# $x < $y => result $x 1N/A # if $y has digits after dot 1N/A if ($y->{
_es}
eq '-')
# has digits after dot 1N/A # 123 % 2.5 => 1230 % 25 => 5 => 0.5 1N/A # $ym is now mantissa of $y based on exponent 0 1N/A if ($x->{
_es}
eq '-')
# has digits after dot 1N/A # 123.4 % 20 => 1234 % 200 1N/A # 123e1 % 20 => 1230 % 20 1N/A # now mantissas are equalized, exponent of $x is adjusted, so calc result 1N/A if ($
neg !=
0)
# one of them negative => correct in place 1N/A $x->
round($a,$p,$r,$y);
# round and return 1N/A # calculate $y'th root of $x 1N/A my ($
self,$x,$y,$a,$p,$r) = (
ref($_[
0]),@_);
1N/A # objectify is costly, so avoid it 1N/A if ((!
ref($_[
0])) || (
ref($_[
0])
ne ref($_[
1])))
1N/A # NaN handling: $x ** 1/0, x or y NaN, or y inf/-inf or y == 0 1N/A # we need to limit the accuracy to protect against overflow 1N/A return $x
if $x->
is_nan();
# error in _find_round_parameters? 1N/A # no rounding at all, so must use fallback 1N/A # simulate old behaviour 1N/A $
params[
2] = $r;
# iound mode by caller or undef 1N/A # the 4 below is empirical, and there might be cases where it is not 1N/A # when user set globals, they would interfere with our calculation, so 1N/A # disable them and later re-enable them 1N/A # we also need to disable any set A or P on $x (_find_round_parameters took 1N/A # them already into account), since these would interfere, too 1N/A # need to disable $upgrade in BigInt, to avoid deep recursion 1N/A # remember sign and make $x positive, since -4 ** (1/2) => -2 1N/A if ($y->
isa(
'Math::BigFloat'))
1N/A # normal square root if $y == 2: 1N/A # copy private parts over 1N/A # calculate the broot() as integer result first, and if it fits, return 1N/A # it rightaway (but only if $x and $y are integer): 1N/A # found result, return it 1N/A delete $u->{
_a};
delete $u->{
_p};
# otherwise it conflicts 1N/A # shortcut to not run through _find_round_parameters again 1N/A # clear a/p after round, since user did not request it 1N/A # calculate square root 1N/A return $x->
bnan()
if $x->{
sign} !~ /^[+]/;
# NaN, -inf or < 0 1N/A return $x
if $x->{
sign}
eq '+inf';
# sqrt(inf) == inf 1N/A # we need to limit the accuracy to protect against overflow 1N/A return $x
if $x->
is_nan();
# error in _find_round_parameters? 1N/A # no rounding at all, so must use fallback 1N/A # simulate old behaviour 1N/A $
params[
2] = $r;
# round mode by caller or undef 1N/A # the 4 below is empirical, and there might be cases where it is not 1N/A # when user set globals, they would interfere with our calculation, so 1N/A # disable them and later re-enable them 1N/A # we also need to disable any set A or P on $x (_find_round_parameters took 1N/A # them already into account), since these would interfere, too 1N/A # need to disable $upgrade in BigInt, to avoid deep recursion 1N/A if (($x->{
_es}
ne '-')
# guess can't be accurate if there are 1N/A # digits after the dot 1N/A # exact result, copy result over to keep $x 1N/A # shortcut to not run through _find_round_parameters again 1N/A # clear a/p after round, since user did not request it 1N/A # re-enable A and P, upgrade is taken care of by "local" 1N/A ${
"$self\::accuracy"} = $
ab; ${
"$self\::precision"} = $
pb;
1N/A # sqrt(2) = 1.4 because sqrt(2*100) = 1.4*10; so we can increase the accuracy 1N/A # of the result by multipyling the input by 100 and then divide the integer 1N/A # result of sqrt(input) by 10. Rounding afterwards returns the real result. 1N/A # The following steps will transform 123.456 (in $x) into 123456 (in $y1) 1N/A # Now calculate how many digits the result of sqrt(y1) would have 1N/A # But we need at least $scale digits, so calculate how many are missing 1N/A # That should never happen (we take care of integer guesses above) 1N/A # $shift = 0 if $shift < 0; 1N/A # Multiply in steps of 100, by shifting left two times the "missing" digits 1N/A # We now make sure that $y1 has the same odd or even number of digits than 1N/A # $x had. So when _e of $x is odd, we must shift $y1 by one digit left, 1N/A # because we always must multiply by steps of 100 (sqrt(100) is 10) and not 1N/A # steps of 10. The length of $x does not count, since an even or odd number 1N/A # of digits before the dot is not changed by adding an even number of digits 1N/A # after the dot (the result is still odd or even digits long). 1N/A # now take the square root and truncate to integer 1N/A # By "shifting" $y1 right (by creating a negative _e) we calculate the final 1N/A # result, which is than later rounded to the desired scale. 1N/A # calculate how many zeros $x had after the '.' (or before it, depending 1N/A # on sign of $dat, the result should have half as many: 1N/A # no zeros after the dot (e.g. 1.23, 0.49 etc) 1N/A # preserve half as many digits before the dot than the input had 1N/A # (but round this "up") 1N/A # shortcut to not run through _find_round_parameters again 1N/A # clear a/p after round, since user did not request it 1N/A # (BFLOAT or num_str, BFLOAT or num_str) return BFLOAT 1N/A # compute factorial number, modifies first argument 1N/A my ($
self,$x,@r) = (
ref($_[
0]),@_);
1N/A # objectify is costly, so avoid it 1N/A return $x
if $x->{
sign}
eq '+inf';
# inf => inf 1N/A if (($x->{
sign}
ne '+') ||
# inf, NaN, <0 etc => NaN 1N/A ($x->{
_es}
ne '+'));
# digits after dot? 1N/A # use BigInt's bfac() for faster calc 1N/A # Calculate a power where $y is a non-integer, like 2 ** 0.5 1N/A my ($x,$y,$a,$p,$r) = @_;
1N/A # if $y == 0.5, it is sqrt($x) 1N/A # a ** x == e ** (x * ln a) 1N/A # Taylor: | u u^2 u^3 | 1N/A # x ** y = 1 + | --- + --- + ----- + ... | 1N/A # we need to limit the accuracy to protect against overflow 1N/A return $x
if $x->
is_nan();
# error in _find_round_parameters? 1N/A # no rounding at all, so must use fallback 1N/A # simulate old behaviour 1N/A $
params[
2] = $r;
# round mode by caller or undef 1N/A # the 4 below is empirical, and there might be cases where it is not 1N/A # when user set globals, they would interfere with our calculation, so 1N/A # disable them and later re-enable them 1N/A # we also need to disable any set A or P on $x (_find_round_parameters took 1N/A # them already into account), since these would interfere, too 1N/A # need to disable $upgrade in BigInt, to avoid deep recursion 1N/A # we calculate the next term, and add it to the last 1N/A # when the next term is below our limit, it won't affect the outcome 1N/A # anymore, so we stop 1N/A # calculate things for the next term 1N/A # shortcut to not run through _find_round_parameters again 1N/A # clear a/p after round, since user did not request it 1N/A # (BFLOAT or num_str, BFLOAT or num_str) return BFLOAT 1N/A # compute power of two numbers, second arg is used as integer 1N/A # modifies first argument 1N/A my ($
self,$x,$y,$a,$p,$r) = (
ref($_[
0]),@_);
1N/A # objectify is costly, so avoid it 1N/A if ((!
ref($_[
0])) || (
ref($_[
0])
ne ref($_[
1])))
1N/A return $x->
_pow($y,$a,$p,$r)
if !$y->
is_int();
# non-integer power 1N/A # if $x == -1 and odd/even y => +1/-1 because +-1 ^ (+-1) => +-1 1N/A return $x
if $y->{
sign}
eq '+';
# 0**y => 0 (if not y <= 0) 1N/A # 0 ** -y => 1 / (0 ** y) => 1 / 0! (1 / 0 => +inf) 1N/A # calculate $x->{_m} ** $y and $x->{_e} * $y separately (faster) 1N/A # modify $x in place! 1N/A return $x->
bdiv($z,$a,$p,$r);
# round in one go (might ignore y's A!) 1N/A############################################################################### 1N/A # precision: round to the $Nth digit left (+$n) or right (-$n) from the '.' 1N/A # $n == 0 means round to integer 1N/A # expects and returns normalized numbers! 1N/A my $x =
shift;
my $
self =
ref($x) || $x; $x = $
self->
new(
shift)
if !
ref($x);
1N/A # never round a 0, +-inf, NaN 1N/A return $x
if $x->{
sign} !~ /^[+-]$/;
1N/A # don't round if x already has lower precision 1N/A delete $x->{
_a};
# and clear A 1N/A # round right from the '.' 1N/A return $x
if $x->{
_es}
eq '+';
# e >= 0 => nothing to round 1N/A # the following poses a restriction on _e, but if _e is bigger than a 1N/A # scalar, you got other problems (memory etc) anyway 1N/A my $
zad =
0;
# zeros after dot 1N/A # p rint "scale $scale dad $dad zad $zad len $len\n"; 1N/A # number bsstr len zad dad 1N/A # 0.123 123e-3 3 0 3 1N/A # 0.0123 123e-4 3 1 4 1N/A # 1.2345 12345e-4 5 0 4 1N/A return $x
if $
scale > $
dad;
# 0.123, scale >= 3 => exit 1N/A # round to zero if rounding inside the $zad, but not for last zero like: 1N/A # 0.0065, scale -2, round last '0' with following '65' (scale == zad case) 1N/A # adjust round-point to be inside mantissa 1N/A # round left from the '.' 1N/A # 123 => 100 means length(123) = 3 - $scale (2) => 1 1N/A # should be the same, so treat it as this 1N/A # shortcut if already integer 1N/A # maximum digits before dot 1N/A # not enough digits before dot, so round to zero 1N/A # pass sign to bround for rounding modes '+inf' and '-inf' 1N/A # accuracy: preserve $N digits, and overwrite the rest with 0's 1N/A my $x =
shift;
my $
self =
ref($x) || $x; $x = $
self->
new(
shift)
if !
ref($x);
1N/A if (($_[
0] ||
0) <
0)
1N/A require Carp;
Carp::
croak (
'bround() needs positive accuracy');
1N/A # scale is now either $x->{_a}, $accuracy, or the user parameter 1N/A # test whether $x already has lower accuracy, do nothing in this case 1N/A # but do round if the accuracy is the same, since a math operation might 1N/A # want to round a number with A=5 to 5 digits afterwards again 1N/A return $x
if defined $_[
0] &&
defined $x->{
_a} && $x->{
_a} < $_[
0];
1N/A # scale < 0 makes no sense 1N/A # never round a +-inf, NaN 1N/A # 1: $scale == 0 => keep all digits 1N/A # 2: never round a 0 1N/A # 3: if we should keep more digits than the mantissa has, do nothing 1N/A # pass sign to bround for '+inf' and '-inf' rounding modes 1N/A delete $x->{
_p};
# and clear P 1N/A $x->
bnorm();
# del trailing zeros gen. by bround() 1N/A # return integer less or equal then $x 1N/A return $x
if $x->{
sign} !~ /^[+-]$/;
# nan, +inf, -inf 1N/A # if $x has digits after dot 1N/A # return integer greater or equal then $x 1N/A return $x
if $x->{
sign} !~ /^[+-]$/;
# nan, +inf, -inf 1N/A # if $x has digits after dot 1N/A # shift right by $y (divide by power of $n) 1N/A my ($
self,$x,$y,$n,$a,$p,$r) = (
ref($_[
0]),@_);
1N/A # objectify is costly, so avoid it 1N/A if ((!
ref($_[
0])) || (
ref($_[
0])
ne ref($_[
1])))
1N/A return $x
if $x->{
sign} !~ /^[+-]$/;
# nan, +inf, -inf 1N/A $n =
2 if !
defined $n; $n = $
self->
new($n);
1N/A # shift left by $y (multiply by power of $n) 1N/A my ($
self,$x,$y,$n,$a,$p,$r) = (
ref($_[
0]),@_);
1N/A # objectify is costly, so avoid it 1N/A if ((!
ref($_[
0])) || (
ref($_[
0])
ne ref($_[
1])))
1N/A return $x
if $x->{
sign} !~ /^[+-]$/;
# nan, +inf, -inf 1N/A $n =
2 if !
defined $n; $n = $
self->
new($n);
1N/A############################################################################### 1N/A # going through AUTOLOAD for every DESTROY is costly, avoid it by empty sub 1N/A # make fxxx and bxxx both work by selectively mapping fxxx() to MBF::bxxx() 1N/A # or falling back to MBI::bxxx() 1N/A $
name =~ s/(.*):://;
# split package 1N/A # delayed load of Carp and avoid recursion 1N/A Carp::
croak (
"$c: Can't call a method without name");
1N/A # delayed load of Carp and avoid recursion 1N/A Carp::
croak (
"Can't call $c\-\>$name, not a valid method");
1N/A # try one level up, but subst. bxxx() for fxxx() since MBI only got bxxx() 1N/A return &{
"Math::BigInt".
"::$name"}(@_);
1N/A # return a copy of the exponent 1N/A my $s = $x->{
sign}; $s =~ s/^[+-]//;
1N/A # return a copy of the mantissa 1N/A my $s = $x->{
sign}; $s =~ s/^[+]//;
1N/A # return a copy of both the exponent and the mantissa 1N/A my $s = $x->{
sign}; $s =~ s/^[+]//;
my $
se = $s; $
se =~ s/^[-]//;
1N/A return ($
self->
new($s),$
self->
new($
se));
# +inf => inf and -inf,+inf => inf 1N/A############################################################################## 1N/A# private stuff (internal use only) 1N/A for (
my $i =
0; $i < $l ; $i++)
1N/A if ( $_[$i]
eq ':constant' )
1N/A # This causes overlord er load to step in. 'binary' and 'integer' 1N/A # are handled by BigInt. 1N/A elsif ($_[$i]
eq 'upgrade')
1N/A # this causes upgrading 1N/A elsif ($_[$i]
eq 'downgrade')
1N/A # this causes downgrading 1N/A elsif ($_[$i]
eq 'lib')
1N/A # alternative library 1N/A $
lib = $_[$i+
1] ||
'';
# default Calc 1N/A elsif ($_[$i]
eq 'with')
1N/A # alternative class for our private parts() 1N/A # XXX: no longer supported 1N/A # $MBI = $_[$i+1] || 'Math::BigInt'; 1N/A # let use Math::BigInt lib => 'GMP'; use Math::BigFloat; still work 1N/A # MBI already loaded 1N/A # MBI not loaded, or with ne "Math::BigInt::Calc" 1N/A $
lib =~ s/^,//;
# don't leave empty 1N/A # replacement library can handle lib statement, but also could ignore it 1N/A # Perl < 5.6.0 dies with "out of memory!" when eval() and ':constant' is 1N/A # used in the same script, or eval inside import(). 1N/A my $
rc =
"use Math::BigInt lib => '$lib', 'objectify';";
1N/A require Carp;
Carp::
croak (
"Couldn't load $lib: $! $@");
1N/A # any non :constant stuff is handled by our parent, Exporter 1N/A # even if @_ is empty, to give it a chance 1N/A # adjust m and e so that m is smallest possible 1N/A # round number according to accuracy and precision settings 1N/A return $x
if $x->{
sign} !~ /^[+-]$/;
# inf, nan etc 1N/A # $x can only be 0Ey if there are no trailing zeros ('0' has 0 trailing 1N/A # zeros). So, for something like 0Ey, set y to 1, and -0 => +0 1N/A $x;
# MBI bnorm is no-op, so dont call it 1N/A############################################################################## 1N/A # return number as hexadecimal string (only for integers defined) 1N/A return $x->
bstr()
if $x->{
sign} !~ /^[+-]$/;
# inf, nan etc 1N/A return $
nan if $x->{
_es}
ne '+';
# how to do 1e-1 in hex!? 1N/A # return number as binary digit string (only for integers defined) 1N/A return $x->
bstr()
if $x->{
sign} !~ /^[+-]$/;
# inf, nan etc 1N/A return $
nan if $x->{
_es}
ne '+';
# how to do 1e-1 in hex!? 1N/A # return copy as a bigint representation of this BigFloat number 1N/AMath::BigFloat - Arbitrary size floating point math package 1N/A $x = Math::BigFloat->new($str); # defaults to 0 1N/A $nan = Math::BigFloat->bnan(); # create a NotANumber 1N/A $zero = Math::BigFloat->bzero(); # create a +0 1N/A $inf = Math::BigFloat->binf(); # create a +inf 1N/A $inf = Math::BigFloat->binf('-'); # create a -inf 1N/A $one = Math::BigFloat->bone(); # create a +1 1N/A $one = Math::BigFloat->bone('-'); # create a -1 1N/A $x->is_zero(); # true if arg is +0 1N/A $x->is_nan(); # true if arg is NaN 1N/A $x->is_one(); # true if arg is +1 1N/A $x->is_one('-'); # true if arg is -1 1N/A $x->is_odd(); # true if odd, false for even 1N/A $x->is_even(); # true if even, false for odd 1N/A $x->is_pos(); # true if >= 0 1N/A $x->is_neg(); # true if < 0 1N/A $x->is_inf(sign); # true if +inf, or -inf (default is '+') 1N/A $x->bcmp($y); # compare numbers (undef,<0,=0,>0) 1N/A $x->bacmp($y); # compare absolutely (undef,<0,=0,>0) 1N/A $x->sign(); # return the sign, either +,- or NaN 1N/A $x->digit($n); # return the nth digit, counting from right 1N/A $x->digit(-$n); # return the nth digit, counting from left 1N/A # The following all modify their first argument. If you want to preserve 1N/A # $x, use $z = $x->copy()->bXXX($y); See under L<CAVEATS> for why this is 1N/A # neccessary when mixing $a = $b assigments with non-overloaded math. 1N/A $x->bzero(); # set $i to 0 1N/A $x->bnan(); # set $i to NaN 1N/A $x->bone(); # set $x to +1 1N/A $x->bone('-'); # set $x to -1 1N/A $x->binf(); # set $x to inf 1N/A $x->binf('-'); # set $x to -inf 1N/A $x->bneg(); # negation 1N/A $x->babs(); # absolute value 1N/A $x->bnorm(); # normalize (no-op) 1N/A $x->bnot(); # two's complement (bit wise not) 1N/A $x->binc(); # increment x by 1 1N/A $x->bdec(); # decrement x by 1 1N/A $x->badd($y); # addition (add $y to $x) 1N/A $x->bsub($y); # subtraction (subtract $y from $x) 1N/A $x->bmul($y); # multiplication (multiply $x by $y) 1N/A $x->bdiv($y); # divide, set $x to quotient 1N/A # return (quo,rem) or quo if scalar 1N/A $x->bmod($y); # modulus ($x % $y) 1N/A $x->bpow($y); # power of arguments ($x ** $y) 1N/A $x->blsft($y); # left shift 1N/A $x->brsft($y); # right shift 1N/A # return (quo,rem) or quo if scalar 1N/A $x->blog(); # logarithm of $x to base e (Euler's number) 1N/A $x->blog($base); # logarithm of $x to base $base (f.i. 2) 1N/A $x->band($y); # bit-wise and 1N/A $x->bior($y); # bit-wise inclusive or 1N/A $x->bxor($y); # bit-wise exclusive or 1N/A $x->bnot(); # bit-wise not (two's complement) 1N/A $x->bsqrt(); # calculate square-root 1N/A $x->broot($y); # $y'th root of $x (e.g. $y == 3 => cubic root) 1N/A $x->bfac(); # factorial of $x (1*2*3*4*..$x) 1N/A $x->bround($N); # accuracy: preserve $N digits 1N/A $x->bfround($N); # precision: round to the $Nth digit 1N/A $x->bfloor(); # return integer less or equal than $x 1N/A $x->bceil(); # return integer greater or equal than $x 1N/A # The following do not modify their arguments: 1N/A bgcd(@values); # greatest common divisor 1N/A blcm(@values); # lowest common multiplicator 1N/A $x->bstr(); # return string 1N/A $x->bsstr(); # return string in scientific notation 1N/A $x->as_int(); # return $x as BigInt 1N/A $x->exponent(); # return exponent as BigInt 1N/A $x->mantissa(); # return mantissa as BigInt 1N/A $x->parts(); # return (mantissa,exponent) as BigInt 1N/A $x->length(); # number of digits (w/o sign and '.') 1N/A ($l,$f) = $x->length(); # number of digits, and length of fraction 1N/A $x->precision(); # return P of $x (or global, if P of $x undef) 1N/A $x->precision($n); # set P of $x to $n 1N/A $x->accuracy(); # return A of $x (or global, if A of $x undef) 1N/A $x->accuracy($n); # set A $x to $n 1N/A # these get/set the appropriate global value for all BigFloat objects 1N/A Math::BigFloat->precision(); # Precision 1N/A Math::BigFloat->accuracy(); # Accuracy 1N/A Math::BigFloat->round_mode(); # rounding mode 1N/AAll operators (inlcuding basic math operations) are overloaded if you 1N/Adeclare your big floating point numbers as 1N/A $i = new Math::BigFloat '12_3.456_789_123_456_789E-2'; 1N/AOperations with overloaded operators preserve the arguments, which is 1N/Aexactly what you expect. 1N/A=head2 Canonical notation 1N/AInput to these routines are either BigFloat objects, or strings of the 1N/Afollowing four forms: 1N/AC</^[+-]\d+E[+-]?\d+$/> 1N/AC</^[+-]\d*\.\d+E[+-]?\d+$/> 1N/Aall with optional leading and trailing zeros and/or spaces. Additonally, 1N/Anumbers are allowed to have an underscore between any two digits. 1N/AEmpty strings as well as other illegal numbers results in 'NaN'. 1N/Abnorm() on a BigFloat object is now effectively a no-op, since the numbers 1N/Aare always stored in normalized form. On a string, it creates a BigFloat 1N/AOutput values are BigFloat objects (normalized), except for bstr() and bsstr(). 1N/AThe string output will always have leading and trailing zeros stripped and drop 1N/Aa plus sign. C<bstr()> will give you always the form with a decimal point, 1N/Awhile C<bsstr()> (s for scientific) gives you the scientific notation. 1N/A Input bstr() bsstr() 1N/A ' -123 123 123' '-123123123' '-123123123E0' 1N/A '00.0123' '0.0123' '123E-4' 1N/A '123.45E-2' '1.2345' '12345E-4' 1N/A '10E+3' '10000' '1E4' 1N/ASome routines (C<is_odd()>, C<is_even()>, C<is_zero()>, C<is_one()>, 1N/AC<is_nan()>) return true or false, while others (C<bcmp()>, C<bacmp()>) 1N/Areturn either undef, <0, 0 or >0 and are suited for sort. 1N/AActual math is done by using the class defined with C<with => Class;> (which 1N/Adefaults to BigInts) to represent the mantissa and exponent. 1N/AThe sign C</^[+-]$/> is stored separately. The string 'NaN' is used to 1N/Arepresent the result when input arguments are not numbers, as well as 1N/Athe result of dividing by zero. 1N/A=head2 C<mantissa()>, C<exponent()> and C<parts()> 1N/AC<mantissa()> and C<exponent()> return the said parts of the BigFloat 1N/Aas BigInts such that: 1N/A $m = $x->mantissa(); 1N/A $e = $x->exponent(); 1N/A $y = $m * ( 10 ** $e ); 1N/A print "ok\n" if $x == $y; 1N/AC<< ($m,$e) = $x->parts(); >> is just a shortcut giving you both of them. 1N/AA zero is represented and returned as C<0E1>, B<not> C<0E0> (after Knuth). 1N/ACurrently the mantissa is reduced as much as possible, favouring higher 1N/Aexponents over lower ones (e.g. returning 1e7 instead of 10e6 or 10000000e0). 1N/AThis might change in the future, so do not depend on it. 1N/A=head2 Accuracy vs. Precision 1N/ASee also: L<Rounding|Rounding>. 1N/AMath::BigFloat supports both precision and accuracy. For a full documentation, 1N/Aexamples and tips on these topics please see the large section in 1N/ASince things like sqrt(2) or 1/3 must presented with a limited precision lest 1N/Aa operation consumes all resources, each operation produces no more than 1N/Athe requested number of digits. 1N/APlease refer to BigInt's documentation for the precedence rules of which 1N/AIf there is no gloabl precision set, B<and> the operation inquestion was not 1N/Acalled with a requested precision or accuracy, B<and> the input $x has no 1N/Aaccuracy or precision set, then a fallback parameter will be used. For 1N/Ahistorical reasons, it is called C<div_scale> and can be accessed via: 1N/A $d = Math::BigFloat->div_scale(); # query 1N/A Math::BigFloat->div_scale($n); # set to $n digits 1N/AThe default value is 40 digits. 1N/AIn case the result of one operation has more precision than specified, 1N/Ait is rounded. The rounding mode taken is either the default mode, or the one 1N/Asupplied to the operation after the I<scale>: 1N/A $x = Math::BigFloat->new(2); 1N/A Math::BigFloat->precision(5); # 5 digits max 1N/A $y = $x->copy()->bdiv(3); # will give 0.66666 1N/A $y = $x->copy()->bdiv(3,6); # will give 0.666666 1N/A $y = $x->copy()->bdiv(3,6,'odd'); # will give 0.666667 1N/A Math::BigFloat->round_mode('zero'); 1N/A $y = $x->copy()->bdiv(3,6); # will give 0.666666 1N/A=item ffround ( +$scale ) 1N/ARounds to the $scale'th place left from the '.', counting from the dot. 1N/AThe first digit is numbered 1. 1N/A=item ffround ( -$scale ) 1N/ARounds to the $scale'th place right from the '.', counting from the dot. 1N/ARounds to an integer. 1N/A=item fround ( +$scale ) 1N/APreserves accuracy to $scale digits from the left (aka significant digits) 1N/Aand pads the rest with zeros. If the number is between 1 and -1, the 1N/Asignificant digits count from the first non-zero after the '.' 1N/A=item fround ( -$scale ) and fround ( 0 ) 1N/AThese are effectively no-ops. 1N/AAll rounding functions take as a second parameter a rounding mode from one of 1N/Athe following: 'even', 'odd', '+inf', '-inf', 'zero' or 'trunc'. 1N/AThe default rounding mode is 'even'. By using 1N/AC<< Math::BigFloat->round_mode($round_mode); >> you can get and set the default 1N/Amode for subsequent rounding. The usage of C<$Math::BigFloat::$round_mode> is 1N/AThe second parameter to the round functions then overrides the default 1N/AThe C<as_number()> function returns a BigInt from a Math::BigFloat. It uses 1N/A'trunc' as rounding mode to make it equivalent to: 1N/AYou can override this by passing the desired rounding mode as parameter to 1N/A $x = Math::BigFloat->new(2.5); 1N/A $y = $x->as_number('odd'); # $y = 3 1N/A=head1 Autocreating constants 1N/AAfter C<use Math::BigFloat ':constant'> all the floating point constants 1N/Ain the given scope are converted to C<Math::BigFloat>. This conversion 1N/Ahappens at compile time. 1N/A perl -MMath::BigFloat=:constant -e 'print 2E-100,"\n"' 1N/Aprints the value of C<2E-100>. Note that without conversion of 1N/Aconstants the expression 2E-100 will be calculated as normal floating point 1N/APlease note that ':constant' does not affect integer constants, nor binary 1N/Anor hexadecimal constants. Use L<bignum> or L<Math::BigInt> to get this to 1N/AMath with the numbers is done (by default) by a module called 1N/AMath::BigInt::Calc. This is equivalent to saying: 1N/A use Math::BigFloat lib => 'Calc'; 1N/AYou can change this by using: 1N/A use Math::BigFloat lib => 'BitVect'; 1N/AThe following would first try to find Math::BigInt::Foo, then 1N/AMath::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc: 1N/A use Math::BigFloat lib => 'Foo,Math::BigInt::Bar'; 1N/ACalc.pm uses as internal format an array of elements of some decimal base 1N/A(usually 1e7, but this might be differen for some systems) with the least 1N/Asignificant digit first, while BitVect.pm uses a bit vector of base 2, most 1N/Asignificant bit first. Other modules might use even different means of 1N/Arepresenting the numbers. See the respective module documentation for further 1N/APlease note that Math::BigFloat does B<not> use the denoted library itself, 1N/Abut it merely passes the lib argument to Math::BigInt. So, instead of the need 1N/A use Math::BigInt lib => 'GMP'; 1N/Ayou can roll it all into one line: 1N/A use Math::BigFloat lib => 'GMP'; 1N/AIt is also possible to just require Math::BigFloat: 1N/A require Math::BigFloat; 1N/AThis will load the neccessary things (like BigInt) when they are needed, and 1N/AUse the lib, Luke! And see L<Using Math::BigInt::Lite> for more details than 1N/Ayou ever wanted to know about loading a different library. 1N/A=head2 Using Math::BigInt::Lite 1N/AIt is possible to use L<Math::BigInt::Lite> with Math::BigFloat: 1N/A use Math::BigFloat with => 'Math::BigInt::Lite'; 1N/AThere is no need to "use Math::BigInt" or "use Math::BigInt::Lite", but you 1N/Acan combine these if you want. For instance, you may want to use 1N/AMath::BigInt objects in your main script, too. 1N/A use Math::BigFloat with => 'Math::BigInt::Lite'; 1N/AOf course, you can combine this with the C<lib> parameter. 1N/A use Math::BigFloat with => 'Math::BigInt::Lite', lib => 'GMP,Pari'; 1N/AThere is no need for a "use Math::BigInt;" statement, even if you want to 1N/Ause Math::BigInt's, since Math::BigFloat will needs Math::BigInt and thus 1N/Aalways loads it. But if you add it, add it B<before>: 1N/A use Math::BigFloat with => 'Math::BigInt::Lite', lib => 'GMP,Pari'; 1N/ANotice that the module with the last C<lib> will "win" and thus 1N/Ait's lib will be used if the lib is available: 1N/A use Math::BigInt lib => 'Bar,Baz'; 1N/A use Math::BigFloat with => 'Math::BigInt::Lite', lib => 'Foo'; 1N/AThat would try to load Foo, Bar, Baz and Calc (in that order). Or in other 1N/Awords, Math::BigFloat will try to retain previously loaded libs when you 1N/Adon't specify it onem but if you specify one, it will try to load them. 1N/AActually, the lib loading order would be "Bar,Baz,Calc", and then 1N/A"Foo,Bar,Baz,Calc", but independend of which lib exists, the result is the 1N/Asame as trying the latter load alone, except for the fact that one of Bar or 1N/ABaz might be loaded needlessly in an intermidiate step (and thus hang around 1N/Aand waste memory). If neither Bar nor Baz exist (or don't work/compile), they 1N/Awill still be tried to be loaded, but this is not as time/memory consuming as 1N/Aactually loading one of them. Still, this type of usage is not recommended due 1N/AThe old way (loading the lib only in BigInt) still works though: 1N/A use Math::BigInt lib => 'Bar,Baz'; 1N/AYou can even load Math::BigInt afterwards: 1N/A use Math::BigInt lib => 'Bar,Baz'; 1N/ABut this has the same problems like #5, it will first load Calc 1N/A(Math::BigFloat needs Math::BigInt and thus loads it) and then later Bar or 1N/Aloads Calc unnecc., it is not recommended. 1N/ASince it also possible to just require Math::BigFloat, this poses the question 1N/Aabout what libary this will use: 1N/A require Math::BigFloat; 1N/A my $x = Math::BigFloat->new(123); $x += 123; 1N/AIt will use Calc. Please note that the call to import() is still done, but 1N/Aonly when you use for the first time some Math::BigFloat math (it is triggered 1N/Avia any constructor, so the first time you create a Math::BigFloat, the load 1N/Awill happen in the background). This means: 1N/A require Math::BigFloat; 1N/A Math::BigFloat->import ( lib => 'Foo,Bar' ); 1N/Awould be the same as: 1N/A use Math::BigFloat lib => 'Foo, Bar'; 1N/ABut don't try to be clever to insert some operations in between: 1N/A require Math::BigFloat; 1N/A my $x = Math::BigFloat->bone() + 4; # load BigInt and Calc 1N/A Math::BigFloat->import( lib => 'Pari' ); # load Pari, too 1N/A $x = Math::BigFloat->bone()+4; # now use Pari 1N/AWhile this works, it loads Calc needlessly. But maybe you just wanted that? 1N/AB<Examples #3 is highly recommended> for daily usage. 1N/APlease see the file BUGS in the CPAN distribution Math::BigInt for known bugs. 1N/A=item stringify, bstr() 1N/ABoth stringify and bstr() now drop the leading '+'. The old code would return 1N/A'+1.23', the new returns '1.23'. See the documentation in L<Math::BigInt> for 1N/Areasoning and details. 1N/AThe following will probably not do what you expect: 1N/A print $c->bdiv(123.456),"\n"; 1N/AIt prints both quotient and reminder since print works in list context. Also, 1N/Abdiv() will modify $c, so be carefull. You probably want to use 1N/A print $c / 123.456,"\n"; 1N/A print scalar $c->bdiv(123.456),"\n"; # or if you want to modify $c 1N/A=item Modifying and = 1N/A $x = Math::BigFloat->new(5); 1N/AIt will not do what you think, e.g. making a copy of $x. Instead it just makes 1N/Aa second reference to the B<same> object and stores it in $y. Thus anything 1N/Athat modifies $x will modify $y (except overloaded math operators), and vice 1N/Aversa. See L<Math::BigInt> for details and how to avoid that. 1N/AC<bpow()> now modifies the first argument, unlike the old code which left 1N/Ait alone and only returned the result. This is to be consistent with 1N/AC<badd()> etc. The first will modify $x, the second one won't: 1N/A print bpow($x,$i),"\n"; # modify $x 1N/A print $x->bpow($i),"\n"; # ditto 1N/A print $x ** $i,"\n"; # leave $x alone 1N/AL<Math::BigInt>, L<Math::BigRat> and L<Math::Big> as well as 1N/AL<Math::BigInt::BitVect>, L<Math::BigInt::Pari> and L<Math::BigInt::GMP>. 1N/AThe pragmas L<bignum>, L<bigint> and L<bigrat> might also be of interest 1N/Amore documentation including a full version history, testcases, empty 1N/Asubclass files and benchmarks. 1N/AThis program is free software; you may redistribute it and/or modify it under 1N/Athe same terms as Perl itself. 1N/AMark Biggar, overloaded interface by Ilya Zakharevich.