std::mersenne_twister_engine

template<
    class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r,
    UIntType a, std::size_t u, UIntType d, std::size_t s,
    UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f
> class mersenne_twister_engine;

mersenne_twister_engine is a random number engine based on Mersenne Twister algorithm. It produces high quality, but not cryptographically secure, unsigned integer random numbers of type UIntType on the interval \(\scriptsize {[0,2^w)}\)[0, 2^w).

Template parameters

If any of the following restrictions is violated, the program is ill-formed:

• m is in [1, n].
• The following expressions are all true:
• w >= 3
• w >= r
• w >= u
• w >= s
• w >= t
• w >= l
• w <= std::numeric_limits<UIntType>::digits
• Given (1u << w) - 1u as w1, the following expressions are all true:
• a <= w1
• b <= w1
• c <= w1
• d <= w1
• f <= w1

Generator properties

The size of the states of mersenne_twister_engine is n, each of them consists of a sequence X of n values of type result_type. \(\scriptsize X_j\)X_j stands for the \(\scriptsize j\mod n\)j mod nth value (starting from 0) of X.

Given the following bitwise operation notations:

• \(\scriptsize \mathsf{bitand}\)bitand, built-in bitwise AND.
• \(\scriptsize \mathsf{xor}\)xor, built-in bitwise XOR.
• \(\scriptsize \mathsf{lshift}\)lshift, built-in bitwise left-shift.
• \(\scriptsize \mathsf{rshift}\)rshift, built-in bitwise right-shift.

The transition algorithm of mersenne_twister_engine (\(\scriptsize TA(x_i)\)TA(x_i)) is defined as follows:

1. Concatenate the upper w - r bits of \(\scriptsize X_{i-n}\)X_i-n with the lower r bits of \(\scriptsize X_{i+1-n}\)X_i+1-n to obtain an unsigned integer value Y.
2. Let y be \(\scriptsize a \cdot (Y\ \mathsf{bitand}\ 1)\)a·(Y bitand 1), and set \(\scriptsize X_i\)X_i to \(\scriptsize X_{i+m−n}\ \mathsf{xor}\ (Y\ \mathsf{rshift}\ 1)\ \mathsf{xor}\ y\)X_i+m−n xor (Y rshift 1) xor y.

The generation algorithm of mersenne_twister_engine (\(\scriptsize GA(x_i)\)GA(x_i)) is defined as follows:

1. Let \(\scriptsize z_1\)z₁ be \(\scriptsize X_i\ \mathsf{xor}\ ((X_i\ \mathsf{rshift}\ u)\ \mathsf{bitand}\ d)\)X_i xor ((X_i rshift u) bitand d).
2. Let \(\scriptsize z_2\)z₂ be \(\scriptsize z_1\ \mathsf{xor}\ (((z_1\ \mathsf{lshift}\ s)\mod 2^w)\ \mathsf{bitand}\ b)\)X_i xor (((X_i lshift s) mod 2^w) bitand b).
3. Let \(\scriptsize z_3\)z₃ be \(\scriptsize z_2\ \mathsf{xor}\ (((z_2\ \mathsf{lshift}\ t)\mod 2^w)\ \mathsf{bitand}\ c)\)X_i xor (((X_i lshift t) mod 2^w) bitand c).
4. Let \(\scriptsize z_4\)z₄ be \(\scriptsize z_3\ \mathsf{xor}\ (z_3\ \mathsf{rshift}\ l)\)z₃ xor (z₃ rshift l).
5. Deliver \(\scriptsize z_4\)z₄ as the result (i.e. \(\scriptsize GA(x_i)=z_4\)GA(x_i)=z₄).

Predefined specializations

The following specializations define the random number engine with two commonly used parameter sets:

Nested types

Data members

Member functions

Non-member functions

Example