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\)
\(\omega_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 = \overline{L_1 R_1 L_0 R_0}\), where \(\overline{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} =mullo(R_1^i, 0xD2511F53)\)

\(R_1^{i+1} =mulhi(R_0^i, 0xCD9E8D57) \oplus k_0^i \oplus L_0^i\)

\(L_0^{i+1} =mullo(R_0^i, 0xCD9E8D57)\)

\(R_0^{i+1} =mulhi(R_1^i, 0xD2511F53) \oplus k_1^i \oplus L_1^i\)

\(k_0^{i+1} =k_0^i + 0xBB67AE85\)

\(k_1^{i+1} =k_1^i + 0x9E3779B9\), where \(mulhi(a, b)\) and \(mullo(a, b)\) are high and low parts of the \(a \cdot b\) product respectively.

2.3. Put \(f(c) = \overline{L_1^N R_1^N L_0^N R_0^N}\), where \(N = 10\)
Integer output: \(r_{4n + k} = \omega_n(k)\), where \(\omega_n(k)\) is the k-th 32-bit integer in quadruple \(\omega_n, k = 0, 1, 2, 3\)
Real output: \(u_n=(int)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 = seed, 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 = seed[0], c = 0\)

if \(n = 2: k = seed[0], c = seed[1]\)

if \(n = 3: k = seed[0], c = seed[1] + seed[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 = seed, 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 = seed[0], c = 0\)

if \(n = 2: k = seed[0], c = seed[1]\)

if \(n = 3: k = seed[0], c = seed[1] + seed[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#