philox4x32x10#

The Philox4x32x10 counter-based pseudorandom number generator.

Description

The Philox4x32x10 engine is a keyed family of generator of counter-based BRNG. The state consists of 128-bit integer counter $c$ and two 32-bits keys $k_{0}$ and $k_{1}$ .

Generation algorithm

The generator has 32-bit integer output obtained in the following way [Salmon11]:

$c_{n} = c_{n - 1} + 1$
$ω_{n} = f (c_{n})$ , where $f$ is a function that takes 128-bit argument and returns a 128-bit number. The returned number is obtained as follows:
2.1. The argument $c$ is interpreted as four 32-bit numbers $c = \overset{―}{L_{1} R_{1} L_{0} R_{0}}$ , where $\overset{―}{A B C D} = A \cdot 2^{96} + B \cdot 2^{64} + C \cdot 2^{32} + D$ , put $k_{0}^{0} = k_{0}, k_{1}^{0} = k_{1}$ .

2.2. The following recurrence is calculated:

$L_{1}^{i + 1} = m u l l o (R_{1}^{i}, 0 x D 2511 F 53)$

$R_{1}^{i + 1} = m u l h i (R_{0}^{i}, 0 x C D 9 E 8 D 57) \oplus k_{0}^{i} \oplus L_{0}^{i}$

$L_{0}^{i + 1} = m u l l o (R_{0}^{i}, 0 x C D 9 E 8 D 57)$

$R_{0}^{i + 1} = m u l h i (R_{1}^{i}, 0 x D 2511 F 53) \oplus k_{1}^{i} \oplus L_{1}^{i}$

$k_{0}^{i + 1} = k_{0}^{i} + 0 x B B 67 A E 85$

$k_{1}^{i + 1} = k_{1}^{i} + 0 x 9 E 3779 B 9$ , where $m u l h i (a, b)$ and $m u l l o (a, b)$ are high and low parts of the $a \cdot b$ product respectively.

2.3. Put $f (c) = \overset{―}{L_{1}^{N} R_{1}^{N} L_{0}^{N} R_{0}^{N}}$ , where $N = 10$
Integer output: $r_{4 n + k} = ω_{n} (k)$ , where $ω_{n} (k)$ is the k-th 32-bit integer in quadruple $ω_{n}, k = 0, 1, 2, 3$
Real output: $u_{n} = (i n t) r_{n} / 2^{32} + 1 / 2$

class philox4x32x10#

Syntax

namespace oneapi::mkl::rng {
class philox4x32x10 {
public:
static constexpr std::uint64_t default_seed = 0;

philox4x32x10(sycl::queue queue, std::uint64_t seed = default_seed);

philox4x32x10(sycl::queue queue, std::initializer_list<std::uint64_t> seed);

philox4x32x10(const philox4x32x10& other);

philox4x32x10(philox4x32x10&& other);

philox4x32x10& operator=(const philox4x32x10& other);

philox4x32x10& operator=(philox4x32x10&& other);

~philox4x32x10();
};
}

Class Members

Routine	Description
philox4x32x10(sycl::queue queue, std::uint64_t seed = default_seed)	Constructor for common seed initialization of the engine
philox4x32x10(sycl::queue queue, std::initializer_list<std::uint64_t> seed)	Constructor for extended seed initialization of the engine
philox4x32x10(const philox4x32x10& other)	Copy constructor
philox4x32x10(philox4x32x10&& other)	Move constructor
philox4x32x10& operator=(const philox4x32x10& other)	Copy assignment operator
philox4x32x10& operator=(philox4x32x10&& other)	Move assignment operator

Constructors

philox4x32x10::philox4x32x10(sycl::queue queue, std::uint64_t seed = default_seed)

Input Parameters

queue: Valid sycl::queue object, calls of the oneapi::mkl::rng::generate() routine submits kernels in this queue to obtain random numbers from a given engine.
seed: The initial conditions of the generator state, assume $k = s e e d, c = 0$ , where $k$ is a 64-bit key, $c$ is a 128-bit counter.

philox4x32x10::philox4x32x10(sycl::queue queue, std::initializer_list<std::uint64_t> seed)

Input Parameters

queue

Valid sycl::queue object, calls of the oneapi::mkl::rng::generate() routine submits kernels in this queue to obtain random numbers from a given engine.

seed

The initial conditions of the generator state, assume if $n = 0 : k = 0, c = 0$

if $n = 1 : k = s e e d [0], c = 0$

if $n = 2 : k = s e e d [0], c = s e e d [1]$

if $n = 3 : k = s e e d [0], c = s e e d [1] + s e e d [2] \cdot 2^{64}$

for $n > 3$ following arguments are ignored

philox4x32x10::philox4x32x10(const philox4x32x10& other)

Input Parameters

other: Valid philox4x32x10 object. The queue and state of the other engine is copied and applied to the current engine.

philox4x32x10::philox4x32x10(philox4x32x10&& other)

Input Parameters

other: Valid philox4x32x10 r-value object. The queue and state of the other engine is moved to the current engine.

philox4x32x10::philox4x32x10& operator=(const philox4x32x10& other)

Input Parameters

other: Valid philox4x32x10 object. The queue and state of the other engine is copied and applied to the current engine.

philox4x32x10::philox4x32x10& operator=(philox4x32x10&& other)

Input Parameters

other: Valid philox4x32x10 r-value object. The queue and state of the other engine is moved to the current engine.

Parent topic: Host Engines (Basic Random Number Generators)

philox4x32x10

Contents

philox4x32x10#

class philox4x32x10#