Provided by: pdl_2.080-3_amd64 
NAME
PDL::GSL::RNG - PDL interface to RNG and randist routines in GSL
DESCRIPTION
This is an interface to the rng and randist packages present in the GNU Scientific
Library.
SYNOPSIS
use PDL;
use PDL::GSL::RNG;
$rng = PDL::GSL::RNG->new('taus');
$rng->set_seed(time());
$x=zeroes(5,5,5)
$rng->get_uniform($x); # inplace
$y=$rng->get_uniform(3,4,5); # creates new pdl
NOMENCLATURE
Throughout this documentation we strive to use the same variables that are present in the
original GSL documentation (see See Also). Oftentimes those variables are called "a" and
"b". Since good Perl coding practices discourage the use of Perl variables $a and $b, here
we refer to Parameters "a" and "b" as $pa and $pb, respectively, and Limits (of domain or
integration) as $la and $lb.
FUNCTIONS
new
The new method initializes a new instance of the RNG.
The available RNGs are:
coveyou cmrg fishman18 fishman20 fishman2x gfsr4 knuthran
knuthran2 knuthran2002 lecuyer21 minstd mrg mt19937 mt19937_1999
mt19937_1998 r250 ran0 ran1 ran2 ran3 rand rand48 random128_bsd
random128_glibc2 random128_libc5 random256_bsd random256_glibc2
random256_libc5 random32_bsd random32_glibc2 random32_libc5
random64_bsd random64_glibc2 random64_libc5 random8_bsd
random8_glibc2 random8_libc5 random_bsd random_glibc2
random_libc5 randu ranf ranlux ranlux389 ranlxd1 ranlxd2 ranlxs0
ranlxs1 ranlxs2 ranmar slatec taus taus2 taus113 transputer tt800
uni uni32 vax waterman14 zuf default
The last one (default) uses the environment variable GSL_RNG_TYPE.
Note that only a few of these rngs are recommended for general use. Please check the GSL
documentation for more information.
Usage:
$blessed_ref = PDL::GSL::RNG->new($RNG_name);
Example:
$rng = PDL::GSL::RNG->new('taus');
set_seed
Sets the RNG seed.
Usage:
$rng->set_seed($integer);
# or
$rng = PDL::GSL::RNG->new('taus')->set_seed($integer);
Example:
$rng->set_seed(666);
min
Return the minimum value generable by this RNG.
Usage:
$integer = $rng->min();
Example:
$min = $rng->min(); $max = $rng->max();
max
Return the maximum value generable by the RNG.
Usage:
$integer = $rng->max();
Example:
$min = $rng->min(); $max = $rng->max();
name
Returns the name of the RNG.
Usage:
$string = $rng->name();
Example:
$name = $rng->name();
get
This function creates an ndarray with given dimensions or accepts an existing ndarray and
fills it. get() returns integer values between a minimum and a maximum specific to every
RNG.
Usage:
$ndarray = $rng->get($list_of_integers)
$rng->get($ndarray);
Example:
$x = zeroes 5,6;
$o = $rng->get(10,10); $rng->get($x);
get_int
This function creates an ndarray with given dimensions or accepts an existing ndarray and
fills it. get_int() returns integer values between 0 and $max.
Usage:
$ndarray = $rng->get($max, $list_of_integers)
$rng->get($max, $ndarray);
Example:
$x = zeroes 5,6; $max=100;
$o = $rng->get(10,10); $rng->get($x);
get_uniform
This function creates an ndarray with given dimensions or accepts an existing ndarray and
fills it. get_uniform() returns values 0<=x<1,
Usage:
$ndarray = $rng->get_uniform($list_of_integers)
$rng->get_uniform($ndarray);
Example:
$x = zeroes 5,6; $max=100;
$o = $rng->get_uniform(10,10); $rng->get_uniform($x);
get_uniform_pos
This function creates an ndarray with given dimensions or accepts an existing ndarray and
fills it. get_uniform_pos() returns values 0<x<1,
Usage:
$ndarray = $rng->get_uniform_pos($list_of_integers)
$rng->get_uniform_pos($ndarray);
Example:
$x = zeroes 5,6;
$o = $rng->get_uniform_pos(10,10); $rng->get_uniform_pos($x);
ran_shuffle
Shuffles values in ndarray
Usage:
$rng->ran_shuffle($ndarray);
ran_shuffle_vec
Shuffles values in ndarray
Usage:
$rng->ran_shuffle_vec(@vec);
ran_choose
Chooses values from $inndarray to $outndarray.
Usage:
$rng->ran_choose($inndarray,$outndarray);
ran_choose_vec
Chooses $n values from @vec.
Usage:
@chosen = $rng->ran_choose_vec($n,@vec);
ran_gaussian
Fills output ndarray with random values from Gaussian distribution with mean zero and
standard deviation $sigma.
Usage:
$ndarray = $rng->ran_gaussian($sigma,[list of integers = output ndarray dims]);
$rng->ran_gaussian($sigma, $output_ndarray);
Example:
$o = $rng->ran_gaussian($sigma,10,10);
$rng->ran_gaussian($sigma,$o);
ran_gaussian_var
This method is similar to "ran_gaussian" except that it takes the parameters of the
distribution as an ndarray and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_gaussian_var($sigma_ndarray);
$rng->ran_gaussian_var($sigma_ndarray, $output_ndarray);
Example:
$sigma_pdl = rvals zeroes 11,11;
$o = $rng->ran_gaussian_var($sigma_pdl);
ran_additive_gaussian
Add Gaussian noise of given sigma to an ndarray.
Usage:
$rng->ran_additive_gaussian($sigma,$ndarray);
Example:
$rng->ran_additive_gaussian(1,$image);
ran_bivariate_gaussian
Generates $n bivariate gaussian random deviates.
Usage:
$ndarray = $rng->ran_bivariate_gaussian($sigma_x,$sigma_y,$rho,$n);
Example:
$o = $rng->ran_bivariate_gaussian(1,2,0.5,1000);
ran_poisson
Fills output ndarray by with random integer values from the Poisson distribution with mean
$mu.
Usage:
$ndarray = $rng->ran_poisson($mu,[list of integers = output ndarray dims]);
$rng->ran_poisson($mu,$output_ndarray);
ran_poisson_var
Similar to "ran_poisson" except that it takes the distribution parameters as an ndarray
and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_poisson_var($mu_ndarray);
ran_additive_poisson
Add Poisson noise of given $mu to a $ndarray.
Usage:
$rng->ran_additive_poisson($mu,$ndarray);
Example:
$rng->ran_additive_poisson(1,$image);
ran_feed_poisson
This method simulates shot noise, taking the values of ndarray as values for $mu to be fed
in the poissonian RNG.
Usage:
$rng->ran_feed_poisson($ndarray);
Example:
$rng->ran_feed_poisson($image);
ran_bernoulli
Fills output ndarray with random values 0 or 1, the result of a Bernoulli trial with
probability $p.
Usage:
$ndarray = $rng->ran_bernoulli($p,[list of integers = output ndarray dims]);
$rng->ran_bernoulli($p,$output_ndarray);
ran_bernoulli_var
Similar to "ran_bernoulli" except that it takes the distribution parameters as an ndarray
and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_bernoulli_var($p_ndarray);
ran_beta
Fills output ndarray with random variates from the beta distribution with parameters $pa
and $pb.
Usage:
$ndarray = $rng->ran_beta($pa,$pb,[list of integers = output ndarray dims]);
$rng->ran_beta($pa,$pb,$output_ndarray);
ran_beta_var
Similar to "ran_beta" except that it takes the distribution parameters as an ndarray and
returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_beta_var($a_ndarray, $b_ndarray);
ran_binomial
Fills output ndarray with random integer values from the binomial distribution, the number
of successes in $n independent trials with probability $p.
Usage:
$ndarray = $rng->ran_binomial($p,$n,[list of integers = output ndarray dims]);
$rng->ran_binomial($p,$n,$output_ndarray);
ran_binomial_var
Similar to "ran_binomial" except that it takes the distribution parameters as an ndarray
and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_binomial_var($p_ndarray, $n_ndarray);
ran_cauchy
Fills output ndarray with random variates from the Cauchy distribution with scale
parameter $pa.
Usage:
$ndarray = $rng->ran_cauchy($pa,[list of integers = output ndarray dims]);
$rng->ran_cauchy($pa,$output_ndarray);
ran_cauchy_var
Similar to "ran_cauchy" except that it takes the distribution parameters as an ndarray and
returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_cauchy_var($a_ndarray);
ran_chisq
Fills output ndarray with random variates from the chi-squared distribution with $nu
degrees of freedom.
Usage:
$ndarray = $rng->ran_chisq($nu,[list of integers = output ndarray dims]);
$rng->ran_chisq($nu,$output_ndarray);
ran_chisq_var
Similar to "ran_chisq" except that it takes the distribution parameters as an ndarray and
returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_chisq_var($nu_ndarray);
ran_exponential
Fills output ndarray with random variates from the exponential distribution with mean $mu.
Usage:
$ndarray = $rng->ran_exponential($mu,[list of integers = output ndarray dims]);
$rng->ran_exponential($mu,$output_ndarray);
ran_exponential_var
Similar to "ran_exponential" except that it takes the distribution parameters as an
ndarray and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_exponential_var($mu_ndarray);
ran_exppow
Fills output ndarray with random variates from the exponential power distribution with
scale parameter $pa and exponent $pb.
Usage:
$ndarray = $rng->ran_exppow($pa,$pb,[list of integers = output ndarray dims]);
$rng->ran_exppow($pa,$pb,$output_ndarray);
ran_exppow_var
Similar to "ran_exppow" except that it takes the distribution parameters as an ndarray and
returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_exppow_var($a_ndarray, $b_ndarray);
ran_fdist
Fills output ndarray with random variates from the F-distribution with degrees of freedom
$nu1 and $nu2.
Usage:
$ndarray = $rng->ran_fdist($nu1, $nu2,[list of integers = output ndarray dims]);
$rng->ran_fdist($nu1, $nu2,$output_ndarray);
ran_fdist_var
Similar to "ran_fdist" except that it takes the distribution parameters as an ndarray and
returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_fdist_var($nu1_ndarray, $nu2_ndarray);
ran_flat
Fills output ndarray with random variates from the flat (uniform) distribution from $la to
$lb.
Usage:
$ndarray = $rng->ran_flat($la,$lb,[list of integers = output ndarray dims]);
$rng->ran_flat($la,$lb,$output_ndarray);
ran_flat_var
Similar to "ran_flat" except that it takes the distribution parameters as an ndarray and
returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_flat_var($a_ndarray, $b_ndarray);
ran_gamma
Fills output ndarray with random variates from the gamma distribution.
Usage:
$ndarray = $rng->ran_gamma($pa,$pb,[list of integers = output ndarray dims]);
$rng->ran_gamma($pa,$pb,$output_ndarray);
ran_gamma_var
Similar to "ran_gamma" except that it takes the distribution parameters as an ndarray and
returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_gamma_var($a_ndarray, $b_ndarray);
ran_geometric
Fills output ndarray with random integer values from the geometric distribution, the
number of independent trials with probability $p until the first success.
Usage:
$ndarray = $rng->ran_geometric($p,[list of integers = output ndarray dims]);
$rng->ran_geometric($p,$output_ndarray);
ran_geometric_var
Similar to "ran_geometric" except that it takes the distribution parameters as an ndarray
and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_geometric_var($p_ndarray);
ran_gumbel1
Fills output ndarray with random variates from the Type-1 Gumbel distribution.
Usage:
$ndarray = $rng->ran_gumbel1($pa,$pb,[list of integers = output ndarray dims]);
$rng->ran_gumbel1($pa,$pb,$output_ndarray);
ran_gumbel1_var
Similar to "ran_gumbel1" except that it takes the distribution parameters as an ndarray
and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_gumbel1_var($a_ndarray, $b_ndarray);
ran_gumbel2
Fills output ndarray with random variates from the Type-2 Gumbel distribution.
Usage:
$ndarray = $rng->ran_gumbel2($pa,$pb,[list of integers = output ndarray dims]);
$rng->ran_gumbel2($pa,$pb,$output_ndarray);
ran_gumbel2_var
Similar to "ran_gumbel2" except that it takes the distribution parameters as an ndarray
and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_gumbel2_var($a_ndarray, $b_ndarray);
ran_hypergeometric
Fills output ndarray with random integer values from the hypergeometric distribution. If
a population contains $n1 elements of type 1 and $n2 elements of type 2 then the
hypergeometric distribution gives the probability of obtaining $x elements of type 1 in $t
samples from the population without replacement.
Usage:
$ndarray = $rng->ran_hypergeometric($n1, $n2, $t,[list of integers = output ndarray dims]);
$rng->ran_hypergeometric($n1, $n2, $t,$output_ndarray);
ran_hypergeometric_var
Similar to "ran_hypergeometric" except that it takes the distribution parameters as an
ndarray and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_hypergeometric_var($n1_ndarray, $n2_ndarray, $t_ndarray);
ran_laplace
Fills output ndarray with random variates from the Laplace distribution with width $pa.
Usage:
$ndarray = $rng->ran_laplace($pa,[list of integers = output ndarray dims]);
$rng->ran_laplace($pa,$output_ndarray);
ran_laplace_var
Similar to "ran_laplace" except that it takes the distribution parameters as an ndarray
and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_laplace_var($a_ndarray);
ran_levy
Fills output ndarray with random variates from the Levy symmetric stable distribution with
scale $c and exponent $alpha.
Usage:
$ndarray = $rng->ran_levy($mu,$x,[list of integers = output ndarray dims]);
$rng->ran_levy($mu,$x,$output_ndarray);
ran_levy_var
Similar to "ran_levy" except that it takes the distribution parameters as an ndarray and
returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_levy_var($mu_ndarray, $a_ndarray);
ran_logarithmic
Fills output ndarray with random integer values from the logarithmic distribution.
Usage:
$ndarray = $rng->ran_logarithmic($p,[list of integers = output ndarray dims]);
$rng->ran_logarithmic($p,$output_ndarray);
ran_logarithmic_var
Similar to "ran_logarithmic" except that it takes the distribution parameters as an
ndarray and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_logarithmic_var($p_ndarray);
ran_logistic
Fills output ndarray with random random variates from the logistic distribution.
Usage:
$ndarray = $rng->ran_logistic($m,[list of integers = output ndarray dims]u)
$rng->ran_logistic($m,$output_ndarray)
ran_logistic_var
Similar to "ran_logistic" except that it takes the distribution parameters as an ndarray
and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_logistic_var($m_ndarray);
ran_lognormal
Fills output ndarray with random variates from the lognormal distribution with parameters
$mu (location) and $sigma (scale).
Usage:
$ndarray = $rng->ran_lognormal($mu,$sigma,[list of integers = output ndarray dims]);
$rng->ran_lognormal($mu,$sigma,$output_ndarray);
ran_lognormal_var
Similar to "ran_lognormal" except that it takes the distribution parameters as an ndarray
and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_lognormal_var($mu_ndarray, $sigma_ndarray);
ran_negative_binomial
Fills output ndarray with random integer values from the negative binomial distribution,
the number of failures occurring before $n successes in independent trials with
probability $p of success. Note that $n is not required to be an integer.
Usage:
$ndarray = $rng->ran_negative_binomial($p,$n,[list of integers = output ndarray dims]);
$rng->ran_negative_binomial($p,$n,$output_ndarray);
ran_negative_binomial_var
Similar to "ran_negative_binomial" except that it takes the distribution parameters as an
ndarray and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_negative_binomial_var($p_ndarray, $n_ndarray);
ran_pareto
Fills output ndarray with random variates from the Pareto distribution of order $pa and
scale $lb.
Usage:
$ndarray = $rng->ran_pareto($pa,$lb,[list of integers = output ndarray dims]);
$rng->ran_pareto($pa,$lb,$output_ndarray);
ran_pareto_var
Similar to "ran_pareto" except that it takes the distribution parameters as an ndarray and
returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_pareto_var($a_ndarray, $b_ndarray);
ran_pascal
Fills output ndarray with random integer values from the Pascal distribution. The Pascal
distribution is simply a negative binomial distribution (see "ran_negative_binomial") with
an integer value of $n.
Usage:
$ndarray = $rng->ran_pascal($p,$n,[list of integers = output ndarray dims]);
$rng->ran_pascal($p,$n,$output_ndarray);
ran_pascal_var
Similar to "ran_pascal" except that it takes the distribution parameters as an ndarray and
returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_pascal_var($p_ndarray, $n_ndarray);
ran_rayleigh
Fills output ndarray with random variates from the Rayleigh distribution with scale
parameter $sigma.
Usage:
$ndarray = $rng->ran_rayleigh($sigma,[list of integers = output ndarray dims]);
$rng->ran_rayleigh($sigma,$output_ndarray);
ran_rayleigh_var
Similar to "ran_rayleigh" except that it takes the distribution parameters as an ndarray
and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_rayleigh_var($sigma_ndarray);
ran_rayleigh_tail
Fills output ndarray with random variates from the tail of the Rayleigh distribution with
scale parameter $sigma and a lower limit of $la.
Usage:
$ndarray = $rng->ran_rayleigh_tail($la,$sigma,[list of integers = output ndarray dims]);
$rng->ran_rayleigh_tail($x,$sigma,$output_ndarray);
ran_rayleigh_tail_var
Similar to "ran_rayleigh_tail" except that it takes the distribution parameters as an
ndarray and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_rayleigh_tail_var($a_ndarray, $sigma_ndarray);
ran_tdist
Fills output ndarray with random variates from the t-distribution (AKA Student's
t-distribution) with $nu degrees of freedom.
Usage:
$ndarray = $rng->ran_tdist($nu,[list of integers = output ndarray dims]);
$rng->ran_tdist($nu,$output_ndarray);
ran_tdist_var
Similar to "ran_tdist" except that it takes the distribution parameters as an ndarray and
returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_tdist_var($nu_ndarray);
ran_ugaussian_tail
Fills output ndarray with random variates from the upper tail of a Gaussian distribution
with "standard deviation = 1" (AKA unit Gaussian distribution).
Usage:
$ndarray = $rng->ran_ugaussian_tail($tail,[list of integers = output ndarray dims]);
$rng->ran_ugaussian_tail($tail,$output_ndarray);
ran_ugaussian_tail_var
Similar to "ran_ugaussian_tail" except that it takes the distribution parameters as an
ndarray and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_ugaussian_tail_var($tail_ndarray);
ran_weibull
Fills output ndarray with random variates from the Weibull distribution with scale $pa and
exponent $pb. (Some literature uses "lambda" for $pa and "k" for $pb.)
Usage:
$ndarray = $rng->ran_weibull($pa,$pb,[list of integers = output ndarray dims]);
$rng->ran_weibull($pa,$pb,$output_ndarray);
ran_weibull_var
Similar to "ran_weibull" except that it takes the distribution parameters as an ndarray
and returns an ndarray of equal dimensions.
Usage:
$ndarray = $rng->ran_weibull_var($a_ndarray, $b_ndarray);
ran_dir
Returns $n random vectors in $ndim dimensions.
Usage:
$ndarray = $rng->ran_dir($ndim,$n);
Example:
$o = $rng->ran_dir($ndim,$n);
ran_discrete_preproc
This method returns a handle that must be used when calling "ran_discrete". You specify
the probability of the integer number that are returned by "ran_discrete".
Usage:
$discrete_dist_handle = $rng->ran_discrete_preproc($double_ndarray_prob);
Example:
$prob = pdl [0.1,0.3,0.6];
$ddh = $rng->ran_discrete_preproc($prob);
$o = $rng->ran_discrete($discrete_dist_handle,100);
ran_discrete
Is used to get the desired samples once a proper handle has been enstablished (see
ran_discrete_preproc()).
Usage:
$ndarray = $rng->ran_discrete($discrete_dist_handle,$num);
Example:
$prob = pdl [0.1,0.3,0.6];
$ddh = $rng->ran_discrete_preproc($prob);
$o = $rng->ran_discrete($discrete_dist_handle,100);
ran_ver
Returns an ndarray with $n values generated by the Verhulst map from $x0 and parameter $r.
Usage:
$rng->ran_ver($x0, $r, $n);
ran_caos
Returns values from Verhuls map with "$r=4.0" and randomly chosen $x0. The values are
scaled by $m.
Usage:
$rng->ran_caos($m,$n);
BUGS
Feedback is welcome. Log bugs in the PDL bug database (the database is always linked from
<http://pdl.perl.org/>).
SEE ALSO
PDL
The GSL documentation for random number distributions is online at
<https://www.gnu.org/software/gsl/doc/html/randist.html>
AUTHOR
This file copyright (C) 1999 Christian Pellegrin <chri@infis.univ.trieste.it> Docs mangled
by C. Soeller. All rights reserved. There is no warranty. You are allowed to redistribute
this software / documentation under certain conditions. For details, see the file COPYING
in the PDL distribution. If this file is separated from the PDL distribution, the
copyright notice should be included in the file.
The GSL RNG and randist modules were written by James Theiler.