Math::BigFloat

scale

 use Math::BigFloat;
 # Number creation
 my $x = Math::BigFloat->new($str);	# defaults to 0
 my $y = $x->copy();			# make a true copy
 my $nan  = Math::BigFloat->bnan();	# create a NotANumber
 my $zero = Math::BigFloat->bzero();	# create a +0
 my $inf = Math::BigFloat->binf();	# create a +inf
 my $inf = Math::BigFloat->binf('-');	# create a -inf
 my $one = Math::BigFloat->bone();	# create a +1
 my $mone = Math::BigFloat->bone('-');	# create a -1
 my $x = Math::BigFloat->bone('-');	#
 my $x = Math::BigFloat->from_hex('0xc.afep+3');    # from hexadecimal
 my $x = Math::BigFloat->from_bin('0b1.1001p-4');   # from binary
 my $x = Math::BigFloat->from_oct('1.3267p-4');     # from octal
 my $pi = Math::BigFloat->bpi(100);	# PI to 100 digits
 # the following examples compute their result to 100 digits accuracy:
 my $cos  = Math::BigFloat->new(1)->bcos(100);	      # cosinus(1)
 my $sin  = Math::BigFloat->new(1)->bsin(100);	      # sinus(1)
 my $atan = Math::BigFloat->new(1)->batan(100);	      # arcus tangens(1)
 my $atan2 = Math::BigFloat->new(  1 )->batan2( 1 ,100); # batan(1)
 my $atan2 = Math::BigFloat->new(  1 )->batan2( 8 ,100); # batan(1/8)
 my $atan2 = Math::BigFloat->new( -2 )->batan2( 1 ,100); # batan(-2)
 # Testing
 $x->is_zero();		 # true if arg is +0
 $x->is_nan();		 # true if arg is NaN
 $x->is_one();		 # true if arg is +1
 $x->is_one('-');	 # true if arg is -1
 $x->is_odd();		 # true if odd, false for even
 $x->is_even();		 # true if even, false for odd
 $x->is_pos();		 # true if >= 0
 $x->is_neg();		 # true if <  0
 $x->is_inf(sign);	 # true if +inf, or -inf (default is '+')
 $x->bcmp($y);		 # compare numbers (undef,<0,=0,>0)
 $x->bacmp($y);		 # compare absolutely (undef,<0,=0,>0)
 $x->sign();		 # return the sign, either +,- or NaN
 $x->digit($n);		 # return the nth digit, counting from right
 $x->digit(-$n);	 # return the nth digit, counting from left 
 # The following all modify their first argument. If you want to pre-
 # serve $x, use $z = $x->copy()->bXXX($y); See under L</CAVEATS> for
 # necessary when mixing $a = $b assignments with non-overloaded math.
 # set 
 $x->bzero();		 # set $i to 0
 $x->bnan();		 # set $i to NaN
 $x->bone();		 # set $x to +1
 $x->bone('-');		 # set $x to -1
 $x->binf();		 # set $x to inf
 $x->binf('-');		 # set $x to -inf
 $x->bneg();		 # negation
 $x->babs();		 # absolute value
 $x->bnorm();		 # normalize (no-op)
 $x->bnot();		 # two's complement (bit wise not)
 $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->bdiv($y);		 # divide, set $x to quotient
			 # return (quo,rem) or quo if scalar
 $x->bmod($y);		 # modulus ($x % $y)
 $x->bpow($y);		 # power of arguments ($x ** $y)
 $x->bmodpow($exp,$mod); # modular exponentiation (($num**$exp) % $mod))
 $x->blsft($y, $n);	 # left shift by $y places in base $n
 $x->brsft($y, $n);	 # right shift by $y places in base $n
			 # returns (quo,rem) or quo if in scalar context
 $x->blog();		 # logarithm of $x to base e (Euler's number)
 $x->blog($base);	 # logarithm of $x to base $base (f.i. 2)
 $x->bexp();		 # calculate e ** $x where e is Euler's number
 $x->band($y);		 # bit-wise and
 $x->bior($y);		 # bit-wise inclusive or
 $x->bxor($y);		 # bit-wise exclusive or
 $x->bnot();		 # bit-wise not (two's complement)
 $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->bround($N); 	 # accuracy: preserve $N digits
 $x->bfround($N);	 # precision: round to the $Nth digit
 $x->bfloor();		 # return integer less or equal than $x
 $x->bceil();		 # return integer greater or equal than $x
 $x->bint();             # round towards zero
  # The following do not modify their arguments:
 bgcd(@values);		 # greatest common divisor
 blcm(@values);		 # lowest common multiplicator
 $x->bstr();		 # return string
 $x->bsstr();		 # return string in scientific notation
 $x->as_int();		 # return $x as BigInt 
 $x->exponent();	 # return exponent as BigInt
 $x->mantissa();	 # return mantissa as BigInt
 $x->parts();		 # return (mantissa,exponent) as BigInt
 $x->length();		 # number of digits (w/o sign and '.')
 ($l,$f) = $x->length(); # number of digits, and length of fraction
 $x->precision();	 # return P of $x (or global, if P of $x undef)
 $x->precision($n);	 # set P of $x to $n
 $x->accuracy();	 # return A of $x (or global, if A of $x undef)
 $x->accuracy($n);	 # set A $x to $n
 # these get/set the appropriate global value for all BigFloat objects
 Math::BigFloat->precision();	# Precision
 Math::BigFloat->accuracy();	# Accuracy
 Math::BigFloat->round_mode();	# rounding mode

Math::BigFloat

NAME

SYNOPSIS

DESCRIPTION

Input

Output

mantissa(), exponent() and parts()

Accuracy vs. Precision

Rounding

METHODS

Autocreating constants

Math library

Using Math::BigInt::Lite

EXPORTS

CAVEATS

BUGS

SUPPORT

LICENSE

SEE ALSO

AUTHORS