[rand.eng.lcong]

A linear_congruential_engine random number engine produces unsigned integer random numbers.

The state x

{i of a linear_congruential_engine object x is of size 1 and consists of a single integer .}_{i of a linear_congruential_engine object x is of size 1 and consists of a single integer .}

The transition algorithm is a modular linear function of the form

T A (x {i) = (a \cdot x {i + c) mod m; the generation algorithm is G A (x {i) = x {i + 1 .}_{i + 1 .}}_{i) = x {i + 1 .}_{i + 1 .}}}_{i + c) mod m; the generation algorithm is G A (x {i) = x {i + 1 .}_{i + 1 .}}_{i) = x {i + 1 .}_{i + 1 .}}}}_{i) = (a \cdot x {i + c) mod m; the generation algorithm is G A (x {i) = x {i + 1 .}_{i + 1 .}}_{i) = x {i + 1 .}_{i + 1 .}}}_{i + c) mod m; the generation algorithm is G A (x {i) = x {i + 1 .}_{i + 1 .}}_{i) = x {i + 1 .}_{i + 1 .}}}}

🔗

namespace std { template<class UIntType, UIntType a, UIntType c, UIntType m> class linear_congruential_engine { public: / types using result_type = UIntType; / engine characteristics static constexpr result_type multiplier = a; static constexpr result_type increment = c; static constexpr result_type modulus = m; static constexpr result_type min() { return c == 0u ? 1u: 0u; } static constexpr result_type max() { return m - 1u; } static constexpr result_type default_seed = 1u; / constructors and seeding functions linear_congruential_engine() : linear_congruential_engine(default_seed) {} explicit linear_congruential_engine(result_type s); template<class Sseq> explicit linear_congruential_engine(Sseq& q); void seed(result_type s = default_seed); template<class Sseq> void seed(Sseq& q); / equality operators friend bool operator=(const linear_congruential_engine& x, const linear_congruential_engine& y); / generating functions result_type operator()(); void discard(unsigned long z); / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, / hosted const linear_congruential_engine& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, / hosted linear_congruential_engine& x); }; }

If the template parameter m is 0, the modulus m used throughout [rand.eng.lcong] is numeric_limits<result_type>::max() plus 1.

[Note 1:

m need not be representable as a value of type result_type.

— end note]

If the template parameter m is not 0, the following relations shall hold: a < m and c < m.

The textual representation consists of the value of x

{i .}_{i .}

🔗

explicit linear_congruential_engine(result_type s);

Effects: If

c mod m is 0 and s mod m is 0, sets the engine's state to 1, otherwise sets the engine's state to s mod m .

🔗

template<class Sseq> explicit linear_congruential_engine(Sseq& q);

Effects: With

k = ⌈ log {2 m 32 ⌉ and a an array (or equivalent) of length k + 3, invokes q . generate (a + 0, a + k + 3) and then computes S = ({\sum k - 1 j = 0 {a j + 3 \cdot {2 32 j) mod m .}^{32 j) mod m .}}_{j + 3 \cdot {2 32 j) mod m .}^{32 j) mod m .}}}^{k - 1 j = 0 {a j + 3 \cdot {2 32 j) mod m .}^{32 j) mod m .}}_{j + 3 \cdot {2 32 j) mod m .}^{32 j) mod m .}}}}_{2 m 32}

c mod m is 0 and S is 0, sets the engine's state to 1, else sets the engine's state to S .