# C++ named requirements: UniformRandomBitGenerator (since C++11)

> C++ Atlas: `cppatlas.com/w/cpp/named_req/UniformRandomBitGenerator` | Source: https://en.cppreference.com/w/cpp/named_req/UniformRandomBitGenerator | Domain: Named Requirements | Standards: C++11, C++17, C++20

A uniform random bit generator is a function object returning unsigned integer values such that each value in the range of possible results has (ideally) equal probability.

## Official Specification Summary (cppreference)

A uniform random bit generator is a function object returning unsigned integer values such that each value in the range of possible results has (ideally) equal probability.

Uniform random bit generators are not intended to be used as random number generators: they are used as the source of random bits (generated in bulk, for efficiency). Any uniform random bit generator may be plugged into any random number distribution in order to obtain a random number (formally, a random variate).

### Requirements

The type `G` satisfies *UniformRandomBitGenerator* if

(until C++20):

Given `g`, a value of type `G`, all following conditions are satisfied:

- `G::result_type` is valid, and denotes an unsigned integer type.
- The following expressions must be valid and have their specified effects:

| Expression | Type | Requirements |
| --- | --- | --- |
| `G::min()` | `G::result_type` | - Yields the smallest value that `G`'s `operator()` may return. - The result value is strictly less than `G::max()`. - The expression must be a constant expression. |
| `G::max()` | `G::result_type` | - Yields the largest value that `G`'s `operator()` may return. - The result value is strictly greater than `G::min()`. - The expression must be a constant expression. |
| `g()` | `G::result_type` | - Returns a value in the closed interval `[G::min(),` `G::max()]`. - Has amortized constant complexity. |

(since C++20):

All following conditions are satisfied:

- `G` models `uniform_random_bit_generator`.
- `std::invoke_result_t<G&>` is an unsigned integer type.
- `G` provides a nested `typedef` name `result_type`, which denotes the same type as `std::invoke_result_t<G&>`.

### Notes

All *RandomNumberEngine*s satisfy this requirement.

### Standard library

The following standard library facilities expect a *UniformRandomBitGenerator* type.

- `random_shuffle` (until C++17), `shuffle` (C++11): randomly re-orders elements in a range (function template)
- `sample` (C++17): selects N random elements from a sequence (function template)
- `generate_canonical` (C++11): evenly distributes real values of given precision across `[​0​,` `1)` (function template)
- `uniform_int_distribution` (C++11): produces integer values evenly distributed across a range (class template)
- `uniform_real_distribution` (C++11): produces real values evenly distributed across a range (class template)
- all other random number distributions

The following standard library facilities satisfy *UniformRandomBitGenerator* without additionally satisfying *RandomNumberEngine*:

- `random_device` (C++11): non-deterministic random number generator using hardware entropy source (class)

### Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

| DR | Applied to | Behavior as published | Correct behavior |
| --- | --- | --- | --- |
| LWG 2154 (P0898R3) | C++11 | it was unclear whether `G::min()` and `G::max()` are required to be constant expressions[1] | required |

1. ↑ The time complexity requirement for these expressions were “compile-time” before C++20. The wording is ambiguous, as “compile-time time complexity” can be interpreted as both “can be evaluated in compile-time” and “the time complexity can be determined in compile-time”.

### See also

- [`uniform_random_bit_generator`](https://en.cppreference.com/w/cpp/numeric/random/uniform_random_bit_generator) (C++20): specifies that a type qualifies as a uniform random bit generator (concept)

---
Attribution: content from https://en.cppreference.com/w/cpp/named_req/UniformRandomBitGenerator (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.