Psuedo random number generators

[wolfram77]

Pseudo random numbers can be generated quickly, when you need a lot of them. May be useful for Procedural generation or Monte Carlo simulation.

haskell/random

High level

• RandomGen: Interface to pure PRNG
• StdGen: Standard PRNG
• Random: Generate random "number"
• uniform(): Uniform over type range
• uniformR(): Uniform over given range
• splitmix: Fast Splittable PRNG

RandomGen class

• genWord8()
• genWord16()
• genWord32()
• genWord64()
• genWord32R()
• genWord64R()
• genShortByteString()
• split(): Return two PRNGs
• uniform()
• uniformM(): Pure uniform()
• uniformR()
• uniformRM(): Pure uniformR()
• genByteString()

Random class

• randomR()
• random()
• randomRs(): Generator version of randomR()
• randoms(): Generator version of random()

StdGen class

• mkStdGen(): Deterministic
• initStdGen(): Use system entropy

The are also global variants of the functions.

[wolfram77]

purescript/purescript-random

• random(): 0 -> 1
• randomInt(): low -> high inclusive
• randomRange(): float low -> high exclusive
• randomBool(): true/false

[wolfram77]

ericzhang-cn/random.js

Continuous Distributions

• arcsine(min, max)
• beta(v, w, min, max)
• cauchy(a, b)
• chiSquare(df)
• consine(min, max)
• doubleLog(min, max)
• erlang(b, c)
• exponential(a, b)
• extremeValue(a, b)
• fRatio(v, w)
• gamma(a, b, c)
• laplace(a, b)
• logarithmic(min, max)
• logistic(a, b)
• lognormal(a, mu, sigma)
• normal(mu, sigma)
• parabolic(min, max)
• pareto(c)
• pearson5(b, c)
• pearson6(b, v, w)
• power(c)
• rayleigh(a, b)
• studentT(df)
• triangular(min, max, c)
• uniform(min, max)
• userSpecified(usf, xMin, xMax, yMin, yMax)
• weibull(a, b, c)

Discrete Distributions

• bernoulli(p)
• binomial(n, p)
• geometric(p)
• hypergeometric(n, N, k)
• negativeBinomial(s, p)
• pascal(s, p)
• poisson(mu)
• uniformDiscrete(i, j)

[wolfram77]

ckknight/random-js

Math.random() produces numbers within [0, 1), but it has different bits of randomness with different engines (min. 32 bits).

Random engines

Provide values within [0, 4294967295], i.e. 32 bits of randomness.

• nativeMath(): Uses Math.random()
• browserCrypto(): Uses crypto.getRandomValues(Int32Array)
• nodeCrypto(): Uses crypto.randomBytes(size)
• MersenneTwister19937

Mersenne Twister class

• seed(value): With 32-bit value
• seedWithArray(array): With 32-bit integer array
• autoSeed(): With Date/other entropy sources
• next(): Get 32-bit random number
• discard(count): Discard some random values
• getUseCount(): Times engines has been used

Random types

• integer(min, max)(engine)
• real(min, max, inclusive)(engine)
• bool()(engine)
• bool(percentage)(engine)
• bool(numerator, denominator)(engine)
• pick(engine, array[, begin[, end]])
• picker(array[, begin[, end]])(engine)
• shuffle(engine, array)
• sample(engine, population, sampleSize)
• die(sideCount)(engine)
• dice(sideCount, dieCount)(engine)
• uuid4(engine)
• string()(engine, length)
• string(pool)(engine, length)
• hex()(engine, length)
• hex(true)(engine, length)
• date(start, end)(engine)

[wolfram77]

jmcvetta/randutil

• AlphaString(n int) (string, error)
• AlphaStringRange(min, max int) (string, error)
• ChoiceInt(choices []int) (int, error)
• ChoiceString(choices []string) (string, error)
• IntRange(min, max int) (int, error)
• String(n int, charset string) (string, error)
• StringRange(min, max int, charset string) (string, error)
• WeightedChoice(choices []Choice) (Choice, error)

[wolfram77]

AndreasMadsen/xorshift

• xorshift.constructor(seedArray)
• xorshift.random()
• xorshift.randomint(): Returns array of 2 32-bit numbers

[wolfram77]

EOSBlox/random

• accumSeed(number/checksum)
• accumSeedRange(array/vector/string)
• next(): Returns uint64
• nextDouble(): in range 0 -> 1
• nextInRange(uint64, uint64)
• nextSample(string)
• shuffle(string): Modifies string
• sample(n, string): Collects n random values

[wolfram77]

skeeto/rng-js

• RNG(string): Create generator with seed JSON.stringify()
• .random(begin, end)
• .uniform(): 0 -> 1
• .normal()
• .exponential()
• .poisson(mean/variance)
• .gamma(?)

[wolfram77]

JuliaRandom/RandomNumbers.jl

PCG Family

Permuted Congruential Generators (PCGs) are a family of RNGs which uses a linear congruential generator as the state-transition function, and uses permutation functions on tuples to produce output that is much more random than the RNG's internal state.

Each PCG generator is available in four variants, based on how it applies the additive constant for its underlying LCG; the variations are:

• PCGStateOneseq: all instances use the same fixed constant, thus the RNG always somewhere in same sequence.
• PCGStateMCG: adds zero, resulting in a single stream and reduced period.
• PCGStateSetseq: the constant can be changed at any time, selecting a different random sequence.
• PCGStateUnique: the constant is based on the memory address of the object, thus every RNG has its own unique sequence.

PCG Method Type:

• PCG_XSH_RS: high xorshift, followed by a random shift. It's fast and is a good performer.
• PCG_XSH_RR: high xorshift, followed by a random rotate. It's fast and is a good performer. Slightly better statistically than PCG_XSH_RS.
• PCG_RXS_M_XS: fixed xorshift (to low bits), random rotate. The most statistically powerful generator, but all those steps make it slower than some of the others. (but in this package the benchmark shows it's even fast than PCG_XSH_RS, which is an current issue.)
• PCG_XSL_RR: fixed xorshift (to low bits), random rotate. Useful for 128-bit types that are split across two CPU registers.
• PCG_XSL_RR_RR: fixed xorshift (to low bits), random rotate (both parts). Useful for 128-bit types that are split across two CPU registers. Use this in need of an invertable 128-bit RNG.

Mersenne Twisters

The Mersenne Twister is so far the most widely used PRNG. Mersenne Twisters are taken as default random number generators of a great many of software systems, including the Julia language until the current 1.0 version. The most commonly used version of Mersenne Twisters is MT19937, which has a very long period of 2^19937−1 and passes numerous tests including the Diehard tests.

However, it also has many flaws by today's standards. For the large period, MT19937 has to use a 2.5 KiB state buffer, which place a load on the memory caches. More severely, it cannot pass all the TestU01 statistical tests2, and the speed is not so fast. So it is not recommended in most situations.

• MT19937: can only produce UInt32 numbers as output.

Random123 Family

Random123 is a library of "counter-based" random number generators (CBRNGs), developed by D.E.Shaw Research1. Counter-based means the RNGs in this family can produce the Nth number by applying a stateless mixing function to the counter N, instead of the conventional approach of using N iterations of a stateful transformation. The current version of Random123 in this package is 1.09, and there are four kinds of RNGs: Threefry, Philox, AESNI, ARS.

Threefry is a non-cryptographic adaptation of the Threefish block cipher from the Skein Hash Function.

• Threefry4x
• Threefry2x

Philox uses a Feistel network and integer multiplication.

• Philox4x
• Philox2x

AESNI uses the Advanced Encryption Standard (AES) New Instruction, available on certain modern x86 processors (some models of Intel Westmere and Sandy Bridge, and AMD Interlagos, as of 2011). AESNI CBRNGs can operate on UInt128 type.

• AESNI1x
• AESNI4x

ARS (Advanced Randomization System) is a non-cryptographic simplification of AESNI.

• ARS1x
• ARS4x

Xorshift Family

Xorshift family is a class of PRNGs based on linear transformation that takes the exclusive or of a number with a bit-shifted version of itself. They are extremely fast on mordern computer architectures, and are very suitable for non-cryptographically-secure use. The suffix -Star and -Plus in the RNG names denote to two classes of improved RNGs23, which make it to pass Big Crush in TestU01. -Star RNGs are obtained by scrambling the output of a normal Xorshift generator with a 64-bit invertible multiplier, while -Plus RNGs return the sum of two consecutive output of a Xorshift generator.

• Xorshift64
• Xorshift64Star

They have a period of 2^64, but not recommended because 64 bits of state are not enough for any serious purpose.

• Xorshift128
• Xorshift128Star
• Xorshift128Plus

They have a period of 2^128. Xorshift128Plus is presently used in the JavaScript engines of Chrome, Firefox and Safari.

• Xorshift1024
• Xorshift1024Star
• Xorshift1024Plus

They have a long period of 2^1024, and takes some more space for storing the state. If you are running large-scale parallel simulations, it's a good choice to use Xorshift1024Star.

• Xoroshiro128
• Xoroshiro128Star
• Xoroshiro128Plus

The successor to Xorshift128 series. They make use of a carefully handcrafted shift/rotate-based linear transformation, resulting in a significant improvement in speed and in statistical quality. Therefore, Xoroshiro128Plus is the current best suggestion for replacing other low-quality generators.

[wolfram77]

cmcqueen/simplerandom

• Main API functions:
  • Seed
  • Generate "next" random value
  • "Discard" also known as "jumpahead" to skip the generator
    ahead by 'n' samples.
  • Mix real random data into the generator state
• Safe seeding. Many generators have some "bad" state values that must
  be avoided. The seed functions for all generators ensure that any
  "bad" state values are avoided, and replaced by a suitable
  alternative initial state.
• Simple algorithms and state size appropriate for limited RAM and ROM
  (e.g. in embedded systems).
• Reasonable statistical properties of pseudo-random output (though
  not for all generators provided).

Most algorithms were obtained from two newsgroup posts by George Marsaglia (mars1) (mars2). However, some modifications have been made. From (rose1), it seems that the SHR3 algorithm defined in (mars1) is flawed and should not be used. It doesn't actually have a period of 2³²-1 as expected, but has 64 different cycles, some with very short periods. The SHR3 in the 2003 post is very similar, but with two shift values swapped. It has a period of 2³²-1 as expected.

We still find KISS from (mars1) useful mainly because it uses 32-bit calculations for MWC, which can be more suitable for small embedded systems. So we define KISS that uses a MWC based on (mars1), but the Cong and SHR3 from (mars2).

From Pierre L'Ecuyer (lecuyer1) (lecuyer2), the Combined LFSR (Tausworthe) LFSR113 algorithm (lecuyer3) and LFSR88 (aka Taus88) have been implemented.

Random Number Generators Provided

The following pseudo-random number generators are provided:

Generator	Notes
MWC1	Two 32-bit MWCs combined. From (mars1).
MWC2	Very similar to MWC1, but slightly modified to improve its statistical properties.
Cong	From (mars2).
SHR3	From (mars2).
MWC64	A single 64-bit multiply-with-carry calculation. From (mars2).
KISS	Combination of MWC2, Cong and SHR3. Based on (mars1) but using Cong and SHR3 from (mars2), and the modified MWC.
KISS2	Combination of MWC64, Cong and SHR3. From (mars2).
LFSR113	Combined LFSR (Tausworthe) random number generator by L'Ecuyer. From (lecuyer1) (lecuyer3).
LFSR88	Combined LFSR (Tausworthe) random number generator by L'Ecuyer. From (lecuyer2).

[wolfram77]

lemire/SIMDxorshift

Please check it out.

[wolfram77]

sirleech/TrueRandom

• random(): 0 to 2,147,483,647
• random(n): 0 to n-1
• random(a,b): a to b-1
• randomBit()
• randomByte()
• rand(): 0 to 32,767
• memfill(address, length)
• mac(address): 6 byte MAC address
• uuid(address): 16 bytes long

[wolfram77]

leesper/go_rng

Supported Distributions and Functionalities

• Uniform Distribution
• Bernoulli Distribution
• Chi-Squared Distribution
• Gamma Distribution
• Beta Distribution
• Fisher's F Distribution
• Cauchy Distribution
• Weibull Distribution
• Pareto Distribution
• Log Normal Distribution
• Exponential Distribution
• Student's t-Distribution
• Binomial Distribution
• Poisson Distribution
• Geometric Distribution
• Gaussian Distribution
• Logistic Distribution
• Dirichlet Distribution

Usage

• NewGaussianGenerator(seed)

[wolfram77]

Remaining References

• randoma package by Sindre Sorhus
• Better Random Numbers for Javascript; by Johannes Baagøe, Nick Quinlan
• random package for Nim; by Oleh Prypin
• wyhash for C++; by WangYi
• mir-random for D lang; by Ilia Ki and others
• random_numbers for C++; by Dave Coleman and others
• testingRNG: testing popular random-number generators; by Daniel Lemire and others
• Random-Number-Generator for Android; by Alexander Chiou
• RandomSequence for C++; by Jeff Preshing
• fastrand for Rust; by Taiki Endo and others
• seedrandom package for JavaScript; by David Bau
• Rand for Rust; by Diggory Hardy and others