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,
p(z | a,b) 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 100
are valid and have the indicated semantics,
and if D and its associated types
also meet all other requirements
of [rand.req.dist].

In Table 100 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 100: Random number distribution requirements [tab:rand.req.dist]

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

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

d.param(p) | void | 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 | constant | ||

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

os << x | reference to the type of os | |||

is >> d | reference to the type of is | If bad input is encountered,
ensures that d is unchanged by the operation
and
calls is.setstate(ios_base::failbit)
(which may throw ios_base::failure ([iostate.flags])). Preconditions: 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 of 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).

P shall meet the
*Cpp17CopyConstructible* (Table 32),
*Cpp17CopyAssignable* (Table 34),
and
*Cpp17EqualityComparable* (Table 28) requirements.

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.