29 Numerics library [numerics]

29.6 Random number generation [rand]

29.6.1 Requirements [rand.req]

29.6.1.1 General requirements [rand.req.genl]

Throughout this subclause [rand], the effect of instantiating a template:
  1. a)
    that has a template type parameter named Sseq is undefined unless the corresponding template argument is cv-unqualified and satisfies the requirements of seed sequence.
  2. b)
    that has a template type parameter named URBG is undefined unless the corresponding template argument is cv-unqualified and satisfies the requirements of uniform random bit generator.
  3. c)
    that has a template type parameter named Engine is undefined unless the corresponding template argument is cv-unqualified and satisfies the requirements of random number engine.
  4. d)
    that has a template type parameter named RealType is undefined unless the corresponding template argument is cv-unqualified and is one of float, double, or long double.
  5. e)
    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, long long, unsigned short, unsigned int, unsigned long, or unsigned long long.
  6. f)
    that has a template type parameter named UIntType is undefined unless the corresponding template argument is cv-unqualified and is one of unsigned short, unsigned int, unsigned long, or unsigned long long.
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”.
Throughout this subclause [rand], any constructor that can be called with a single argument and that satisfies a requirement specified in this subclause shall be declared explicit.

29.6.1.2 Seed sequence requirements [rand.req.seedseq]

A seed sequence is an object that consumes a sequence of integer-valued data and produces a requested number of unsigned integer values i, , based on the consumed data.
[Note
:
Such an object provides a mechanism to avoid replication of streams of random variates.
This can be useful, for example, in applications requiring large numbers of random number engines.
end note
]
A class S satisfies the requirements of a seed sequence if the expressions shown in Table 102 are valid and have the indicated semantics, and if S also satisfies all other requirements of this section [rand.req.seedseq].
In that Table and throughout this section:
  1. a)
    T is the type named by S's associated result_­type;
  2. b)
    q is a value of S and r is a possibly const value of S;
  3. c)
    ib and ie are input iterators with an unsigned integer value_­type of at least 32 bits;
  4. d)
    rb and re are mutable random access iterators with an unsigned integer value_­type of at least 32 bits;
  5. e)
    ob is an output iterator; and
  6. f)
    il is a value of initializer_­list<T>.
Table 102 — Seed sequence requirements
Expression
Return type
Pre/post-condition
Complexity
S​::​result_­type
T
T is an unsigned integer type of at least 32 bits.
compile-time
S()
Creates a seed sequence with the same initial state as all other default-constructed seed sequences of type S.
constant
S(ib,ie)
Creates a seed sequence having internal state that depends on some or all of the bits of the supplied sequence .
S(il)
Same as S(il.begin(), il.end()).
same as S(il.begin(), il.end())
q.generate(rb,re)
void
Does nothing if rb == re.
Otherwise, fills the supplied sequence 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.
r.size()
size_­t
The number of 32-bit units that would be copied by a call to r.param.
constant
r.param(ob)
void
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.

29.6.1.3 Uniform random bit generator requirements [rand.req.urng]

A uniform random bit generator g 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.
[Note
:
The degree to which g's results approximate the ideal is often determined statistically.
end note
]
A class G satisfies the requirements of a uniform random bit generator if the expressions shown in Table 103 are valid and have the indicated semantics, and if G also satisfies all other requirements of this section [rand.req.urng].
In that Table and throughout this section:
  1. a)
    T is the type named by G's associated result_­type, and
  2. b)
    g is a value of G.
Table 103 — Uniform random bit generator requirements
Expression
Return type
Pre/post-condition
Complexity
G​::​result_­type
T
compile-time
g()
T
Returns a value in the closed interval [G​::​min(), G​::​max()].
amortized constant
G​::​min()
T
Denotes the least value potentially returned by operator().
compile-time
G​::​max()
T
Denotes the greatest value potentially returned by operator().
compile-time
The following relation shall hold: G​::​min() < G​::​max().

29.6.1.4 Random number engine requirements [rand.req.eng]

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 section.
At any given time, e has a state e for some integer .
Upon construction, e has an initial state e.
An engine's state may be established via a constructor, a seed function, assignment, or a suitable operator>>.
E's specification shall define:
  1. a)
    the size of E's state in multiples of the size of result_­type, given as an integral constant expression;
  2. b)
    the transition algorithm TA by which e's state e is advanced to its successor state e; and
  3. c)
    the generation algorithm GA by which an engine's state is mapped to a value of type result_­type.
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 Table 104 are valid and have the indicated semantics, and if E also satisfies all other requirements of this section [rand.req.eng].
In that Table and throughout this section:
  1. a)
    T is the type named by E's associated result_­type;
  2. b)
    e is a value of E, v is an lvalue of E, x and y are (possibly const) values of E;
  3. c)
    s is a value of T;
  4. d)
    q is an lvalue satisfying the requirements of a seed sequence;
  5. e)
    z is a value of type unsigned long long;
  6. f)
    os is an lvalue of the type of some class template specialization basic_­ostream<charT, traits>; and
  7. g)
    is is an lvalue of the type of some class template specialization basic_­istream<charT, traits>;
where charT and traits are constrained according to Clause [strings] and Clause [input.output].
Table 104 — Random number engine requirements
Expression
Return type
Pre/post-condition
Complexity
E()
Creates an engine with the same initial state as all other default-constructed engines of type E.
E(x)
Creates an engine that compares equal to x.
E(s)
Creates an engine with initial state determined by s.
E(q)268
Creates an engine with an initial state that depends on a sequence produced by one call to q.generate.
same as complexity of q.generate called on a sequence whose length is size of state
e.seed()
void
Postconditions: e == E().
same as E()
e.seed(s)
void
Postconditions: e == E(s).
same as E(s)
e.seed(q)
void
Postconditions: e == E(q).
same as E(q)
e()
T
Advances e's state e to e e) and returns GA(e).
per Table 103
e.discard(z) 269
void
Advances e's state e to by any means equivalent to z consecutive calls e().
no worse than the complexity of z consecutive calls e()
x == y
bool
This operator is an equivalence relation.
With and as the infinite sequences of values that would be generated by repeated future calls to x() and y(), respectively, returns true if ; else returns false.
x != y
bool
!(x == y).
os << x
reference to the type of os
With os.fmtflags set to ios_­base​::​dec|ios_­base​::​left and the fill character set to the space character, writes to os the textual representation of x's current state.
In the output, adjacent numbers are separated by one or more space characters.
Postconditions: The os.fmtflags and fill character are unchanged.
is >> v
reference to the type of is
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.
Postconditions: The is.fmtflags are unchanged.
E shall meet the requirements of CopyConstructible and CopyAssignable types.
These operations shall each be of complexity no worse than .
This constructor (as well as the subsequent corresponding seed() function) may be particularly useful to applications requiring a large number of independent random sequences.
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().

29.6.1.5 Random number engine adaptor requirements [rand.req.adapt]

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.
The requirements of a random number engine type shall be interpreted as follows with respect to a random number engine adaptor type.
A::A();
Effects: The base engine is initialized as if by its default constructor.
bool operator==(const A& a1, const A& a2);
Returns: true if a1's base engine is equal to a2's base engine.
Otherwise returns false.
A::A(result_type s);
Effects: The base engine is initialized with s.
template<class Sseq> A::A(Sseq& q);
Effects: The base engine is initialized with q.
void seed();
Effects: With b as the base engine, invokes b.seed().
void seed(result_type s);
Effects: With b as the base engine, invokes b.seed(s).
template<class Sseq> void seed(Sseq& q);
Effects: With b as the base engine, invokes b.seed(q).
A shall also satisfy the following additional requirements:
  1. a)
    The complexity of each function shall not exceed the complexity of the corresponding function applied to the base engine.
  2. b)
    The state of A shall include the state of its base engine.
    The size of A's state shall be no less than the size of the base engine.
  3. c)
    Copying A's state (e.g., during copy construction or copy assignment) shall include copying the state of the base engine of A.
  4. d)
    The textual representation of A shall include the textual representation of its base engine.

29.6.1.6 Random number distribution requirements [rand.req.dist]

A random number distribution (commonly shortened to distribution) d of type D is a function object returning values that are distributed according to an associated mathematical probability density function p(z) or according to an associated discrete probability function .
A distribution's specification identifies its associated probability function p(z) or .
An associated probability function is typically expressed using certain externally-supplied quantities known as the parameters of the distribution.
Such distribution parameters are identified in this context by writing, for example, or , to name specific parameters, or by writing, for example, p(z|{p}) or , 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 Table 105 are valid and have the indicated semantics, and if D and its associated types also satisfy all other requirements of this section [rand.req.dist].
In that Table and throughout this section,
  1. a)
    T is the type named by D's associated result_­type;
  2. b)
    P is the type named by D's associated param_­type;
  3. c)
    d is a value of D, and x and y are (possibly const) values of D;
  4. d)
    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;
  5. e)
    p is a (possibly const) value of P;
  6. f)
    g, g1, and g2 are lvalues of a type satisfying the requirements of a uniform random bit generator;
  7. g)
    os is an lvalue of the type of some class template specialization basic_­ostream<charT, traits>; and
  8. h)
    is is an lvalue of the type of some class template specialization basic_­istream<charT, traits>;
where charT and traits are constrained according to Clauses [strings] and [input.output].
Table 105 — Random number distribution requirements
Expression
Return type
Pre/post-condition
Complexity
D​::​result_­type
T
compile-time
D​::​param_­type
P
compile-time
D()
Creates a distribution whose behavior is indistinguishable from that of any other newly default-constructed distribution of type D.
constant
D(p)
Creates a distribution whose behavior is indistinguishable from that of a distribution newly constructed directly from the values used to construct p.
same as p's construction
d.reset()
void
Subsequent uses of d do not depend on values produced by any engine prior to invoking reset.
constant
x.param()
P
Returns a value p such that D(p).param() == p.
no worse than the complexity of D(p)
d.param(p)
void
Postconditions: d.param() == p.
no worse than the complexity of D(p)
d(g)
T
With , the sequence of numbers returned by successive invocations with the same object g is randomly distributed according to the associated p(z|{p}) or function.
amortized constant number of invocations of g
d(g,p)
T
The sequence of numbers returned by successive invocations with the same objects g and p is randomly distributed according to the associated p(z|{p}) or function.
amortized constant number of invocations of g
x.min()
T
Returns glb.
constant
x.max()
T
Returns lub.
constant
x == y
bool
This operator is an equivalence relation.
Returns true if x.param() == y.param() and , where and are the infinite sequences of values that would be generated, respectively, by repeated future calls to x(g1) and y(g2) whenever g1 == g2.
Otherwise returns false.
constant
x != y
bool
!(x == y).
same as x == y.
os << x
reference to the type of os
Writes to os a textual representation for the parameters and the additional internal data of x.
Postconditions: The os.fmtflags and fill character are unchanged.
is >> d
reference to the type of is
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.
Postconditions: The is.fmtflags are unchanged.
D shall satisfy the requirements of CopyConstructible and CopyAssignable types.
The sequence of numbers produced by repeated invocations of d(g) shall be independent of any invocation of os << d or of any const member function of D between any of the invocations d(g).
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).
It is unspecified whether D​::​param_­type is declared as a (nested) class or via a typedef.
In this subclause [rand], declarations of D​::​param_­type are in the form of typedefs for convenience of exposition only.
P shall satisfy the requirements of CopyConstructible, CopyAssignable, and EqualityComparable types.
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.
P shall have a declaration of the form
using distribution_type =  D;