Pseudo-random number generation

From cppreference.com
 
 
 
Pseudo-random number generation
Engines and engine adaptors
linear_congruential_engine (C++11)
mersenne_twister_engine (C++11)
subtract_with_carry_engine (C++11)
discard_block_engine (C++11)
independent_bits_engine (C++11)
shuffle_order_engine (C++11)
Generators
random_device (C++11)
Distributions
Uniform distributions
uniform_int_distribution (C++11)
uniform_real_distribution (C++11)
generate_canonical (C++11)
Bernoulli distributions
bernoulli_distribution (C++11)
binomial_distribution (C++11)
negative_binomial_distribution (C++11)
geometric_distribution (C++11)
Poisson distributions
poisson_distribution (C++11)
exponential_distribution (C++11)
gamma_distribution (C++11)
weibull_distribution (C++11)
extreme_value_distribution (C++11)
Normal distributions
normal_distribution (C++11)
lognormal_distribution (C++11)
chi_squared_distribution (C++11)
cauchy_distribution (C++11)
fisher_f_distribution (C++11)
student_t_distribution (C++11)
Sampling distributions
discrete_distribution (C++11)
piecewise_constant_distribution (C++11)
piecewise_linear_distribution (C++11)
Seed Sequences
seed_seq (C++11)
C library
rand
srand
RAND_MAX
 

The random number library provides a set of generator engines (both pseudo-random number generators, which generate integer sequences with a uniform distribution, and true random number generators if available) and a set of random number distribution classes which convert the uniform distribution of the generator engines into various statistical distributions.

All of the generator engines may be specifically seeded, serialized, and deserialized for use with repeatable simulators.

Contents

[edit] Random number engines

Random number engines generate pseudo-random numbers using seed data as entropy source. Several different classes of pseudo-random number generation algorithms are implemented as templates that can be customized.

The choice of which engine to use involves a number of tradeoffs: the linear congruential engine is moderately fast and has a very small storage requirement for state. The lagged Fibonacci generators are very fast even on processors without advanced arithmetic instruction sets, at the expense of greater state storage and sometimes less desirable spectral characteristics. The Mersenne twister is slower and has greater state storage requirements but with the right parameters has the longest non-repeating sequence with the most desirable spectral characteristics (for a given definition of desirable).

Defined in header <random>
implements linear congruential algorithm
(class template)
implements Mersenne twister algorithm
(class template)
implements subtract with carry (a lagged Fibonacci) algorithm
(class template)

[edit] Random number engine adaptors

Random number engine adaptors generate pseudo-random numbers using another random number engine as entropy source. They are generally used to alter the spectral characteristics of the underlying engine.

Defined in header <random>
discards some output of a random number engine
(class template)
packs the output of a random number engine into blocks of specified number of bits
(class template)
delivers the output of a random number engine in different order
(class template)

[edit] Predefined random number generators

Several specific popular algorithms are predefined.

Defined in header <random>
Type Definition
minstd_rand0 std::linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
minstd_rand std::linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
mt19937 std::mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,

                             0x9908b0df, 11,
                             0xffffffff, 7,
                             0x9d2c5680, 15,
                             0xefc60000, 18, 1812433253>

mt19937_64 std::mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,

                             0xb5026f5aa96619e9, 29,
                             0x5555555555555555, 17,
                             0x71d67fffeda60000, 37,
                             0xfff7eee000000000, 43, 6364136223846793005>

ranlux24_base std::subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
ranlux48_base std::subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
ranlux24 std::discard_block_engine<ranlux24_base, 223, 23>
ranlux48 std::discard_block_engine<ranlux48_base, 389, 11>
knuth_b std::shuffle_order_engine<minstd_rand0, 256>
default_random_engine implementation-defined
non-deterministic random number generator using hardware entropy source
(class)

[edit] Random number distributions

Random number distributions are post-process the output of an random number engine or adaptors in such a way that resulting output is distributed on a defined statistical probability density function.

Defined in header <random>
Uniform distributions
produces integer values evenly distributed across a range
(class template)
produces real values evenly distributed across a range
(class template)
evenly distributes real values of given precision across [0, 1)
(function template)
Bernoulli distributions
produces bool values on a Bernoulli distribution.
(class)
produces integer values on a binomial distribution.
(class template)
produces integer values on a negative binomial distribution.
(class template)
produces integer values on a geometric distribution.
(class template)
Poisson distributions
produces integer values on a poisson distribution.
(class template)
produces real values on an exponential distribution.
(class template)
produces real values on an gamma distribution.
(class template)
produces real values on a Weibull distribution.
(class template)
produces real values on an extreme value distribution.
(class template)
Normal distributions
produces real values on a standard normal (Gaussian) distribution.
(class template)
produces real values on a lognormal distribution.
(class template)
produces real values on a chi-squared distribution.
(class template)
produces real values on a Cauchy distribution.
(class template)
produces real values on a Fisher's F-distribution.
(class template)
produces real values on a Student's t-distribution.
(class template)
Sampling distributions
produces random integers on a discrete distribution.
(class template)
produces real values distributed on constant subintervals.
(class template)
produces real values distributed on defined subintervals.
(class template)

[edit] Predefined seed sequence generators

Defined in header <random>
(C++11)
general-purpose bias-eliminating scrambled seed sequence generator
(class)

[edit] C library

Defined in header <cstdlib>
generates a pseudo-random number
(function)
initializes pseudo-random number generator
(function)
maximum possible value generated by std::rand
(macro constant)