Each type instantiated
from a class template specified in this subclause [rand.adapt]
meets the requirements
of a random number engine adaptor type.

Except where specified otherwise,
the complexity of each function
specified in this subclause [rand.adapt]
is constant.

Except where specified otherwise,
no function described in this subclause [rand.adapt]
throws an exception.

Every function described in this subclause [rand.adapt]
that has a function parameter q of type Sseq&
for a template type parameter named Sseq
that is different from type seed_seq
throws what and when the invocation of q.generate throws.

Descriptions are provided in this subclause [rand.adapt]
only for adaptor operations
that are not described in subclause [rand.req.adapt]
or for operations where there is additional semantic information.

In particular,
declarations for copy constructors,
for copy assignment operators,
for streaming operators,
and for equality and inequality operators
are not shown in the synopses.

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

namespace std {
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);
// equality operators
friend bool operator==(const discard_block_engine& x, const discard_block_engine& y);
// generating functions
result_type operator()();
void discard(unsigned long long z);
// property functions
const Engine& base() const noexcept { return e; }
// inserters and extractors
template<class charT, class traits>
friend basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const discard_block_engine& x);
template<class charT, class traits>
friend basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is, discard_block_engine& x);
private:
Engine e; // *exposition only*
size_t n; // *exposition only*
};
}

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

An independent_bits_engine
random number engine adaptor
combines random numbers
that are produced by some base engine e,
so as to produce random numbers
with a specified number of bits w.

The state x
of an independent_bits_engine
engine adaptor object x
consists of
the state e of its base engine e;
the size of the state is
the size of e's state.

The transition algorithm
is carried out by invoking e()
as often as needed to obtain
values less than
and values less than .

The generation algorithm
uses the values produced
while advancing the state as described above
to yield a quantity S
obtained as if by the following algorithm:
S = 0;
for (k = 0; ; k += 1) {
do u = e() - e.min(); while ();
S = ;
}
for (k = ; k ≠ n; k += 1) {
do u = e() - e.min(); while ();
S = ;
}

namespace std {
template<class Engine, size_t w, class UIntType>
class independent_bits_engine {
public:
// types
using result_type = UIntType;
// engine characteristics
static constexpr result_type min() { return 0; }
static constexpr result_type max() { return ; }
// constructors and seeding functions
independent_bits_engine();
explicit independent_bits_engine(const Engine& e);
explicit independent_bits_engine(Engine&& e);
explicit independent_bits_engine(result_type s);
template<class Sseq> explicit independent_bits_engine(Sseq& q);
void seed();
void seed(result_type s);
template<class Sseq> void seed(Sseq& q);
// equality operators
friend bool operator==(const independent_bits_engine& x, const independent_bits_engine& y);
// generating functions
result_type operator()();
void discard(unsigned long long z);
// property functions
const Engine& base() const noexcept { return e; }
// inserters and extractors
template<class charT, class traits>
friend basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os, const independent_bits_engine& x);
template<class charT, class traits>
friend basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is, independent_bits_engine& x);
private:
Engine e; // *exposition only*
};
}

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 x
of a shuffle_order_engine engine adaptor object x
consists 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 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:
// types
using result_type = typename Engine::result_type;
// engine characteristics
static constexpr size_t table_size = k;
static constexpr result_type min() { return Engine::min(); }
static constexpr result_type max() { return Engine::max(); }
// constructors and seeding functions
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);
// equality operators
friend bool operator==(const shuffle_order_engine& x, const shuffle_order_engine& y);
// generating functions
result_type operator()();
void discard(unsigned long long z);
// property functions
const Engine& base() const noexcept { return e; }
// inserters and extractors
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; // *exposition only*
result_type V[k]; // *exposition only*
result_type Y; // *exposition only*
};
}

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 constructor
that is not a copy constructor
initializes V[0], …, V[k-1] and Y,
in that order,
with values returned by successive invocations of e().