A discard_block_engine random number engine adaptor
produces random numbers
selected from those produced by some base engine e.
The state
x_{i}
of a discard_block_engine engine adaptor object x
consists of the state e_{i} 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 e_{i} to e_{i+p-r}
and set n to 0.
In any case,
then increment n
and advance e's then-current state e_{j}
to e_{j+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: // types typedef typename Engine::result_type result_type; // engine characteristics 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(); } // constructors and seeding functions 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); // generating functions result_type operator()(); void discard(unsigned long long z); // property functions const Engine& base() const noexcept { return e; }; private: Engine e; //exposition onlyint n; //exposition only};

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

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