[rand.util]

26.6.8.1 Class seed_seq [rand.util.seedseq]

class seed_seq { public: // types using result_type = uint_least32_t; // constructors seed_seq(); template<class T> seed_seq(initializer_list<T> il); template<class InputIterator> seed_seq(InputIterator begin, InputIterator end); // generating functions template<class RandomAccessIterator> void generate(RandomAccessIterator begin, RandomAccessIterator end); // property functions size_t size() const noexcept; template<class OutputIterator> void param(OutputIterator dest) const; // no copy functions seed_seq(const seed_seq&) = delete; void operator=(const seed_seq&) = delete; private: vector<result_type> v; // exposition only };

🔗

seed_seq();

Postconditions: v.empty() is true.

Throws: Nothing.

🔗

template<class T>
 seed_seq(initializer_list<T> il);

Mandates: T is an integer type.

Effects: Same as seed_seq(il.begin(), il.end()).

🔗

template<class InputIterator>
  seed_seq(InputIterator begin, InputIterator end);

Mandates: iterator_traits<InputIterator>::value_type is an integer type.

Preconditions: InputIterator meets the Cpp17InputIterator requirements ([input.iterators]).

Effects: Initializes v by the following algorithm: for (InputIterator s = begin; s != end; ++s) v.push_back((*s)

mod 2^{32}

);

🔗

template<class RandomAccessIterator>
  void generate(RandomAccessIterator begin, RandomAccessIterator end);

Mandates: iterator_traits<RandomAccessIterator>::value_type is an unsigned integer type capable of accommodating 32-bit quantities.

Preconditions: RandomAccessIterator meets the Cpp17RandomAccessIterator requirements ([random.access.iterators]) and the requirements of a mutable iterator.

Effects: Does nothing if begin == end.

Otherwise, with

s = v.size()

and

n = end - begin

, fills the supplied range

[begin, end)

according to the following algorithm in which each operation is to be carried out modulo

2^{32}

, each indexing operator applied to begin is to be taken modulo n, and T(x) is defined as

x x o r (x r s h i f t 27)

(10.1)
By way of initialization, set each element of the range to the value 0x8b8b8b8b.

Additionally, for use in subsequent steps, let $p = (n - t) / 2$ and let $q = p + t$ , where
$t = (n \geq 623) ? 11 : (n \geq 68) ? 7 : (n \geq 39) ? 5 : (n \geq 7) ? 3 : (n - 1) / 2;$
(10.2)
With m as the larger of $s + 1$ and n, transform the elements of the range: iteratively for $k = 0, \dots, m - 1$ , calculate values
$\begin{matrix} r_{1} & = & 1664525 \cdot T (begin[k] x o r begin[k + p] x o r begin[k - 1]) r_{2} & = & r_{1} + ⎧ ⎪ ⎨ ⎪ ⎩ \begin{matrix} s & , k = 0 k mod n + v[k - 1] & , 0 < k \leq s k mod n & , s < k \end{matrix} \end{matrix}$ and, in order, increment begin[ $k + p$ ] by $r_{1}$ , increment begin[ $k + q$ ] by $r_{2}$ , and set begin[k] to $r_{2}$ .
(10.3)
Transform the elements of the range again, beginning where the previous step ended: iteratively for $k = m, \dots, m + n - 1$ , calculate values
$\begin{matrix} r_{3} & = & 1566083941 \cdot T (begin[k] + begin[k + p] + begin[k - 1]) r_{4} & = & r_{3} - (k mod n) \end{matrix}$ and, in order, update begin[ $k + p$ ] by xoring it with $r_{3}$ , update begin[ $k + q$ ] by xoring it with $r_{4}$ , and set begin[k] to $r_{4}$ .

Throws: What and when RandomAccessIterator operations of begin and end throw.

🔗

size_t size() const noexcept;

Returns: The number of 32-bit units that would be returned by a call to param().

Complexity: Constant time.

🔗

template<class OutputIterator>
  void param(OutputIterator dest) const;

Mandates: Values of type result_type are writable ([iterator.requirements.general]) to dest.

Preconditions: OutputIterator meets the Cpp17OutputIterator requirements ([output.iterators]).

Effects: Copies the sequence of prepared 32-bit units to the given destination, as if by executing the following statement: copy(v.begin(), v.end(), dest);

Throws: What and when OutputIterator operations of dest throw.

26.6.8.2 Function template generate_canonical [rand.util.canonical]

🔗

template<class RealType, size_t bits, class URBG>
  RealType generate_canonical(URBG& g);

Complexity: Exactly

k = max (1, ⌈ b / log_{2} R ⌉)

invocations of g, where b252 is the lesser of numeric_limits<RealType>::digits and bits, and R is the value of

g.max() - g.min() + 1

Effects: Invokes g() k times to obtain values

g_{0}, \dots, g_{k - 1}

, respectively.

Calculates a quantity

S = k - 1 \sum i = 0 (g_{i} - g.min()) \cdot R^{i}

using arithmetic of type RealType.

Returns:

S / R^{k}

[Note 1:

0 \leq S / R^{k} < 1

— end note]

Throws: What and when g throws.

[Note 2:

If the values

g_{i}

produced by g are uniformly distributed, the instantiation's results are distributed as uniformly as possible.

Obtaining a value in this way can be a useful step in the process of transforming a value generated by a uniform random bit generator into a value that can be delivered by a random number distribution.

— end note]

252)

b is introduced to avoid any attempt to produce more bits of randomness than can be held in RealType.

⮥

26 Numerics library [numerics]

26.6 Random number generation [rand]

26.6.8 Utilities [rand.util]

26.6.8.1 Class seed_seq [rand.util.seedseq]

26.6.8.2 Function template generate_canonical [rand.util.canonical]

26 Numerics library [numerics]

26.6 Random number generation [rand]

26.6.8 Utilities [rand.util]

26.6.8.1 Class seed_­seq [rand.util.seedseq]

26.6.8.2 Function template generate_­canonical [rand.util.canonical]

26.6.8.1 Class seed_seq [rand.util.seedseq]

26.6.8.2 Function template generate_canonical [rand.util.canonical]