is often determined statistically.

\end{note}

\pnum

A class \tcode{G}

satisfies the requirements

of a \term{uniform random bit generator}

if the expressions shown

in \tref{UniformRandomBitGenerator}

are valid and have the indicated semantics,

and if \tcode{G} also satisfies all other requirements

of this subclause \ref{rand.req.urng}.

In that Table and throughout this subclause:

\begin{enumeratea}

\item

\tcode{T} is the type named by

\tcode{G}'s associated \tcode{result_type},

and

\item

\tcode{g} is a value of \tcode{G}.

\end{enumeratea}

\begin{libreqtab4d}

{Uniform random bit generator requirements}

{tab:UniformRandomBitGenerator}

\\ \topline

\lhdr{Expression}

& \chdr{Return type}

& \chdr{Pre/post-condition}

& \rhdr{Complexity}

\\ \capsep

\endfirsthead

\hline

\lhdr{Expression}

& \chdr{Return type}

& \chdr{Pre/post-condition}

& \rhdr{Complexity}

\\ \capsep

\endhead

\indextext{\idxcode{result_type}!uniform random bit generator requirement}%

\tcode{G::result_type}

& \tcode{T}

& \tcode{T} is an unsigned integer type\iref{basic.fundamental}.

& compile-time

\\ \rowsep

\tcode{g()}%

\indextext{\idxcode{operator()}!uniform random bit generator requirement}

& \tcode{T}

& Returns a value in the closed interval

$[$\tcode{G::min()}, \tcode{G::max()}$]$.

& amortized constant

\\ \rowsep

\tcode{G::min()}%

\indextext{\idxcode{min}!uniform random bit generator requirement}

& \tcode{T}

& Denotes the least value potentially returned

by \tcode{operator()}.

& compile-time

\\ \rowsep

\tcode{G::max()}

\indextext{\idxcode{max}!uniform random bit generator requirement}

& \tcode{T}

& Denotes the greatest value potentially returned

by \tcode{operator()}.

& compile-time

\\

\end{libreqtab4d}

\pnum

The following relation shall hold:

\tcode{G::min() < G::max()}.

\indextext{requirements!uniform random bit generator|)}%

\indextext{uniform random bit generator!requirements|)}

\pnum

The \libconcept{UniformRandomBitGenerator} concept is a slight relaxation of the

uniform random bit generator requirements, in that it does not require a nested

\grammarterm{typedef-name} \tcode{result_type}.

\begin{codeblock}

template<class G>

concept UniformRandomBitGenerator =

\end{codeblock}

\pnum

Let \tcode{g} be an object of type \tcode{G}.

\tcode{\libconcept{UniformRandomBitGenerator}<G>} is satisfied only if

Let \tcode{g} be an object of type \tcode{G}. \tcode{G} models

\libconcept{UniformRandomBitGenerator} only if

\begin{itemize}

\item both \tcode{G::min()} and \tcode{G::max()} are constant

\item \tcode{g()} has amortized constant complexity.

\end{itemize}

\indextext{requirements!uniform random bit generator|)}%

\indextext{uniform random bit generator!requirements|)}%

\pnum

A class \tcode{G} meets the \term{uniform random bit generator} requirements if

\tcode{G} models \libconcept{UniformRandomBitGenerator},

\tcode{invoke_result_t<G\&>} is an unsigned integer type\iref{basic.fundamental},

and

\tcode{G} provides a nested \grammarterm{typedef-name} \tcode{result_type}

that denotes the same type as \tcode{invoke_result_t<G\&>}.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Random Number Engine requirements:

\state{e}{i+1} $= \mathsf{TA}($\state{e}{i}$)$

and returns

$\mathsf{GA}($\state{e}{i}$)$.

& per \tref{UniformRandomBitGenerator}

& per \ref{rand.req.urng}

\\ \rowsep

\tcode{e.discard(z)}%

\indextext{\idxcode{discard}!random number engine requirement}