## 29.6 Random number generation [rand]

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

A discard_block_engine random number engine adaptor
produces random numbers
selected from those produced by some base engine e.
The state
xi
of a discard_block_engine engine adaptor object x
consists of the state ei of its base engine e
and an additional integer n.
The size of the state is
the size of e's state plus 1.

The transition algorithm
discards all but r>0 values
from each block of p≥r values delivered by e.
The state transition is performed as follows:
If n≥r,
advance the state of e from ei to ei+p−r
and set n to 0.
In any case,
then increment n
and advance e's then-current state ej
to ej+1.

The generation algorithm
yields the value returned by the last invocation of e()
while advancing e's state as described above.

template<class Engine, size_t p, size_t r>
class discard_block_engine {
public:
using result_type = typename Engine::result_type;
static constexpr size_t block_size = p;
static constexpr size_t used_block = r;
static constexpr result_type min() { return Engine::min(); }
static constexpr result_type max() { return Engine::max(); }
discard_block_engine();
explicit discard_block_engine(const Engine& e);
explicit discard_block_engine(Engine&& e);
explicit discard_block_engine(result_type s);
template<class Sseq> explicit discard_block_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; int n; };

The following relations shall hold:
0 < r
and
r <= p.

The textual representation
consists of
the textual representation of e
followed by
the value of n.

In addition to its behavior
pursuant to section [rand.req.adapt],
each constructor
that is not a copy constructor
sets n to 0.