29 Numerics library [numerics]

29.6 Random number generation [rand]

29.6.4 Random number engine adaptor class templates [rand.adapt] Class template discard_­block_­engine [rand.adapt.disc]

A discard_­block_­engine random number engine adaptor produces random numbers selected from those produced by some base engine e. The state x of a discard_­block_­engine engine adaptor object x consists of the state e 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 values from each block of values delivered by e. The state transition is performed as follows: If , advance the state of e from e to e and set n to 0. In any case, then increment n and advance e's then-current state e to e.

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 {
    // types
    using result_type = typename Engine::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
    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; };

    Engine e;   // exposition only
    int n;      // exposition only

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.