randomstate.prng.mrg32k3a.RandomState(seed=None)¶Container for L’Ecuyer MRG32K3A pseudo-random number generator.
MRG32K3A is a 32-bit implementation of L’Ecuyer’s combined multiple recursive generator [1], [2]. MRG32K3A has a period of \(2^{191}\), supports jumping ahead and is suitable for parallel applications.
mrg32k3a.RandomState exposes a number of methods for generating random
numbers drawn from a variety of probability distributions. In addition to the
distribution-specific arguments, each method takes a keyword argument
size that defaults to None. If size is None, then a single
value is generated and returned. If size is an integer, then a 1-D
array filled with generated values is returned. If size is a tuple,
then an array with that shape is filled and returned.
No Compatibility Guarantee
mrg32k3a.RandomState does not make a guarantee that a fixed seed and a
fixed series of calls to mrg32k3a.RandomState methods using the same
parameters will always produce the same results. This is different from
numpy.random.RandomState guarantee. This is done to simplify improving
random number generators. To ensure identical results, you must use the
same release version.
| Parameters: | seed ({None, int, array_like}, optional) – Random seed initializing the pseudo-random number generator.
Can be an integer in [0, 2**64-1], array of integers in
[0, 2**64-1] or None (the default). If seed is None,
then mrg32k3a.RandomState will try to read data from
/dev/urandom (or the Windows analog) if available. If
unavailable, a 64-bit hash of the time and process ID is used. |
|---|
Notes
The state of the MRG32KA PRNG is represented by 6 64-bit integers.
This implementation is integer based and produces integers in the interval \([0, 2^{32}-209+1]\). These are treated as if they 32-bit random integers.
Parallel Features
mrg32k3a.RandomState can be used in parallel applications by
calling the method jump which advances the state as-if
\(2^{127}\) random numbers have been generated [3]. This
allows the original sequence to be split so that distinct segments can be used
in each worker process. All generators should be initialized with the same
seed to ensure that the segments come from the same sequence.
>>> import randomstate.prng.mrg32k3a as rnd
>>> rs = [rnd.RandomState(12345) for _ in range(10)]
# Advance rs[i] by i jumps
>>> for i in range(10):
rs[i].jump(i)
State and Seeding
The mrg32k3a.RandomState state vector consists of a 6 element array
of 64-bit signed integers plus a single integers value between 0 and 2
indicating the current position within the state vector. The first three
elements of the state vector are in [0, 4294967087) and the second 3 are
in [0, 4294944443).
mrg32k3a.RandomState is seeded using either a single 64-bit unsigned integer
or a vector of 64-bit unsigned integers. In either case, the input seed is
used as an input (or inputs) for another simple random number generator,
Splitmix64, and the output of this PRNG function is used as the initial state.
Using a single 64-bit value for the seed can only initialize a small range of
the possible initial state values. When using an array, the SplitMix64 state
for producing the ith component of the initial state is XORd with the ith
value of the seed array until the seed array is exhausted. When using an array
the initial state for the SplitMix64 state is 0 so that using a single element
array and using the same value as a scalar will produce the same initial state.
References
| [1] | “Software developed by the Canada Research Chair in Stochastic Simulation and Optimization”, http://simul.iro.umontreal.ca/ |
| [2] | Pierre L’Ecuyer, (1999) “Good Parameters and Implementations for Combined Multiple Recursive Random Number Generators.”, Operations Research 47(1):159-164 |
| [3] | L’ecuyer, Pierre, Richard Simard, E. Jack Chen, and W. David Kelton. “An object-oriented random-number package with many long streams and substreams.” Operations research 50, no. 6, pp. 1073-1075, 2002. |
seed([seed]) |
Seed the generator. |
get_state() |
Return a dict containing the internal state of the generator. |
set_state(state) |
Set the internal state of the generator from a tuple. |
jump(iter = 1) |
Jumps the state of the random number generator as-if 2**127 random numbers have been generated. |
rand(d0, d1, …, dn[, dtype]) |
Random values in a given shape. |
randn(d0, d1, …, dn[, method, dtype]) |
Return a sample (or samples) from the “standard normal” distribution. |
randint(low[, high, size, dtype]) |
Return random integers from low (inclusive) to high (exclusive). |
random_integers(low[, high, size]) |
Random integers of type np.int between low and high, inclusive. |
random_sample([size, dtype, out]) |
Return random floats in the half-open interval [0.0, 1.0). |
random |
random_sample(size=None, dtype=’d’, out=None) |
ranf |
random_sample(size=None, dtype=’d’, out=None) |
sample |
random_sample(size=None, dtype=’d’, out=None) |
choice(a[, size, replace, p]) |
Generates a random sample from a given 1-D array |
bytes(length) |
Return random bytes. |
random_uintegers([size, bits]) |
Return random unsigned integers |
random_raw(self[, size]) |
Return randoms as generated by the underlying PRNG |
shuffle(x) |
Modify a sequence in-place by shuffling its contents. |
permutation(x) |
Randomly permute a sequence, or return a permuted range. |
beta(a, b[, size]) |
Draw samples from a Beta distribution. |
binomial(n, p[, size]) |
Draw samples from a binomial distribution. |
chisquare(df[, size]) |
Draw samples from a chi-square distribution. |
complex_normal([loc, gamma, relation, size, …]) |
Draw random samples from a complex normal (Gaussian) distribution. |
dirichlet(alpha[, size]) |
Draw samples from the Dirichlet distribution. |
exponential([scale, size]) |
Draw samples from an exponential distribution. |
f(dfnum, dfden[, size]) |
Draw samples from an F distribution. |
gamma(shape[, scale, size]) |
Draw samples from a Gamma distribution. |
geometric(p[, size]) |
Draw samples from the geometric distribution. |
gumbel([loc, scale, size]) |
Draw samples from a Gumbel distribution. |
hypergeometric(ngood, nbad, nsample[, size]) |
Draw samples from a Hypergeometric distribution. |
laplace([loc, scale, size]) |
Draw samples from the Laplace or double exponential distribution with specified location (or mean) and scale (decay). |
logistic([loc, scale, size]) |
Draw samples from a logistic distribution. |
lognormal([mean, sigma, size]) |
Draw samples from a log-normal distribution. |
logseries(p[, size]) |
Draw samples from a logarithmic series distribution. |
multinomial(n, pvals[, size]) |
Draw samples from a multinomial distribution. |
multivariate_normal(mean, cov[, size, …) |
Draw random samples from a multivariate normal distribution. |
negative_binomial(n, p[, size]) |
Draw samples from a negative binomial distribution. |
noncentral_chisquare(df, nonc[, size]) |
Draw samples from a noncentral chi-square distribution. |
noncentral_f(dfnum, dfden, nonc[, size]) |
Draw samples from the noncentral F distribution. |
normal([loc, scale, size, method]) |
Draw random samples from a normal (Gaussian) distribution. |
pareto(a[, size]) |
Draw samples from a Pareto II or Lomax distribution with specified shape. |
poisson([lam, size]) |
Draw samples from a Poisson distribution. |
power(a[, size]) |
Draws samples in [0, 1] from a power distribution with positive exponent a - 1. |
rayleigh([scale, size]) |
Draw samples from a Rayleigh distribution. |
standard_cauchy([size]) |
Draw samples from a standard Cauchy distribution with mode = 0. |
standard_exponential([size, dtype, method, out]) |
Draw samples from the standard exponential distribution. |
standard_gamma(shape[, size, dtype, method, out]) |
Draw samples from a standard Gamma distribution. |
standard_normal([size, dtype, method, out]) |
Draw samples from a standard Normal distribution (mean=0, stdev=1). |
standard_t(df[, size]) |
Draw samples from a standard Student’s t distribution with df degrees of freedom. |
triangular(left, mode, right[, size]) |
Draw samples from the triangular distribution over the interval [left, right]. |
uniform([low, high, size]) |
Draw samples from a uniform distribution. |
vonmises(mu, kappa[, size]) |
Draw samples from a von Mises distribution. |
wald(mean, scale[, size]) |
Draw samples from a Wald, or inverse Gaussian, distribution. |
weibull(a[, size]) |
Draw samples from a Weibull distribution. |
zipf(a[, size]) |
Draw samples from a Zipf distribution. |