64-bit PCG Randomstate¶

Random generator¶

class randomstate.prng.pcg64.RandomState(seed=None)¶

Container for the PCG-64 pseudo-random number generator.

PCG-64 is a 128-bit implementation of O’Neill’s permutation congruential generator ([1], [2]). PCG-64 has a period of \(2^{128}\) and supports advancing an arbitrary number of steps as well as \(2^{127}\) streams.

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

pcg64.RandomState does not make a guarantee that a fixed seed and a fixed series of calls to pcg64.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, long}, optional) – Random seed initializing the pseudo-random number generator. Can be an integer in [0, 2**128] or None (the default). If seed is None, then pcg64.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.
inc ({None, int}, optional) – Stream to return. Can be an integer in [0, 2**128] or None (the default). If inc is None, then 1 is used. Can be used with the same seed to produce multiple streams using other values of inc.

Notes

Supports the method advance to advance the PRNG an arbitrary number of steps. The state of the PCG-64 PRNG is represented by 2 128-bit unsigned integers.

See pcg32 for a similar implementation with a smaller period.

Parallel Features

pcg64.RandomState can be used in parallel applications in one of two ways. The preferable method is to use sub-streams, which are generated by using the same value of seed and incrementing the second value, inc.

>>> import randomstate.prng.pcg64 as rnd
>>> rs = [rng.RandomState(1234, i + 1) for i in range(10)]

The alternative method is to call advance on a single RandomState to produce non-overlapping sequences.

>>> import randomstate.prng.pcg64 as rnd
>>> rs = [rng.RandomState(1234, 1) for _ in range(10)]
>>> for i in range(10):
        rs[i].advance(i * 2**64)

State and Seeding

The pcg64.RandomState state vector consists of 2 unsigned 128-bit values, which are represented externally as python longs (2.x) or ints (Python 3+). pcg64.RandomState is seeded using a single 128-bit unsigned integer (Python long/int). In addition, a second 128-bit unsigned integer is used to set the stream.

References

[1]	“PCG, A Family of Better Random Number Generators”, http://www.pcg-random.org/

[2]	O’Neill, Melissa E. “PCG: A Family of Simple Fast Space-Efficient Statistically Good Algorithms for Random Number Generation”

`seed`([seed, stream])	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.

Parallel generation¶

advance(delta) Advance the underlying PRNG as-if delta draws have occurred.

Simple random data¶

`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

Permutations¶

`shuffle`(x)	Modify a sequence in-place by shuffling its contents.
`permutation`(x)	Randomly permute a sequence, or return a permuted range.

Distributions¶

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

Table Of Contents