# NAME

Math::Big - routines (cos,sin,primes,hailstone,euler,fibbonaci etc) with big numbers

# SYNOPSIS

```
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
$fak = fak(1000); # faktorial 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
```

# REQUIRES

perl5.005, Exporter, Math::BigInt, Math::BigFloat

# EXPORTS

Exports nothing on default, but can export `primes()`

, `fibonacci()`

, `hailstone()`

, `bernoulli`

, `euler`

, `sin`

, `cos`

, `tan`

, `cosh`

, `sinh`

, `arctan`

, `arcsin`

, `arcsinh`

, `pi`

, `log`

and `factorial`

.

# DESCRIPTION

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.

# METHODS

**primes()**

```
@primes = primes($n);
$prime = primes($n);
```

Calculates the first N primes and returns them as array. In scalar context returns the Nth prime.

This uses an optimzes version of the **Sieve of Eratosthenes**, which takes half of the time and half of the space, but is still O(N).

**fibonacci()**

```
@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.

**hailstone()**

```
@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.

**base()**

` ($n,$a) = base($number,$base);`

Reduces a number to $base to the $nth 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.

**factorial()**

` $n = factorial($number);`

Calculate `n!`

for `n `

= 0>.

Uses internally Math::BigInt's bfac() method.

**bernoulli()**

```
$b = bernoulli($n);
($c,$d) = bernoulli($n); # $b = $c/$d
```

Calculate the Nth number in the *Bernoulli* series. Only the first 20 are defined for now.

**euler()**

` $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 = sin($x,$d);`

Calculate *sinus* of x, to $d digits.

**cos()**

` $cos = cos($x,$d);`

Calculate *cosinus* of x, to $d digits.

**tan()**

` $tan = tan($x,$d);`

Calculate *tangens* of x, to $d digits.

**arctan()**

` $arctan = arctan($x,$d);`

Calculate *arcus tangens* of x, to $d digits.

**arcsin()**

` $arcsin = arcsin($x,$d);`

Calculate *arcus sinus* of x, to $d digits.

**arcsinh()**

` $arcsinh = arcsinh($x,$d);`

Calculate *arcus sinus hyperbolicus* of x, to $d digits.

**cosh()**

` $cosh = cosh($x,$d);`

Calculate *cosinus hyperbolicus* of x, to $d digits.

**sinh()**

` $sinh = sinh($x,$d);`

Calculate *sinus hyperbolicus* of x, to $d digits.

**pi()**

` $pi = pi(1024);`

The number PI to 1024 digits after the dot.

**log()**

` $log = log($number,$base);`

Calculates the logarithmn of $number to base $base.

# BUGS

Primes and the Fibonacci series use an array of size N and will not be able to calculate big sequences due to memory constraints.

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 20 elements. So

`bernoulli($x)`

with $x > 42 will fail.

# LICENSE

This program is free software; you may redistribute it and/or modify it under the same terms as Perl itself.

# AUTHOR

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-2003.