[rand] (original) (raw)

29 Numerics library [numerics]

29.5 Random number generation [rand]

29.5.1 General [rand.general]

Subclause [rand] defines a facility for generating (pseudo-)random numbers.

In addition to a few utilities, four categories of entities are described:uniform random bit generators,random number engines,random number engine adaptors, andrandom number distributions .

These categorizations are applicable to types that meet the corresponding requirements, to objects instantiated from such types, and to templates producing such types when instantiated.

[Note 1:

These entities are specified in such a way as to permit the binding of any uniform random bit generator object e as the argument to any random number distribution object d, thus producing a zero-argument function object such as given bybind(d,e).

— _end note_]

Each of the entities specified in [rand] has an associated arithmetic type ([basic.fundamental]) identified as result_type.

With T as the result_typethus associated with such an entity, that entity is characterized:

as boolean or equivalently as boolean-valued, if T is bool;
otherwise as integral or equivalently as integer-valued, if numeric_limits<T>::is_integer is true;
otherwise as floating-point or equivalently as real-valued.

If integer-valued, an entity may optionally be further characterized assigned or unsigned, according to numeric_limits<T>::is_signed.

Unless otherwise specified, all descriptions of calculations in [rand] use mathematical real numbers.

Throughout [rand], the operatorsbitand, bitor, and xordenote the respective conventional bitwise operations.

Further:

the operator rshift denotes a bitwise right shift with zero-valued bits appearing in the high bits of the result, and
the operator denotes a bitwise left shift with zero-valued bits appearing in the low bits of the result, and whose result is always taken modulo .

29.5.2 Header synopsis [rand.synopsis]

#include <initializer_list> namespace std { template<class G> concept uniform_random_bit_generator = see below; template<class UIntType, UIntType a, UIntType c, UIntType m> class linear_congruential_engine; template<class UIntType, size_t w, size_t n, size_t m, size_t r, UIntType a, size_t u, UIntType d, size_t s, UIntType b, size_t t, UIntType c, size_t l, UIntType f> class mersenne_twister_engine;template<class UIntType, size_t w, size_t s, size_t r> class subtract_with_carry_engine; template<class Engine, size_t p, size_t r> class discard_block_engine; template<class Engine, size_t w, class UIntType> class independent_bits_engine; template<class Engine, size_t k> class shuffle_order_engine;template<class UIntType, size_t w, size_t n, size_t r, UIntType... consts> class philox_engine;using minstd_rand0 = see below; using minstd_rand = see below; using mt19937 = see below; using mt19937_64 = see below; using ranlux24_base = see below; using ranlux48_base = see below; using ranlux24 = see below; using ranlux48 = see below; using knuth_b = see below;using philox4x32 = see below;using philox4x64 = see below;using default_random_engine = see below;class random_device;class seed_seq;template<class RealType, size_t digits, class URBG> RealType generate_canonical(URBG& g);namespace ranges { template<class R, class G> requires output_range<R, invoke_result_t<G&>> && uniform_random_bit_generator<remove_cvref_t<G>> constexpr borrowed_iterator_t<R> generate_random(R&& r, G&& g);template<class G, output_iterator<invoke_result_t<G&>> O, sentinel_for<O> S> requires uniform_random_bit_generator<remove_cvref_t<G>> constexpr O generate_random(O first, S last, G&& g);template<class R, class G, class D> requires output_range<R, invoke_result_t<D&, G&>> && invocable<D&, G&> && uniform_random_bit_generator<remove_cvref_t<G>> && is_arithmetic_v<invoke_result_t<D&, G&>> constexpr borrowed_iterator_t<R> generate_random(R&& r, G&& g, D&& d);template<class G, class D, output_iterator<invoke_result_t<D&, G&>> O, sentinel_for<O> S> requires invocable<D&, G&> && uniform_random_bit_generator<remove_cvref_t<G>> && is_arithmetic_v<invoke_result_t<D&, G&>> constexpr O generate_random(O first, S last, G&& g, D&& d);} template<class IntType = int> class uniform_int_distribution; template<class RealType = double> class uniform_real_distribution;class bernoulli_distribution;template<class IntType = int> class binomial_distribution;template<class IntType = int> class geometric_distribution;template<class IntType = int> class negative_binomial_distribution;template<class IntType = int> class poisson_distribution;template<class RealType = double> class exponential_distribution;template<class RealType = double> class gamma_distribution;template<class RealType = double> class weibull_distribution;template<class RealType = double> class extreme_value_distribution;template<class RealType = double> class normal_distribution;template<class RealType = double> class lognormal_distribution;template<class RealType = double> class chi_squared_distribution;template<class RealType = double> class cauchy_distribution;template<class RealType = double> class fisher_f_distribution;template<class RealType = double> class student_t_distribution;template<class IntType = int> class discrete_distribution;template<class RealType = double> class piecewise_constant_distribution;template<class RealType = double> class piecewise_linear_distribution;}

29.5.3 Requirements [rand.req]

29.5.3.1 General requirements [rand.req.genl]

Throughout [rand], the effect of instantiating a template:

that has a template type parameter named Sseq is undefined unless the corresponding template argument is cv-unqualified and meets the requirements of seed sequence .
that has a template type parameter named URBG is undefined unless the corresponding template argument is cv-unqualified and meets the requirements of uniform random bit generator .
that has a template type parameter named Engine is undefined unless the corresponding template argument is cv-unqualified and meets the requirements of random number engine .
that has a template type parameter named RealType is undefined unless the corresponding template argument is cv-unqualified and is one offloat, double, or long double.
that has a template type parameter named IntType is undefined unless the corresponding template argument is cv-unqualified and is one ofshort,int,long,long long,unsigned short,unsigned int,unsigned long, orunsigned long long.
that has a template type parameter named UIntType is undefined unless the corresponding template argument is cv-unqualified and is one ofunsigned short,unsigned int,unsigned long, orunsigned long long.

Throughout [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 meeting the requirements of the specified iterator type”.

Throughout [rand], any constructor that can be called with a single argument and that meets a requirement specified in this subclause shall be declared explicit.

29.5.3.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 1:

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 Smeets the requirements of a seed sequence if the expressions shown in Table 124are valid and have the indicated semantics, and if S also meets all other requirements of [rand.req.seedseq].

In Table 124 and throughout this subclause:

T is the type named byS's associated result_type;
q is a value of type S andr is a value of type S or const S;
ib and ie are input iterators with an unsigned integer value_type of at least 32 bits;
rb and re are mutable random access iterators with an unsigned integer value_type of at least 32 bits;
ob is an output iterator; and
il is a value of type initializer_list<T>.

Table 124 — Seed sequence requirements [tab:rand.req.seedseq]

🔗Expression	Return type	Pre/post-condition	Complexity
🔗S::result_type	T	T is an unsigned integer type of at least 32 bits.
🔗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 [ib,ie).
🔗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 [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.
🔗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.5.3.3 Uniform random bit generator requirements [rand.req.urng]

A uniform random bit generator g of type Gis 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 1:

The degree to which g's results approximate the ideal is often determined statistically.

— _end note_]

template<class G> concept uniform_random_bit_generator = invocable<G&> && unsigned_integral<invoke_result_t<G&>> && requires { { G::min() } -> same_as<invoke_result_t<G&>>;{ G::max() } -> same_as<invoke_result_t<G&>>;requires bool_constant<(G::min() < G::max())>::value;};

Let g be an object of type G.

G modelsuniform_random_bit_generator only if

G::min() <= g(),
g() <= G::max(), and
g() has amortized constant complexity.

A class G meets the uniform random bit generator requirements ifG models uniform_random_bit_generator,invoke_result_t<G&> is an unsigned integer type ([basic.fundamental]), andG provides a nested typedef-name result_typethat denotes the same type as invoke_result_t<G&>.

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

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

At any given time,e has a state efor some integer i ≥ 0.

Upon construction,ehas 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:

the size of E's state in multiples of the size of result_type, given as an integral constant expression;
the transition algorithm TA by which e's state e is advanced to its successor state e; and
the generation algorithm GA by which an engine's state is mapped to a value of type result_type.

A class Ethat meets the requirements of a uniform random bit generatoralso meets the requirements of a random number engineif the expressions shown in Table 125are valid and have the indicated semantics, and if E also meets all other requirements of [rand.req.eng].

In Table 125 and throughout this subclause:

T is the type named byE's associated result_type;
e is a value of E,v is an lvalue of E,x and y are (possibly const) values of E;
s is a value of T;
q is an lvalue meeting the requirements of a seed sequence;
z is a value of type unsigned long long;
os is an lvalue of the type of some class template specializationbasic_ostream<charT, traits>; and
is is an lvalue of the type of some class template specializationbasic_istream<charT, traits>;

where charT and traits are constrained according to [strings] and [input.output].

Table 125 — Random number engine requirements [tab:rand.req.eng]

🔗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)241	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 toe e) and returnsGA(e).	per [rand.req.urng]
🔗e.discard(z)242	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).

These operations shall each be of complexity no worse than .

On hosted implementations, the following expressions are well-formed and have the specified semantics.

Effects: With os.fmtflags set toios_base::dec|ios_base::leftand the fill character set to the space character, writes to osthe 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.

Result: reference to the type of os.

Preconditions: 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 argumentscharT and traitswere respectively the same as those of is.

Effects: 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_base::failbit)(which may throw ios_base::failure ([iostate.flags])).

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

Postconditions: The is.fmtflags are unchanged.

Result: reference to the type of is.

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

A random number engine adaptor(commonly shortened to adaptor)a of type Ais 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 enginein 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.

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.

Effects: The base engine is initialized with s.

template<class Sseq> A::A(Sseq& q);

Effects: The base engine is initialized with q.

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 meet the following additional requirements:

The complexity of each function shall not exceed the complexity of the corresponding function applied to the base engine.
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.
Copying A's state (e.g., during copy construction or copy assignment) shall include copying the state of the base engine of A.
The textual representation of A shall include the textual representation of its base engine.

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

A random number distribution(commonly shortened to distribution)d of type Dis 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 functionp(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,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 Dmeets the requirements of a random number distributionif the expressions shown in Table 126are valid and have the indicated semantics, and if D and its associated types also meet all other requirements of [rand.req.dist].

In Table 126 and throughout this subclause,

T is the type named byD's associated result_type;
P is the type named byD's associated param_type;
d is a value of D, andx 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 specializationbasic_ostream<charT, traits>; and
is is an lvalue of the type of some class template specializationbasic_istream<charT, traits>;

where charT and traits are constrained according to [strings] and [input.output].

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

🔗Expression	Return type	Pre/post-condition	Complexity
🔗D::result_type	T	T is an arithmetic type .
🔗D::param_type	P
🔗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 valuep 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 associatedp(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 associatedp(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.

The sequence of numbers produced by repeated invocations of d(g)shall be independent of any invocation ofos << dor of any const member function of Dbetween any of the invocations of d(g).

If a textual representation is written using os << xand that representation is restored into the same or a different object yof 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_typeis declared as a (nested) classor via a typedef.

In [rand], declarations of D::param_typeare in the form of typedefs for convenience of exposition only.

For each of the constructors of Dtaking 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 Dthat 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 formusing distribution_type = D;

On hosted implementations, the following expressions are well-formed and have the specified semantics.

Effects: 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.

Result: reference to the type of os.

Preconditions: is provides a textual representation that was previously written using an os whose imbued locale and whose type's template specialization argumentscharT and traitswere the same as those of is.

Effects: Restores from isthe 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_base::failbit)(which may throw ios_base::failure ([iostate.flags])).

Postconditions: The is.fmtflags are unchanged.

Result: reference to the type of is.

29.5.4 Random number engine class templates [rand.eng]

29.5.4.1 General [rand.eng.general]

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

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

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

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

Descriptions are provided in [rand.eng]only for engine operations that are not described in [rand.req.eng]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.

Each template specified in [rand.eng]requires one or more relationships, involving the value(s) of its constant template parameter(s), to hold.

A program instantiating any of these templates is ill-formed if any such required relationship fails to hold.

For every random number engine and for every random number engine adaptor Xdefined in [rand.eng] and in [rand.adapt]:

if the constructortemplate<class Sseq> explicit X(Sseq& q);is called with a type Sseq that does not qualify as a seed sequence, then this constructor shall not participate in overload resolution;
if the member functiontemplate<class Sseq> void seed(Sseq& q);is called with a type Sseq that does not qualify as a seed sequence, then this function shall not participate in overload resolution.

The extent to which an implementation determines that a type cannot be a seed sequence is unspecified, except that as a minimum a type shall not qualify as a seed sequence if it is implicitly convertible to X::result_type.

29.5.4.2 Class template linear_congruential_engine [rand.eng.lcong]

A linear_congruential_engine random number engine produces unsigned integer random numbers.

The state xof a linear_congruential_engine object xis of size 1and consists of a single integer.

The transition algorithm is a modular linear function of the form; the generation algorithm is .

namespace std { template<class UIntType, UIntType a, UIntType c, UIntType m> class linear_congruential_engine { public: using result_type = UIntType;static constexpr result_type multiplier = a;static constexpr result_type increment = c;static constexpr result_type modulus = m;static constexpr result_type min() { return c == 0u ? 1u: 0u; } static constexpr result_type max() { return m - 1u; } static constexpr result_type default_seed = 1u; linear_congruential_engine() : linear_congruential_engine(default_seed) {} explicit linear_congruential_engine(result_type s);template<class Sseq> explicit linear_congruential_engine(Sseq& q);void seed(result_type s = default_seed);template<class Sseq> void seed(Sseq& q);friend bool operator==(const linear_congruential_engine& x,const linear_congruential_engine& y); result_type operator()();void discard(unsigned long long z);template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const linear_congruential_engine& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, linear_congruential_engine& x);};}

If the template parameterm is 0, the modulus mused throughout [rand.eng.lcong]is numeric_limits<result_type>::max() plus 1.

[Note 1:

m need not be representable as a value of type result_type.

— _end note_]

If the template parameterm is not 0, the following relations shall hold:a < mandc < m.

The textual representation consists of the value of x.

explicit linear_congruential_engine(result_type s);

Effects: If is 0 and is 0, sets the engine's state to 1, otherwise sets the engine's state to .

template<class Sseq> explicit linear_congruential_engine(Sseq& q);

Effects: With and a an array (or equivalent) of length , invokes q.generate(, ) and then computes.

If is 0 and S is 0, sets the engine's state to 1, else sets the engine's state to S.

29.5.4.3 Class template mersenne_twister_engine [rand.eng.mers]

A mersenne_twister_engine random number engine243produces unsigned integer random numbers in the closed interval .

The statexof a mersenne_twister_engine object xis of size nand consists of a sequence Xof n values of the type delivered by x; all subscripts applied to X are to be taken modulo n.

The transition algorithm employs a twisted generalized feedback shift register defined by shift values n and m, a twist value r, and a conditional xor-mask a.

To improve the uniformity of the result, the bits of the raw shift register are additionally tempered(i.e., scrambled) according to a bit-scrambling matrix defined by values u, d, s, b, t, c, and ℓ.

The state transition is performed as follows:

Concatenate the upper bits of with the lower r bits of to obtain an unsigned integer value Y.

The sequence X is initialized with the help of an initialization multiplier f.

The generation algorithm determines the unsigned integer values as follows, then delivers as its result:

namespace std { template<class UIntType, size_t w, size_t n, size_t m, size_t r, UIntType a, size_t u, UIntType d, size_t s, UIntType b, size_t t, UIntType c, size_t l, UIntType f> class mersenne_twister_engine { public: using result_type = UIntType;static constexpr size_t word_size = w;static constexpr size_t state_size = n;static constexpr size_t shift_size = m;static constexpr size_t mask_bits = r;static constexpr UIntType xor_mask = a;static constexpr size_t tempering_u = u;static constexpr UIntType tempering_d = d;static constexpr size_t tempering_s = s;static constexpr UIntType tempering_b = b;static constexpr size_t tempering_t = t;static constexpr UIntType tempering_c = c;static constexpr size_t tempering_l = l;static constexpr UIntType initialization_multiplier = f;static constexpr result_type min() { return 0; } static constexpr result_type max() { return ; } static constexpr result_type default_seed = 5489u; mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} explicit mersenne_twister_engine(result_type value);template<class Sseq> explicit mersenne_twister_engine(Sseq& q);void seed(result_type value = default_seed);template<class Sseq> void seed(Sseq& q);friend bool operator==(const mersenne_twister_engine& x, const mersenne_twister_engine& y); result_type operator()();void discard(unsigned long long z);template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const mersenne_twister_engine& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, mersenne_twister_engine& x);};}

The following relations shall hold:0 < m,m <= n,2u < w,r <= w,u <= w,s <= w,t <= w,l <= w,w <= numeric_limits<UIntType>::digits,a <= (1u << w) - 1u,b <= (1u << w) - 1u,c <= (1u << w) - 1u,d <= (1u << w) - 1u, andf <= (1u << w) - 1u.

The textual representation of xconsists of the values of , in that order.

explicit mersenne_twister_engine(result_type value);

Effects: Sets to .

Then, iteratively for , sets to

template<class Sseq> explicit mersenne_twister_engine(Sseq& q);

Effects: With and a an array (or equivalent) of length , invokes q.generate(, ) and then, iteratively for , sets to .

Finally, if the most significant bits of are zero, and if each of the other resulting is 0, changes to .

29.5.4.4 Class template subtract_with_carry_engine [rand.eng.sub]

A subtract_with_carry_engine random number engine produces unsigned integer random numbers.

The state xof a subtract_with_carry_engine object xis of size, and consists of a sequence X of r integer values ; all subscripts applied to X are to be taken modulo r.

The state xadditionally consists of an integer c(known as the carry) whose value is either 0 or 1.

The state transition is performed as follows:

Set to .
Set c to 1 if , otherwise set c to 0.

[Note 1:

This algorithm corresponds to a modular linear function of the form, where b is of the form and .

— _end note_]

The generation algorithm is given by , where y is the value produced as a result of advancing the engine's state as described above.

namespace std { template<class UIntType, size_t w, size_t s, size_t r> class subtract_with_carry_engine { public: using result_type = UIntType;static constexpr size_t word_size = w;static constexpr size_t short_lag = s;static constexpr size_t long_lag = r;static constexpr result_type min() { return 0; } static constexpr result_type max() { return ; } static constexpr uint_least32_t default_seed = 19780503u; subtract_with_carry_engine() : subtract_with_carry_engine(0u) {} explicit subtract_with_carry_engine(result_type value);template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);void seed(result_type value = 0u);template<class Sseq> void seed(Sseq& q);friend bool operator==(const subtract_with_carry_engine& x,const subtract_with_carry_engine& y); result_type operator()();void discard(unsigned long long z);template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const subtract_with_carry_engine& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, subtract_with_carry_engine& x);};}

The following relations shall hold:0u < s,s < r,0 < w, andw <= numeric_limits<UIntType>::digits.

The textual representation consists of the values of, in that order, followed by c.

explicit subtract_with_carry_engine(result_type value);

Effects: Sets the values of, in that order, as specified below.

If is then 0, sets c to 1; otherwise sets c to 0.

To set the values , first construct e, a linear_congruential_engine object, as if by the following definition:linear_congruential_engine<uint_least32_t, 40014u, 0u, 2147483563u> e( value == 0u ? default_seed : static_cast<uint_least32_t>(value % 2147483563u));

Then, to set each , obtain new values from successive invocations of e.

Set to .

Complexity: Exactly invocations of e.

template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);

Effects: With and a an array (or equivalent) of length , invokes q.generate(, ) and then, iteratively for , sets to .

If is then 0, sets c to 1; otherwise sets c to 0.

29.5.4.5 Class template philox_engine [rand.eng.philox]

A philox_engine random number engine produces unsigned integer random numbers in the interval [0, m), where and the template parameter w defines the range of the produced numbers.

The state of a philox_engine object consists of a sequence X of n unsigned integer values of width w, a sequence K of values of result_type, a sequence Y of n values of result_type, and a scalar i, where

X is the interpretation of the unsigned integer counter value of bits,
K are keys, which are generated once from the seed (see constructors below) and remain constant unless the seed function ([rand.req.eng]) is invoked,
Y stores a batch of output values, and
i is an index for an element of the sequence Y.

The generation algorithm returns , the value stored in the element of Y after applying the transition algorithm.

The state transition is performed as if by the following algorithm:i = i + 1 if (i == n) { Y = Philox(K, X) Z = Z + 1 i = 0 }

The Philox function maps the length- sequence K and the length-n sequence X into a length-n output sequence Y.

Philox applies an r-round substitution-permutation network to the values in X.

A single round of the generation algorithm performs the following steps:

The output sequence of the previous round (X in case of the first round) is permuted to obtain the intermediate state V: where and is defined in Table 127.
[Note 1:
For the sequence is not permuted.
— _end note_]
The following computations are applied to the elements of the V sequence: where:
- mullo(a, b, w) is the low half of the modular multiplication of a and b:,
- mulhi(a, b, w) is the high half of the modular multiplication of a and b:,
- is the index in the sequences,
- is the index of the round,
- is the round key for round q,,
- are the elements of the key sequence K,
- is multipliers[k], and
- is round_consts[k].

After r applications of the single-round function,Philox returns the sequence .

namespace std { template<class UIntType, size_t w, size_t n, size_t r, UIntType... consts> class philox_engine { static constexpr size_t array-size = n / 2; public: using result_type = UIntType;static constexpr size_t word_size = w;static constexpr size_t word_count = n;static constexpr size_t round_count = r;static constexpr array<result_type, array-size_> multipliers;static constexpr array<result_type, _array-size> round_consts;static constexpr result_type min() { return 0; } static constexpr result_type max() { return m - 1; } static constexpr result_type default_seed = 20111115u; philox_engine() : philox_engine(default_seed) {} explicit philox_engine(result_type value);template<class Sseq> explicit philox_engine(Sseq& q);void seed(result_type value = default_seed);template<class Sseq> void seed(Sseq& q);void set_counter(const array<result_type, n>& counter);friend bool operator==(const philox_engine& x, const philox_engine& y); result_type operator()();void discard(unsigned long long z);template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const philox_engine& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, philox_engine& x);};}

Mandates:

sizeof...(consts) == n is true, and
n == 2 || n == 4 is true, and
0 < r is true, and
0 < w && w <= numeric_limits<UIntType>::digits is true.

The template parameter pack consts represents the and constants which are grouped as follows:.

The textual representation consists of the values of, in that order.

[Note 2:

The stream extraction operator can reconstruct Y from K and X, as needed.

— _end note_]

explicit philox_engine(result_type value);

Effects: Sets the element of sequence K to .

All elements of sequences X and K (except ) are set to 0.

The value of i is set to .

template<class Sseq> explicit philox_engine(Sseq& q);

Effects: With and an array (or equivalent) a of length , invokes q.generate(a + 0, a + n / 2 * p) and then iteratively for , sets to.

All elements of sequence X are set to 0.

The value of i is set to .

void set_counter(const array<result_type, n>& c);

Effects: For sets to .

The value of i is set to .

[Note 3:

The counter is the value Z introduced at the beginning of this subclause.

— _end note_]

29.5.5 Random number engine adaptor class templates [rand.adapt]

29.5.5.1 General [rand.adapt.general]

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

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

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

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

Descriptions are provided in [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.

Each template specified in [rand.adapt]requires one or more relationships, involving the value(s) of its constant template parameter(s), to hold.

A program instantiating any of these templates is ill-formed if any such required relationship fails to hold.

29.5.5.2 Class template discard_block_engine [rand.adapt.disc]

A discard_block_engine random number engine adaptor produces random numbers selected from those produced by some base engine e.

The state xof a discard_block_engine engine adaptor object xconsists of the state e of its base engine eand an additional integer n.

The size of the state is the size of e's state plus 1.

The transition algorithm discards all but values from each block of p ≥ r values delivered by e.

The state transition is performed as follows: If n ≥ r, advance the state of e from e to e and set n to 0.

In any case, then increment n and advance e's then-current state e to e.

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: using result_type = typename Engine::result_type;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(); } 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);friend bool operator==(const discard_block_engine& x, const discard_block_engine& y); result_type operator()();void discard(unsigned long long z);const Engine& base() const noexcept { return e; } 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; size_t n; };}

The following relations shall hold:0 < randr <= p.

The textual representation consists of the textual representation of efollowed by the value of n.

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

29.5.5.3 Class template independent_bits_engine [rand.adapt.ibits]

An independent_bits_enginerandom 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 xof an independent_bits_engineengine adaptor object xconsists of the state e of its base engine e; the size of the state is the size of e's state.

The transition and generation algorithms are described in terms of the following integral constants:

With n as determined below, let,,, and.
Let if and only if the relation holds as a result.
Otherwise let.

[Note 1:

The relation always holds.

— _end note_]

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 Sobtained 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: using result_type = UIntType;static constexpr result_type min() { return 0; } static constexpr result_type max() { return ; } 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);friend bool operator==(const independent_bits_engine& x, const independent_bits_engine& y); result_type operator()();void discard(unsigned long long z);const Engine& base() const noexcept { return e; } 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; };}

The following relations shall hold:0 < wandw <= numeric_limits<result_type>::digits.

The textual representation consists of the textual representation of e.

29.5.5.4 Class template shuffle_order_engine [rand.adapt.shuf]

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 xof a shuffle_order_engine engine adaptor object xconsists 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 size of the state is the size of e's state plus .

The transition algorithm permutes the values produced by e.

The state transition is performed as follows:

Set Y to and then set to 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: using result_type = typename Engine::result_type;static constexpr size_t table_size = k;static constexpr result_type min() { return Engine::min(); } static constexpr result_type max() { return Engine::max(); } 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);friend bool operator==(const shuffle_order_engine& x, const shuffle_order_engine& y); result_type operator()();void discard(unsigned long long z);const Engine& base() const noexcept { return e; } 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; result_type V[k]; result_type Y; };}

The following relation shall hold:0 < k.

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

29.5.6 Engines and engine adaptors with predefined parameters [rand.predef]

using minstd_rand0 = linear_congruential_engine<uint_fast32_t, 16'807, 0, 2'147'483'647>;

Required behavior: The consecutive invocation of a default-constructed object of type minstd_rand0 produces the value 1043618065.

using minstd_rand = linear_congruential_engine<uint_fast32_t, 48'271, 0, 2'147'483'647>;

Required behavior: The consecutive invocation of a default-constructed object of type minstd_rand produces the value 399268537.

using mt19937 = mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,0x9908'b0df, 11, 0xffff'ffff, 7, 0x9d2c'5680, 15, 0xefc6'0000, 18, 1'812'433'253>;

Required behavior: The consecutive invocation of a default-constructed object of type mt19937 produces the value 4123659995.

using mt19937_64 = mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,0xb502'6f5a'a966'19e9, 29, 0x5555'5555'5555'5555, 17,0x71d6'7fff'eda6'0000, 37, 0xfff7'eee0'0000'0000, 43, 6'364'136'223'846'793'005>;

Required behavior: The consecutive invocation of a default-constructed object of type mt19937_64 produces the value 9981545732273789042.

using ranlux24_base = subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>;

Required behavior: The consecutive invocation of a default-constructed object of type ranlux24_base produces the value7937952.

using ranlux48_base = subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>;

Required behavior: The consecutive invocation of a default-constructed object of type ranlux48_base produces the value61839128582725.

using ranlux24 = discard_block_engine<ranlux24_base, 223, 23>;

Required behavior: The consecutive invocation of a default-constructed object of type ranlux24 produces the value9901578.

using ranlux48 = discard_block_engine<ranlux48_base, 389, 11>;

Required behavior: The consecutive invocation of a default-constructed object of type ranlux48 produces the value249142670248501.

using knuth_b = shuffle_order_engine<minstd_rand0,256>;

Required behavior: The consecutive invocation of a default-constructed object of type knuth_b produces the value 1112339016.

using default_random_engine = _implementation-defined_;

Remarks: The choice of engine type named by this typedefis implementation-defined.

[Note 1:

The implementation can select this type on the basis of performance, size, quality, or any combination of such factors, so as to provide at least acceptable engine behavior for relatively casual, inexpert, and/or lightweight use.

Because different implementations can select different underlying engine types, code that uses this typedef need not generate identical sequences across implementations.

— _end note_]

using philox4x32 = philox_engine<uint_fast32_t, 32, 4, 10,0xCD9E8D57, 0x9E3779B9, 0xD2511F53, 0xBB67AE85>;

Required behavior: The consecutive invocation a default-constructed object of type philox4x32produces the value 1955073260.

using philox4x64 = philox_engine<uint_fast64_t, 64, 4, 10,0xCA5A826395121157, 0x9E3779B97F4A7C15, 0xD2E7470EE14C6C93, 0xBB67AE8584CAA73B>;

Required behavior: The consecutive invocation a default-constructed object of type philox4x64produces the value 3409172418970261260.

29.5.7 Class random_device [rand.device]

A random_deviceuniform random bit generator produces nondeterministic random numbers.

If implementation limitations prevent generating nondeterministic random numbers, the implementation may employ a random number engine.

namespace std { class random_device { public: using result_type = unsigned int;static constexpr result_type min() { return numeric_limits<result_type>::min(); } static constexpr result_type max() { return numeric_limits<result_type>::max(); } random_device() : random_device(implementation-defined) {} explicit random_device(const string& token); result_type operator()();double entropy() const noexcept; random_device(const random_device&) = delete;void operator=(const random_device&) = delete;};}

explicit random_device(const string& token);

Throws: A value of an implementation-defined type derived from exception if the random_device cannot be initialized.

Remarks: The semantics of the token parameter and the token value used by the default constructor areimplementation-defined.244

double entropy() const noexcept;

Returns: If the implementation employs a random number engine, returns 0.0.

Otherwise, returns an entropy estimate245 for the random numbers returned by operator(), in the rangemin() to.

result_type operator()();

Returns: A nondeterministic random value, uniformly distributed between min() and max() (inclusive).

It is implementation-defined how these values are generated.

Throws: A value of an implementation-defined type derived from exception if a random number cannot be obtained.

29.5.8 Utilities [rand.util]

29.5.8.1 Class seed_seq [rand.util.seedseq]

namespace std { class seed_seq { public: using result_type = uint_least32_t; seed_seq() noexcept;template<class T> seed_seq(initializer_list<T> il);template<class InputIterator> seed_seq(InputIterator begin, InputIterator end);template<class RandomAccessIterator> void generate(RandomAccessIterator begin, RandomAccessIterator end); size_t size() const noexcept;template<class OutputIterator> void param(OutputIterator dest) const; seed_seq(const seed_seq&) = delete;void operator=(const seed_seq&) = delete;private: vector<result_type> v; };}

Postconditions: v.empty() is true.

template<class T> seed_seq(initializer_list<T> il);

Constraints: T is an integer type.

Effects: Same as seed_seq(il.begin(), il.end()).

template<class InputIterator> seed_seq(InputIterator begin, InputIterator end);

Mandates: iterator_traits<InputIterator>::value_type is an integer type.

Effects: Initializes vby the following algorithm:for (InputIterator s = begin; s != end; ++s) v.push_back((*s));

template<class RandomAccessIterator> void generate(RandomAccessIterator begin, RandomAccessIterator end);

Mandates: iterator_traits<RandomAccessIterator>::value_type is an unsigned integer type capable of accommodating 32-bit quantities.

Effects: Does nothing if begin == end.

Otherwise, with and , fills the supplied range [begin,end) according to the following algorithm in which each operation is to be carried out modulo , each indexing operator applied to begin is to be taken modulo n, and T(x) is defined as x xor(x rshift27):

By way of initialization, set each element of the range to the value 0x8b8b8b8b.
Additionally, for use in subsequent steps, let and let , where
With m as the larger of and n, transform the elements of the range: iteratively for , calculate values
and, in order, increment begin[] by , increment begin[] by , and set begin[k] to .
Transform the elements of the range again, beginning where the previous step ended: iteratively for , calculate values
and, in order, update begin[] by xoring it with , update begin[] by xoring it with , and set begin[k] to .

Throws: What and when RandomAccessIterator operations of beginand end throw.

size_t size() const noexcept;

Returns: The number of 32-bit units that would be returned by a call to param().

Complexity: Constant time.

template<class OutputIterator> void param(OutputIterator dest) const;

Effects: Copies the sequence of prepared 32-bit units to the given destination, as if by executing the following statement:copy(v.begin(), v.end(), dest);

Throws: What and when OutputIterator operations of dest throw.

29.5.8.2 Function template generate_canonical [rand.util.canonical]

template<class RealType, size_t digits, class URBG> RealType generate_canonical(URBG& g);

Let

r be numeric_limits<RealType>::radix,
R be ,
d be the smaller ofdigits and numeric_limits<RealType>::digits,246
k be the smallest integer such that , and
x be .

An attempt is k invocations of g()to obtain values , respectively, and the calculation of a quantity S given by Formula 29.1:

Effects: Attempts are made until .

[Note 1:

When R is a power of r, precisely one attempt is made.

— _end note_]

Returns: .

[Note 2:

The return value c satisfies.

— _end note_]

Throws: What and when g throws.

Complexity: Exactly k invocations of g per attempt.

[Note 3:

If the values produced by g are uniformly distributed, the instantiation's results are distributed as uniformly as possible.

Obtaining a value in this way can be a useful step in the process of transforming a value generated by a uniform random bit generator into a value that can be delivered by a random number distribution.

— _end note_]

[Note 4:

When R is a power of r, an implementation can avoid using an arithmetic type that is wider than the output when computing S.

— _end note_]

29.5.9 Random number distribution class templates [rand.dist]

29.5.9.1 General [rand.dist.general]

Each type instantiated from a class template specified in [rand.dist]meets the requirements of a random number distribution type.

Descriptions are provided in [rand.dist]only for distribution operations that are not described in [rand.req.dist]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 algorithms for producing each of the specified distributions areimplementation-defined.

The value of each probability density function p(z)and of each discrete probability function specified in this subclause is 0everywhere outside its stated domain.

29.5.9.2 Uniform distributions [rand.dist.uni]

29.5.9.2.1 Class template uniform_int_distribution [rand.dist.uni.int]

A uniform_int_distribution random number distribution produces random integers i,a ≤ i ≤ b, distributed according to the constant discrete probability function in Formula 29.2 .

namespace std { template<class IntType = int> class uniform_int_distribution { public: using result_type = IntType;using param_type = unspecified; uniform_int_distribution() : uniform_int_distribution(0) {} explicit uniform_int_distribution(IntType a, IntType b = numeric_limits<IntType>::max());explicit uniform_int_distribution(const param_type& parm);void reset();friend bool operator==(const uniform_int_distribution& x, const uniform_int_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); result_type a() const; result_type b() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const uniform_int_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, uniform_int_distribution& x);};}

explicit uniform_int_distribution(IntType a, IntType b = numeric_limits<IntType>::max());

Remarks: a and b correspond to the respective parameters of the distribution.

Returns: The value of the a parameter with which the object was constructed.

Returns: The value of the b parameter with which the object was constructed.

29.5.9.2.2 Class template uniform_real_distribution [rand.dist.uni.real]

A uniform_real_distribution random number distribution produces random numbers x,, distributed according to the constant probability density function in Formula 29.3 .

[Note 1:

This implies that p(x | a,b) is undefined when a == b.

— _end note_]

namespace std { template<class RealType = double> class uniform_real_distribution { public: using result_type = RealType;using param_type = unspecified; uniform_real_distribution() : uniform_real_distribution(0.0) {} explicit uniform_real_distribution(RealType a, RealType b = 1.0);explicit uniform_real_distribution(const param_type& parm);void reset();friend bool operator==(const uniform_real_distribution& x,const uniform_real_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); result_type a() const; result_type b() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const uniform_real_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, uniform_real_distribution& x);};}

explicit uniform_real_distribution(RealType a, RealType b = 1.0);

Preconditions: a ≤ band.

Remarks: a and b correspond to the respective parameters of the distribution.

Returns: The value of the a parameter with which the object was constructed.

Returns: The value of the b parameter with which the object was constructed.

29.5.9.3 Bernoulli distributions [rand.dist.bern]

29.5.9.3.1 Class bernoulli_distribution [rand.dist.bern.bernoulli]

A bernoulli_distribution random number distribution produces bool values bdistributed according to the discrete probability function in Formula 29.4 .

namespace std { class bernoulli_distribution { public: using result_type = bool;using param_type = unspecified; bernoulli_distribution() : bernoulli_distribution(0.5) {} explicit bernoulli_distribution(double p);explicit bernoulli_distribution(const param_type& parm);void reset();friend bool operator==(const bernoulli_distribution& x, const bernoulli_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);double p() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const bernoulli_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, bernoulli_distribution& x);};}

explicit bernoulli_distribution(double p);

Preconditions: 0 ≤ p ≤ 1.

Remarks: p corresponds to the parameter of the distribution.

Returns: The value of the p parameter with which the object was constructed.

29.5.9.3.2 Class template binomial_distribution [rand.dist.bern.bin]

A binomial_distribution random number distribution produces integer values i ≥ 0distributed according to the discrete probability function in Formula 29.5 .

namespace std { template<class IntType = int> class binomial_distribution { public: using result_type = IntType;using param_type = unspecified; binomial_distribution() : binomial_distribution(1) {} explicit binomial_distribution(IntType t, double p = 0.5);explicit binomial_distribution(const param_type& parm);void reset();friend bool operator==(const binomial_distribution& x, const binomial_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); IntType t() const;double p() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const binomial_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, binomial_distribution& x);};}

explicit binomial_distribution(IntType t, double p = 0.5);

Preconditions: 0 ≤ p ≤ 1 and 0 ≤ t.

Remarks: t and p correspond to the respective parameters of the distribution.

Returns: The value of the t parameter with which the object was constructed.

Returns: The value of the p parameter with which the object was constructed.

29.5.9.3.3 Class template geometric_distribution [rand.dist.bern.geo]

A geometric_distribution random number distribution produces integer values i ≥ 0distributed according to the discrete probability function in Formula 29.6 .

namespace std { template<class IntType = int> class geometric_distribution { public: using result_type = IntType;using param_type = unspecified; geometric_distribution() : geometric_distribution(0.5) {} explicit geometric_distribution(double p);explicit geometric_distribution(const param_type& parm);void reset();friend bool operator==(const geometric_distribution& x, const geometric_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);double p() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const geometric_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, geometric_distribution& x);};}

explicit geometric_distribution(double p);

Remarks: p corresponds to the parameter of the distribution.

Returns: The value of the p parameter with which the object was constructed.

29.5.9.3.4 Class template negative_binomial_distribution [rand.dist.bern.negbin]

A negative_binomial_distribution random number distribution produces random integers i ≥ 0distributed according to the discrete probability function in Formula 29.7 .

[Note 1:

This implies that P(i | k,p) is undefined when p == 1.

— _end note_]

namespace std { template<class IntType = int> class negative_binomial_distribution { public: using result_type = IntType;using param_type = unspecified; negative_binomial_distribution() : negative_binomial_distribution(1) {} explicit negative_binomial_distribution(IntType k, double p = 0.5);explicit negative_binomial_distribution(const param_type& parm);void reset();friend bool operator==(const negative_binomial_distribution& x,const negative_binomial_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); IntType k() const;double p() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const negative_binomial_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, negative_binomial_distribution& x);};}

explicit negative_binomial_distribution(IntType k, double p = 0.5);

Remarks: k and p correspond to the respective parameters of the distribution.

Returns: The value of the k parameter with which the object was constructed.

Returns: The value of the p parameter with which the object was constructed.

29.5.9.4 Poisson distributions [rand.dist.pois]

29.5.9.4.1 Class template poisson_distribution [rand.dist.pois.poisson]

A poisson_distribution random number distribution produces integer values i ≥ 0distributed according to the discrete probability function in Formula 29.8 .

The distribution parameter μis also known as this distribution's mean.

namespace std { template<class IntType = int> class poisson_distribution { public: using result_type = IntType;using param_type = unspecified; poisson_distribution() : poisson_distribution(1.0) {} explicit poisson_distribution(double mean);explicit poisson_distribution(const param_type& parm);void reset();friend bool operator==(const poisson_distribution& x, const poisson_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);double mean() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const poisson_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, poisson_distribution& x);};}

explicit poisson_distribution(double mean);

Remarks: mean corresponds to the parameter of the distribution.

Returns: The value of the mean parameter with which the object was constructed.

29.5.9.4.2 Class template exponential_distribution [rand.dist.pois.exp]

An exponential_distribution random number distribution produces random numbers distributed according to the probability density function in Formula 29.9 .

namespace std { template<class RealType = double> class exponential_distribution { public: using result_type = RealType;using param_type = unspecified; exponential_distribution() : exponential_distribution(1.0) {} explicit exponential_distribution(RealType lambda);explicit exponential_distribution(const param_type& parm);void reset();friend bool operator==(const exponential_distribution& x, const exponential_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); RealType lambda() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const exponential_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, exponential_distribution& x);};}

explicit exponential_distribution(RealType lambda);

Remarks: lambda corresponds to the parameter of the distribution.

Returns: The value of the lambda parameter with which the object was constructed.

29.5.9.4.3 Class template gamma_distribution [rand.dist.pois.gamma]

A gamma_distribution random number distribution produces random numbers distributed according to the probability density function in Formula 29.10 .

namespace std { template<class RealType = double> class gamma_distribution { public: using result_type = RealType;using param_type = unspecified; gamma_distribution() : gamma_distribution(1.0) {} explicit gamma_distribution(RealType alpha, RealType beta = 1.0);explicit gamma_distribution(const param_type& parm);void reset();friend bool operator==(const gamma_distribution& x, const gamma_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); RealType alpha() const; RealType beta() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const gamma_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, gamma_distribution& x);};}

explicit gamma_distribution(RealType alpha, RealType beta = 1.0);

Remarks: alpha and betacorrespond to the parameters of the distribution.

Returns: The value of the alpha parameter with which the object was constructed.

Returns: The value of the beta parameter with which the object was constructed.

29.5.9.4.4 Class template weibull_distribution [rand.dist.pois.weibull]

A weibull_distribution random number distribution produces random numbers x ≥ 0distributed according to the probability density function in Formula 29.11 .

namespace std { template<class RealType = double> class weibull_distribution { public: using result_type = RealType;using param_type = unspecified; weibull_distribution() : weibull_distribution(1.0) {} explicit weibull_distribution(RealType a, RealType b = 1.0);explicit weibull_distribution(const param_type& parm);void reset();friend bool operator==(const weibull_distribution& x, const weibull_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); RealType a() const; RealType b() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const weibull_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, weibull_distribution& x);};}

explicit weibull_distribution(RealType a, RealType b = 1.0);

Remarks: a and bcorrespond to the respective parameters of the distribution.

Returns: The value of the a parameter with which the object was constructed.

Returns: The value of the b parameter with which the object was constructed.

29.5.9.4.5 Class template extreme_value_distribution [rand.dist.pois.extreme]

An extreme_value_distribution random number distribution produces random numbers xdistributed according to the probability density function in Formula 29.12 .247

namespace std { template<class RealType = double> class extreme_value_distribution { public: using result_type = RealType;using param_type = unspecified; extreme_value_distribution() : extreme_value_distribution(0.0) {} explicit extreme_value_distribution(RealType a, RealType b = 1.0);explicit extreme_value_distribution(const param_type& parm);void reset();friend bool operator==(const extreme_value_distribution& x,const extreme_value_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); RealType a() const; RealType b() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const extreme_value_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, extreme_value_distribution& x);};}

explicit extreme_value_distribution(RealType a, RealType b = 1.0);

Remarks: a and bcorrespond to the respective parameters of the distribution.

Returns: The value of the a parameter with which the object was constructed.

Returns: The value of the b parameter with which the object was constructed.

29.5.9.5 Normal distributions [rand.dist.norm]

29.5.9.5.1 Class template normal_distribution [rand.dist.norm.normal]

A normal_distribution random number distribution produces random numbers xdistributed according to the probability density function in Formula 29.13 .

The distribution parameters μ and σare also known as this distribution's meanand standard deviation.

namespace std { template<class RealType = double> class normal_distribution { public: using result_type = RealType;using param_type = unspecified; normal_distribution() : normal_distribution(0.0) {} explicit normal_distribution(RealType mean, RealType stddev = 1.0);explicit normal_distribution(const param_type& parm);void reset();friend bool operator==(const normal_distribution& x, const normal_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); RealType mean() const; RealType stddev() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const normal_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, normal_distribution& x);};}

explicit normal_distribution(RealType mean, RealType stddev = 1.0);

Remarks: mean and stddevcorrespond to the respective parameters of the distribution.

Returns: The value of the mean parameter with which the object was constructed.

Returns: The value of the stddev parameter with which the object was constructed.

29.5.9.5.2 Class template lognormal_distribution [rand.dist.norm.lognormal]

A lognormal_distribution random number distribution produces random numbers distributed according to the probability density function in Formula 29.14 .

namespace std { template<class RealType = double> class lognormal_distribution { public: using result_type = RealType;using param_type = unspecified; lognormal_distribution() : lognormal_distribution(0.0) {} explicit lognormal_distribution(RealType m, RealType s = 1.0);explicit lognormal_distribution(const param_type& parm);void reset();friend bool operator==(const lognormal_distribution& x, const lognormal_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); RealType m() const; RealType s() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const lognormal_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, lognormal_distribution& x);};}

explicit lognormal_distribution(RealType m, RealType s = 1.0);

Remarks: m and scorrespond to the respective parameters of the distribution.

Returns: The value of the m parameter with which the object was constructed.

Returns: The value of the s parameter with which the object was constructed.

29.5.9.5.3 Class template chi_squared_distribution [rand.dist.norm.chisq]

A chi_squared_distribution random number distribution produces random numbers distributed according to the probability density function in Formula 29.15 .

namespace std { template<class RealType = double> class chi_squared_distribution { public: using result_type = RealType;using param_type = unspecified; chi_squared_distribution() : chi_squared_distribution(1.0) {} explicit chi_squared_distribution(RealType n);explicit chi_squared_distribution(const param_type& parm);void reset();friend bool operator==(const chi_squared_distribution& x, const chi_squared_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); RealType n() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const chi_squared_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, chi_squared_distribution& x);};}

explicit chi_squared_distribution(RealType n);

Remarks: n corresponds to the parameter of the distribution.

Returns: The value of the n parameter with which the object was constructed.

29.5.9.5.4 Class template cauchy_distribution [rand.dist.norm.cauchy]

A cauchy_distribution random number distribution produces random numbers xdistributed according to the probability density function in Formula 29.16 .

namespace std { template<class RealType = double> class cauchy_distribution { public: using result_type = RealType;using param_type = unspecified; cauchy_distribution() : cauchy_distribution(0.0) {} explicit cauchy_distribution(RealType a, RealType b = 1.0);explicit cauchy_distribution(const param_type& parm);void reset();friend bool operator==(const cauchy_distribution& x, const cauchy_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); RealType a() const; RealType b() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const cauchy_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, cauchy_distribution& x);};}

explicit cauchy_distribution(RealType a, RealType b = 1.0);

Remarks: a and bcorrespond to the respective parameters of the distribution.

Returns: The value of the a parameter with which the object was constructed.

Returns: The value of the b parameter with which the object was constructed.

29.5.9.5.5 Class template fisher_f_distribution [rand.dist.norm.f]

A fisher_f_distribution random number distribution produces random numbers x ≥ 0distributed according to the probability density function in Formula 29.17 .

namespace std { template<class RealType = double> class fisher_f_distribution { public: using result_type = RealType;using param_type = unspecified; fisher_f_distribution() : fisher_f_distribution(1.0) {} explicit fisher_f_distribution(RealType m, RealType n = 1.0);explicit fisher_f_distribution(const param_type& parm);void reset();friend bool operator==(const fisher_f_distribution& x, const fisher_f_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); RealType m() const; RealType n() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const fisher_f_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, fisher_f_distribution& x);};}

explicit fisher_f_distribution(RealType m, RealType n = 1);

Remarks: m and ncorrespond to the respective parameters of the distribution.

Returns: The value of the m parameter with which the object was constructed.

Returns: The value of the n parameter with which the object was constructed.

29.5.9.5.6 Class template student_t_distribution [rand.dist.norm.t]

A student_t_distribution random number distribution produces random numbers xdistributed according to the probability density function in Formula 29.18 .

namespace std { template<class RealType = double> class student_t_distribution { public: using result_type = RealType;using param_type = unspecified; student_t_distribution() : student_t_distribution(1.0) {} explicit student_t_distribution(RealType n);explicit student_t_distribution(const param_type& parm);void reset();friend bool operator==(const student_t_distribution& x, const student_t_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); RealType n() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const student_t_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, student_t_distribution& x);};}

explicit student_t_distribution(RealType n);

Remarks: n corresponds to the parameter of the distribution.

Returns: The value of the n parameter with which the object was constructed.

29.5.9.6 Sampling distributions [rand.dist.samp]

29.5.9.6.1 Class template discrete_distribution [rand.dist.samp.discrete]

A discrete_distribution random number distribution produces random integers i, , distributed according to the discrete probability function in Formula 29.19 .

Unless specified otherwise, the distribution parameters are calculated as: for , in which the values , commonly known as the weights, shall be non-negative, non-NaN, and non-infinity.

Moreover, the following relation shall hold:.

namespace std { template<class IntType = int> class discrete_distribution { public: using result_type = IntType;using param_type = unspecified; discrete_distribution();template<class InputIterator> discrete_distribution(InputIterator firstW, InputIterator lastW); discrete_distribution(initializer_list<double> wl);template<class UnaryOperation> discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);explicit discrete_distribution(const param_type& parm);void reset();friend bool operator==(const discrete_distribution& x, const discrete_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); vector<double> probabilities() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const discrete_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, discrete_distribution& x);};}

Effects: Constructs a discrete_distribution object with and .

[Note 1:

Such an object will always deliver the value 0.

— _end note_]

template<class InputIterator> discrete_distribution(InputIterator firstW, InputIterator lastW);

Mandates: is_convertible_v<iterator_traits<InputIterator>::value_type,double> is true.

If firstW == lastW, let and .

Otherwise,[firstW, lastW) forms a sequence w of length .

Effects: Constructs a discrete_distribution object with probabilities given by the Formula 29.19 .

discrete_distribution(initializer_list<double> wl);

Effects: Same as discrete_distribution(wl.begin(), wl.end()).

template<class UnaryOperation> discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);

Mandates: is_invocable_r_v<double, UnaryOperation&, double> is true.

Preconditions: If , let , otherwise let .

The relation holds.

Effects: Constructs a discrete_distribution object with probabilities given by the formula above, using the following values: If , let .

Otherwise, let for .

Complexity: The number of invocations of fw does not exceed n.

vector<double> probabilities() const;

Returns: A vector<double> whose size member returns n and whose operator[] member returns when invoked with argument k for .

29.5.9.6.2 Class template piecewise_constant_distribution [rand.dist.samp.pconst]

A piecewise_constant_distribution random number distribution produces random numbers x,, uniformly distributed over each subintervalaccording to the probability density function in Formula 29.20 .

The distribution parameters , also known as this distribution's interval boundaries, shall satisfy the relation for .

Unless specified otherwise, the remaining n distribution parameters are calculated as:
in which the values , commonly known as the weights, shall be non-negative, non-NaN, and non-infinity.

Moreover, the following relation shall hold:.

namespace std { template<class RealType = double> class piecewise_constant_distribution { public: using result_type = RealType;using param_type = unspecified; piecewise_constant_distribution();template<class InputIteratorB, class InputIteratorW> piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB, InputIteratorW firstW);template<class UnaryOperation> piecewise_constant_distribution(initializer_list<RealType> bl, UnaryOperation fw);template<class UnaryOperation> piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);explicit piecewise_constant_distribution(const param_type& parm);void reset();friend bool operator==(const piecewise_constant_distribution& x,const piecewise_constant_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); vector<result_type> intervals() const; vector<result_type> densities() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const piecewise_constant_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, piecewise_constant_distribution& x);};}

piecewise_constant_distribution();

Effects: Constructs a piecewise_constant_distribution object with ,,, and .

template<class InputIteratorB, class InputIteratorW> piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB, InputIteratorW firstW);

Mandates: Both of

is_convertible_v<iterator_traits<InputIteratorB>::value_type, double>
is_convertible_v<iterator_traits<InputIteratorW>::value_type, double>

are true.

If firstB == lastB or ++firstB == lastB, let ,,, and .

Otherwise,[firstB, lastB) forms a sequence b of length , the length of the sequence w starting from firstW is at least n, and any for k ≥ n are ignored by the distribution.

Effects: Constructs a piecewise_constant_distribution object with parameters as specified above.

template<class UnaryOperation> piecewise_constant_distribution(initializer_list<RealType> bl, UnaryOperation fw);

Mandates: is_invocable_r_v<double, UnaryOperation&, double> is true.

Effects: Constructs a piecewise_constant_distribution object with parameters taken or calculated from the following values: If , let ,,, and .

Otherwise, let [bl.begin(), bl.end()) form a sequence , and let for .

Complexity: The number of invocations of fw does not exceed n.

template<class UnaryOperation> piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);

Mandates: is_invocable_r_v<double, UnaryOperation&, double> is true.

Preconditions: If , let , otherwise let .

The relation holds.

Effects: Constructs a piecewise_constant_distribution object with parameters taken or calculated from the following values: Let for , and for .

Complexity: The number of invocations of fw does not exceed n.

vector<result_type> intervals() const;

Returns: A vector<result_type> whose size member returns and whose operator[] member returns when invoked with argument k for .

vector<result_type> densities() const;

Returns: A vector<result_type> whose size member returns n and whose operator[] member returns when invoked with argument k for .

29.5.9.6.3 Class template piecewise_linear_distribution [rand.dist.samp.plinear]

A piecewise_linear_distribution random number distribution produces random numbers x,, distributed over each subintervalaccording to the probability density function in Formula 29.21 .

The distribution parameters , also known as this distribution's interval boundaries, shall satisfy the relation for .

Unless specified otherwise, the remaining distribution parameters are calculated as for , in which the values , commonly known as the weights at boundaries, shall be non-negative, non-NaN, and non-infinity.

Moreover, the following relation shall hold:

namespace std { template<class RealType = double> class piecewise_linear_distribution { public: using result_type = RealType;using param_type = unspecified; piecewise_linear_distribution();template<class InputIteratorB, class InputIteratorW> piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB, InputIteratorW firstW);template<class UnaryOperation> piecewise_linear_distribution(initializer_list<RealType> bl, UnaryOperation fw);template<class UnaryOperation> piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);explicit piecewise_linear_distribution(const param_type& parm);void reset();friend bool operator==(const piecewise_linear_distribution& x,const piecewise_linear_distribution& y);template<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm); vector<result_type> intervals() const; vector<result_type> densities() const; param_type param() const;void param(const param_type& parm); result_type min() const; result_type max() const;template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const piecewise_linear_distribution& x);template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, piecewise_linear_distribution& x);};}

piecewise_linear_distribution();

Effects: Constructs a piecewise_linear_distribution object with ,,, and .

template<class InputIteratorB, class InputIteratorW> piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB, InputIteratorW firstW);

Mandates: Both of

is_convertible_v<iterator_traits<InputIteratorB>::value_type, double>
is_convertible_v<iterator_traits<InputIteratorW>::value_type, double>

are true.

If firstB == lastB or ++firstB == lastB, let ,,, and .

Otherwise,[firstB, lastB) forms a sequence b of length , the length of the sequence w starting from firstW is at least , and any for are ignored by the distribution.

Effects: Constructs a piecewise_linear_distribution object with parameters as specified above.

template<class UnaryOperation> piecewise_linear_distribution(initializer_list<RealType> bl, UnaryOperation fw);

Mandates: is_invocable_r_v<double, UnaryOperation&, double> is true.

Effects: Constructs a piecewise_linear_distribution object with parameters taken or calculated from the following values: If , let ,,, and .

Otherwise, let [bl.begin(), bl.end()) form a sequence , and let for .

Complexity: The number of invocations of fw does not exceed .

template<class UnaryOperation> piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);

Mandates: is_invocable_r_v<double, UnaryOperation&, double> is true.

Preconditions: If , let , otherwise let .

The relation holds.

Effects: Constructs a piecewise_linear_distribution object with parameters taken or calculated from the following values: Let for , and for .

Complexity: The number of invocations of fw does not exceed .

vector<result_type> intervals() const;

Returns: A vector<result_type> whose size member returns and whose operator[] member returns when invoked with argument k for .

vector<result_type> densities() const;

Returns: A vector<result_type> whose size member returns n and whose operator[] member returns when invoked with argument k for .

29.5.10 Low-quality random number generation [c.math.rand]

[Note 1:

The header declares the functions described in this subclause.

— _end note_]

int rand();void srand(unsigned int seed);

Effects: Therand and srandfunctions have the semantics specified in the C standard library.

Remarks: The implementation may specify that particular library functions may callrand.

It is implementation-defined whether the rand function may introduce data races ([res.on.data.races]).

[Note 2:

The other random number generation facilities in this document ([rand]) are often preferable to rand, because rand's underlying algorithm is unspecified.

Use of rand therefore continues to be non-portable, with unpredictable and oft-questionable quality and performance.

— _end note_]