Pseudo-random number generation

The random number library provides classes that generate random and pseudo-random numbers. These classes include:

• Uniform random bit generators (URBGs), which include both random number engines, which are pseudo-random number generators that generate integer sequences with a uniform distribution, and true random number generators (if available).
• Random number distributions (e.g. uniform, normal, or poisson distributions

URBGs and distributions are designed to be used together to produce random values. All of the random number engines may be specifically seeded, serialized, and de-serialized for use with repeatable simulators.

Uniform random bit generators

A uniform random bit generator is a function object returning unsigned integer values such that each value in the range of possible results has (ideally) equal probability of being returned.

All uniform random bit generators meet the UniformRandomBitGenerator requirements. C++20 also defines a uniform_random_bit_generator

Random number engines

A random number engine (commonly shortened to engine ) is a uniform random bit generator which generates pseudo-random numbers using seed data as entropy source.

At any given time, an engine e of type E has a state e_i for some non-negative integer i. Upon construction, e has an initial state e₀

The following properties are always defined for any engine type E:

• The size of E’s state in multiples of the size of E::result_type (i.e. (sizeof e _i ) / sizeof(E::result_type)
• The transition algorithm TA by which e’s state e_i is advanced to its successor state e_i+1 (i.e. TA(e _i ) == e _i+1
• The generation algorithm GA by which e’s state is mapped to a value of type E::result_type

A pseudo-random number sequence can be generated by calling TA and GA alternatively.

The standard library provides the implementations of three different classes of pseudo-random number generation algorithms as class templates, so that the algorithms can be customized. The choice of which engine to use involves a number of trade-offs:

• The linear congruential engine is moderately fast and has a very small storage requirement for state.
• The Mersenne twister engine
• The subtract with carry engine

None of these random number engines are cryptographically secure OpenSSL RAND_bytes

All types instantiated from these templates meet the RandomNumberEngine

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.

Predefined random number generators

Several specific popular algorithms are predefined.

Non-deterministic random numbers

std::random_device is a non-deterministic uniform random bit generator, although implementations are allowed to implement std::random_device

Random number distributions

A random number distribution post-processes the output of a URBG in such a way that resulting output is distributed according to a defined statistical probability density function.

Random number distributions satisfy RandomNumberDistribution

Utilities

Random number algorithms

C random library

In addition to the engines and distributions described above, the functions and constants from the C random library are also available though not recommended:

Example

#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <random>
#include <string>
 
int main()
{
    // Seed with a real random value, if available
    std::random_device r;
 
    // Choose a random mean between 1 and 6
    std::default_random_engine e1(r());
    std::uniform_int_distribution<int> uniform_dist(1, 6);
    int mean = uniform_dist(e1);
    std::cout << "Randomly-chosen mean: " << mean << '\n';
 
    // Generate a normal distribution around that mean
    std::seed_seq seed2{r(), r(), r(), r(), r(), r(), r(), r()};
    std::mt19937 e2(seed2);
    std::normal_distribution<> normal_dist(mean, 2);
 
    std::map<int, int> hist;
    for (int n = 0; n != 10000; ++n)
        ++hist[std::round(normal_dist(e2))];
 
    std::cout << "Normal distribution around " << mean << ":\n"
              << std::fixed << std::setprecision(1);
    for (auto [x, y] : hist)
        std::cout << std::setw(2) << x << ' ' << std::string(y / 200, '*') << '\n';
}

Randomly-chosen mean: 4
Normal distribution around 4:
-4
-3
-2
-1
 0 *
 1 ***
 2 ******
 3 ********
 4 *********
 5 ********
 6 ******
 7 ***
 8 *
 9
10
11
12

See also