## 29.6 Random number generation [rand]

### 29.6.4 Random number engine adaptor class templates [rand.adapt]

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.

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

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

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

c)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:
The relation
w=n0w0+(n−n0)(w0+1)
always holds.
— end note ]

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().

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;
}

template<class Engine, size_t w, class UIntType>
class independent_bits_engine {
public:
using result_type = UIntType;
static constexpr result_type min() { return 0; }
static constexpr result_type max() { return 2w−1; }
independent_bits_engine();
explicit independent_bits_engine(const Engine& e);
explicit independent_bits_engine(Engine&& e);
explicit independent_bits_engine(result_type s);
template<class Sseq> explicit independent_bits_engine(Sseq& q);
void seed();
void seed(result_type s);
template<class Sseq> void seed(Sseq& q);
result_type operator()();
void discard(unsigned long long z);
const Engine& base() const noexcept { return e; };
private:
Engine e; };

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

The textual representation
consists of
the textual representation of e.