cppdraft_translate/cppdraft/rand/adapt/ibits.md

[rand.adapt.ibits]

29 Numerics library [numerics]

29.5 Random number generation [rand]

29.5.5 Random number engine adaptor class templates [rand.adapt]

29.5.5.3 Class template independent_bits_engine [rand.adapt.ibits]

1

#

An independent_bits_engine random number engine adaptor combines random numbers that are produced by some base engine e, so as to produce random numbers with a specified number of bits w.

The state xi of an independent_bits_engine engine adaptor object x consists of the state ei of its base engine e; the size of the state is the size of e's state.

2

#

The transition and generation algorithms are described in terms of the following integral constants:

• (2.1)

  Let R=e.max() - e.min() + 1 and m=⌊log2R⌋.

• (2.2)

  With n as determined below, let w0=⌊w/n⌋, n0=n−wmodn, y0=2w0⌊R/2w0⌋, and y1=2w0+1⌊R/2w0+1⌋.

• (2.3)

  Let n=⌈w/m⌉ if and only if the relation R−y0≤⌊y0/n⌋ holds as a result. Otherwise let n=1+⌈w/m⌉.

[Note 1:

The relation w=n0w0+(n−n0)(w0+1) always holds.

— end note]

3

#

The transition algorithm is carried out by invoking e() as often as needed to obtain n0 values less than y0+e.min() and n−n0 values less than y1+e.min().

4

#

The generation algorithm uses the values produced while advancing the state as described above to yield a quantity S obtained as if by the following algorithm:S = 0;for (k = 0; k≠n0; k += 1) {do u = e() - e.min(); while (u≥y0); S = 2w0â‹S+umod2w0;}for (k = n0; k ≠n; k += 1) {do u = e() - e.min(); while (u≥y1); S = 2w0+1â‹S+umod2w0+1;}

🔗

namespace std {template<class Engine, size_t w, class UIntType>class independent_bits_engine {public:// typesusing result_type = UIntType; // engine characteristicsstatic constexpr result_type min() { return 0; }static constexpr result_type max() { return 2w−1; }// constructors and seeding functions independent_bits_engine(); explicit independent_bits_engine(const Engine& e); explicit independent_bits_engine(Engine&& e); explicit independent_bits_engine(result_type s); template explicit independent_bits_engine(Sseq& q); void seed(); void seed(result_type s); template void seed(Sseq& q); // equality operatorsfriend bool operator==(const independent_bits_engine& x, const independent_bits_engine& y); // generating functions result_type operator()(); void discard(unsigned long long z); // property functionsconst Engine& base() const noexcept { return e; }// inserters and extractorstemplate<class charT, class traits>friend basic_ostream<charT, traits>&operator<<(basic_ostream<charT, traits>& os, const independent_bits_engine& x); // hostedtemplate<class charT, class traits>friend basic_istream<charT, traits>&operator>>(basic_istream<charT, traits>& is, independent_bits_engine& x); // hostedprivate: Engine e; // exposition only};}

5

#

The following relations shall hold: 0 < w and w <= numeric_limits<result_type>​::​digits.

6

#

The textual representation consists of the textual representation of e.