that has a template type parameter
named IntType
is undefined unless the corresponding template argument
is cv-unqualified and
is one of
short,
int,
long,
longlong,
unsignedshort,
unsignedint,
unsignedlong,
or
unsignedlonglong.

Throughout this subclause [rand],
phrases of the form “x is an iterator of a specific kind”
shall be interpreted as equivalent to the more formal requirement that
“x is a value
of a type satisfying the requirements
of the specified iterator type”.

A class S
satisfies the requirements
of a seed sequence
if the expressions shown
in [tab:SeedSequence]Table *tab:SeedSequence
are valid and have the indicated semantics,
and if S also satisfies all other requirements
of this subclause [rand.req.seedseq].

Otherwise,
fills the supplied sequence [rb,re)
with 32-bit quantities
that depend on the sequence supplied to the constructor
and possibly also depend on the history
of generate's previous invocations.

Copies to the given destination
a sequence of 32-bit units
that can be provided
to the constructor of a second object of type S,
and that would reproduce in that second object
a state indistinguishable
from the state of the first object.

A uniform random bit generatorg of type G
is a function object
returning unsigned integer values
such that each value
in the range of possible results
has (ideally) equal probability
of being returned.

A random number engine
(commonly shortened to engine)
e of type E
is a uniform random bit generator
that additionally meets the requirements
(e.g., for seeding and for input/output)
specified in this subclause.

A class E
that satisfies the requirements
of a uniform random bit generator
also satisfies the requirements
of a random number engine
if the expressions shown
in [tab:RandomEngine]Table *tab:RandomEngine
are valid and have the indicated semantics,
and if E also satisfies all other requirements
of this subclause [rand.req.eng].

With is.fmtflags
set to ios_­base::dec,
sets v's state
as determined by reading its textual representation from is.

If bad input is encountered,
ensures that v's state is unchanged by the operation
and
calls is.setstate(ios::failbit)
(which may throw ios::failure ([iostate.flags])).

If a textual representation written via os << x
was subsequently read via is >> v,
then x == v
provided that there have been no intervening invocations
of x or of v.

Requires:is provides a textual representation
that was previously written
using an output stream
whose imbued locale
was the same as that of is,
and whose type's template specialization arguments
charT and traits
were respectively the same as those of is.

This operation is common
in user code,
and can often be implemented
in an engine-specific manner
so as to provide significant performance improvements
over an equivalent naive loop
that makes z consecutive calls e().

A random number engine adaptor
(commonly shortened to adaptor)
a of type A
is a random number engine
that takes values
produced by some other random number engine,
and applies an algorithm to those values
in order to deliver a sequence of values
with different randomness properties.

An engine b of type B adapted in this way
is termed a base engine
in this context.

The expression a.base() shall be valid and shall return a
const reference to a's base engine.

Such distribution parameters are identified
in this context by writing, for example,
p(z|a,b) or P(zi|a,b),
to name specific parameters,
or by writing, for example,
p(z|{p})
or P(zi|{p}),
to denote a distribution's parameters p taken as a whole.

A class D
satisfies the requirements
of a random number distribution
if the expressions shown
in [tab:RandomDistribution]Table *tab:RandomDistribution
are valid and have the indicated semantics,
and if D and its associated types
also satisfy all other requirements
of this subclause [rand.req.dist].

glb and lub
are values of T
respectively corresponding to
the greatest lower bound and the least upper bound
on the values potentially returned by d's operator(),
as determined by the current values of d's parameters;

Returns true
if x.param()== y.param() and S1=S2,
where S1 and S2 are
the infinite sequences of values
that would be generated, respectively,
by repeated future calls
to x(g1) and y(g2)
whenever g1 == g2.

Restores from is
the parameters and additional internal data of the lvalue d.

If bad input is encountered,
ensures that d is unchanged by the operation
and
calls is.setstate(ios::failbit)
(which may throw ios::failure ([iostate.flags])).

Requires:is provides a textual representation
that was previously written
using an os whose imbued locale
and whose type's template specialization arguments
charT and traits
were the same as those of is.

If a textual representation is written using os << x
and that representation is restored
into the same or a different object y
of the same type using is >> y,
repeated invocations of y(g)
shall produce the same sequence of numbers
as would repeated invocations of x(g).

For each of the constructors of D
taking arguments corresponding to parameters of the distribution,
P shall have a corresponding constructor
subject to the same requirements
and taking arguments identical in number, type, and default values.

Moreover,
for each of the member functions of D
that return values corresponding to parameters of the distribution,
P shall have a corresponding member function
with the identical name, type, and semantics.