[rand.adapt.shuf] (original) (raw)

29 Numerics library [numerics]

29.5 Random number generation [rand]

29.5.5 Random number engine adaptor class templates [rand.adapt]

29.5.5.4 Class template shuffle_order_engine [rand.adapt.shuf]

A shuffle_order_engine random number engine adaptor produces the same random numbers that are produced by some base engine e, but delivers them in a different sequence.

The state xof a shuffle_order_engine engine adaptor object xconsists of the state e of its base engine e, an additional value Y of the type delivered by e, and an additional sequence V of k values also of the type delivered by e.

The size of the state is the size of e's state plus .

The transition algorithm permutes the values produced by e.

The state transition is performed as follows:

The generation algorithm yields the last value of Y produced while advancing e's state as described above.

namespace std { template<class Engine, size_t k> class shuffle_order_engine { public: using result_type = typename Engine::result_type;static constexpr size_t table_size = k;static constexpr result_type min() { return Engine::min(); } static constexpr result_type max() { return Engine::max(); } shuffle_order_engine();explicit shuffle_order_engine(const Engine& e);explicit shuffle_order_engine(Engine&& e);explicit shuffle_order_engine(result_type s);template<class Sseq> explicit shuffle_order_engine(Sseq& q);void seed();void seed(result_type s);template<class Sseq> void seed(Sseq& q);friend bool operator==(const shuffle_order_engine& x, const shuffle_order_engine& y); result_type operator()();void discard(unsigned long long z);const Engine& base() const noexcept { return e; } template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const shuffle_order_engine& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, shuffle_order_engine& x);private: Engine e; result_type V[k]; result_type Y; };}

The following relation shall hold:0 < k.

The textual representation consists of the textual representation of e, followed by the k values of V, followed by the value of Y.

In addition to its behavior pursuant to subclause [rand.req.adapt], each constructorthat is not a copy constructor initializes V[0], …, V[k - 1] and Y, in that order, with values returned by successive invocations of e().