philox4x32x10#

A Philox4x32-10 counter-based pseudorandom number generator [Salmon11].

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::math::rng::device {
  template<std::int32_t VecSize = 1>
  class philox4x32x10 {
  public:
    static constexpr std::uint64_t default_seed = 1;
    static constexpr std::int32_t vec_size = VecSize;

    philox4x32x10();
    philox4x32x10(std::uint64_t seed, std::uint64_t offset = 0);
    philox4x32x10(std::initializer_list<std::uint64_t> seed, std::uint64_t offset = 0);
    philox4x32x10(std::uint64_t seed, std::initializer_list<std::uint64_t> offset);
    philox4x32x10(std::initializer_list<std::uint64_t> seed, std::initializer_list<std::uint64_t> offset);
  };
}

Class Template Parameters

VecSize: Describes the size of vector which will be produced by generate function by this engine. VecSize values may be 1, 2, 3, 4, 8, 16 as sycl::vec class size. By default VecSize = 1, for this case, a single random number is returned by the generate function.

Class Members

Routine	Description
philox4x32x10()	Default constructor
philox4x32x10(std::uint32_t seed, std::uint64_t offset = 0)	Constructor for common seed initialization of the engine and common number of skipped elements
philox4x32x10(std::initializer_list<std::uint32_t> seed, std::uint64_t offset = 0)	Constructor for extended seed initialization of the engine and common number of skipped elements
philox4x32x10(std::uint32_t seed, std::initializer_list<std::uint64_t> offset)	Constructor for common seed initialization of the engine and extended number of skipped elements
philox4x32x10(std::initializer_list<std::uint32_t> seed, std::initializer_list<std::uint64_t> offset)	Constructor for extended seed initialization of the engine and extended number of skipped elements

Constructors

philox4x32x10::philox4x32x10()

philox4x32x10::philox4x32x10(std::uint32_t seed, std::uint64_t offset = 0)

Input Parameters

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.
offset: Number of skipped elements.

philox4x32x10::philox4x32x10(std::initializer_list<std::uint32_t> seed, std::uint64_t offset = 0)

Input Parameters

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.

offset

Number of skipped elements.

philox4x32x10::philox4x32x10(std::uint32_t seed, std::initializer_list<std::uint64_t> offset)

Input Parameters

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.
offset: Number of skipped elements. Offset is calculated as: num_to_skip [0]+ num_to_skip [1]*2⁶⁴ + num_to_skip [2]* 2¹²⁸ + … + num_to_skip [n-1]*2⁶⁴ *(n-1).

philox4x32x10::philox4x32x10(std::initializer_list<std::uint32_t> seed, std::initializer_list<std::uint64_t> offset)

Input Parameters

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.

offset

Number of skipped elements. Offset is calculated as: num_to_skip [0]+ num_to_skip [1]*2⁶⁴ + num_to_skip [2]* 2¹²⁸ + … + num_to_skip [n-1]*2⁶⁴ *(n-1).

Parent topic: Device Engines (Basic Random Number Generators)

philox4x32x10

Contents

philox4x32x10#

class philox4x32x10#