Math::Big - routines with big numbers |
Math::Big - routines (cos,sin,primes,hailstone,euler,fibbonaci etc) with big numbers
use Math::Big qw/primes fibonacci hailstone factors wheel cos sin tan euler bernoulli arctan arcsin pi/;
@primes = primes(100); # first 100 primes $prime = primes(100); # 100th prime @fib = fibonacci (100); # first 100 fibonacci numbers $fib_1000 = fibonacci (1000); # 1000th fibonacci number $hailstone = hailstone (1000); # length of sequence @hailstone = hailstone (127); # the entire sequence $factorial = factorial(1000); # factorial 1000! $e = euler(1,64); # e to 64 digits
$b3 = bernoulli(3);
$cos = cos(0.5,128); # cosinus to 128 digits $sin = sin(0.5,128); # sinus to 128 digits $cosh = cosh(0.5,128); # cosinus hyperbolicus to 128 digits $sinh = sinh(0.5,128); # sinus hyperbolicus to 128 digits $tan = tan(0.5,128); # tangens to 128 digits $arctan = arctan(0.5,64); # arcus tangens to 64 digits $arcsin = arcsin(0.5,32); # arcus sinus to 32 digits $arcsinh = arcsin(0.5,18); # arcus sinus hyperbolicus to 18 digits
$pi = pi(1024); # first 1024 digits $log = log(64,2); # $log==6, because 2**6==64 $log = log(100,10); # $log==2, because 10**2==100 $log = log(100); # base defaults to 10: $log==2
perl5.006002, Exporter, Math::BigInt, Math::BigFloat
Exports nothing on default, but can export primes()
, fibonacci()
,
hailstone()
, bernoulli
, euler
, sin
, cos
, tan
, cosh
,
sinh
, arctan
, arcsin
, arcsinh
, pi
, log
and factorial
.
This module contains some routines that may come in handy when you want to do some math with really, really big (or small) numbers. These are primarily examples.
@primes = primes($n); $primes = primes($n);
Calculates all the primes below N and returns them as array. In scalar context returns the number of primes below N.
This uses an optimized version of the B<Sieve of Eratosthenes>, which takes half of the time and half of the space, but is still O(N). Or in other words, quite slow.
@fib = fibonacci($n); $fib = fibonacci($n);
Calculates the first N fibonacci numbers and returns them as array. In scalar context returns the Nth number of the Fibonacci series.
The scalar context version uses an ultra-fast conquer-divide style algorithm to calculate the result and is many times faster than the straightforward way of calculating the linear sum.
@hail = hailstone($n); # sequence $hail = hailstone($n); # length of sequence
Calculates the Hailstone sequence for the number N. This sequence is defined as follows:
while (N != 0) { if (N is even) { N is N /2 } else { N = N * 3 +1 } }
It is not yet proven whether for every N the sequence reaches 1, but it apparently does so. The number of steps is somewhat chaotically.
($n,$a) = base($number,$base);
Reduces a number to $base
to the $n
th power plus $a
. Example:
use Math::BigInt :constant; use Math::Big qw/base/;
print base ( 2 ** 150 + 42,2);
This will print 150 and 42.
$string = to_base($number,$base);
$string = to_base($number,$base, $alphabet);
Returns a string of $number
in base $base
. The alphabet is optional if
$base
is less or equal than 36. $alphabet
is a string.
Examples:
print to_base(15,2); # 1111 print to_base(15,16); # F print to_base(31,16); # 1F
$n = factorial($number);
Calculate n!
for n
= 0>.
Uses internally Math::BigInt's bfac()
method.
$b = bernoulli($n); ($c,$d) = bernoulli($n); # $b = $c/$d
Calculate the Nth number in the Bernoulli series. Only the first 40 are defined for now.
$e = euler($x,$d);
Calculate Euler's constant to the power of $x (usual 1), to $d digits. Defaults to 1 and 42 digits.
$sin = sin($x,$d);
Calculate sinus of $x
, to $d
digits.
$cos = cos($x,$d);
Calculate cosinus of $x
, to $d
digits.
$tan = tan($x,$d);
Calculate tangens of $x
, to $d
digits.
$arctan = arctan($x,$d);
Calculate arcus tangens of $x
, to $d
digits.
$arctanh = arctanh($x,$d);
Calculate arcus tangens hyperbolicus of $x
, to $d
digits.
$arcsin = arcsin($x,$d);
Calculate arcus sinus of $x
, to $d
digits.
$arcsinh = arcsinh($x,$d);
Calculate arcus sinus hyperbolicus of $x
, to $d
digits.
$cosh = cosh($x,$d);
Calculate cosinus hyperbolicus of $x
, to $d
digits.
$sinh = sinh($x,$d);
Calculate sinus hyperbolicus of $<$x>, to $d
digits.
$pi = pi($N);
The number PI to $N
digits after the dot.
$log = log($number,$base,$A);
Calculates the logarithmn of $number
to base $base
, with $A
digits accuracy
and returns a new number as the result (leaving $number
alone).
BigInts are promoted to BigFloats, meaning you will never get a truncated
integer result like when using Math::BigInt::blog
.
The exception is fibonacci in scalar context, this is able to calculate
arbitrarily big numbers in O(N)
time:
use Math::Big; use Math::BigInt qw/:constant/;
$fib = Math::Big::fibonacci( 2 ** 320 );The Bernoulli numbers are not yet calculated, but looked up in a table, which has only 40 elements. So
bernoulli($x)
with $x > 42 will fail.
If you know of an algorithmn to calculate them, please drop me a note.
This program is free software; you may redistribute it and/or modify it under the same terms as Perl itself.
If you use this module in one of your projects, then please email me. I want to hear about how my code helps you ;)
Quite a lot of ideas from other people, especially D. E. Knuth, have been used, thank you!
Tels http://bloodgate.com 2001 - 2007.
Math::Big - routines with big numbers |