[rand] - C++17 → C++20

Files changed (1) hide show

tmp/tmpid53kr4w/{from.md → to.md} +706 -593

tmp/tmpid53kr4w/{from.md → to.md} RENAMED Viewed

@@ -4,49 +4,222 @@ This subclause 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*, and *random number distributions*.
-These categorizations are applicable to types that satisfy 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 by
 `bind(d,e)`. — *end note*]
 Each of the entities specified via this subclause has an associated
-arithmetic type ([[basic.fundamental]]) identified as `result_type`.
-With `T` as the `result_type` thus associated with such an entity, that
 entity is characterized:
 If integer-valued, an entity may optionally be further characterized as
 *signed* or *unsigned*, according to `numeric_limits<T>::is_signed`.
 Unless otherwise specified, all descriptions of calculations in this
 subclause use mathematical real numbers.
-Throughout this subclause, the operators , , and denote the respective
-conventional bitwise operations. Further:
 ### Requirements <a id="rand.req">[[rand.req]]</a>
 #### General requirements <a id="rand.req.genl">[[rand.req.genl]]</a>
 Throughout this subclause [[rand]], the effect of instantiating a
 template:
 Throughout this subclause [[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 satisfying the
 requirements of the specified iterator type”.
 Throughout this subclause [[rand]], any constructor that can be called
-with a single argument and that satisfies a requirement specified in
-this subclause shall be declared `explicit`.
 #### Seed sequence requirements <a id="rand.req.seedseq">[[rand.req.seedseq]]</a>
 A *seed sequence* is an object that consumes a sequence of
 integer-valued data and produces a requested number of unsigned integer
@@ -55,61 +228,105 @@ values i, 0 ≤ i < 2³², 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 `S` satisfies the requirements of a seed sequence if the
-expressions shown in Table  [[tab:SeedSequence]] are valid and have the
-indicated semantics, and if `S` also satisfies all other requirements of
-this section [[rand.req.seedseq]]. In that Table and throughout this
-section:
 #### Uniform random bit generator requirements <a id="rand.req.urng">[[rand.req.urng]]</a>
 A *uniform random bit generator* `g` of type `G` is 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*]
-A class `G` satisfies the requirements of a *uniform random bit
-generator* if the expressions shown in Table
-[[tab:UniformRandomBitGenerator]] are valid and have the indicated
-semantics, and if `G` also satisfies all other requirements of this
-section [[rand.req.urng]]. In that Table and throughout this section:
-The following relation shall hold: `G::min() < G::max()`.
 #### Random number engine requirements <a id="rand.req.eng">[[rand.req.eng]]</a>
 A *random number engine* (commonly shortened to *engine*) `e` of type
 `E` is a uniform random bit generator that additionally meets the
 requirements (e.g., for seeding and for input/output) specified in this
-section.
 At any given time, `e` has a state eᵢ for some integer i ≥ 0. Upon
 construction, `e` has 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:
-A class `E` that satisfies the requirements of a uniform random bit
-generator ([[rand.req.urng]]) also satisfies the requirements of a
-*random number engine* if the expressions shown in Table
-[[tab:RandomEngine]] are valid and have the indicated semantics, and if
-`E` also satisfies all other requirements of this section
-[[rand.req.eng]]. In that Table and throughout this section:
-where `charT` and `traits` are constrained according to Clause
-[[strings]] and Clause  [[input.output]].
-`E` shall meet the requirements of `CopyConstructible` (Table
-[[tab:copyconstructible]]) and `CopyAssignable` (Table
-[[tab:copyassignable]]) types. These operations shall each be of
-complexity no worse than 𝑂(\mbox{size of state}).
 #### Random number engine adaptor requirements <a id="rand.req.adapt">[[rand.req.adapt]]</a>
 A *random number engine adaptor* (commonly shortened to *adaptor*) `a`
 of type `A` is a random number engine that takes values produced by some
@@ -164,11 +381,20 @@ void seed(result_type s);
 template<class Sseq> void seed(Sseq& q);
 ```
 *Effects:* With `b` as the base engine, invokes `b.seed(q)`.
-`A` shall also satisfy the following additional requirements:
 #### Random number distribution requirements <a id="rand.req.dist">[[rand.req.dist]]</a>
 A *random number distribution* (commonly shortened to *distribution*)
 `d` of type `D` is a function object returning values that are
@@ -183,22 +409,38 @@ distribution*. Such distribution parameters are identified in this
 context by writing, for example, p(z | a,b) or P(zᵢ | a,b), to name
 specific parameters, or by writing, for example, p(z |{`p`}) or
 P(zᵢ |{`p`}), to denote a distribution’s parameters `p` taken as a
 whole.
-A class `D` satisfies the requirements of a *random number distribution*
-if the expressions shown in Table  [[tab:RandomDistribution]] are valid
-and have the indicated semantics, and if `D` and its associated types
-also satisfy all other requirements of this section [[rand.req.dist]].
-In that Table and throughout this section,
-where `charT` and `traits` are constrained according to Clauses
-[[strings]] and [[input.output]].
-`D` shall satisfy the requirements of `CopyConstructible` (Table
-[[tab:copyconstructible]]) and `CopyAssignable` (Table
-[[tab:copyassignable]]) types.
 The sequence of numbers produced by repeated invocations of `d(g)` shall
 be independent of any invocation of `os << d` or of any `const` member
 function of `D` between any of the invocations `d(g)`.
@@ -211,14 +453,14 @@ produce the same sequence of numbers as would repeated invocations of
 It is unspecified whether `D::param_type` is declared as a (nested)
 `class` or via a `typedef`. In this subclause [[rand]], declarations of
 `D::param_type` are in the form of `typedef`s for convenience of
 exposition only.
-`P` shall satisfy the requirements of `CopyConstructible` (Table
-[[tab:copyconstructible]]), `CopyAssignable` (Table
-[[tab:copyassignable]]), and `EqualityComparable` (Table
-[[tab:equalitycomparable]]) types.
 For each of the constructors of `D` taking arguments corresponding to
 parameters of the distribution, `P` shall have a corresponding
 constructor subject to the same requirements and taking arguments
 identical in number, type, and default values. Moreover, for each of the
@@ -230,178 +472,41 @@ the identical name, type, and semantics.
 ``` cpp
 using distribution_type =  D;
 ```
-### Header `<random>` synopsis <a id="rand.synopsis">[[rand.synopsis]]</a>
-``` cpp
-#include <initializer_list>
-namespace std {
-  // [rand.eng.lcong], class template linear_congruential_engine
-  template<class UIntType, UIntType a, UIntType c, UIntType m>
-    class linear_congruential_engine;
-  // [rand.eng.mers], class template mersenne_twister_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;
-  // [rand.eng.sub], class template subtract_with_carry_engine
-  template<class UIntType, size_t w, size_t s, size_t r>
-    class subtract_with_carry_engine;
-  // [rand.adapt.disc], class template discard_block_engine
-  template<class Engine, size_t p, size_t r>
-    class discard_block_engine;
-  // [rand.adapt.ibits], class template independent_bits_engine
-  template<class Engine, size_t w, class UIntType>
-    class independent_bits_engine;
-  // [rand.adapt.shuf], class template shuffle_order_engine
-  template<class Engine, size_t k>
-    class shuffle_order_engine;
-  // [rand.predef], engines and engine adaptors with predefined parameters
-  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 default_random_engine = see below;
-  // [rand.device], class random_device
-  class random_device;
-  // [rand.util.seedseq], class seed_seq
-  class seed_seq;
-  // [rand.util.canonical], function template generate_canonical
-  template<class RealType, size_t bits, class URBG>
-    RealType generate_canonical(URBG& g);
-  // [rand.dist.uni.int], class template uniform_int_distribution
-  template<class IntType = int>
-    class uniform_int_distribution;
-  // [rand.dist.uni.real], class template uniform_real_distribution
-  template<class RealType = double>
-    class uniform_real_distribution;
-  // [rand.dist.bern.bernoulli], class bernoulli_distribution
-  class bernoulli_distribution;
-  // [rand.dist.bern.bin], class template binomial_distribution
-  template<class IntType = int>
-    class binomial_distribution;
-  // [rand.dist.bern.geo], class template geometric_distribution
-  template<class IntType = int>
-    class geometric_distribution;
-  // [rand.dist.bern.negbin], class template negative_binomial_distribution
-  template<class IntType = int>
-    class negative_binomial_distribution;
-  // [rand.dist.pois.poisson], class template poisson_distribution
-  template<class IntType = int>
-    class poisson_distribution;
-  // [rand.dist.pois.exp], class template exponential_distribution
-  template<class RealType = double>
-    class exponential_distribution;
-  // [rand.dist.pois.gamma], class template gamma_distribution
-  template<class RealType = double>
-    class gamma_distribution;
-  // [rand.dist.pois.weibull], class template weibull_distribution
-  template<class RealType = double>
-    class weibull_distribution;
-  // [rand.dist.pois.extreme], class template extreme_value_distribution
-  template<class RealType = double>
-    class extreme_value_distribution;
-  // [rand.dist.norm.normal], class template normal_distribution
-  template<class RealType = double>
-    class normal_distribution;
-  // [rand.dist.norm.lognormal], class template lognormal_distribution
-  template<class RealType = double>
-    class lognormal_distribution;
-  // [rand.dist.norm.chisq], class template chi_squared_distribution
-  template<class RealType = double>
-    class chi_squared_distribution;
-  // [rand.dist.norm.cauchy], class template cauchy_distribution
-  template<class RealType = double>
-    class cauchy_distribution;
-  // [rand.dist.norm.f], class template fisher_f_distribution
-  template<class RealType = double>
-    class fisher_f_distribution;
-  // [rand.dist.norm.t], class template student_t_distribution
-  template<class RealType = double>
-    class student_t_distribution;
-  // [rand.dist.samp.discrete], class template discrete_distribution
-  template<class IntType = int>
-    class discrete_distribution;
-  // [rand.dist.samp.pconst], class template piecewise_constant_distribution
-  template<class RealType = double>
-    class piecewise_constant_distribution;
-  // [rand.dist.samp.plinear], class template piecewise_linear_distribution
-  template<class RealType = double>
-    class piecewise_linear_distribution;
-}
-```
 ### Random number engine class templates <a id="rand.eng">[[rand.eng]]</a>
-Each type instantiated from a class template specified in this section
-[[rand.eng]] satisfies the requirements of a random number engine (
-[[rand.req.eng]]) type.
 Except where specified otherwise, the complexity of each function
-specified in this section  [[rand.eng]] is constant.
-Except where specified otherwise, no function described in this section
-[[rand.eng]] throws an exception.
-Every function described in this section  [[rand.eng]] that has a
 function parameter `q` of type `Sseq&` for a template type parameter
 named `Sseq` that is different from type `seed_seq` throws what and when
 the invocation of `q.generate` throws.
-Descriptions are provided in this section  [[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 this section  [[rand.eng]] requires one or
 more relationships, involving the value(s) of its non-type 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 `X` defined in this subclause ([[rand.eng]]) and in subclause
 [[rand.adapt]]:
 - if the constructor
   ``` cpp
   template<class Sseq> explicit X(Sseq& q);
@@ -445,11 +550,12 @@ template<class UIntType, UIntType a, UIntType c, UIntType 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;
     // constructors and seeding functions
- explicit linear_congruential_engine(result_type s = default_seed);
     template<class Sseq> explicit linear_congruential_engine(Sseq& q);
     void seed(result_type s = default_seed);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
@@ -457,41 +563,38 @@ template<class UIntType, UIntType a, UIntType c, UIntType m>
     void discard(unsigned long long z);
   };
 ```
 If the template parameter `m` is 0, the modulus m used throughout this
-section  [[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 parameter `m` is not 0, the following relations shall
 hold: `a < m` and `c < m`.
 The textual representation consists of the value of xᵢ.
 ``` cpp
-explicit linear_congruential_engine(result_type s = default_seed);
 ```
-*Effects:* Constructs a `linear_congruential_engine` object. If
-c  mod  m is 0 and `s`  mod  m is 0, sets the engine’s state to 1,
-otherwise sets the engine’s state to `s`  mod  m.
 ``` cpp
 template<class Sseq> explicit linear_congruential_engine(Sseq& q);
 ```
-*Effects:* Constructs a `linear_congruential_engine` object. With
-$k = \left\lceil \frac{\log_2 m}
-                        {32}
- \right\rceil$ and a an array (or equivalent) of length
-k + 3, invokes `q.generate(`a+0`, `a+k+3`)` and then computes
-$S = \left(\sum_{j=0}^{k-1}a_{j+3} \cdot 2^{32j} \right) \bmod m$. If
-c  mod  m is 0 and S is 0, sets the engine’s state to 1, else sets the
-engine’s state to S.
 #### Class template `mersenne_twister_engine` <a id="rand.eng.mers">[[rand.eng.mers]]</a>
 A `mersenne_twister_engine` random number engine[^2] produces unsigned
 integer random numbers in the closed interval [0,2ʷ-1]. The state xᵢ of
@@ -501,21 +604,31 @@ 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:
 The sequence X is initialized with the help of an initialization
 multiplier f.
 The generation algorithm determines the unsigned integer values
 z₁, z₂, z₃, z₄ as follows, then delivers z₄ as its result:
 ``` cpp
 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>
@@ -541,11 +654,12 @@ template<class UIntType, size_t w, size_t n, size_t m, size_t r,
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return  2^w - 1; }
     static constexpr result_type default_seed = 5489u;
     // constructors and seeding functions
- explicit mersenne_twister_engine(result_type value = default_seed);
     template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
@@ -559,18 +673,18 @@ The following relations shall hold: `0 < m`, `m <= n`, `2u < w`,
 `w <= numeric_limits<UIntType>::digits`, `a <= (1u<<w) - 1u`,
 `b <= (1u<<w) - 1u`, `c <= (1u<<w) - 1u`, `d <= (1u<<w) - 1u`, and
 `f <= (1u<<w) - 1u`.
 The textual representation of xᵢ consists of the values of
-Xᵢ₋ₙ, …, Xᵢ₋₁, in that order.
 ``` cpp
-explicit mersenne_twister_engine(result_type value = default_seed);
 ```
-*Effects:* Constructs a `mersenne_twister_engine` object. Sets X₋ₙ to
-`value`  mod  2ʷ. Then, iteratively for i = 1-n,…,-1, sets Xᵢ to $$%
  \bigl[f \cdot
        \bigl(X_{i-1} \xor \bigl(X_{i-1} \rightshift (w-2)\bigr)
        \bigr)
        + i \bmod n
  \bigr] \bmod 2^w
@@ -580,14 +694,13 @@ explicit mersenne_twister_engine(result_type value = default_seed);
 ``` cpp
 template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
 ```
-*Effects:* Constructs a `mersenne_twister_engine` object. With
-k = ⌈ w / 32 ⌉ and a an array (or equivalent) of length n ⋅ k, invokes
-`q.generate(`a+0`, `a+n ⋅ k`)` and then, iteratively for i = -n,…,-1,
-sets Xᵢ to
 $\left(\sum_{j=0}^{k-1}a_{k(i+n)+j} \cdot 2^{32j} \right) \bmod 2^w$.
 Finally, if the most significant w-r bits of X₋ₙ are zero, and if each
 of the other resulting Xᵢ is 0, changes X₋ₙ to 2ʷ⁻¹.
 #### Class template `subtract_with_carry_engine` <a id="rand.eng.sub">[[rand.eng.sub]]</a>
@@ -601,10 +714,13 @@ all subscripts applied to X are to be taken modulo r. The state xᵢ
 additionally consists of an integer c (known as the *carry*) whose value
 is either 0 or 1.
 The state transition is performed as follows:
 [*Note 1*: This algorithm corresponds to a modular linear function of
 the form TA(xᵢ) = (a ⋅ xᵢ)  mod  b, where b is of the form mʳ - mˢ + 1
 and a = b - (b - 1) / m. — *end note*]
 The generation algorithm is given by GA(xᵢ) = y, where y is the value
@@ -624,11 +740,12 @@ template<class UIntType, size_t w, size_t s, size_t r>
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return m - 1; }
     static constexpr result_type default_seed = 19780503u;
     // constructors and seeding functions
- explicit subtract_with_carry_engine(result_type value = default_seed);
     template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
@@ -642,16 +759,15 @@ The following relations shall hold: `0u < s`, `s < r`, `0 < w`, and
 The textual representation consists of the values of Xᵢ₋ᵣ, …, Xᵢ₋₁, in
 that order, followed by c.
 ``` cpp
-explicit subtract_with_carry_engine(result_type value = default_seed);
 ```
-*Effects:* Constructs a `subtract_with_carry_engine` object. Sets the
-values of X₋ᵣ, …, X₋₁, in that order, as specified below. If X₋₁ is then
-0, sets c to 1; otherwise sets c to 0.
 To set the values Xₖ, first construct `e`, a
 `linear_congruential_engine` object, as if by the following definition:
 ``` cpp
@@ -667,45 +783,44 @@ $\left( \sum_{j=0}^{n-1} z_j \cdot 2^{32j}\right) \bmod m$.
 ``` cpp
 template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
 ```
-*Effects:* Constructs a `subtract_with_carry_engine` object. With
-k = ⌈ w / 32 ⌉ and a an array (or equivalent) of length r ⋅ k, invokes
-`q.generate(`a+0`, `a+r ⋅ k`)` and then, iteratively for i = -r, …, -1,
-sets Xᵢ to
 $\left(\sum_{j=0}^{k-1}a_{k(i+r)+j} \cdot 2^{32j} \right) \bmod m$. If
 X₋₁ is then 0, sets c to 1; otherwise sets c to 0.
 ### Random number engine adaptor class templates <a id="rand.adapt">[[rand.adapt]]</a>
 #### In general <a id="rand.adapt.general">[[rand.adapt.general]]</a>
-Each type instantiated from a class template specified in this section
-[[rand.adapt]] satisfies the requirements of a random number engine
-adaptor ([[rand.req.adapt]]) type.
 Except where specified otherwise, the complexity of each function
-specified in this section  [[rand.adapt]] is constant.
-Except where specified otherwise, no function described in this section
-[[rand.adapt]] throws an exception.
-Every function described in this section  [[rand.adapt]] that has a
 function parameter `q` of type `Sseq&` for a template type parameter
 named `Sseq` that is different from type `seed_seq` throws what and when
 the invocation of `q.generate` throws.
-Descriptions are provided in this section  [[rand.adapt]] only for
-adaptor operations that are not described in section  [[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 this section  [[rand.adapt]] requires one or
-more relationships, involving the value(s) of its non-type template
 parameter(s), to hold. A program instantiating any of these templates is
 ill-formed if any such required relationship fails to hold.
 #### Class template `discard_block_engine` <a id="rand.adapt.disc">[[rand.adapt.disc]]</a>
@@ -763,11 +878,11 @@ template<class Engine, size_t p, size_t r>
 The following relations shall hold: `0 < r` and `r <= p`.
 The textual representation consists of the textual representation of `e`
 followed by the value of `n`.
-In addition to its behavior pursuant to section  [[rand.req.adapt]],
 each constructor that is not a copy constructor sets `n` to 0.
 #### Class template `independent_bits_engine` <a id="rand.adapt.ibits">[[rand.adapt.ibits]]</a>
 An `independent_bits_engine` random number engine adaptor combines
@@ -778,10 +893,17 @@ 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:
 [*Note 1*: The relation w = n₀ w₀ + (n - n₀)(w₀ + 1) always
 holds. — *end note*]
 The transition algorithm is carried out by invoking `e()` as often as
 needed to obtain n₀ values less than y₀ + `e.min()` and n - n₀ values
@@ -853,10 +975,15 @@ 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 k + 1.
 The transition algorithm permutes the values produced by e. The state
 transition is performed as follows:
 The generation algorithm yields the last value of `Y` produced while
 advancing `e`’s state as described above.
 ``` cpp
 template<class Engine, size_t k>
@@ -897,99 +1024,96 @@ template<class Engine, size_t k>
 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 section  [[rand.req.adapt]],
 each constructor that is not a copy constructor initializes
 `V[0]`, …, `V[k-1]` and Y, in that order, with values returned by
 successive invocations of `e()`.
 ### Engines and engine adaptors with predefined parameters <a id="rand.predef">[[rand.predef]]</a>
 ``` cpp
 using minstd_rand0 =
-      linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `minstd_rand0` shall produce the
-value 1043618065.
 ``` cpp
 using minstd_rand =
-      linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `minstd_rand` shall produce the value
 399268537.
 ``` cpp
 using mt19937 =
-      mersenne_twister_engine<uint_fast32_t,
- 32,624,397,31,0x9908b0df,11,0xffffffff,7,0x9d2c5680,15,0xefc60000,18,1812433253>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `mt19937` shall produce the value
 4123659995.
 ``` cpp
 using mt19937_64 =
-      mersenne_twister_engine<uint_fast64_t,
- 64,312,156,31,0xb5026f5aa96619e9,29,
- 0x5555555555555555,17,
-       0x71d67fffeda60000,37,
-       0xfff7eee000000000,43,
-       6364136223846793005>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `mt19937_64` shall produce the value
 9981545732273789042.
 ``` cpp
 using ranlux24_base =
       subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `ranlux24_base` shall produce the
-value 7937952.
 ``` cpp
 using ranlux48_base =
       subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `ranlux48_base` shall produce the
-value 61839128582725.
 ``` cpp
 using ranlux24 = discard_block_engine<ranlux24_base, 223, 23>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `ranlux24` shall produce the value
 9901578.
 ``` cpp
 using ranlux48 = discard_block_engine<ranlux48_base, 389, 11>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `ranlux48` shall produce the value
 249142670248501.
 ``` cpp
 using knuth_b = shuffle_order_engine<minstd_rand0,256>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `knuth_b` shall produce the value
 1112339016.
 ``` cpp
 using default_random_engine = implementation-defined;
 ```
@@ -1022,11 +1146,12 @@ public:
   // generator characteristics
   static constexpr result_type min() { return numeric_limits<result_type>::min(); }
   static constexpr result_type max() { return numeric_limits<result_type>::max(); }
   // constructors
- explicit random_device(const string& token = implementation-defined);
   // generating functions
   result_type operator()();
   // property functions
@@ -1037,16 +1162,15 @@ public:
   void operator=(const random_device&) = delete;
 };
 ```
 ``` cpp
-explicit random_device(const string& token = implementation-defined);
 ```
-*Effects:* Constructs a `random_device` nondeterministic uniform random
-bit generator object. The semantics and default value of the `token`
-parameter are *implementation-defined*. [^3]
 *Throws:* A value of an *implementation-defined* type derived from
 `exception` if the `random_device` could not be initialized.
 ``` cpp
@@ -1060,11 +1184,11 @@ returned by `operator()`, in the range `min()` to log₂( `max()`+1).
 ``` cpp
 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 could not be obtained.
@@ -1105,35 +1229,35 @@ private:
 ``` cpp
 seed_seq();
 ```
-*Effects:* Constructs a `seed_seq` object as if by default-constructing
-its member `v`.
 *Throws:* Nothing.
 ``` cpp
 template<class T>
  seed_seq(initializer_list<T> il);
 ```
-*Requires:* `T` shall be an integer type.
 *Effects:* Same as `seed_seq(il.begin(), il.end())`.
 ``` cpp
 template<class InputIterator>
   seed_seq(InputIterator begin, InputIterator end);
 ```
-*Requires:* `InputIterator` shall satisfy the requirements of an input
-iterator (Table  [[tab:iterator.input.requirements]]) type. Moreover,
-`iterator_traits<InputIterator>::value_type` shall denote an integer
 type.
-*Effects:* Constructs a `seed_seq` object by the following algorithm:
 ``` cpp
 for (InputIterator s = begin; s != end; ++s)
  v.push_back((*s) mod  2³²);
 ```
@@ -1141,21 +1265,63 @@ for( InputIterator s = begin; s != end; ++s)
 ``` cpp
 template<class RandomAccessIterator>
   void generate(RandomAccessIterator begin, RandomAccessIterator end);
 ```
-*Requires:* `RandomAccessIterator` shall meet the requirements of a
-mutable random access iterator ([[random.access.iterators]]). Moreover,
-`iterator_traits<RandomAccessIterator>::value_type` shall denote an
 unsigned integer type capable of accommodating 32-bit quantities.
 *Effects:* Does nothing if `begin == end`. Otherwise, with
 s = `v.size()` and n = `end` - `begin`, fills the supplied range
 [`begin`,`end`) according to the following algorithm in which each
 operation is to be carried out modulo 2³², each indexing operator
 applied to `begin` is to be taken modulo n, and T(x) is defined as
-$x \, \xor \, (x \, \rightshift \, 27)$:
 *Throws:* What and when `RandomAccessIterator` operations of `begin` and
 `end` throw.
 ``` cpp
@@ -1170,13 +1336,15 @@ to `param()`.
 ``` cpp
 template<class OutputIterator>
   void param(OutputIterator dest) const;
 ```
-*Requires:* `OutputIterator` shall satisfy the requirements of an output
-iterator ([[output.iterators]]). Moreover, the expression `*dest = rt`
-shall be valid for a value `rt` of type `result_type`.
 *Effects:* Copies the sequence of prepared 32-bit units to the given
 destination, as if by executing the following statement:
 ``` cpp
@@ -1185,22 +1353,10 @@ copy(v.begin(), v.end(), dest);
 *Throws:* What and when `OutputIterator` operations of `dest` throw.
 #### Function template `generate_canonical` <a id="rand.util.canonical">[[rand.util.canonical]]</a>
-Each function instantiated from the template described in this section
-[[rand.util.canonical]] maps the result of one or more invocations of a
-supplied uniform random bit generator `g` to one member of the specified
-`RealType` such that, if the values gᵢ produced by `g` are uniformly
-distributed, the instantiation’s results tⱼ, 0 ≤ tⱼ < 1, are distributed
-as uniformly as possible as specified below.
-[*Note 1*: 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*]
 ``` cpp
 template<class RealType, size_t bits, class URBG>
   RealType generate_canonical(URBG& g);
 ```
@@ -1213,54 +1369,62 @@ respectively. Calculates a quantity
 $$S = \sum_{i=0}^{k-1} (g_i - \texttt{g.min()})
                         \cdot R^i$$ using arithmetic of type `RealType`.
 *Returns:* S / Rᵏ.
 *Throws:* What and when `g` throws.
 ### Random number distribution class templates <a id="rand.dist">[[rand.dist]]</a>
 #### In general <a id="rand.dist.general">[[rand.dist.general]]</a>
-Each type instantiated from a class template specified in this section
-[[rand.dist]] satisfies the requirements of a random number
-distribution ([[rand.req.dist]]) type.
-Descriptions are provided in this section  [[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 are
 *implementation-defined*.
 The value of each probability density function p(z) and of each discrete
-probability function P(zᵢ) specified in this section is 0 everywhere
 outside its stated domain.
 #### Uniform distributions <a id="rand.dist.uni">[[rand.dist.uni]]</a>
 ##### Class template `uniform_int_distribution` <a id="rand.dist.uni.int">[[rand.dist.uni.int]]</a>
 A `uniform_int_distribution` random number distribution produces random
 integers i, a ≤ i ≤ b, distributed according to the constant discrete
-probability function $$%
- P(i\,|\,a,b) = 1 / (b - a + 1)
-\; \mbox{.}$$
 ``` cpp
 template<class IntType = int>
   class uniform_int_distribution {
   public:
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
- explicit uniform_int_distribution(IntType a = 0, IntType b = numeric_limits<IntType>::max());
     explicit uniform_int_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -1277,17 +1441,17 @@ template<class IntType = int>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit uniform_int_distribution(IntType a = 0, IntType b = numeric_limits<IntType>::max());
 ```
-*Requires:* `a` ≤ `b`.
-*Effects:* Constructs a `uniform_int_distribution` object; `a` and `b`
-correspond to the respective parameters of the distribution.
 ``` cpp
 result_type a() const;
 ```
@@ -1303,13 +1467,11 @@ constructed.
 ##### Class template `uniform_real_distribution` <a id="rand.dist.uni.real">[[rand.dist.uni.real]]</a>
 A `uniform_real_distribution` random number distribution produces random
 numbers x, a ≤ x < b, distributed according to the constant probability
-density function $$%
- p(x\,|\,a,b) = 1 / (b - a)
-\; \mbox{.}$$
 [*Note 1*: This implies that p(x | a,b) is undefined when
 `a == b`. — *end note*]
 ``` cpp
@@ -1319,11 +1481,12 @@ template<class RealType = double>
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructors and reset functions
- explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
     explicit uniform_real_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -1340,17 +1503,18 @@ template<class RealType = double>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
 ```
-*Requires:* `a` ≤ `b` and `b` - `a` ≤ `numeric_limits<RealType>::max()`.
-*Effects:* Constructs a `uniform_real_distribution` object; `a` and `b`
-correspond to the respective parameters of the distribution.
 ``` cpp
 result_type a() const;
 ```
@@ -1367,27 +1531,26 @@ constructed.
 #### Bernoulli distributions <a id="rand.dist.bern">[[rand.dist.bern]]</a>
 ##### Class `bernoulli_distribution` <a id="rand.dist.bern.bernoulli">[[rand.dist.bern.bernoulli]]</a>
 A `bernoulli_distribution` random number distribution produces `bool`
-values b distributed according to the discrete probability function $$%
- P(b\,|\,p)
-      = \left\{ \begin{array}{lcl}
- p & \mbox{if} & b = \tcode{true} \\
-          1-p  &  \mbox{if} & b = \tcode{false}
-        \end{array}\right.
-\; \mbox{.}$$
 ``` cpp
 class bernoulli_distribution {
 public:
   // types
   using result_type = bool;
   using param_type  = unspecified;
   // constructors and reset functions
- explicit bernoulli_distribution(double p = 0.5);
   explicit bernoulli_distribution(const param_type& parm);
   void reset();
   // generating functions
   template<class URBG>
@@ -1403,17 +1566,16 @@ public:
   result_type max() const;
 };
 ```
 ``` cpp
-explicit bernoulli_distribution(double p = 0.5);
 ```
-*Requires:* 0 ≤ `p` ≤ 1.
-*Effects:* Constructs a `bernoulli_distribution` object; `p` corresponds
-to the parameter of the distribution.
 ``` cpp
 double p() const;
 ```
@@ -1422,25 +1584,23 @@ constructed.
 ##### Class template `binomial_distribution` <a id="rand.dist.bern.bin">[[rand.dist.bern.bin]]</a>
 A `binomial_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
-$$%
- P(i\,|\,t,p)
-      = \binom{t}{i} \cdot p^i \cdot (1-p)^{t-i}
-\; \mbox{.}$$
 ``` cpp
 template<class IntType = int>
   class binomial_distribution {
   public:
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
- explicit binomial_distribution(IntType t = 1, double p = 0.5);
     explicit binomial_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -1457,17 +1617,17 @@ template<class IntType = int>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit binomial_distribution(IntType t = 1, double p = 0.5);
 ```
-*Requires:* 0 ≤ `p` ≤ 1 and 0 ≤ `t`.
-*Effects:* Constructs a `binomial_distribution` object; `t` and `p`
-correspond to the respective parameters of the distribution.
 ``` cpp
 IntType t() const;
 ```
@@ -1483,25 +1643,23 @@ constructed.
 ##### Class template `geometric_distribution` <a id="rand.dist.bern.geo">[[rand.dist.bern.geo]]</a>
 A `geometric_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
-$$%
- P(i\,|\,p)
-      = p \cdot (1-p)^{i}
-\; \mbox{.}$$
 ``` cpp
 template<class IntType = int>
   class geometric_distribution {
   public:
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
- explicit geometric_distribution(double p = 0.5);
     explicit geometric_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -1517,17 +1675,16 @@ template<class IntType = int>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit geometric_distribution(double p = 0.5);
 ```
-*Requires:* 0 < `p` < 1.
-*Effects:* Constructs a `geometric_distribution` object; `p` corresponds
-to the parameter of the distribution.
 ``` cpp
 double p() const;
 ```
@@ -1536,14 +1693,12 @@ constructed.
 ##### Class template `negative_binomial_distribution` <a id="rand.dist.bern.negbin">[[rand.dist.bern.negbin]]</a>
 A `negative_binomial_distribution` random number distribution produces
 random integers i ≥ 0 distributed according to the discrete probability
-function $$%
- P(i\,|\,k,p)
-      = \binom{k+i-1}{i} \cdot p^k \cdot (1-p)^i
-\; \mbox{.}$$
 [*Note 1*: This implies that P(i | k,p) is undefined when
 `p == 1`. — *end note*]
 ``` cpp
@@ -1553,11 +1708,12 @@ template<class IntType = int>
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructor and reset functions
- explicit negative_binomial_distribution(IntType k = 1, double p = 0.5);
     explicit negative_binomial_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -1574,17 +1730,17 @@ template<class IntType = int>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit negative_binomial_distribution(IntType k = 1, double p = 0.5);
 ```
-*Requires:* 0 < `p` ≤ 1 and 0 < `k`.
-*Effects:* Constructs a `negative_binomial_distribution` object; `k` and
-`p` correspond to the respective parameters of the distribution.
 ``` cpp
 IntType k() const;
 ```
@@ -1602,16 +1758,12 @@ constructed.
 ##### Class template `poisson_distribution` <a id="rand.dist.pois.poisson">[[rand.dist.pois.poisson]]</a>
 A `poisson_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
-$$%
- P(i\,|\,\mu)
-      = \frac{ e^{-\mu} \mu^{i} }
-             { i\,! }
-\; \mbox{.}$$ The distribution parameter μ is also known as this
-distribution’s *mean* .
 ``` cpp
 template<class IntType = int>
   class poisson_distribution
   {
@@ -1619,11 +1771,12 @@ template<class IntType = int>
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
- explicit poisson_distribution(double mean = 1.0);
     explicit poisson_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -1639,17 +1792,16 @@ template<class IntType = int>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit poisson_distribution(double mean = 1.0);
 ```
-*Requires:* 0 < `mean`.
-*Effects:* Constructs a `poisson_distribution` object; `mean`
-corresponds to the parameter of the distribution.
 ``` cpp
 double mean() const;
 ```
@@ -1658,25 +1810,23 @@ constructed.
 ##### Class template `exponential_distribution` <a id="rand.dist.pois.exp">[[rand.dist.pois.exp]]</a>
 An `exponential_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
-$$%
- p(x\,|\,\lambda)
-      = \lambda e^{-\lambda x}
-\; \mbox{.}$$
 ``` cpp
 template<class RealType = double>
   class exponential_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructors and reset functions
- explicit exponential_distribution(RealType lambda = 1.0);
     explicit exponential_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -1692,17 +1842,16 @@ template<class RealType = double>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit exponential_distribution(RealType lambda = 1.0);
 ```
-*Requires:* 0 < `lambda`.
-*Effects:* Constructs an `exponential_distribution` object; `lambda`
-corresponds to the parameter of the distribution.
 ``` cpp
 RealType lambda() const;
 ```
@@ -1711,26 +1860,25 @@ constructed.
 ##### Class template `gamma_distribution` <a id="rand.dist.pois.gamma">[[rand.dist.pois.gamma]]</a>
 A `gamma_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
-$$%
- p(x\,|\,\alpha,\beta)
-      = \frac{e^{-x/\beta}}{\beta^{\alpha} \cdot \Gamma(\alpha)}
-        \, \cdot \, x^{\, \alpha-1}
-\; \mbox{.}$$
 ``` cpp
 template<class RealType = double>
   class gamma_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructors and reset functions
- explicit gamma_distribution(RealType alpha = 1.0, RealType beta = 1.0);
     explicit gamma_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -1747,17 +1895,17 @@ template<class RealType = double>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit gamma_distribution(RealType alpha = 1.0, RealType beta = 1.0);
 ```
-*Requires:* 0 < `alpha` and 0 < `beta`.
-*Effects:* Constructs a `gamma_distribution` object; `alpha` and `beta`
-correspond to the parameters of the distribution.
 ``` cpp
 RealType alpha() const;
 ```
@@ -1773,27 +1921,26 @@ constructed.
 ##### Class template `weibull_distribution` <a id="rand.dist.pois.weibull">[[rand.dist.pois.weibull]]</a>
 A `weibull_distribution` random number distribution produces random
 numbers x ≥ 0 distributed according to the probability density function
-$$%
- p(x\,|\,a,b)
-      =       \frac{a}{b}
      \cdot \left(\frac{x}{b}\right)^{a-1}
      \cdot \, \exp\left( -\left(\frac{x}{b}\right)^a\right)
-\; \mbox{.}$$
 ``` cpp
 template<class RealType = double>
   class weibull_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
- explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0);
     explicit weibull_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -1810,17 +1957,17 @@ template<class RealType = double>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0);
 ```
-*Requires:* 0 < `a` and 0 < `b`.
-*Effects:* Constructs a `weibull_distribution` object; `a` and `b`
-correspond to the respective parameters of the distribution.
 ``` cpp
 RealType a() const;
 ```
@@ -1836,28 +1983,25 @@ constructed.
 ##### Class template `extreme_value_distribution` <a id="rand.dist.pois.extreme">[[rand.dist.pois.extreme]]</a>
 An `extreme_value_distribution` random number distribution produces
 random numbers x distributed according to the probability density
-function[^6] $$%
- p(x\,|\,a,b)
-      =       \frac{1}{b}
-        \cdot \exp\left(  \frac{a-x}{b}
-                       \,-\, \exp\left(\frac{a-x}{b}\right)
-                  \right)
-\; \mbox{.}$$
 ``` cpp
 template<class RealType = double>
   class extreme_value_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
- explicit extreme_value_distribution(RealType a = 0.0, RealType b = 1.0);
     explicit extreme_value_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -1874,17 +2018,17 @@ template<class RealType = double>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit extreme_value_distribution(RealType a = 0.0, RealType b = 1.0);
 ```
-*Requires:* 0 < `b`.
-*Effects:* Constructs an `extreme_value_distribution` object; `a` and
-`b` correspond to the respective parameters of the distribution.
 ``` cpp
 RealType a() const;
 ```
@@ -1910,11 +2054,11 @@ numbers x distributed according to the probability density function $$%
         % e^{-(x-\mu)^2 / (2\sigma^2)}
         \exp{\left(- \, \frac{(x - \mu)^2}
                              {2 \sigma^2}
              \right)
             }
-\; \mbox{.}$$ The distribution parameters μ and σ are also known as this
 distribution’s *mean* and *standard deviation* .
 ``` cpp
 template<class RealType = double>
   class normal_distribution {
@@ -1922,11 +2066,12 @@ template<class RealType = double>
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructors and reset functions
- explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0);
     explicit normal_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -1943,17 +2088,17 @@ template<class RealType = double>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0);
 ```
-*Requires:* 0 < `stddev`.
-*Effects:* Constructs a `normal_distribution` object; `mean` and
-`stddev` correspond to the respective parameters of the distribution.
 ``` cpp
 RealType mean() const;
 ```
@@ -1969,31 +2114,25 @@ constructed.
 ##### Class template `lognormal_distribution` <a id="rand.dist.norm.lognormal">[[rand.dist.norm.lognormal]]</a>
 A `lognormal_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
-$$%
- p(x\,|\,m,s)
-      = \frac{1}
-             {s x \sqrt{2 \pi}}
-        \cdot
-        \exp{\left(- \, \frac{(\ln{x} - m)^2}
-                             {2 s^2}
-             \right)
-            }
-\; \mbox{.}$$
 ``` cpp
 template<class RealType = double>
   class lognormal_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
- explicit lognormal_distribution(RealType m = 0.0, RealType s = 1.0);
     explicit lognormal_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -2010,17 +2149,17 @@ template<class RealType = double>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit lognormal_distribution(RealType m = 0.0, RealType s = 1.0);
 ```
-*Requires:* 0 < `s`.
-*Effects:* Constructs a `lognormal_distribution` object; `m` and `s`
-correspond to the respective parameters of the distribution.
 ``` cpp
 RealType m() const;
 ```
@@ -2036,26 +2175,23 @@ constructed.
 ##### Class template `chi_squared_distribution` <a id="rand.dist.norm.chisq">[[rand.dist.norm.chisq]]</a>
 A `chi_squared_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
-$$%
- p(x\,|\,n)
-      =  \frac{ x^{(n/2)-1} \cdot e^{-x/2}}
-              {\Gamma(n/2) \cdot 2^{n/2}}
-\; \mbox{.}$$
 ``` cpp
 template<class RealType = double>
   class chi_squared_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
- explicit chi_squared_distribution(RealType n = 1);
     explicit chi_squared_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -2071,17 +2207,16 @@ template<class RealType = double>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit chi_squared_distribution(RealType n = 1);
 ```
-*Requires:* 0 < `n`.
-*Effects:* Constructs a `chi_squared_distribution` object; `n`
-corresponds to the parameter of the distribution.
 ``` cpp
 RealType n() const;
 ```
@@ -2089,25 +2224,24 @@ RealType n() const;
 constructed.
 ##### Class template `cauchy_distribution` <a id="rand.dist.norm.cauchy">[[rand.dist.norm.cauchy]]</a>
 A `cauchy_distribution` random number distribution produces random
-numbers x distributed according to the probability density function $$%
- p(x\,|\,a,b)
-      = \left( \pi b \left( 1 + \left( \frac{x-a}{b}  \right)^2 \;\right)\right)^{-1}
-\; \mbox{.}$$
 ``` cpp
 template<class RealType = double>
   class cauchy_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
- explicit cauchy_distribution(RealType a = 0.0, RealType b = 1.0);
     explicit cauchy_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -2124,17 +2258,17 @@ template<class RealType = double>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit cauchy_distribution(RealType a = 0.0, RealType b = 1.0);
 ```
-*Requires:* 0 < `b`.
-*Effects:* Constructs a `cauchy_distribution` object; `a` and `b`
-correspond to the respective parameters of the distribution.
 ``` cpp
 RealType a() const;
 ```
@@ -2150,32 +2284,27 @@ constructed.
 ##### Class template `fisher_f_distribution` <a id="rand.dist.norm.f">[[rand.dist.norm.f]]</a>
 A `fisher_f_distribution` random number distribution produces random
 numbers x ≥ 0 distributed according to the probability density function
-$$%
- p(x\,|\,m,n)
-      = \frac{\Gamma\big((m+n)/2\big)}
-             {\Gamma(m/2) \; \Gamma(n/2)}
- \cdot
-        \left(\frac{m}{n}\right)^{m/2}
-        \cdot
-        x^{(m/2)-1}
-        \cdot
-        {\left( 1 + \frac{m x}{n}  \right)}^{-(m+n)/2}
-\; \mbox{.}$$
 ``` cpp
 template<class RealType = double>
   class fisher_f_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
- explicit fisher_f_distribution(RealType m = 1, RealType n = 1);
     explicit fisher_f_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -2192,17 +2321,17 @@ template<class RealType = double>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit fisher_f_distribution(RealType m = 1, RealType n = 1);
 ```
-*Requires:* 0 < `m` and 0 < `n`.
-*Effects:* Constructs a `fisher_f_distribution` object; `m` and `n`
-correspond to the respective parameters of the distribution.
 ``` cpp
 RealType m() const;
 ```
@@ -2217,29 +2346,27 @@ RealType n() const;
 constructed.
 ##### Class template `student_t_distribution` <a id="rand.dist.norm.t">[[rand.dist.norm.t]]</a>
 A `student_t_distribution` random number distribution produces random
-numbers x distributed according to the probability density function $$%
- p(x\,|\,n)
-      =  \frac{1}
-              {\sqrt{n \pi}}
-         \cdot \frac{\Gamma\big((n+1)/2\big)}
-                    {\Gamma(n/2)}
      \cdot \left(1 + \frac{x^2}{n} \right)^{-(n+1)/2}
-\; \mbox{.}$$
 ``` cpp
 template<class RealType = double>
   class student_t_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
- explicit student_t_distribution(RealType n = 1);
     explicit student_t_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -2255,17 +2382,16 @@ template<class RealType = double>
     result_type max() const;
   };
 ```
 ``` cpp
-explicit student_t_distribution(RealType n = 1);
 ```
-*Requires:* 0 < `n`.
-*Effects:* Constructs a `student_t_distribution` object; `n` corresponds
-to the parameter of the distribution.
 ``` cpp
 RealType n() const;
 ```
@@ -2276,20 +2402,17 @@ constructed.
 ##### Class template `discrete_distribution` <a id="rand.dist.samp.discrete">[[rand.dist.samp.discrete]]</a>
 A `discrete_distribution` random number distribution produces random
 integers i, 0 ≤ i < n, distributed according to the discrete probability
-function $$%
- P(i\,|\,p_0,\ldots,p_{n-1})
-      = p_i
-\; \mbox{.}$$
 Unless specified otherwise, the distribution parameters are calculated
-as: $p_k = {w_k / S} \; \mbox{  for } k = 0, \ldots, n\!-\!1$ , in which
-the values wₖ, commonly known as the *weights* , shall be non-negative,
-non-NaN, and non-infinity. Moreover, the following relation shall hold:
-0 < S = w₀ + ⋯ + wₙ₋₁.
 ``` cpp
 template<class IntType = int>
   class discrete_distribution {
   public:
@@ -2335,15 +2458,18 @@ p₀ = 1.
 ``` cpp
 template<class InputIterator>
   discrete_distribution(InputIterator firstW, InputIterator lastW);
 ```
-*Requires:* `InputIterator` shall satisfy the requirements of an input
-iterator ([[input.iterators]]). Moreover,
-`iterator_traits<InputIterator>::value_type` shall denote a type that is
-convertible to `double`. If `firstW == lastW`, let n = 1 and w₀ = 1.
-Otherwise, [`firstW`, `lastW`) shall form a sequence w of length n > 0.
 *Effects:* Constructs a `discrete_distribution` object with
 probabilities given by the formula above.
 ``` cpp
@@ -2355,22 +2481,22 @@ discrete_distribution(initializer_list<double> wl);
 ``` cpp
 template<class UnaryOperation>
   discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);
 ```
-*Requires:* Each instance of type `UnaryOperation` shall be a function
-object ([[function.objects]]) whose return type shall be convertible to
-`double`. Moreover, `double` shall be convertible to the type of
-`UnaryOperation`’s sole parameter. If `nw` = 0, let n = 1, otherwise let
-n = `nw`. The relation 0 < δ = (`xmax` - `xmin`) / n shall hold.
 *Effects:* Constructs a `discrete_distribution` object with
 probabilities given by the formula above, using the following values: If
 `nw` = 0, let w₀ = 1. Otherwise, let wₖ = `fw`(`xmin` + k ⋅ δ + δ / 2)
 for k = 0, …, n - 1.
-*Complexity:* The number of invocations of `fw` shall not exceed n.
 ``` cpp
 vector<double> probabilities() const;
 ```
@@ -2381,27 +2507,21 @@ k = 0, …, n-1.
 ##### Class template `piecewise_constant_distribution` <a id="rand.dist.samp.pconst">[[rand.dist.samp.pconst]]</a>
 A `piecewise_constant_distribution` random number distribution produces
 random numbers x, b₀ ≤ x < bₙ, uniformly distributed over each
 subinterval [ bᵢ, bᵢ₊₁ ) according to the probability density function
-$$%
- p(x\,|\,b_0,\ldots,b_n,\;\rho_0,\ldots,\rho_{n-1})
-      = \rho_i
-\; \mbox{,}
-\mbox{ for } b_i \le x < b_{i+1}
-\; \mbox{.}$$
 The n + 1 distribution parameters bᵢ, also known as this distribution’s
-*interval boundaries* , shall satisfy the relation bᵢ < bᵢ₊₁ for
-i = 0, …, n-1. Unless specified otherwise, the remaining n distribution
-parameters are calculated as: $$%
- \rho_k = \;
-   \frac{w_k}{S \cdot (b_{k+1}-b_k)}
-   \; \mbox{ for } k = 0, \ldots, n\!-\!1,$$ in which the values wₖ,
-commonly known as the *weights* , shall be non-negative, non-NaN, and
-non-infinity. Moreover, the following relation shall hold:
-0 < S = w₀ + ⋯ + wₙ₋₁.
 ``` cpp
 template<class RealType = double>
   class piecewise_constant_distribution {
   public:
@@ -2449,59 +2569,60 @@ n = 1, ρ₀ = 1, b₀ = 0, and b₁ = 1.
 template<class InputIteratorB, class InputIteratorW>
  piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB,
                                  InputIteratorW firstW);
 ```
-*Requires:* `InputIteratorB` and `InputIteratorW` shall each satisfy the
-requirements of an input iterator
-(Table  [[tab:iterator.input.requirements]]) type. Moreover,
-`iterator_traits<InputIteratorB>::value_type` and
-`iterator_traits<InputIteratorW>::value_type` shall each denote a type
-that is convertible to `double`. If `firstB == lastB` or
-`++firstB == lastB`, let n = 1, w₀ = 1, b₀ = 0, and b₁ = 1. Otherwise,
-[`firstB`, `lastB`) shall form a sequence b of length n+1, the length of
-the sequence w starting from `firstW` shall be at least n, and any wₖ
-for k ≥ n shall be ignored by the distribution.
 *Effects:* Constructs a `piecewise_constant_distribution` object with
 parameters as specified above.
 ``` cpp
 template<class UnaryOperation>
  piecewise_constant_distribution(initializer_list<RealType> bl, UnaryOperation fw);
 ```
-*Requires:* Each instance of type `UnaryOperation` shall be a function
-object ([[function.objects]]) whose return type shall be convertible to
-`double`. Moreover, `double` shall be convertible to the type of
-`UnaryOperation`’s sole parameter.
 *Effects:* Constructs a `piecewise_constant_distribution` object with
 parameters taken or calculated from the following values: If
 `bl.size()` < 2, let n = 1, w₀ = 1, b₀ = 0, and b₁ = 1. Otherwise, let
 [`bl.begin()`, `bl.end()`) form a sequence b₀, …, bₙ, and let
 wₖ = `fw`((bₖ₊₁ + bₖ) / 2) for k = 0, …, n - 1.
-*Complexity:* The number of invocations of `fw` shall not exceed n.
 ``` cpp
 template<class UnaryOperation>
  piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
 ```
-*Requires:* Each instance of type `UnaryOperation` shall be a function
-object ([[function.objects]]) whose return type shall be convertible to
-`double`. Moreover, `double` shall be convertible to the type of
-`UnaryOperation`’s sole parameter. If `nw` = 0, let n = 1, otherwise let
-n = `nw`. The relation 0 < δ = (`xmax` - `xmin`) / n shall hold.
 *Effects:* Constructs a `piecewise_constant_distribution` object with
 parameters taken or calculated from the following values: Let
 bₖ = `xmin` + k ⋅ δ for k = 0, …, n, and wₖ = `fw`(bₖ + δ / 2) for
 k = 0, …, n - 1.
-*Complexity:* The number of invocations of `fw` shall not exceed n.
 ``` cpp
 vector<result_type> intervals() const;
 ```
@@ -2519,29 +2640,24 @@ k = 0, …, n-1.
 ##### Class template `piecewise_linear_distribution` <a id="rand.dist.samp.plinear">[[rand.dist.samp.plinear]]</a>
 A `piecewise_linear_distribution` random number distribution produces
 random numbers x, b₀ ≤ x < bₙ, distributed over each subinterval
-[ bᵢ, bᵢ₊₁ ) according to the probability density function $$%
- p(x\,|\,b_0,\ldots,b_n,\;\rho_0,\ldots,\rho_n)
- = \rho_i     \cdot {\frac{b_{i+1} - x}{b_{i+1} - b_i}}
      + \rho_{i+1} \cdot {\frac{x - b_i}{b_{i+1} - b_i}}
-\; \mbox{,}
-\mbox{ for } b_i \le x < b_{i+1}
-\; \mbox{.}$$
 The n + 1 distribution parameters bᵢ, also known as this distribution’s
 *interval boundaries* , shall satisfy the relation bᵢ < bᵢ₊₁ for
 i = 0, …, n - 1. Unless specified otherwise, the remaining n + 1
-distribution parameters are calculated as
-$\rho_k = {w_k / S} \; \mbox{ for } k = 0, \ldots, n$, in which the
-values wₖ, commonly known as the *weights at boundaries* , shall be
-non-negative, non-NaN, and non-infinity. Moreover, the following
-relation shall hold: $$%
- 0 < S = \frac{1}{2}
-       \cdot \sum_{k=0}^{n-1} (w_k + w_{k+1}) \cdot (b_{k+1} - b_k)
-\; \mbox{.}$$
 ``` cpp
 template<class RealType = double>
   class piecewise_linear_distribution {
   public:
@@ -2588,58 +2704,55 @@ n = 1, ρ₀ = ρ₁ = 1, b₀ = 0, and b₁ = 1.
 template<class InputIteratorB, class InputIteratorW>
  piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB,
                                InputIteratorW firstW);
 ```
-*Requires:* `InputIteratorB` and `InputIteratorW` shall each satisfy the
-requirements of an input iterator
-(Table  [[tab:iterator.input.requirements]]) type. Moreover,
-`iterator_traits<InputIteratorB>::value_type` and
-`iterator_traits<InputIteratorW>::value_type` shall each denote a type
-that is convertible to `double`. If `firstB == lastB` or
-`++firstB == lastB`, let n = 1, ρ₀ = ρ₁ = 1, b₀ = 0, and b₁ = 1.
-Otherwise, [`firstB`, `lastB`) shall form a sequence b of length n+1,
-the length of the sequence w starting from `firstW` shall be at least
-n+1, and any wₖ for k ≥ n+1 shall be ignored by the distribution.
 *Effects:* Constructs a `piecewise_linear_distribution` object with
 parameters as specified above.
 ``` cpp
 template<class UnaryOperation>
  piecewise_linear_distribution(initializer_list<RealType> bl, UnaryOperation fw);
 ```
-*Requires:* Each instance of type `UnaryOperation` shall be a function
-object ([[function.objects]]) whose return type shall be convertible to
-`double`. Moreover, `double` shall be convertible to the type of
-`UnaryOperation`’s sole parameter.
 *Effects:* Constructs a `piecewise_linear_distribution` object with
 parameters taken or calculated from the following values: If
 `bl.size()` < 2, let n = 1, ρ₀ = ρ₁ = 1, b₀ = 0, and b₁ = 1. Otherwise,
 let [`bl.begin(),` `bl.end()`) form a sequence b₀, …, bₙ, and let
 wₖ = `fw`(bₖ) for k = 0, …, n.
-*Complexity:* The number of invocations of `fw` shall not exceed n+1.
 ``` cpp
 template<class UnaryOperation>
  piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
 ```
-*Requires:* Each instance of type `UnaryOperation` shall be a function
-object ([[function.objects]]) whose return type shall be convertible to
-`double`. Moreover, `double` shall be convertible to the type of
-`UnaryOperation`’s sole parameter. If `nw` = 0, let n = 1, otherwise let
-n = `nw`. The relation 0 < δ = (`xmax` - `xmin`) / n shall hold.
 *Effects:* Constructs a `piecewise_linear_distribution` object with
 parameters taken or calculated from the following values: Let
 bₖ = `xmin` + k ⋅ δ for k = 0, …, n, and wₖ = `fw`(bₖ) for k = 0, …, n.
-*Complexity:* The number of invocations of `fw` shall not exceed n+1.
 ``` cpp
 vector<result_type> intervals() const;
 ```
@@ -2655,12 +2768,12 @@ vector<result_type> densities() const;
 whose `operator[]` member returns ρₖ when invoked with argument k for
 k = 0, …, n.
 ### Low-quality random number generation <a id="c.math.rand">[[c.math.rand]]</a>
-[*Note 1*: The header `<cstdlib>` ([[cstdlib.syn]]) declares the
-functions described in this subclause. — *end note*]
 ``` cpp
 int rand();
 void srand(unsigned int seed);
 ```
@@ -2668,15 +2781,15 @@ void srand(unsigned int seed);
 *Effects:* The `rand` and `srand` functions have the semantics specified
 in the C standard library.
 *Remarks:* The implementation may specify that particular library
 functions may call `rand`. It is *implementation-defined* whether the
-`rand` function may introduce data races ([[res.on.data.races]]).
 [*Note 1*: The other random number generation facilities in this
-International Standard ([[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*]
-ISO C 7.22.2

 numbers.
 In addition to a few utilities, four categories of entities are
 described: *uniform random bit generators*, *random number engines*,
 *random number engine adaptors*, and *random 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 by
 `bind(d,e)`. — *end note*]
 Each of the entities specified via this subclause has an associated
+arithmetic type [[basic.fundamental]] identified as `result_type`. With
+`T` as the `result_type` thus 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 as
 *signed* or *unsigned*, according to `numeric_limits<T>::is_signed`.
 Unless otherwise specified, all descriptions of calculations in this
 subclause use mathematical real numbers.
+Throughout this subclause, the operators , , and \xor denote the
+respective conventional bitwise operations. Further:
+- the operator \rightshift 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 2ʷ.
+### Header `<random>` synopsis <a id="rand.synopsis">[[rand.synopsis]]</a>
+``` cpp
+#include <initializer_list>
+namespace std {
+  // [rand.req.urng], uniform random bit generator requirements
+  template<class G>
+    concept uniform_random_bit_generator = see below;
+  // [rand.eng.lcong], class template linear_congruential_engine
+  template<class UIntType, UIntType a, UIntType c, UIntType m>
+    class linear_congruential_engine;
+  // [rand.eng.mers], class template mersenne_twister_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;
+  // [rand.eng.sub], class template subtract_with_carry_engine
+  template<class UIntType, size_t w, size_t s, size_t r>
+    class subtract_with_carry_engine;
+  // [rand.adapt.disc], class template discard_block_engine
+  template<class Engine, size_t p, size_t r>
+    class discard_block_engine;
+  // [rand.adapt.ibits], class template independent_bits_engine
+  template<class Engine, size_t w, class UIntType>
+    class independent_bits_engine;
+  // [rand.adapt.shuf], class template shuffle_order_engine
+  template<class Engine, size_t k>
+    class shuffle_order_engine;
+  // [rand.predef], engines and engine adaptors with predefined parameters
+  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 default_random_engine = see below;
+  // [rand.device], class random_device
+  class random_device;
+  // [rand.util.seedseq], class seed_seq
+  class seed_seq;
+  // [rand.util.canonical], function template generate_canonical
+  template<class RealType, size_t bits, class URBG>
+    RealType generate_canonical(URBG& g);
+  // [rand.dist.uni.int], class template uniform_int_distribution
+  template<class IntType = int>
+    class uniform_int_distribution;
+  // [rand.dist.uni.real], class template uniform_real_distribution
+  template<class RealType = double>
+    class uniform_real_distribution;
+  // [rand.dist.bern.bernoulli], class bernoulli_distribution
+  class bernoulli_distribution;
+  // [rand.dist.bern.bin], class template binomial_distribution
+  template<class IntType = int>
+    class binomial_distribution;
+  // [rand.dist.bern.geo], class template geometric_distribution
+  template<class IntType = int>
+    class geometric_distribution;
+  // [rand.dist.bern.negbin], class template negative_binomial_distribution
+  template<class IntType = int>
+    class negative_binomial_distribution;
+  // [rand.dist.pois.poisson], class template poisson_distribution
+  template<class IntType = int>
+    class poisson_distribution;
+  // [rand.dist.pois.exp], class template exponential_distribution
+  template<class RealType = double>
+    class exponential_distribution;
+  // [rand.dist.pois.gamma], class template gamma_distribution
+  template<class RealType = double>
+    class gamma_distribution;
+  // [rand.dist.pois.weibull], class template weibull_distribution
+  template<class RealType = double>
+    class weibull_distribution;
+  // [rand.dist.pois.extreme], class template extreme_value_distribution
+  template<class RealType = double>
+    class extreme_value_distribution;
+  // [rand.dist.norm.normal], class template normal_distribution
+  template<class RealType = double>
+    class normal_distribution;
+  // [rand.dist.norm.lognormal], class template lognormal_distribution
+  template<class RealType = double>
+    class lognormal_distribution;
+  // [rand.dist.norm.chisq], class template chi_squared_distribution
+  template<class RealType = double>
+    class chi_squared_distribution;
+  // [rand.dist.norm.cauchy], class template cauchy_distribution
+  template<class RealType = double>
+    class cauchy_distribution;
+  // [rand.dist.norm.f], class template fisher_f_distribution
+  template<class RealType = double>
+    class fisher_f_distribution;
+  // [rand.dist.norm.t], class template student_t_distribution
+  template<class RealType = double>
+    class student_t_distribution;
+  // [rand.dist.samp.discrete], class template discrete_distribution
+  template<class IntType = int>
+    class discrete_distribution;
+  // [rand.dist.samp.pconst], class template piecewise_constant_distribution
+  template<class RealType = double>
+    class piecewise_constant_distribution;
+  // [rand.dist.samp.plinear], class template piecewise_linear_distribution
+  template<class RealType = double>
+    class piecewise_linear_distribution;
+}
+```
 ### Requirements <a id="rand.req">[[rand.req]]</a>
 #### General requirements <a id="rand.req.genl">[[rand.req.genl]]</a>
 Throughout this subclause [[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 [[rand.req.seedseq]].
+- 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 [[rand.req.urng]].
+- 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 [[rand.req.eng]].
+- that has a template type parameter named `RealType` is undefined
+  unless the corresponding template argument is cv-unqualified and is
+  one of `float`, `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 of
+  `short`, `int`, `long`, `long long`, `unsigned short`, `unsigned int`,
+  `unsigned long`, or `unsigned long long`.
+- that has a template type parameter named `UIntType` is undefined
+  unless the corresponding template argument is cv-unqualified and is
+  one of `unsigned short`, `unsigned int`, `unsigned long`, or
+  `unsigned long long`.
 Throughout this subclause [[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 this subclause [[rand]], any constructor that can be called
+with a single argument and that meets a requirement specified in this
+subclause shall be declared `explicit`.
 #### Seed sequence requirements <a id="rand.req.seedseq">[[rand.req.seedseq]]</a>
 A *seed sequence* is an object that consumes a sequence of
 integer-valued data and produces a requested number of unsigned integer
 [*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 `S` meets the requirements of a seed sequence if the expressions
+shown in [[rand.req.seedseq]] are valid and have the indicated
+semantics, and if `S` also meets all other requirements of this
+subclause [[rand.req.seedseq]]. In that Table and throughout this
+subclause:
+- `T` is the type named by `S`’s associated `result_type`;
+- `q` is a value of `S` and `r` is a possibly const value of `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 `initializer_list<T>`.
 #### Uniform random bit generator requirements <a id="rand.req.urng">[[rand.req.urng]]</a>
 A *uniform random bit generator* `g` of type `G` is 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*]
+``` cpp
+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` models
+`uniform_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 if `G`
+models `uniform_random_bit_generator`, `invoke_result_t<G&>` is an
+unsigned integer type [[basic.fundamental]], and `G` provides a nested
+*typedef-name* `result_type` that denotes the same type as
+`invoke_result_t<G&>`.
 #### Random number engine requirements <a id="rand.req.eng">[[rand.req.eng]]</a>
 A *random number engine* (commonly shortened to *engine*) `e` of type
 `E` is 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 eᵢ for some integer i ≥ 0. Upon
 construction, `e` has 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 `E` that meets the requirements of a uniform random bit
+generator [[rand.req.urng]] also meets the requirements of a *random
+number engine* if the expressions shown in [[rand.req.eng]] are valid
+and have the indicated semantics, and if `E` also meets all other
+requirements of this subclause [[rand.req.eng]]. In that Table and
+throughout this subclause:
+- `T` is the type named by `E`’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
+  [[rand.req.seedseq]];
+- `z` is a value of type `unsigned long long`;
+- `os` is an lvalue of the type of some class template specialization
+  `basic_ostream<charT,` `traits>`; and
+- `is` is an lvalue of the type of some class template specialization
+  `basic_istream<charT,` `traits>`;
+where `charT` and `traits` are constrained according to [[strings]] and
+[[input.output]].
+`E` shall meet the *Cpp17CopyConstructible* (
+[[cpp17.copyconstructible]]) and *Cpp17CopyAssignable* (
+[[cpp17.copyassignable]]) requirements. These operations shall each be
+of complexity no worse than 𝑂(\text{size of state}).
 #### Random number engine adaptor requirements <a id="rand.req.adapt">[[rand.req.adapt]]</a>
 A *random number engine adaptor* (commonly shortened to *adaptor*) `a`
 of type `A` is a random number engine that takes values produced by some
 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.
 #### Random number distribution requirements <a id="rand.req.dist">[[rand.req.dist]]</a>
 A *random number distribution* (commonly shortened to *distribution*)
 `d` of type `D` is a function object returning values that are
 context by writing, for example, p(z | a,b) or P(zᵢ | a,b), to name
 specific parameters, or by writing, for example, p(z |{`p`}) or
 P(zᵢ |{`p`}), to denote a distribution’s parameters `p` taken as a
 whole.
+A class `D` meets the requirements of a *random number distribution* if
+the expressions shown in [[rand.req.dist]] are valid and have the
+indicated semantics, and if `D` and its associated types also meet all
+other requirements of this subclause [[rand.req.dist]]. In that Table
+and throughout this subclause,
+- `T` is the type named by `D`’s associated `result_type`;
+- `P` is the type named by `D`’s associated `param_type`;
+- `d` is a value of `D`, and `x` and `y` are (possibly `const`) values
+  of `D`;
+- `glb` and `lub` are values of `T` respectively corresponding to the
+  greatest lower bound and the least upper bound on the values
+  potentially returned by `d`’s `operator()`, as determined by the
+  current values of `d`’s parameters;
+- `p` is a (possibly `const`) value of `P`;
+- `g`, `g1`, and `g2` are lvalues of a type meeting the requirements of
+  a uniform random bit generator [[rand.req.urng]];
+- `os` is an lvalue of the type of some class template specialization
+  `basic_ostream<charT,` `traits>`; and
+- `is` is an lvalue of the type of some class template specialization
+  `basic_istream<charT,` `traits>`;
+where `charT` and `traits` are constrained according to [[strings]] and
+[[input.output]].
+`D` shall meet the *Cpp17CopyConstructible* (
+[[cpp17.copyconstructible]]) and *Cpp17CopyAssignable* (
+[[cpp17.copyassignable]]) requirements.
 The sequence of numbers produced by repeated invocations of `d(g)` shall
 be independent of any invocation of `os << d` or of any `const` member
 function of `D` between any of the invocations `d(g)`.
 It is unspecified whether `D::param_type` is declared as a (nested)
 `class` or via a `typedef`. In this subclause [[rand]], declarations of
 `D::param_type` are in the form of `typedef`s for convenience of
 exposition only.
+`P` shall meet the *Cpp17CopyConstructible* (
+[[cpp17.copyconstructible]]), *Cpp17CopyAssignable* (
+[[cpp17.copyassignable]]), and *Cpp17EqualityComparable* (
+[[cpp17.equalitycomparable]]) requirements.
 For each of the constructors of `D` taking arguments corresponding to
 parameters of the distribution, `P` shall have a corresponding
 constructor subject to the same requirements and taking arguments
 identical in number, type, and default values. Moreover, for each of the
 ``` cpp
 using distribution_type =  D;
 ```
 ### Random number engine class templates <a id="rand.eng">[[rand.eng]]</a>
+Each type instantiated from a class template specified in this
+subclause  [[rand.eng]] meets the requirements of a random number engine
+[[rand.req.eng]] type.
 Except where specified otherwise, the complexity of each function
+specified in this subclause  [[rand.eng]] is constant.
+Except where specified otherwise, no function described in this
+subclause  [[rand.eng]] throws an exception.
+Every function described in this subclause  [[rand.eng]] that has a
 function parameter `q` of type `Sseq&` for a template type parameter
 named `Sseq` that is different from type `seed_seq` throws what and when
 the invocation of `q.generate` throws.
+Descriptions are provided in this subclause  [[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 this subclause  [[rand.eng]] requires one or
 more relationships, involving the value(s) of its non-type 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 `X` defined in this subclause [[rand.eng]] and in subclause
 [[rand.adapt]]:
 - if the constructor
   ``` cpp
   template<class Sseq> explicit X(Sseq& q);
     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;
     // constructors and seeding functions
+    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);
     // generating functions
     void discard(unsigned long long z);
   };
 ```
 If the template parameter `m` is 0, the modulus m used throughout this
+subclause  [[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 parameter `m` is not 0, the following relations shall
 hold: `a < m` and `c < m`.
 The textual representation consists of the value of xᵢ.
 ``` cpp
+explicit linear_congruential_engine(result_type s);
 ```
+*Effects:* If c  mod  m is 0 and `s`  mod  m is 0, sets the engine’s
+state to 1, otherwise sets the engine’s state to `s`  mod  m.
 ``` cpp
 template<class Sseq> explicit linear_congruential_engine(Sseq& q);
 ```
+*Effects:* With $k = \left\lceil \frac{\log_2 m}{32} \right\rceil$ and a
+an array (or equivalent) of length k + 3, invokes
+`q.generate(`a + 0`, `a + k + 3`)` and then computes
+$S = \left(\sum_{j = 0}^{k - 1} a_{j + 3} \cdot 2^{32j} \right) \bmod m$.
+If c  mod  m is 0 and S is 0, sets the engine’s state to 1, else sets
+the engine’s state to S.
 #### Class template `mersenne_twister_engine` <a id="rand.eng.mers">[[rand.eng.mers]]</a>
 A `mersenne_twister_engine` random number engine[^2] produces unsigned
 integer random numbers in the closed interval [0,2ʷ-1]. The state xᵢ of
 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 w-r bits of Xᵢ₋ₙ with the lower r bits of
+  $X_{i+1-n}$ to obtain an unsigned integer value Y.
+- With $\alpha = a \cdot (Y \bitand 1)$, set Xᵢ to
+  $X_{i+m-n} \xor (Y \rightshift 1) \xor \alpha$.
 The sequence X is initialized with the help of an initialization
 multiplier f.
 The generation algorithm determines the unsigned integer values
 z₁, z₂, z₃, z₄ as follows, then delivers z₄ as its result:
+- Let $z_1 = X_i \xor \bigl(( X_i \rightshift u ) \bitand d\bigr)$.
+- Let $z_2 = z_1 \xor \bigl( (z_1 \leftshift{w} s) \bitand b \bigr)$.
+- Let $z_3 = z_2 \xor \bigl( (z_2 \leftshift{w} t) \bitand c \bigr)$.
+- Let $z_4 = z_3 \xor ( z_3 \rightshift \ell )$.
 ``` cpp
 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>
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return  2^w - 1; }
     static constexpr result_type default_seed = 5489u;
     // constructors and seeding functions
+    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);
     // generating functions
 `w <= numeric_limits<UIntType>::digits`, `a <= (1u<<w) - 1u`,
 `b <= (1u<<w) - 1u`, `c <= (1u<<w) - 1u`, `d <= (1u<<w) - 1u`, and
 `f <= (1u<<w) - 1u`.
 The textual representation of xᵢ consists of the values of
+$X_{i - n}, \dotsc, X_{i - 1}$, in that order.
 ``` cpp
+explicit mersenne_twister_engine(result_type value);
 ```
+*Effects:* Sets X₋ₙ to `value`  mod  2ʷ. Then, iteratively for
+i = 1 - n, …, -1, sets Xᵢ to $$%
  \bigl[f \cdot
        \bigl(X_{i-1} \xor \bigl(X_{i-1} \rightshift (w-2)\bigr)
        \bigr)
        + i \bmod n
  \bigr] \bmod 2^w
 ``` cpp
 template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
 ```
+*Effects:* With k = ⌈ w / 32 ⌉ and a an array (or equivalent) of length
+n ⋅ k, invokes `q.generate(`a+0`, `a+n ⋅ k`)` and then, iteratively for
+i = -n,…,-1, sets Xᵢ to
 $\left(\sum_{j=0}^{k-1}a_{k(i+n)+j} \cdot 2^{32j} \right) \bmod 2^w$.
 Finally, if the most significant w-r bits of X₋ₙ are zero, and if each
 of the other resulting Xᵢ is 0, changes X₋ₙ to 2ʷ⁻¹.
 #### Class template `subtract_with_carry_engine` <a id="rand.eng.sub">[[rand.eng.sub]]</a>
 additionally consists of an integer c (known as the *carry*) whose value
 is either 0 or 1.
 The state transition is performed as follows:
+- Let Y = Xᵢ₋ₛ - Xᵢ₋ᵣ - c.
+- Set Xᵢ to y = Y  mod  m. Set c to 1 if Y < 0, otherwise set c to 0.
 [*Note 1*: This algorithm corresponds to a modular linear function of
 the form TA(xᵢ) = (a ⋅ xᵢ)  mod  b, where b is of the form mʳ - mˢ + 1
 and a = b - (b - 1) / m. — *end note*]
 The generation algorithm is given by GA(xᵢ) = y, where y is the value
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return m - 1; }
     static constexpr result_type default_seed = 19780503u;
     // constructors and seeding functions
+    subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
+    explicit subtract_with_carry_engine(result_type value);
     template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
 The textual representation consists of the values of Xᵢ₋ᵣ, …, Xᵢ₋₁, in
 that order, followed by c.
 ``` cpp
+explicit subtract_with_carry_engine(result_type value);
 ```
+*Effects:* Sets the values of X₋ᵣ, …, X₋₁, in that order, as specified
+below. If X₋₁ is then 0, sets c to 1; otherwise sets c to 0.
 To set the values Xₖ, first construct `e`, a
 `linear_congruential_engine` object, as if by the following definition:
 ``` cpp
 ``` cpp
 template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
 ```
+*Effects:* With k = ⌈ w / 32 ⌉ and a an array (or equivalent) of length
+r ⋅ k, invokes `q.generate(`a + 0`, `a + r ⋅ k`)` and then, iteratively
+for i = -r, …, -1, sets Xᵢ to
 $\left(\sum_{j=0}^{k-1}a_{k(i+r)+j} \cdot 2^{32j} \right) \bmod m$. If
 X₋₁ is then 0, sets c to 1; otherwise sets c to 0.
 ### Random number engine adaptor class templates <a id="rand.adapt">[[rand.adapt]]</a>
 #### In general <a id="rand.adapt.general">[[rand.adapt.general]]</a>
+Each type instantiated from a class template specified in this
+subclause  [[rand.adapt]] meets the requirements of a random number
+engine adaptor [[rand.req.adapt]] type.
 Except where specified otherwise, the complexity of each function
+specified in this subclause  [[rand.adapt]] is constant.
+Except where specified otherwise, no function described in this
+subclause  [[rand.adapt]] throws an exception.
+Every function described in this subclause  [[rand.adapt]] that has a
 function parameter `q` of type `Sseq&` for a template type parameter
 named `Sseq` that is different from type `seed_seq` throws what and when
 the invocation of `q.generate` throws.
+Descriptions are provided in this subclause  [[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 this subclause  [[rand.adapt]] requires one
+or more relationships, involving the value(s) of its non-type template
 parameter(s), to hold. A program instantiating any of these templates is
 ill-formed if any such required relationship fails to hold.
 #### Class template `discard_block_engine` <a id="rand.adapt.disc">[[rand.adapt.disc]]</a>
 The following relations shall hold: `0 < r` and `r <= p`.
 The textual representation consists of the textual representation of `e`
 followed by the value of `n`.
+In addition to its behavior pursuant to subclause  [[rand.req.adapt]],
 each constructor that is not a copy constructor sets `n` to 0.
 #### Class template `independent_bits_engine` <a id="rand.adapt.ibits">[[rand.adapt.ibits]]</a>
 An `independent_bits_engine` random number engine adaptor combines
 e’s state.
 The transition and generation algorithms are described in terms of the
 following integral constants:
+- Let R = `e.max() - e.min() + 1` and m = ⌊ log₂ R ⌋.
+- With n as determined below, let w₀ = ⌊ w / n ⌋, n₀ = n - w  mod  n,
+  $y_0 = 2^{w_0} \left\lfloor R / 2^{w_0} \right\rfloor$, and
+  $y_1 = 2^{w_0 + 1} \left\lfloor R / 2^{w_0 + 1} \right\rfloor$.
+- Let n = ⌈ w / m ⌉ if and only if the relation R - y₀ ≤ ⌊ y₀ / n ⌋
+  holds as a result. Otherwise let n = 1 + ⌈ w / m ⌉.
 [*Note 1*: The relation w = n₀ w₀ + (n - n₀)(w₀ + 1) always
 holds. — *end note*]
 The transition algorithm is carried out by invoking `e()` as often as
 needed to obtain n₀ values less than y₀ + `e.min()` and n - n₀ values
 size of the state is the size of e’s state plus k + 1.
 The transition algorithm permutes the values produced by e. The state
 transition is performed as follows:
+- Calculate an integer $j = \left\lfloor \frac{k \cdot (Y - e_{\min})}
+                            {e_{\max} - e_{\min} +1}
+          \right\rfloor$ .
+- Set Y to Vⱼ and then set Vⱼ to `e()`.
 The generation algorithm yields the last value of `Y` produced while
 advancing `e`’s state as described above.
 ``` cpp
 template<class Engine, size_t k>
 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 constructor that is not a copy constructor initializes
 `V[0]`, …, `V[k-1]` and Y, in that order, with values returned by
 successive invocations of `e()`.
 ### Engines and engine adaptors with predefined parameters <a id="rand.predef">[[rand.predef]]</a>
 ``` cpp
 using minstd_rand0 =
+      linear_congruential_engine<uint_fast32_t, 16'807, 0, 2'147'483'647>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `minstd_rand0` produces the value
+1043618065.
 ``` cpp
 using minstd_rand =
+      linear_congruential_engine<uint_fast32_t, 48'271, 0, 2'147'483'647>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `minstd_rand` produces the value
 399268537.
 ``` cpp
 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 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `mt19937` produces the value
 4123659995.
 ``` cpp
 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 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `mt19937_64` produces the value
 9981545732273789042.
 ``` cpp
 using ranlux24_base =
       subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `ranlux24_base` produces the value
+7937952.
 ``` cpp
 using ranlux48_base =
       subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `ranlux48_base` produces the value
+61839128582725.
 ``` cpp
 using ranlux24 = discard_block_engine<ranlux24_base, 223, 23>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `ranlux24` produces the value
 9901578.
 ``` cpp
 using ranlux48 = discard_block_engine<ranlux48_base, 389, 11>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `ranlux48` produces the value
 249142670248501.
 ``` cpp
 using knuth_b = shuffle_order_engine<minstd_rand0,256>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `knuth_b` produces the value
 1112339016.
 ``` cpp
 using default_random_engine = implementation-defined;
 ```
   // generator characteristics
   static constexpr result_type min() { return numeric_limits<result_type>::min(); }
   static constexpr result_type max() { return numeric_limits<result_type>::max(); }
   // constructors
+  random_device() : random_device(implementation-defined) {}
+  explicit random_device(const string& token);
   // generating functions
   result_type operator()();
   // property functions
   void operator=(const random_device&) = delete;
 };
 ```
 ``` cpp
+explicit random_device(const string& token);
 ```
+*Remarks:* The semantics of the `token` parameter and the token value
+used by the default constructor are *implementation-defined*. [^3]
 *Throws:* A value of an *implementation-defined* type derived from
 `exception` if the `random_device` could not be initialized.
 ``` cpp
 ``` cpp
 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 could not be obtained.
 ``` cpp
 seed_seq();
 ```
+*Ensures:* `v.empty()` is `true`.
 *Throws:* Nothing.
 ``` cpp
 template<class T>
  seed_seq(initializer_list<T> il);
 ```
+*Mandates:* `T` is an integer type.
 *Effects:* Same as `seed_seq(il.begin(), il.end())`.
 ``` cpp
 template<class InputIterator>
   seed_seq(InputIterator begin, InputIterator end);
 ```
+*Mandates:* `iterator_traits<InputIterator>::value_type` is an integer
 type.
+*Preconditions:* `InputIterator` meets the *Cpp17InputIterator*
+requirements [[input.iterators]].
+*Effects:* Initializes `v` by the following algorithm:
 ``` cpp
 for (InputIterator s = begin; s != end; ++s)
  v.push_back((*s) mod  2³²);
 ```
 ``` cpp
 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.
+*Preconditions:* `RandomAccessIterator` meets the
+*Cpp17RandomAccessIterator* requirements [[random.access.iterators]] and
+the requirements of a mutable iterator.
 *Effects:* Does nothing if `begin == end`. Otherwise, with
 s = `v.size()` and n = `end` - `begin`, fills the supplied range
 [`begin`,`end`) according to the following algorithm in which each
 operation is to be carried out modulo 2³², each indexing operator
 applied to `begin` is to be taken modulo n, and T(x) is defined as
+$x \xor (x \rightshift 27)$:
+- By way of initialization, set each element of the range to the value
+  `0x8b8b8b8b`. Additionally, for use in subsequent steps, let
+  p = (n - t) / 2 and let q = p + t, where $$%
+       t = (n \ge 623) \mbox{ ? } 11 \mbox{ : } (n \ge 68) \mbox{ ? } 7 \mbox{ : } (n \ge 39) \mbox{ ? } 5 \mbox{ : } (n \ge 7) \mbox{ ? } 3 \mbox{ : } (n - 1)/2;$$
+- With m as the larger of s + 1 and n, transform the elements of the
+  range: iteratively for k = 0, …, m - 1, calculate values
+  $$\begin{aligned}
+       r_1 & = &
+         1664525 \cdot T(    \texttt{begin[}k\texttt{]}
+                        \xor \texttt{begin[}k+p\texttt{]}
+                        \xor \texttt{begin[}k-1 \texttt{]}
+                        )
+       \\
+       r_2 & = & r_1 + \left\{
+         \begin{array}{cl}
+           s                                  & \mbox{,  } k = 0
+           \\
+           k \bmod n + \texttt{v[}k-1\texttt{]} & \mbox{,  } 0 < k \le s
+           \\
+           k \bmod n                          & \mbox{,  } s < k
+         \end{array}
+       \right.
+  \end{aligned}$$ and, in order, increment `begin[`k+p`]` by r₁,
+  increment `begin[`k+q`]` by r₂, and set `begin[`k`]` to r₂.
+- Transform the elements of the range again, beginning where the
+  previous step ended: iteratively for k = m, …, m + n - 1, calculate
+  values $$\begin{aligned}
+       r_3 & = &
+         1566083941 \cdot T( \texttt{begin[}k  \texttt{]}
+                           + \texttt{begin[}k+p\texttt{]}
+                           + \texttt{begin[}k-1\texttt{]}
+                           )
+       \\
+       r_4 & = & r_3 - (k \bmod n)
+  \end{aligned}$$ and, in order, update `begin[`k+p`]` by xoring it with
+  r₃, update `begin[`k+q`]` by xoring it with r₄, and set `begin[`k`]`
+  to r₄.
 *Throws:* What and when `RandomAccessIterator` operations of `begin` and
 `end` throw.
 ``` cpp
 ``` cpp
 template<class OutputIterator>
   void param(OutputIterator dest) const;
 ```
+*Mandates:* Values of type `result_type` are
+writable [[iterator.requirements.general]] to `dest`.
+*Preconditions:* `OutputIterator` meets the *Cpp17OutputIterator*
+requirements [[output.iterators]].
 *Effects:* Copies the sequence of prepared 32-bit units to the given
 destination, as if by executing the following statement:
 ``` cpp
 *Throws:* What and when `OutputIterator` operations of `dest` throw.
 #### Function template `generate_canonical` <a id="rand.util.canonical">[[rand.util.canonical]]</a>
 ``` cpp
 template<class RealType, size_t bits, class URBG>
   RealType generate_canonical(URBG& g);
 ```
 $$S = \sum_{i=0}^{k-1} (g_i - \texttt{g.min()})
                         \cdot R^i$$ using arithmetic of type `RealType`.
 *Returns:* S / Rᵏ.
+[*Note 1*: 0 ≤ S / Rᵏ < 1. — *end note*]
 *Throws:* What and when `g` throws.
+[*Note 2*: If the values gᵢ 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*]
 ### Random number distribution class templates <a id="rand.dist">[[rand.dist]]</a>
 #### In general <a id="rand.dist.general">[[rand.dist.general]]</a>
+Each type instantiated from a class template specified in this
+subclause  [[rand.dist]] meets the requirements of a random number
+distribution [[rand.req.dist]] type.
+Descriptions are provided in this subclause  [[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 are
 *implementation-defined*.
 The value of each probability density function p(z) and of each discrete
+probability function P(zᵢ) specified in this subclause is 0 everywhere
 outside its stated domain.
 #### Uniform distributions <a id="rand.dist.uni">[[rand.dist.uni]]</a>
 ##### Class template `uniform_int_distribution` <a id="rand.dist.uni.int">[[rand.dist.uni.int]]</a>
 A `uniform_int_distribution` random number distribution produces random
 integers i, a ≤ i ≤ b, distributed according to the constant discrete
+probability function $$P(i\,|\,a,b) = 1 / (b - a + 1) \text{ .}$$
 ``` cpp
 template<class IntType = int>
   class uniform_int_distribution {
   public:
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
+    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();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit uniform_int_distribution(IntType a, IntType b = numeric_limits<IntType>::max());
 ```
+*Preconditions:* `a` ≤ `b`.
+*Remarks:* `a` and `b` correspond to the respective parameters of the
+distribution.
 ``` cpp
 result_type a() const;
 ```
 ##### Class template `uniform_real_distribution` <a id="rand.dist.uni.real">[[rand.dist.uni.real]]</a>
 A `uniform_real_distribution` random number distribution produces random
 numbers x, a ≤ x < b, distributed according to the constant probability
+density function $$p(x\,|\,a,b) = 1 / (b - a) \text{ .}$$
 [*Note 1*: This implies that p(x | a,b) is undefined when
 `a == b`. — *end note*]
 ``` cpp
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructors and reset functions
+    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();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit uniform_real_distribution(RealType a, RealType b = 1.0);
 ```
+*Preconditions:* `a` ≤ `b` and
+`b` - `a` ≤ `numeric_limits<RealType>::max()`.
+*Remarks:* `a` and `b` correspond to the respective parameters of the
+distribution.
 ``` cpp
 result_type a() const;
 ```
 #### Bernoulli distributions <a id="rand.dist.bern">[[rand.dist.bern]]</a>
 ##### Class `bernoulli_distribution` <a id="rand.dist.bern.bernoulli">[[rand.dist.bern.bernoulli]]</a>
 A `bernoulli_distribution` random number distribution produces `bool`
+values b distributed according to the discrete probability function
+$$P(b\,|\,p) = \left\{ \begin{array}{ll}
+                          p     & \text{ if $b = \tcode{true}$, or} \\
+                          1 - p & \text{ if $b = \tcode{false}$.}
+ \end{array}\right.$$
 ``` cpp
 class bernoulli_distribution {
 public:
   // types
   using result_type = bool;
   using param_type  = unspecified;
   // constructors and reset functions
+  bernoulli_distribution() : bernoulli_distribution(0.5) {}
+  explicit bernoulli_distribution(double p);
   explicit bernoulli_distribution(const param_type& parm);
   void reset();
   // generating functions
   template<class URBG>
   result_type max() const;
 };
 ```
 ``` cpp
+explicit bernoulli_distribution(double p);
 ```
+*Preconditions:* 0 ≤ `p` ≤ 1.
+*Remarks:* `p` corresponds to the parameter of the distribution.
 ``` cpp
 double p() const;
 ```
 ##### Class template `binomial_distribution` <a id="rand.dist.bern.bin">[[rand.dist.bern.bin]]</a>
 A `binomial_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
+$$P(i\,|\,t,p) = \binom{t}{i} \cdot p^i \cdot (1-p)^{t-i} \text{ .}$$
 ``` cpp
 template<class IntType = int>
   class binomial_distribution {
   public:
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
+    binomial_distribution() : binomial_distribution(1) {}
+    explicit binomial_distribution(IntType t, double p = 0.5);
     explicit binomial_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+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.
 ``` cpp
 IntType t() const;
 ```
 ##### Class template `geometric_distribution` <a id="rand.dist.bern.geo">[[rand.dist.bern.geo]]</a>
 A `geometric_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
+$$P(i\,|\,p) = p \cdot (1-p)^{i} \text{ .}$$
 ``` cpp
 template<class IntType = int>
   class geometric_distribution {
   public:
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
+    geometric_distribution() : geometric_distribution(0.5) {}
+    explicit geometric_distribution(double p);
     explicit geometric_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit geometric_distribution(double p);
 ```
+*Preconditions:* 0 < `p` < 1.
+*Remarks:* `p` corresponds to the parameter of the distribution.
 ``` cpp
 double p() const;
 ```
 ##### Class template `negative_binomial_distribution` <a id="rand.dist.bern.negbin">[[rand.dist.bern.negbin]]</a>
 A `negative_binomial_distribution` random number distribution produces
 random integers i ≥ 0 distributed according to the discrete probability
+function
+$$P(i\,|\,k,p) = \binom{k+i-1}{i} \cdot p^k \cdot (1-p)^i \text{ .}$$
 [*Note 1*: This implies that P(i | k,p) is undefined when
 `p == 1`. — *end note*]
 ``` cpp
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructor and reset functions
+    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();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit negative_binomial_distribution(IntType k, double p = 0.5);
 ```
+*Preconditions:* 0 < `p` ≤ 1 and 0 < `k`.
+*Remarks:* `k` and `p` correspond to the respective parameters of the
+distribution.
 ``` cpp
 IntType k() const;
 ```
 ##### Class template `poisson_distribution` <a id="rand.dist.pois.poisson">[[rand.dist.pois.poisson]]</a>
 A `poisson_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
+$$P(i\,|\,\mu) = \frac{e^{-\mu} \mu^{i}}{i\,!} \text{ .}$$ The
+distribution parameter μ is also known as this distribution’s *mean* .
 ``` cpp
 template<class IntType = int>
   class poisson_distribution
   {
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
+    poisson_distribution() : poisson_distribution(1.0) {}
+    explicit poisson_distribution(double mean);
     explicit poisson_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit poisson_distribution(double mean);
 ```
+*Preconditions:* 0 < `mean`.
+*Remarks:* `mean` corresponds to the parameter of the distribution.
 ``` cpp
 double mean() const;
 ```
 ##### Class template `exponential_distribution` <a id="rand.dist.pois.exp">[[rand.dist.pois.exp]]</a>
 An `exponential_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
+$$p(x\,|\,\lambda) = \lambda e^{-\lambda x} \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class exponential_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructors and reset functions
+    exponential_distribution() : exponential_distribution(1.0) {}
+    explicit exponential_distribution(RealType lambda);
     explicit exponential_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit exponential_distribution(RealType lambda);
 ```
+*Preconditions:* 0 < `lambda`.
+*Remarks:* `lambda` corresponds to the parameter of the distribution.
 ``` cpp
 RealType lambda() const;
 ```
 ##### Class template `gamma_distribution` <a id="rand.dist.pois.gamma">[[rand.dist.pois.gamma]]</a>
 A `gamma_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
+$$p(x\,|\,\alpha,\beta) =
+     \frac{e^{-x/\beta}}{\beta^{\alpha} \cdot \Gamma(\alpha)} \, \cdot \, x^{\, \alpha-1}
+ \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class gamma_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructors and reset functions
+    gamma_distribution() : gamma_distribution(1.0) {}
+    explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
     explicit gamma_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
 ```
+*Preconditions:* 0 < `alpha` and 0 < `beta`.
+*Remarks:* `alpha` and `beta` correspond to the parameters of the
+distribution.
 ``` cpp
 RealType alpha() const;
 ```
 ##### Class template `weibull_distribution` <a id="rand.dist.pois.weibull">[[rand.dist.pois.weibull]]</a>
 A `weibull_distribution` random number distribution produces random
 numbers x ≥ 0 distributed according to the probability density function
+$$p(x\,|\,a,b) = \frac{a}{b}
      \cdot \left(\frac{x}{b}\right)^{a-1}
      \cdot \, \exp\left( -\left(\frac{x}{b}\right)^a\right)
+ \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class weibull_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    weibull_distribution() : weibull_distribution(1.0) {}
+    explicit weibull_distribution(RealType a, RealType b = 1.0);
     explicit weibull_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit weibull_distribution(RealType a, RealType b = 1.0);
 ```
+*Preconditions:* 0 < `a` and 0 < `b`.
+*Remarks:* `a` and `b` correspond to the respective parameters of the
+distribution.
 ``` cpp
 RealType a() const;
 ```
 ##### Class template `extreme_value_distribution` <a id="rand.dist.pois.extreme">[[rand.dist.pois.extreme]]</a>
 An `extreme_value_distribution` random number distribution produces
 random numbers x distributed according to the probability density
+function[^6] $$p(x\,|\,a,b) = \frac{1}{b}
+     \cdot \exp\left(\frac{a-x}{b} - \exp\left(\frac{a-x}{b}\right)\right)
+ \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class extreme_value_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    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();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit extreme_value_distribution(RealType a, RealType b = 1.0);
 ```
+*Preconditions:* 0 < `b`.
+*Remarks:* `a` and `b` correspond to the respective parameters of the
+distribution.
 ``` cpp
 RealType a() const;
 ```
         % e^{-(x-\mu)^2 / (2\sigma^2)}
         \exp{\left(- \, \frac{(x - \mu)^2}
                              {2 \sigma^2}
              \right)
             }
+ \text{ .}$$ The distribution parameters μ and σ are also known as this
 distribution’s *mean* and *standard deviation* .
 ``` cpp
 template<class RealType = double>
   class normal_distribution {
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructors and reset functions
+    normal_distribution() : normal_distribution(0.0) {}
+    explicit normal_distribution(RealType mean, RealType stddev = 1.0);
     explicit normal_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit normal_distribution(RealType mean, RealType stddev = 1.0);
 ```
+*Preconditions:* 0 < `stddev`.
+*Remarks:* `mean` and `stddev` correspond to the respective parameters
+of the distribution.
 ``` cpp
 RealType mean() const;
 ```
 ##### Class template `lognormal_distribution` <a id="rand.dist.norm.lognormal">[[rand.dist.norm.lognormal]]</a>
 A `lognormal_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
+$$p(x\,|\,m,s) = \frac{1}{s x \sqrt{2 \pi}}
+     \cdot \exp{\left(-\frac{(\ln{x} - m)^2}{2 s^2}\right)}
+ \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class lognormal_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    lognormal_distribution() : lognormal_distribution(0.0) {}
+    explicit lognormal_distribution(RealType m, RealType s = 1.0);
     explicit lognormal_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit lognormal_distribution(RealType m, RealType s = 1.0);
 ```
+*Preconditions:* 0 < `s`.
+*Remarks:* `m` and `s` correspond to the respective parameters of the
+distribution.
 ``` cpp
 RealType m() const;
 ```
 ##### Class template `chi_squared_distribution` <a id="rand.dist.norm.chisq">[[rand.dist.norm.chisq]]</a>
 A `chi_squared_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
+$$p(x\,|\,n) = \frac{x^{(n/2)-1} \cdot e^{-x/2}}{\Gamma(n/2) \cdot 2^{n/2}} \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class chi_squared_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    chi_squared_distribution() : chi_squared_distribution(1.0) {}
+    explicit chi_squared_distribution(RealType n);
     explicit chi_squared_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit chi_squared_distribution(RealType n);
 ```
+*Preconditions:* 0 < `n`.
+*Remarks:* `n` corresponds to the parameter of the distribution.
 ``` cpp
 RealType n() const;
 ```
 constructed.
 ##### Class template `cauchy_distribution` <a id="rand.dist.norm.cauchy">[[rand.dist.norm.cauchy]]</a>
 A `cauchy_distribution` random number distribution produces random
+numbers x distributed according to the probability density function
+$$p(x\,|\,a,b) = \left(\pi b \left(1 + \left(\frac{x-a}{b} \right)^2 \, \right)\right)^{-1} \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class cauchy_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    cauchy_distribution() : cauchy_distribution(0.0) {}
+    explicit cauchy_distribution(RealType a, RealType b = 1.0);
     explicit cauchy_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit cauchy_distribution(RealType a, RealType b = 1.0);
 ```
+*Preconditions:* 0 < `b`.
+*Remarks:* `a` and `b` correspond to the respective parameters of the
+distribution.
 ``` cpp
 RealType a() const;
 ```
 ##### Class template `fisher_f_distribution` <a id="rand.dist.norm.f">[[rand.dist.norm.f]]</a>
 A `fisher_f_distribution` random number distribution produces random
 numbers x ≥ 0 distributed according to the probability density function
+$$p(x\,|\,m,n) = \frac{\Gamma\big((m+n)/2\big)}{\Gamma(m/2) \; \Gamma(n/2)}
+     \cdot \left(\frac{m}{n}\right)^{m/2}
+ \cdot x^{(m/2)-1}
+ \cdot \left(1 + \frac{m x}{n}\right)^{-(m + n)/2}
+ \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class fisher_f_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    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();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit fisher_f_distribution(RealType m, RealType n = 1);
 ```
+*Preconditions:* 0 < `m` and 0 < `n`.
+*Remarks:* `m` and `n` correspond to the respective parameters of the
+distribution.
 ``` cpp
 RealType m() const;
 ```
 constructed.
 ##### Class template `student_t_distribution` <a id="rand.dist.norm.t">[[rand.dist.norm.t]]</a>
 A `student_t_distribution` random number distribution produces random
+numbers x distributed according to the probability density function
+$$p(x\,|\,n) = \frac{1}{\sqrt{n \pi}}
+ \cdot \frac{\Gamma\big((n+1)/2\big)}{\Gamma(n/2)}
      \cdot \left(1 + \frac{x^2}{n} \right)^{-(n+1)/2}
+ \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class student_t_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    student_t_distribution() : student_t_distribution(1.0) {}
+    explicit student_t_distribution(RealType n);
     explicit student_t_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit student_t_distribution(RealType n);
 ```
+*Preconditions:* 0 < `n`.
+*Remarks:* `n` corresponds to the parameter of the distribution.
 ``` cpp
 RealType n() const;
 ```
 ##### Class template `discrete_distribution` <a id="rand.dist.samp.discrete">[[rand.dist.samp.discrete]]</a>
 A `discrete_distribution` random number distribution produces random
 integers i, 0 ≤ i < n, distributed according to the discrete probability
+function $$P(i \,|\, p_0, \dotsc, p_{n-1}) = p_i \text{ .}$$
 Unless specified otherwise, the distribution parameters are calculated
+as: pₖ = {wₖ / S} for k = 0, …, n - 1, in which the values wₖ, commonly
+known as the *weights* , shall be non-negative, non-NaN, and
+non-infinity. Moreover, the following relation shall hold:
+$0 < S = w_0 + \dotsb + w_{n - 1}$.
 ``` cpp
 template<class IntType = int>
   class discrete_distribution {
   public:
 ``` cpp
 template<class InputIterator>
   discrete_distribution(InputIterator firstW, InputIterator lastW);
 ```
+*Mandates:*
+`is_convertible_v<iterator_traits<InputIterator>::value_type, double>`
+is `true`.
+*Preconditions:* `InputIterator` meets the *Cpp17InputIterator*
+requirements [[input.iterators]]. If `firstW == lastW`, let n = 1 and
+w₀ = 1. Otherwise, [`firstW`, `lastW`) forms a sequence w of length
+n > 0.
 *Effects:* Constructs a `discrete_distribution` object with
 probabilities given by the formula above.
 ``` cpp
 ``` cpp
 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 `nw` = 0, let n = 1, otherwise let n = `nw`. The
+relation 0 < δ = (`xmax` - `xmin`) / n holds.
 *Effects:* Constructs a `discrete_distribution` object with
 probabilities given by the formula above, using the following values: If
 `nw` = 0, let w₀ = 1. Otherwise, let wₖ = `fw`(`xmin` + k ⋅ δ + δ / 2)
 for k = 0, …, n - 1.
+*Complexity:* The number of invocations of `fw` does not exceed n.
 ``` cpp
 vector<double> probabilities() const;
 ```
 ##### Class template `piecewise_constant_distribution` <a id="rand.dist.samp.pconst">[[rand.dist.samp.pconst]]</a>
 A `piecewise_constant_distribution` random number distribution produces
 random numbers x, b₀ ≤ x < bₙ, uniformly distributed over each
 subinterval [ bᵢ, bᵢ₊₁ ) according to the probability density function
+$$p(x \,|\, b_0, \dotsc, b_n, \; \rho_0, \dotsc, \rho_{n-1}) = \rho_i
+ \text{ , for $b_i \le x < b_{i+1}$.}$$
 The n + 1 distribution parameters bᵢ, also known as this distribution’s
+*interval boundaries* , shall satisfy the relation $b_i < b_{i + 1}$ for
+i = 0, …, n - 1. Unless specified otherwise, the remaining n
+distribution parameters are calculated as:
+$$\rho_k = \frac{w_k}{S \cdot (b_{k+1}-b_k)} \text{ for } k = 0, \dotsc, n - 1 \text{ ,}$$
+in which the values wₖ, commonly known as the *weights* , shall be
+non-negative, non-NaN, and non-infinity. Moreover, the following
+relation shall hold: 0 < S = w₀ + … + wₙ₋₁.
 ``` cpp
 template<class RealType = double>
   class piecewise_constant_distribution {
   public:
 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`.
+*Preconditions:* `InputIteratorB` and `InputIteratorW` each meet the
+*Cpp17InputIterator* requirements [[input.iterators]]. If
+`firstB == lastB` or `++firstB == lastB`, let n = 1, w₀ = 1, b₀ = 0, and
+b₁ = 1. Otherwise, [`firstB`, `lastB`) forms a sequence b of length n+1,
+the length of the sequence w starting from `firstW` is at least n, and
+any wₖ for k ≥ n are ignored by the distribution.
 *Effects:* Constructs a `piecewise_constant_distribution` object with
 parameters as specified above.
 ``` cpp
 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
 `bl.size()` < 2, let n = 1, w₀ = 1, b₀ = 0, and b₁ = 1. Otherwise, let
 [`bl.begin()`, `bl.end()`) form a sequence b₀, …, bₙ, and let
 wₖ = `fw`((bₖ₊₁ + bₖ) / 2) for k = 0, …, n - 1.
+*Complexity:* The number of invocations of `fw` does not exceed n.
 ``` cpp
 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 `nw` = 0, let n = 1, otherwise let n = `nw`. The
+relation 0 < δ = (`xmax` - `xmin`) / n holds.
 *Effects:* Constructs a `piecewise_constant_distribution` object with
 parameters taken or calculated from the following values: Let
 bₖ = `xmin` + k ⋅ δ for k = 0, …, n, and wₖ = `fw`(bₖ + δ / 2) for
 k = 0, …, n - 1.
+*Complexity:* The number of invocations of `fw` does not exceed n.
 ``` cpp
 vector<result_type> intervals() const;
 ```
 ##### Class template `piecewise_linear_distribution` <a id="rand.dist.samp.plinear">[[rand.dist.samp.plinear]]</a>
 A `piecewise_linear_distribution` random number distribution produces
 random numbers x, b₀ ≤ x < bₙ, distributed over each subinterval
+[bᵢ, bᵢ₊₁) according to the probability density function
+$$p(x \,|\, b_0, \dotsc, b_n, \; \rho_0, \dotsc, \rho_n)
+ = \rho_{i}   \cdot {\frac{b_{i+1} - x}{b_{i+1} - b_i}}
      + \rho_{i+1} \cdot {\frac{x - b_i}{b_{i+1} - b_i}}
+ \text{ , for $b_i \le x < b_{i+1}$.}$$
 The n + 1 distribution parameters bᵢ, also known as this distribution’s
 *interval boundaries* , shall satisfy the relation bᵢ < bᵢ₊₁ for
 i = 0, …, n - 1. Unless specified otherwise, the remaining n + 1
+distribution parameters are calculated as ρₖ = {wₖ / S} for k = 0, …, n,
+in which the values wₖ, commonly known as the *weights at boundaries* ,
+shall be non-negative, non-NaN, and non-infinity. Moreover, the
+following relation shall hold:
+$$0 < S = \frac{1}{2} \cdot \sum_{k=0}^{n-1} (w_k + w_{k+1}) \cdot (b_{k+1} - b_k) \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class piecewise_linear_distribution {
   public:
 template<class InputIteratorB, class InputIteratorW>
  piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB,
                                InputIteratorW firstW);
 ```
+*Mandates:* `is_invocable_r_v<double, UnaryOperation&, double>` is
+`true`.
+*Preconditions:* `InputIteratorB` and `InputIteratorW` each meet the
+*Cpp17InputIterator* requirements [[input.iterators]]. If
+`firstB == lastB` or `++firstB == lastB`, let n = 1, ρ₀ = ρ₁ = 1,
+b₀ = 0, and b₁ = 1. Otherwise, [`firstB`, `lastB`) forms a sequence b of
+length n+1, the length of the sequence w starting from `firstW` is at
+least n+1, and any wₖ for k ≥ n + 1 are ignored by the distribution.
 *Effects:* Constructs a `piecewise_linear_distribution` object with
 parameters as specified above.
 ``` cpp
 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
 `bl.size()` < 2, let n = 1, ρ₀ = ρ₁ = 1, b₀ = 0, and b₁ = 1. Otherwise,
 let [`bl.begin(),` `bl.end()`) form a sequence b₀, …, bₙ, and let
 wₖ = `fw`(bₖ) for k = 0, …, n.
+*Complexity:* The number of invocations of `fw` does not exceed n+1.
 ``` cpp
 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 `nw` = 0, let n = 1, otherwise let n = `nw`. The
+relation 0 < δ = (`xmax` - `xmin`) / n holds.
 *Effects:* Constructs a `piecewise_linear_distribution` object with
 parameters taken or calculated from the following values: Let
 bₖ = `xmin` + k ⋅ δ for k = 0, …, n, and wₖ = `fw`(bₖ) for k = 0, …, n.
+*Complexity:* The number of invocations of `fw` does not exceed n+1.
 ``` cpp
 vector<result_type> intervals() const;
 ```
 whose `operator[]` member returns ρₖ when invoked with argument k for
 k = 0, …, n.
 ### Low-quality random number generation <a id="c.math.rand">[[c.math.rand]]</a>
+[*Note 1*: The header `<cstdlib>` declares the functions described in
+this subclause. — *end note*]
 ``` cpp
 int rand();
 void srand(unsigned int seed);
 ```
 *Effects:* The `rand` and `srand` functions have the semantics specified
 in the C standard library.
 *Remarks:* The implementation may specify that particular library
 functions may call `rand`. It is *implementation-defined* whether the
+`rand` function may introduce data races [[res.on.data.races]].
 [*Note 1*: 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*]
+See also: ISO C 7.22.2

Diff to HTML by rtfpessoa