[rand.req.eng]

At any given time, e has a state e

{i for some integer i \geq 0 .}_{i for some integer i \geq 0 .}

Upon construction, e has an initial state e

{0 .}_{0 .}

An engine's state may be established via a constructor, a seed function, assignment, or a suitable operator>.

E's specification shall define:

(3.1)
the size of E's state in multiples of the size of result_type, given as an integral constant expression;
(3.2)
the transition algorithm TA by which e's state e ${i is advanced to its successor state e {i + 1; and}_{i + 1; and}}_{i is advanced to its successor state e {i + 1; and}_{i + 1; and}}$
(3.3)
the generation algorithm GA by which an engine's state is mapped to a value of type result_type.

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

In Table 127 and throughout this subclause:

(4.1)
T is the type named by E's associated result_type;
(4.2)
e is a value of E, v is an lvalue of E, x and y are (possibly const) values of E;
(4.3)
s is a value of T;
(4.4)
q is an lvalue meeting the requirements of a seed sequence;
(4.5)
z is a value of type unsigned long;
(4.6)
os is an lvalue of the type of some class template specialization basic_ostream<charT, traits>; and
(4.7)
is is an lvalue of the type of some class template specialization basic_istream<charT, traits>;

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

Table 127 — 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.	$O (size of state)$
🔗 E(x)		Creates an engine that compares equal to x.	$O (size of state)$
🔗 E(s)		Creates an engine with initial state determined by s.	$O (size of state)$
🔗 E(q)232		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 ${i to e {i + 1 = T A (e {i) and returns GA (e {i) .}_{i) .}}_{i) and returns GA (e {i) .}_{i) .}}}_{i + 1 = T A (e {i) and returns GA (e {i) .}_{i) .}}_{i) and returns GA (e {i) .}_{i) .}}}}_{i to e {i + 1 = T A (e {i) and returns GA (e {i) .}_{i) .}}_{i) and returns GA (e {i) .}_{i) .}}}_{i + 1 = T A (e {i) and returns GA (e {i) .}_{i) .}}_{i) and returns GA (e {i) .}_{i) .}}}}$	per [rand.req.urng]
🔗 e.discard(z)233	void	Advances e's state e ${i to e {i + z by any means equivalent to z consecutive calls e () .}_{i + z by any means equivalent to z consecutive calls e () .}}_{i to e {i + z by any means equivalent to z consecutive calls e () .}_{i + z 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 ${S x and {S y as the infinite sequences of values that would be generated by repeated future calls to x () and y (), respectively, returns true if {S x = {S y; else returns false .}_{y; else returns false .}}_{x = {S y; else returns false .}_{y; else returns false .}}}_{y as the infinite sequences of values that would be generated by repeated future calls to x () and y (), respectively, returns true if {S x = {S y; else returns false .}_{y; else returns false .}}_{x = {S y; else returns false .}_{y; else returns false .}}}}_{x and {S y as the infinite sequences of values that would be generated by repeated future calls to x () and y (), respectively, returns true if {S x = {S y; else returns false .}_{y; else returns false .}}_{x = {S y; else returns false .}_{y; else returns false .}}}_{y as the infinite sequences of values that would be generated by repeated future calls to x () and y (), respectively, returns true if {S x = {S y; else returns false .}_{y; else returns false .}}_{x = {S y; else returns false .}_{y; else returns false .}}}}$	$O (size of state)$
🔗 x != y	bool	!(x == y).	$O (size of state)$

E shall meet the Cpp17CopyConstructible (Table 32) and Cpp17CopyAssignable (Table 34) requirements.

These operations shall each be of complexity no worse than

O (size of state) .

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

🔗

os << x

Effects: With os.fmtflags set to ios_base::dec|ios_base::left and the fill character set to the space character, writes to os the textual representation of x's current state.

In the output, adjacent numbers are separated by one or more space characters.

Complexity:

O (size of state)

🔗

is >> v

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 arguments charT and traits were 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 << x was subsequently read via is >> v, then x == v provided that there have been no intervening invocations of x or of v.

Complexity:

O (size of state)

232)232)

This constructor (as well as the subsequent corresponding seed() function) can be particularly useful to applications requiring a large number of independent random sequences.

233)233)

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