template< class UIntType, std::size_t w, std::size_t n, std::size_t r, UIntType... consts > class philox_engine;		(since C++26)

std::philox_engine is a counter-based random number engine.

Template parameters

UIntType	-	The result type generated by the generator. The effect is undefined if this is not one of unsigned short, unsigned int, unsigned long, or unsigned long long.
w	-	the word size in bits
n	-	the word count
r	-	the round count
consts	-	the sequence of multipliers and round constants used for generating random numbers

If any of the following values is not true, the program is ill-formed:

• sizeof...(consts) == n
• n == 2 || n == 4
• 0 < r
• 0 < w && w <= std::numeric_limits<UIntType>::digits

Generator properties

In the following description, let Qi denote the ith element of sequence Q, where the subscript starts from zero.

The size of the states of philox_engine is O(n), each of them consists of four parts:

• A sequence X of n integer values, where each value is in [0, 2w
).

• This sequence represents a large unsigned integer counter value Z=∑n-1
  j=0X⋅2wj
  of n⋅w bits.

• A sequence K of n / 2 keys of type UIntType.
• A buffer Y of n produced values of type UIntType.
• An index j in Y buffer.

The transition algorithm of philox_engine (TA(Xi)) is defined as follows:

• If j is not n - 1, increments j by 1.^[1]
• If j is n - 1, performs the following operations:^[2]

1. Generates a new sequence of n random values (see below) and stores them in Y.
2. Increments the counter Z by 1.
3. Resets j to 0.

The generation algorithm of philox_engine is GA(Xi)=Yj.

Generating random values

Random values are generated from the following parameters:

• the number of rounds r
• the current counter sequence X
• the key sequence K
• the multiplier sequence M
• the round constant sequence C

The sequences M and C are formed from the values from template parameter pack consts, which represents the Mk and Ck constants as [M0, C0, M1, C1,... , ..., Mn/2-1, Cn/2-1].

Random numbers are generated by the following process:

1. Initializes the output sequence S with the elements of X.
2. Updates the elements of S for r rounds.
3. Replaces the values in the buffer Y with the values in S.

Updating the output sequence

For each round of update, an intermediate sequence V is initialized with the elements of S in a specified order:

n	V0	V1	V2	V3
2	S0	S1	N/A
4	S2	S1	S0	S3

Given the following operation notations:

• xor, built-in bitwise XOR.
• mullo, it calcuates the low half of modular multiplication and is defined as mullo(a,b,w)=(a⋅b) mod 2w
  .
• mulhi, it calcuates the high half of multiplication and is defined as mulhi(a,b,w)=⌊(a⋅b)/2w
  ⌋.

Let q be the current round number (starting from zero), for each integer k in [0, n / 2), the elements of the output sequence S are updated as follows:

• X2⋅k=mulhi(V2⋅k,Mk,w) xor ((Kk+q⋅Ck) mod 2w
  ) xor V2⋅k+1
• X2⋅k+1=mullo(V2⋅k,Mk,w)

Predefined specializations

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

Type	Definition
philox4x32 (C++26)	std::philox_engine<std::uint_fast32_t, 32, 4, 10,                    0xCD9E8D57, 0x9E3779B9,                    0xD2511F53, 0xBB67AE85>[edit]
philox4x64 (C++26)	std::philox_engine<std::uint_fast64_t, 64, 4, 10,                    0xCA5A826395121157, 0x9E3779B97F4A7C15,                    0xD2E7470EE14C6C93, 0xBB67AE8584CAA73B>[edit]

Nested types

Type	Definition
result_type	UIntType

Data members

constexpr std::size_t word_size [static]	w (public static member constant)
constexpr std::size_t word_count [static]	n (public static member constant)
constexpr std::size_t round_count [static]	r (public static member constant)
constexpr multipliers [static]	the multiplier sequence M (public static member constant)
constexpr round_consts [static]	the round constant sequence C (public static member constant)
constexpr std::uint_least32_t default_seed [static]	20111115u (public static member constant)

Member functions

Construction and Seeding
(constructor)	constructs the engine (public member function) [edit]
seed	sets the current state of the engine (public member function) [edit]
set_counter	sets the current counter of the engine (public member function) [edit]
Generation
operator()	advances the engine's state and returns the generated value (public member function) [edit]
discard	advances the engine's state by a specified amount (public member function) [edit]
Characteristics
min [static]	gets the smallest possible value in the output range (public static member function) [edit]
max [static]	gets the largest possible value in the output range (public static member function) [edit]

Non-member functions

	compares the internal states of two pseudo-random number engines (function) [edit]
	performs stream input and output on pseudo-random number engine (function template) [edit]

Notes

Feature-test macro	Value	Std	Feature
__cpp_lib_philox_engine	202406L	(C++26)	std::philox_engine

Example