# 26 Numerics library [numerics]

## 26.5 Random number generation [rand]

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:

1. Let R = e.max() - e.min() + 1 and m = log2 R .

2. With n as determined below, let w0 = w / n , n0 = n - w mod n , y0 = 2w0 R / 2w0 , and y1 = 2w0 + 1 R / 2w0 + 1 .

3. Let n = w / m if and only if the relation R - y0y0 / n holds as a result. Otherwise let n = 1 + w / m .

Note: The relation w = n0 w0 + (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 + u mod 2w0 ;
}
for (k = n0; k ≠ n; k += 1)  {
do u = e() - e.min(); while ( u ≥ y1 );
S =  2w0 + 1 · S + u mod 2w0 + 1 ;
}
```
```template<class Engine, size_t w, class UIntType>
class independent_bits_engine{
public:
// types
typedef UIntType result_type;

// engine characteristics
static 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<class Sseq> explicit independent_bits_engine(Sseq& q);
void seed();
void seed(result_type s);
template<class Sseq> void seed(Sseq& q);

// generating functions
result_type operator()();