29 Numerics library [numerics]

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\ge r$ values delivered by e. The state transition is performed as follows: If $n\ge 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
    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
    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 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.