[rand.eng.philox]

The generation algorithm returns

{Y i, the value stored in the {i th element of Y after applying the transition algorithm .}^{th element of Y after applying the transition algorithm .}}_{i, the value stored in the {i th element of Y after applying the transition algorithm .}^{th element of Y after applying the transition algorithm .}}

The state transition is performed as if by the following algorithm: i = i + 1 if (i == n) { Y = Philox(K, X) / see below Z = Z + 1 i = 0 }

The Philox function maps the length-

n / 2 sequence K and the length- n sequence X into a length- n output sequence Y .

Philox applies an r-round substitution-permutation network to the values in X.

A single round of the generation algorithm performs the following steps:

(4.1)
The output sequence
(4.2)
The following computations are applied to the elements of the V sequence:
X2k+0=mulhi(V2k,Mk,w)xorkeyqkxorV2k+1

After r applications of the single-round function, Philox returns the sequence

Y = {X' .}^{' .}

🔗

namespace std { template<class UIntType, size_t w, size_t n, size_t r, UIntType.. consts> class philox_engine { static constexpr size_t array-size = n / 2; / exposition only public: / types using result_type = UIntType; / engine characteristics static constexpr size_t word_size = w; static constexpr size_t word_count = n; static constexpr size_t round_count = r; static constexpr array<result_type, array-size> multipliers; static constexpr array<result_type, array-size> round_consts; static constexpr result_type min() { return 0; } static constexpr result_type max() { return m - 1; } static constexpr result_type default_seed = 20111115u; / constructors and seeding functions philox_engine() : philox_engine(default_seed) {} explicit philox_engine(result_type value); template<class Sseq> explicit philox_engine(Sseq& q); void seed(result_type value = default_seed); template<class Sseq> void seed(Sseq& q); void set_counter(const array<result_type, n>& counter); / equality operators friend bool operator=(const philox_engine& x, const philox_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, const philox_engine& x); / hosted template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, philox_engine& x); / hosted }; }

The template parameter pack consts represents the

The textual representation consists of the values of

{K 0, \dots, {K n / 2 - 1, {X 0, \dots, {X n - 1, i, in that order .}_{n - 1, i, in that order .}}_{0, \dots, {X n - 1, i, in that order .}_{n - 1, i, in that order .}}}_{n / 2 - 1, {X 0, \dots, {X n - 1, i, in that order .}_{n - 1, i, in that order .}}_{0, \dots, {X n - 1, i, in that order .}_{n - 1, i, in that order .}}}}_{0, \dots, {K n / 2 - 1, {X 0, \dots, {X n - 1, i, in that order .}_{n - 1, i, in that order .}}_{0, \dots, {X n - 1, i, in that order .}_{n - 1, i, in that order .}}}_{n / 2 - 1, {X 0, \dots, {X n - 1, i, in that order .}_{n - 1, i, in that order .}}_{0, \dots, {X n - 1, i, in that order .}_{n - 1, i, in that order .}}}}

[Note 2:

The stream extraction operator can reconstruct Y from K and X, as needed.

— end note]

🔗

explicit philox_engine(result_type value);

Effects: Sets the

{K 0 element of sequence K to value mod {2 w .}^{w .}}_{0 element of sequence K to value mod {2 w .}^{w .}}

All elements of sequences X and K (except

{K 0) are set to 0 .}_{0) are set to 0 .}

The value of i is set to

n - 1 .

🔗

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

Effects: With

p = ⌈ w / 32 ⌉ and an array (or equivalent) a of length (n / 2) \cdot p, invokes q . generate (a + 0, a + n / 2 * p) and then iteratively for k = 0, \dots, n / 2 - 1, sets {K k to ({\sum p - 1 j = 0 {a k p + j \cdot {2 32 j) mod}^{32 j) mod^{.}}}_{k p + j \cdot {2 32 j) mod^{.}}^{32 j) mod {2 .}^{w .}}}}^{p - 1 j = 0 {a k p + j \cdot {2 32 j) mod {2 .}^{w .}}^{32 j) mod {2 w .}^{w .}}}_{k p + j \cdot {2 32 j) mod {2 w .}^{w .}}^{32 j) mod {2 w .}^{w .}}}}}_{k to ({\sum p - 1 j = 0 {a k p + j \cdot {2 32 j) mod^{.}}^{32 j) mod {2 .}^{w .}}}_{k p + j \cdot {2 32 j) mod {2 .}^{w .}}^{32 j) mod {2 w .}^{w .}}}}^{p - 1 j = 0 {a k p + j \cdot {2 32 j) mod {2 w .}^{w .}}^{32 j) mod {2 w .}^{w .}}}_{k p + j \cdot {2 32 j) mod {2 w .}^{w .}}^{32 j) mod {2 w .}^{w .}}}}}

All elements of sequence X are set to 0.

The value of i is set to

n - 1 .

🔗

void set_counter(const array<result_type, n>& c);

Effects: For

j = 0, \dots, n - 1 sets {X j to {C n - 1 - j mod {2 w .}^{w .}}_{n - 1 - j mod {2 w .}^{w .}}}_{j to {C n - 1 - j mod {2 w .}^{w .}}_{n - 1 - j mod {2 w .}^{w .}}}

The value of i is set to

n - 1 .

[Note 3:

The counter is the value Z introduced at the beginning of this subclause.

— end note]