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*
.

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
meets the requirements
of a *random number distribution*
if the expressions shown
in Table 94
are valid and have the indicated semantics,
and if D and its associated types
also meet all other requirements
of this subclause [rand.req.dist].

In that Table and throughout this subclause,

- T is the type named by D's associated result_type;
- P is the type named by D's associated param_type;
- d is a value of D, and x and y are (possibly const) values of 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;
- p is a (possibly const) value of P;
- g, g1, and g2 are lvalues of a type meeting the requirements of a uniform random bit generator;
- os is an lvalue of the type of some class template specialization basic_ostream<charT, traits>; and
- is is an lvalue of the type of some class template specialization basic_istream<charT, traits>;

Table 94: Random number distribution requirements [tab:rand.req.dist]

Expression | Return type | Pre/post-condition | Complexity |

T | compile-time | ||

P | compile-time | ||

Creates a distribution whose behavior is indistinguishable
from that of any other newly default-constructed distribution
of type D. | constant | ||

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 | ||

void | constant | ||

P | no worse than the complexity of D(p) | ||

void | no worse than the complexity of D(p) | ||

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 | |

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 | |

T | Returns glb. | constant | |

T | Returns lub. | constant | |

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 | |

bool | !(x == y). | same as x == y. | |

reference to the type of os | |||

reference to the type of is | 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. |

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).

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.