Math::GSL::RNG - Random Number Generators

use Math::GSL::RNG;
my $rng = Math::GSL::RNG->new;
my @random = $rng->get(100);

my $rng = Math::GSL::RNG->new;
my $rng = Math::GSL::RNG->new($gsl_rng_knuthran,5);

Creates a new RNG object of type $type, seeded with $seed. Both of these
parameters are optional. The type $gsl_rng_default is used when no $type is
given.

my $copy = $rng->copy;

Make a copy of a RNG object.

$rng->free();

Free memory associated with RNG object.

my $name = $rng->name();

Get the name of the RNG object as a string.

my $nextval = $rng->get;
my (@values) = $rng->get(100);

Get the next random value from the RNG object. If given an integer N, returns
the next N values.

my $raw = $rng->raw();

Return the raw GSL RNG object, useful for functions which take a RNG, such as
the Monte Carlo integration functions or the random number distribution
functions in Math::GSL::Randist.

my @array = $rng->shuffle(@other_array);

Given a RNG, shuffle an array.

my @array = $rng->choose(4, @other_array);

This function fills the destination array with k objects taken randomly from the
n elements of the array argument. The objects are sampled without replacement,
thus each object can only appear once in destination array. It is required
that k be less than or equal to n.

my @array = $rng->sample(4, @other_array);

This method is like "choose" but samples k items from the original
array of n items src with replacement, so the same object can appear more than
once in the output sequence dest. There is no requirement that k be less than
n in this case.

- gsl_rng_alloc($T) - This function returns a pointer to a newly-created
instance of a random number generator of type $T. $T must be one of the
constants below. The generator is automatically initialized with the default
seed, $gsl_rng_default.

- gsl_rng_set($r, $s) - This function initializes (or `seeds') the random
number generator. If the generator is seeded with the same value of $s on
two different runs, the same stream of random numbers will be generated by
successive calls to the routines below. If different values of $s are
supplied, then the generated streams of random numbers should be completely
different. If the seed $s is zero then the standard seed from the original
implementation is used instead. For example, the original Fortran source
code for the ranlux generator used a seed of 314159265, and so choosing $s
equal to zero reproduces this when using $gsl_rng_ranlux.

- gsl_rng_get($r) - This function returns a random integer from the
generator $r. The minimum and maximum values depend on the algorithm used,
but all integers in the range [min,max] are equally likely. The values of
min and max can determined using the auxiliary functions gsl_rng_max($r) and
gsl_rng_min($r).

- gsl_rng_free($r) - This function frees all the memory associated with the
generator $r.

- gsl_rng_memcpy($dest, $src) - This function copies the random number
generator $src into the pre-existing generator $dest, making $dest into an
exact copy of $src. The two generators must be of the same type.

- gsl_rng_uniform($r) - This function returns a double precision floating
point number uniformly distributed in the range [0,1). The range includes
0.0 but excludes 1.0. The value is typically obtained by dividing the result
of gsl_rng_get($r) by gsl_rng_max($r) + 1.0 in double precision. Some
generators compute this ratio internally so that they can provide floating
point numbers with more than 32 bits of randomness (the maximum number of
bits that can be portably represented in a single unsigned long int).

- gsl_rng_uniform_pos($r) - This function returns a positive double
precision floating point number uniformly distributed in the range (0,1),
excluding both 0.0 and 1.0. The number is obtained by sampling the generator
with the algorithm of gsl_rng_uniform until a non-zero value is obtained.
You can use this function if you need to avoid a singularity at 0.0.

- gsl_rng_uniform_int($r, $n) - This function returns a random integer from
0 to $n-1 inclusive by scaling down and/or discarding samples from the
generator $r. All integers in the range [0,$n-1] are produced with equal
probability. For generators with a non-zero minimum value an offset is
applied so that zero is returned with the correct probability. Note that
this function is designed for sampling from ranges smaller than the range of
the underlying generator. The parameter $n must be less than or equal to the
range of the generator $r. If $n is larger than the range of the generator
then the function calls the error handler with an error code of $GSL_EINVAL
and returns zero. In particular, this function is not intended for
generating the full range of unsigned integer values [0,2^32-1]. Instead
choose a generator with the maximal integer range and zero mimimum value,
such as $gsl_rng_ranlxd1, $gsl_rng_mt19937 or $gsl_rng_taus, and sample it
directly using gsl_rng_get. The range of each generator can be found using
the auxiliary functions described in the next section.

- gsl_rng_fwrite($stream, $r) - This function writes the random number state
of the random number generator $r to the stream $stream (opened with the
gsl_fopen function from the Math::GSL module) in binary format. The return
value is 0 for success and $GSL_EFAILED if there was a problem writing to
the file. Since the data is written in the native binary format it may not
be portable between different architectures.

- gsl_rng_fread($stream, $r) - This function reads the random number state
into the random number generator $r from the open stream $stream (opened
with the gsl_fopen function from the Math::GSL module) in binary format. The
random number generator $r must be preinitialized with the correct random
number generator type since type information is not saved. The return value
is 0 for success and $GSL_EFAILED if there was a problem reading from the
file. The data is assumed to have been written in the native binary format
on the same architecture.

- gsl_rng_clone($r) - This function returns a pointer to a newly created
generator which is an exact copy of the generator $r.

- gsl_rng_max($r) - This function returns the largest value that gsl_rng_get
can return.

- gsl_rng_min($r) - gsl_rng_min returns the smallest value that gsl_rng_get
can return. Usually this value is zero. There are some generators with
algorithms that cannot return zero, and for these generators the minimum
value is 1.

- gsl_rng_name($r) - This function returns a pointer to the name of the
generator. For example,

- print "r is a " . gsl_rng_name($r) .
"generator\n";

- would print something like r is a 'taus' generator.

- gsl_rng_size($r) - This function returns the size of the state of
generator $r. You can use this information to access the state
directly.

- gsl_rng_state($r) - This function returns a pointer to the state of
generator $r. You can use this information to access the state
directly.

- gsl_rng_print_state($r)

- $gsl_rng_default

- $gsl_rng_knuthran

- $gsl_rng_ran0

- $gsl_rng_borosh13

- $gsl_rng_coveyou

- $gsl_rng_cmrg

- $gsl_rng_fishman18

- $gsl_rng_fishman20

- $gsl_rng_fishman2x - This is the L'Ecuyer-Fishman random number generator.
It is taken from Knuth's Seminumerical Algorithms, 3rd Ed., page 108. Its
sequence is, z_{n+1} = (x_n - y_n) mod m with m = 2^31 - 1. x_n and y_n are
given by the fishman20 and lecuyer21 algorithms. The seed specifies the
initial value, x_1.

- $gsl_rng_gfsr4

- $gsl_rng_knuthran

- $gsl_rng_knuthran2

- $gsl_rng_knuthran2002

- $gsl_rng_lecuyer21

- $gsl_rng_minstd

- $gsl_rng_mrg

- $gsl_rng_mt19937

- $gsl_rng_mt19937_1999

- $gsl_rng_mt19937_1998

- $gsl_rng_r250

- $gsl_rng_ran0

- $gsl_rng_ran1

- $gsl_rng_ran2

- $gsl_rng_ran3

- $gsl_rng_rand - This is the BSD rand generator. Its sequence is x_{n+1} =
(a x_n + c) mod m with a = 1103515245, c = 12345 and m = 2^31. The seed
specifies the initial value, x_1. The period of this generator is 2^31, and
it uses 1 word of storage per generator.

- $gsl_rng_rand48

- $gsl_rng_random128_bsd

- $gsl_rng_random128_gli

- $gsl_rng_random128_lib

- $gsl_rng_random256_bsd

- $gsl_rng_random256_gli

- $gsl_rng_random256_lib

- $gsl_rng_random32_bsd

- $gsl_rng_random32_glib

- $gsl_rng_random32_libc

- $gsl_rng_random64_bsd

- $gsl_rng_random64_glib

- $gsl_rng_random64_libc

- $gsl_rng_random8_bsd

- $gsl_rng_random8_glibc

- $gsl_rng_random8_libc5

- $gsl_rng_random_bsd

- $gsl_rng_random_glibc2

- $gsl_rng_random_libc5

- $gsl_rng_randu

- $gsl_rng_ranf

- $gsl_rng_ranlux

- $gsl_rng_ranlux389

- $gsl_rng_ranlxd1

- $gsl_rng_ranlxd2

- $gsl_rng_ranlxs0

- $gsl_rng_ranlxs1

- $gsl_rng_ranlxs2

- $gsl_rng_ranmar - This is the RANMAR lagged-fibonacci generator of
Marsaglia, Zaman and Tsang. It is a 24-bit generator, originally designed
for single-precision IEEE floating point numbers. It was included in the
CERNLIB high-energy physics library.

- $gsl_rng_slatec - This is the SLATEC random number generator RAND. It is
ancient. The original source code is available from NETLIB.

- $gsl_rng_taus

- $gsl_rng_taus2

- $gsl_rng_taus113

- $gsl_rng_transputer

- $gsl_rng_tt800

- $gsl_rng_uni

- $gsl_rng_uni32

- $gsl_rng_vax - This is the VAX generator MTH$RANDOM. Its sequence is,
x_{n+1} = (a x_n + c) mod m with a = 69069, c = 1 and m = 2^32. The seed
specifies the initial value, x_1. The period of this generator is 2^32 and
it uses 1 word of storage per generator.

- $gsl_rng_waterman14

- $gsl_rng_zuf - This is the ZUFALL lagged Fibonacci series generator of
Peterson. Its sequence is,

- t = u_{n-273} + u_{n-607}

- u_n = t - floor(t)

The original source code is available from NETLIB. For more information see,
* W. Petersen, XLagged Fibonacci Random Number Generators for the NEC SX-3X, International Journal of High Speed Computing (1994).

For more informations on the functions, we refer you to the GSL offcial
documentation:

<http://www.gnu.org/software/gsl/manual/html_node/>

The following example will print out a list a random integers between certain
minimum and maximum values. The command line arguments are first the number of
random numbers wanted, the minimum and then maximum. The defaults are 10, 0
and 100, respectively.

use Math::GSL::RNG qw/:all/;
my $seed = int rand(100);
my $rng = Math::GSL::RNG->new($gsl_rng_knuthran, $seed );
my ($num,$min,$max) = @ARGV;
$num ||= 10;
$min ||= 0;
$max ||= 100;
print join "\n", map { $min + $rng->get % ($max-$min+1) } (1..$num);
print "\n";

The $seed argument is optional but encouraged. This program is available in the

**examples/** directory that comes with the source of this module.

If you would like a series of random non-integer numbers, then you can generate
one "scaling factor" and multiple by that, such as

use Math::GSL::RNG qw/:all/;
my $scale= rand(10);
my $seed = int rand(100);
my $rng = Math::GSL::RNG->new($gsl_rng_knuthran, $seed );
my ($num,$min,$max) = (10,0,100);
print join "\n", map { $scale*($min + $rng->get % ($max-$min+1)) } (1..$num);
print "\n";

Jonathan "Duke" Leto <jonathan@leto.net> and Thierry Moisan
<thierry.moisan@gmail.com>

Copyright (C) 2008-2014 Jonathan "Duke" Leto and Thierry Moisan

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