[rand] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpna0gkhta/{from.md → to.md} +453 -164

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

@@ -49,65 +49,94 @@ conventional bitwise operations. Further:
 #include <initializer_list>     // see [initializer.list.syn]
 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;
@@ -186,12 +215,11 @@ namespace std {
 ### 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
@@ -210,18 +238,18 @@ template:
 - 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
@@ -232,12 +260,12 @@ 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 type `S` and `r` is a value of type `S` or
   `const S`;
@@ -304,12 +332,12 @@ suitable `operator>>`.
 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`;
@@ -327,10 +355,56 @@ where `charT` and `traits` are constrained according to [[strings]] and
 `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
 other random number engine, and applies an algorithm to those values in
@@ -415,12 +489,12 @@ 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`;
@@ -452,13 +526,12 @@ representation is restored into the same or a different object `y` of
 the same type using `is >> y`, repeated invocations of `y(g)` shall
 produce the same sequence of numbers as would repeated invocations of
 `x(g)`.
 It is unspecified whether `D::param_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.
@@ -475,10 +548,46 @@ the identical name, type, and semantics.
 ``` cpp
 using distribution_type =  D;
 ```
 ### Random number engine class templates <a id="rand.eng">[[rand.eng]]</a>
 #### General <a id="rand.eng.general">[[rand.eng.general]]</a>
 Each type instantiated from a class template specified in [[rand.eng]]
@@ -500,11 +609,11 @@ that are not described in [[rand.req.eng]] or for operations where there
 is additional semantic information. In particular, declarations for copy
 constructors, for copy assignment operators, for streaming operators,
 and for equality and inequality operators are not shown in the synopses.
 Each template specified in [[rand.eng]] requires one or more
-relationships, involving the value(s) of its 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 [[rand.eng]] and in [[rand.adapt]]:
@@ -570,21 +679,22 @@ namespace std {
     void discard(unsigned long long z);
     // inserters and extractors
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
-        operator<<(basic_ostream<charT, traits>& os, const linear_congruential_engine& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
-        operator>>(basic_istream<charT, traits>& is, linear_congruential_engine& x);
   };
 }
 ```
-If the template 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
@@ -688,14 +798,16 @@ namespace std {
     void discard(unsigned long long z);
     // inserters and extractors
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
-        operator<<(basic_ostream<charT, traits>& os, const mersenne_twister_engine& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
-        operator>>(basic_istream<charT, traits>& is, mersenne_twister_engine& x);
   };
 }
 ```
 The following relations shall hold: `0 < m`, `m <= n`, `2u < w`,
@@ -768,17 +880,17 @@ namespace std {
     static constexpr size_t word_size = w;
     static constexpr size_t short_lag = s;
     static constexpr size_t long_lag = r;
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return 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);
     // equality operators
     friend bool operator==(const subtract_with_carry_engine& x,
                            const subtract_with_carry_engine& y);
@@ -788,14 +900,16 @@ namespace std {
     void discard(unsigned long long z);
     // inserters and extractors
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
-        operator<<(basic_ostream<charT, traits>& os, const subtract_with_carry_engine& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
-        operator>>(basic_istream<charT, traits>& is, subtract_with_carry_engine& x);
   };
 }
 ```
 The following relations shall hold: `0u < s`, `s < r`, `0 < w`, and
@@ -813,12 +927,12 @@ 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
-linear_congruential_engine<result_type,
-                          40014u,0u,2147483563u> e(value == 0u ? default_seed : value);
 ```
 Then, to set each Xₖ, obtain new values z₀, …, zₙ₋₁ from n = ⌈ w/32 ⌉
 successive invocations of `e`. Set Xₖ to
 $\left( \sum_{j=0}^{n-1} z_j \cdot 2^{32j}\right) \bmod m$.
@@ -833,38 +947,207 @@ template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
 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>
@@ -887,11 +1170,11 @@ invocation of `e()` while advancing `e`’s state as described above.
 namespace std {
   template<class Engine, size_t p, size_t r>
   class discard_block_engine {
   public:
     // types
-    using result_type = typename Engine::result_type;
     // engine characteristics
     static constexpr size_t block_size = p;
     static constexpr size_t used_block = r;
     static constexpr result_type min() { return Engine::min(); }
@@ -918,14 +1201,14 @@ namespace std {
     const Engine& base() const noexcept { return e; }
     // inserters and extractors
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
-        operator<<(basic_ostream<charT, traits>& os, const discard_block_engine& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
-        operator>>(basic_istream<charT, traits>& is, discard_block_engine& x);
   private:
     Engine e;   // exposition only
     size_t n;   // exposition only
   };
@@ -981,10 +1264,11 @@ for (k = n₀; k \neq n; k += 1)  {
  S = 2^{w₀ + 1} \cdot S + u \bmod 2^{w₀ + 1};
 }
 ```
 ``` cpp
   template<class Engine, size_t w, class UIntType>
   class independent_bits_engine {
   public:
     // types
     using result_type = UIntType;
@@ -1014,18 +1298,19 @@ template<class Engine, size_t w, class UIntType>
     const Engine& base() const noexcept { return e; }
     // inserters and extractors
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
-        operator<<(basic_ostream<charT, traits>& os, const independent_bits_engine& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
-        operator>>(basic_istream<charT, traits>& is, independent_bits_engine& x);
   private:
     Engine e;   // exposition only
   };
 ```
 The following relations shall hold: `0 < w` and
 `w <= numeric_limits<result_type>::digits`.
@@ -1057,11 +1342,11 @@ advancing `e`’s state as described above.
 namespace std {
   template<class Engine, size_t k>
   class shuffle_order_engine {
   public:
     // types
-    using result_type = typename Engine::result_type;
     // engine characteristics
     static constexpr size_t table_size = k;
     static constexpr result_type min() { return Engine::min(); }
     static constexpr result_type max() { return Engine::max(); }
@@ -1208,10 +1493,30 @@ provide at least acceptable engine behavior for relatively casual,
 inexpert, and/or lightweight use. Because different implementations can
 select different underlying engine types, code that uses this `typedef`
 need not generate identical sequences across
 implementations. — *end note*]
 ### Class `random_device` <a id="rand.device">[[rand.device]]</a>
 A `random_device` uniform random bit generator produces nondeterministic
 random numbers.
@@ -1439,52 +1744,64 @@ 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>
 ``` cpp
-template<class RealType, size_t bits, class URBG>
   RealType generate_canonical(URBG& g);
 ```
-*Effects:* Invokes `g()` k times to obtain values g₀, …, gₖ₋₁,
-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ᵏ.
-[*Note 1*: 0 ≤ S / Rᵏ < 1. — *end note*]
 *Throws:* What and when `g` throws.
-*Complexity:* Exactly k = max(1, ⌈ b / log₂ R ⌉) invocations of `g`,
-where b[^6]
-is the lesser of `numeric_limits<RealType>::digits` and `bits`, and R is
-the value of `g.max()` - `g.min()` + 1.
-[*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
@@ -1495,11 +1812,11 @@ outside its stated domain.
 ##### 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
 namespace std {
   template<class IntType = int>
   class uniform_int_distribution {
@@ -1532,14 +1849,16 @@ namespace std {
     result_type max() const;
     // inserters and extractors
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
-        operator<<(basic_ostream<charT, traits>& os, const uniform_int_distribution& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
-        operator>>(basic_istream<charT, traits>& is, uniform_int_distribution& x);
   };
 }
 ```
 ``` cpp
@@ -1567,11 +1886,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) \text{ .}$$
 [*Note 1*: This implies that p(x | a,b) is undefined when
 `a == b`. — *end note*]
 ``` cpp
@@ -1645,15 +1964,11 @@ 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}{ll}
-                          p     & \text{ if $b = \tcode{true}$, or} \\
-                          1 - p & \text{ if $b = \tcode{false}$.}
-                          \end{array}\right.$$
 ``` cpp
 namespace std {
   class bernoulli_distribution {
   public:
@@ -1711,11 +2026,11 @@ 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} \text{ .}$$
 ``` cpp
 namespace std {
   template<class IntType = int>
   class binomial_distribution {
@@ -1783,11 +2098,11 @@ 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} \text{ .}$$
 ``` cpp
 namespace std {
   template<class IntType = int>
   class geometric_distribution {
@@ -1846,12 +2161,11 @@ 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 \text{ .}$$
 [*Note 1*: This implies that P(i | k,p) is undefined when
 `p == 1`. — *end note*]
 ``` cpp
@@ -1925,17 +2239,19 @@ 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\,!} \text{ .}$$ The
-distribution parameter μ is also known as this distribution’s *mean* .
 ``` cpp
   template<class IntType = int>
-  class poisson_distribution
-  {
   public:
     // types
     using result_type = IntType;
     using param_type  = unspecified;
@@ -1967,10 +2283,11 @@ template<class IntType = int>
         operator<<(basic_ostream<charT, traits>& os, const poisson_distribution& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
         operator>>(basic_istream<charT, traits>& is, poisson_distribution& x);
   };
 ```
 ``` cpp
 explicit poisson_distribution(double mean);
 ```
@@ -1988,11 +2305,11 @@ 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} \text{ .}$$
 ``` cpp
 namespace std {
   template<class RealType = double>
   class exponential_distribution {
@@ -2051,13 +2368,11 @@ 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}
-     \text{ .}$$
 ``` cpp
 namespace std {
   template<class RealType = double>
   class gamma_distribution {
@@ -2125,14 +2440,11 @@ 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)
-     \text{ .}$$
 ``` cpp
 namespace std {
   template<class RealType = double>
   class weibull_distribution {
@@ -2200,15 +2512,11 @@ 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[^7]
-$$p(x\,|\,a,b) = \frac{1}{b}
-     \cdot \exp\left(\frac{a-x}{b} - \exp\left(\frac{a-x}{b}\right)\right)
-     \text{ .}$$
 ``` cpp
 namespace std {
   template<class RealType = double>
   class extreme_value_distribution {
@@ -2278,20 +2586,13 @@ constructed.
 #### Normal distributions <a id="rand.dist.norm">[[rand.dist.norm]]</a>
 ##### Class template `normal_distribution` <a id="rand.dist.norm.normal">[[rand.dist.norm.normal]]</a>
 A `normal_distribution` random number distribution produces random
-numbers x distributed according to the probability density function $$%
- p(x\,|\,\mu,\sigma)
-      = \frac{1}{\sigma \sqrt{2\pi}}
-        \cdot
-        % 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
 namespace std {
   template<class RealType = double>
@@ -2360,13 +2661,11 @@ 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)}
-     \text{ .}$$
 ``` cpp
 namespace std {
   template<class RealType = double>
   class lognormal_distribution {
@@ -2434,11 +2733,11 @@ 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}} \text{ .}$$
 ``` cpp
 namespace std {
   template<class RealType = double>
   class chi_squared_distribution {
@@ -2496,12 +2795,11 @@ 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
 namespace std {
   template<class RealType = double>
   class cauchy_distribution {
@@ -2569,15 +2867,11 @@ 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}
-     \text{ .}$$
 ``` cpp
 namespace std {
   template<class RealType = double>
   class fisher_f_distribution {
@@ -2644,15 +2938,11 @@ 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}
-     \text{ .}$$
 ``` cpp
 namespace std {
   template<class RealType = double>
   class student_t_distribution {
@@ -2713,11 +3003,11 @@ 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, \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:
@@ -2792,11 +3082,11 @@ is `true`.
 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
 discrete_distribution(initializer_list<double> wl);
 ```
@@ -2831,12 +3121,11 @@ 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, \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:
@@ -2978,15 +3267,11 @@ 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, \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,
@@ -3056,12 +3341,16 @@ n = 1, ρ₀ = ρ₁ = 1, b₀ = 0, and b₁ = 1.
 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
@@ -3141,7 +3430,7 @@ functions may call `rand`. It is *implementation-defined* whether the
 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

 #include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   // [rand.req.urng], uniform random bit generator requirements
   template<class G>
+    concept uniform_random_bit_generator = see below;           // freestanding
   // [rand.eng.lcong], class template linear_congruential_engine
   template<class UIntType, UIntType a, UIntType c, UIntType m>
+    class linear_congruential_engine;                           // partially freestanding
   // [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;                           // partially freestanding
   // [rand.adapt.disc], class template discard_block_engine
   template<class Engine, size_t p, size_t r>
+    class discard_block_engine;                                 // partially freestanding
   // [rand.adapt.ibits], class template independent_bits_engine
   template<class Engine, size_t w, class UIntType>
+    class independent_bits_engine;                              // partially freestanding
   // [rand.adapt.shuf], class template shuffle_order_engine
   template<class Engine, size_t k>
     class shuffle_order_engine;
+  // [rand.eng.philox], class template philox_engine
+  template<class UIntType, size_t w, size_t n, size_t r, UIntType... consts>
+    class philox_engine;                                        // partially freestanding
   // [rand.predef], engines and engine adaptors with predefined parameters
+  using minstd_rand0  = see below;      // freestanding
+  using minstd_rand   = see below;      // freestanding
+  using mt19937       = see below;      // freestanding
+  using mt19937_64    = see below;      // freestanding
+  using ranlux24_base = see below;      // freestanding
+  using ranlux48_base = see below;      // freestanding
+  using ranlux24      = see below;      // freestanding
+  using ranlux48      = see below;      // freestanding
   using knuth_b       = see below;
+  using philox4x32    = see below;      // freestanding
+  using philox4x64    = see below;      // freestanding
   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 digits, class URBG>
     RealType generate_canonical(URBG& g);
+  namespace ranges {
+    // [alg.rand.generate], generate_random
+    template<class R, class G>
+      requires output_range<R, invoke_result_t<G&>> &&
+               uniform_random_bit_generator<remove_cvref_t<G>>
+      constexpr borrowed_iterator_t<R> generate_random(R&& r, G&& g);
+    template<class G, output_iterator<invoke_result_t<G&>> O, sentinel_for<O> S>
+      requires uniform_random_bit_generator<remove_cvref_t<G>>
+      constexpr O generate_random(O first, S last, G&& g);
+    template<class R, class G, class D>
+      requires output_range<R, invoke_result_t<D&, G&>> && invocable<D&, G&> &&
+               uniform_random_bit_generator<remove_cvref_t<G>> &&
+               is_arithmetic_v<invoke_result_t<D&, G&>>
+    constexpr borrowed_iterator_t<R> generate_random(R&& r, G&& g, D&& d);
+    template<class G, class D, output_iterator<invoke_result_t<D&, G&>> O, sentinel_for<O> S>
+      requires invocable<D&, G&> && uniform_random_bit_generator<remove_cvref_t<G>> &&
+               is_arithmetic_v<invoke_result_t<D&, G&>>
+    constexpr O generate_random(O first, S last, G&& g, D&& d);
+  }
   // [rand.dist.uni.int], class template uniform_int_distribution
   template<class IntType = int>
+    class uniform_int_distribution;                             // partially freestanding
   // [rand.dist.uni.real], class template uniform_real_distribution
   template<class RealType = double>
     class uniform_real_distribution;
 ### Requirements <a id="rand.req">[[rand.req]]</a>
 #### General requirements <a id="rand.req.genl">[[rand.req.genl]]</a>
+Throughout [[rand]], the effect of instantiating a template:
 - that has a template type parameter named `Sseq` is undefined unless
   the corresponding template argument is cv-unqualified and meets the
   requirements of seed sequence [[rand.req.seedseq]].
 - that has a template type parameter named `URBG` is undefined unless
 - 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 [[rand]], phrases of the form “`x` is an iterator of a
+specific kind” shall be interpreted as equivalent to the more formal
+requirement that “`x` is a value of a type meeting the requirements of
+the specified iterator type”.
+Throughout [[rand]], any constructor that can be called with a single
+argument and that meets a requirement specified in this subclause shall
+be declared `explicit`.
 #### 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
 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
+[[rand.req.seedseq]]. In [[rand.req.seedseq]] and throughout this
 subclause:
 - `T` is the type named by `S`’s associated `result_type`;
 - `q` is a value of type `S` and `r` is a value of type `S` or
   `const S`;
 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 [[rand.req.eng]]. In [[rand.req.eng]] 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`;
 `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}).
+On hosted implementations, the following expressions are well-formed and
+have the specified semantics.
+``` cpp
+os << x
+```
+*Effects:* With `os.`*`fmtflags`* set to `ios_base::dec|ios_base::left`
+and the fill character set to the space character, writes to `os` the
+textual representation of `x`’s current state. In the output, adjacent
+numbers are separated by one or more space characters.
+*Ensures:* The `os.`*`fmtflags`* and fill character are unchanged.
+*Result:* reference to the type of `os`.
+*Returns:* `os`.
+*Complexity:* 𝑂(size of state)
+``` cpp
+is >> v
+```
+*Preconditions:* `is` provides a textual representation that was
+previously written using an output stream whose imbued locale was the
+same as that of `is`, and whose type’s template specialization arguments
+`charT` and `traits` were respectively the same as those of `is`.
+*Effects:* With `is.`*`fmtflags`* set to `ios_base::dec`, sets `v`’s
+state as determined by reading its textual representation from `is`. If
+bad input is encountered, ensures that `v`’s state is unchanged by the
+operation and calls `is.setstate(ios_base::failbit)` (which may throw
+`ios_base::failure` [[iostate.flags]]). If a textual representation
+written via `os << x` was subsequently read via `is >> v`, then `x == v`
+provided that there have been no intervening invocations of `x` or of
+`v`.
+*Ensures:* The `is.`*`fmtflags`* are unchanged.
+*Result:* reference to the type of `is`.
+*Returns:* `is`.
+*Complexity:* 𝑂(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
 other random number engine, and applies an algorithm to those values in
 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 [[rand.req.dist]]. In [[rand.req.dist]] 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`;
 the same type using `is >> y`, repeated invocations of `y(g)` shall
 produce the same sequence of numbers as would repeated invocations of
 `x(g)`.
 It is unspecified whether `D::param_type` is declared as a (nested)
+`class` or via a `typedef`. In [[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.
 ``` cpp
 using distribution_type =  D;
 ```
+On hosted implementations, the following expressions are well-formed and
+have the specified semantics.
+``` cpp
+os << x
+```
+*Effects:* Writes to `os` a textual representation for the parameters
+and the additional internal data of `x`.
+*Ensures:* The `os.`*`fmtflags`* and fill character are unchanged.
+*Result:* reference to the type of `os`.
+*Returns:* `os`.
+``` cpp
+is >> d
+```
+*Preconditions:* `is` provides a textual representation that was
+previously written using an `os` whose imbued locale and whose type’s
+template specialization arguments `charT` and `traits` were the same as
+those of `is`.
+*Effects:* Restores from `is` the parameters and additional internal
+data of the lvalue `d`. If bad input is encountered, ensures that `d` is
+unchanged by the operation and calls `is.setstate(ios_base::failbit)`
+(which may throw `ios_base::failure` [[iostate.flags]]).
+*Ensures:* The `is.`*`fmtflags`* are unchanged.
+*Result:* reference to the type of `is`.
+*Returns:* `is`.
 ### Random number engine class templates <a id="rand.eng">[[rand.eng]]</a>
 #### General <a id="rand.eng.general">[[rand.eng.general]]</a>
 Each type instantiated from a class template specified in [[rand.eng]]
 is additional semantic information. In particular, declarations for copy
 constructors, for copy assignment operators, for streaming operators,
 and for equality and inequality operators are not shown in the synopses.
 Each template specified in [[rand.eng]] requires one or more
+relationships, involving the value(s) of its constant template
 parameter(s), to hold. A program instantiating any of these templates is
 ill-formed if any such required relationship fails to hold.
 For every random number engine and for every random number engine
 adaptor `X` defined in [[rand.eng]] and in [[rand.adapt]]:
     void discard(unsigned long long z);
     // inserters and extractors
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os,            // hosted
+                   const linear_congruential_engine& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is,            // hosted
+                   linear_congruential_engine& x);
   };
 }
 ```
+If the template parameter `m` is 0, the modulus m used throughout
+[[rand.eng.lcong]] is `numeric_limits<result_type>::max()` plus 1.
 [*Note 1*: m need not be representable as a value of type
 `result_type`. — *end note*]
 If the template parameter `m` is not 0, the following relations shall
     void discard(unsigned long long z);
     // inserters and extractors
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os,            // hosted
+                   const mersenne_twister_engine& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is,            // hosted
+                   mersenne_twister_engine& x);
   };
 }
 ```
 The following relations shall hold: `0 < m`, `m <= n`, `2u < w`,
     static constexpr size_t word_size = w;
     static constexpr size_t short_lag = s;
     static constexpr size_t long_lag = r;
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return m - 1; }
+    static constexpr uint_least32_t default_seed = 19780503u;
     // constructors and seeding functions
+    subtract_with_carry_engine() : subtract_with_carry_engine(0u) {}
     explicit subtract_with_carry_engine(result_type value);
     template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
+    void seed(result_type value = 0u);
     template<class Sseq> void seed(Sseq& q);
     // equality operators
     friend bool operator==(const subtract_with_carry_engine& x,
                            const subtract_with_carry_engine& y);
     void discard(unsigned long long z);
     // inserters and extractors
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os,            // hosted
+                   const subtract_with_carry_engine& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is,            // hosted
+                   subtract_with_carry_engine& x);
   };
 }
 ```
 The following relations shall hold: `0u < s`, `s < r`, `0 < w`, and
 To set the values Xₖ, first construct `e`, a
 `linear_congruential_engine` object, as if by the following definition:
 ``` cpp
+linear_congruential_engine<uint_least32_t, 40014u, 0u, 2147483563u> e(
+ value == 0u ? default_seed : static_cast<uint_least32_t>(value % 2147483563u));
 ```
 Then, to set each Xₖ, obtain new values z₀, …, zₙ₋₁ from n = ⌈ w/32 ⌉
 successive invocations of `e`. Set Xₖ to
 $\left( \sum_{j=0}^{n-1} z_j \cdot 2^{32j}\right) \bmod m$.
 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.
+#### Class template `philox_engine` <a id="rand.eng.philox">[[rand.eng.philox]]</a>
+A `philox_engine` random number engine produces unsigned integer random
+numbers in the interval \[`0`, m), where m = 2ʷ and the template
+parameter w defines the range of the produced numbers. The state of a
+`philox_engine` object consists of a sequence X of n unsigned integer
+values of width w, a sequence K of n/2 values of `result_type`, a
+sequence Y of n values of `result_type`, and a scalar i, where
+- X is the interpretation of the unsigned integer *counter* value
+  $Z \cedef \sum_{j = 0}^{n - 1} X_j \cdot 2^{wj}$ of n ⋅ w bits,
+- K are keys, which are generated once from the seed (see constructors
+  below) and remain constant unless the `seed` function [[rand.req.eng]]
+  is invoked,
+- Y stores a batch of output values, and
+- i is an index for an element of the sequence Y.
+The generation algorithm returns Yᵢ, the value stored in the iᵗʰ element
+of Y after applying the transition algorithm.
+The state transition is performed as if by the following algorithm:
+``` cpp
+i = i + 1
+if (i == n) {
+  Y = Philox(K, X) // see below
+  Z = Z + 1
+  i = 0
+}
+```
+The `Philox` function maps the length-n/2 sequence K and the length-n
+sequence X into a length-n output sequence Y. Philox applies an r-round
+substitution-permutation network to the values in X. A single round of
+the generation algorithm performs the following steps:
+- The output sequence X' of the previous round (X in case of the first
+  round) is permuted to obtain the intermediate state V:
+  ``` cpp
+  Vⱼ = X'_{fₙ(j)}
+  ```
+  where j = 0, …, n - 1 and fₙ(j) is defined in [[rand.eng.philox.f]].
+  **Table: Values for the word permutation $\bm{f}_{\bm{n}}\bm{(j)}$** <a id="rand.eng.philox.f">[rand.eng.philox.f]</a>
+  |                                               |                              |
+  | --------------------------------------------- | ---------------------------- |
+  | *[spans 2 columns]* $\bm{f}_{\bm{n}}\bm{(j)}$ | *[spans 4 columns]* $\bm{j}$ |
+  | \multicolumn{2}{|c|}                          | 0                            | 1   | 2   | 3   |
+  | $\bm{n} $                                     | 2                            | 0   | 1   | \multicolumn{2}{c|} |
+  |                                               | 4                            | 2   | 1   | 0   | 3   |
+  \[*Note 1*: For n = 2 the sequence is not permuted. — *end note*]
+- The following computations are applied to the elements of the V
+  sequence:
+  ``` cpp
+  X_2k + 0} = \mulhi(V_2k, Mₖ, w) \xor key^qₖ \xor V_2k + 1}
+  X_2k + 1} = \mullo(V_2k, Mₖ, w)
+  ```
+  where:
+  - μllo(`a`, `b`, `w`) is the low half of the modular multiplication of
+    `a` and `b`: $(\tcode{a} \cdot \tcode{b}) \mod 2^w$,
+  - μlhi(`a`, `b`, `w`) is the high half of the modular multiplication
+    of `a` and `b`: (⌊ (`a` ⋅ `b`) / 2ʷ ⌋),
+  - k = 0, …, n/2 - 1 is the index in the sequences,
+  - q = 0, …, r - 1 is the index of the round,
+  - $\mathit{key}^q_k$ is the kᵗʰ round key for round q,
+    $\mathit{key}^q_k \cedef (K_k + q \cdot C_k) \mod 2^w$,
+  - Kₖ are the elements of the key sequence K,
+  - Mₖ is `multipliers[k]`, and
+  - Cₖ is `round_consts[k]`.
+After r applications of the single-round function, `Philox` returns the
+sequence Y = X'.
+``` cpp
+namespace std {
+  template<class UIntType, size_t w, size_t n, size_t r, UIntType... consts>
+  class philox_engine {
+    static constexpr size_t array-size = n / 2;   // exposition only
+  public:
+    // types
+    using result_type = UIntType;
+    // engine characteristics
+    static constexpr size_t word_size = w;
+    static constexpr size_t word_count = n;
+    static constexpr size_t round_count = r;
+    static constexpr array<result_type, array-size> multipliers;
+    static constexpr array<result_type, array-size> round_consts;
+    static constexpr result_type min() { return 0; }
+    static constexpr result_type max() { return m - 1; }
+    static constexpr result_type default_seed = 20111115u;
+    // constructors and seeding functions
+    philox_engine() : philox_engine(default_seed) {}
+    explicit philox_engine(result_type value);
+    template<class Sseq> explicit philox_engine(Sseq& q);
+    void seed(result_type value = default_seed);
+    template<class Sseq> void seed(Sseq& q);
+    void set_counter(const array<result_type, n>& counter);
+    // equality operators
+    friend bool operator==(const philox_engine& x, const philox_engine& y);
+    // generating functions
+    result_type operator()();
+    void discard(unsigned long long z);
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const philox_engine& x);   // hosted
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, philox_engine& x);         // hosted
+  };
+}
+```
+*Mandates:*
+- `sizeof...(consts) == n` is `true`, and
+- `n == 2 || n == 4` is `true`, and
+- `0 < r` is `true`, and
+- `0 < w && w <= numeric_limits<UIntType>::digits` is `true`.
+The template parameter pack `consts` represents the Mₖ and Cₖ constants
+which are grouped as follows:
+$[ M_0, C_0, M_1, C_1, M_2, C_2, \dotsc, M_{n/2 - 1}, C_{n/2 - 1} ]$.
+The textual representation consists of the values of
+$K_0, \dotsc, K_{n/2 - 1}, X_{0}, \dotsc, X_{n - 1}, i$, in that order.
+[*Note 2*: The stream extraction operator can reconstruct Y from K and
+X, as needed. — *end note*]
+``` cpp
+explicit philox_engine(result_type value);
+```
+*Effects:* Sets the K₀ element of sequence K to
+$\texttt{value} \mod 2^w$. All elements of sequences X and K (except K₀)
+are set to `0`. The value of i is set to n - 1.
+``` cpp
+template<class Sseq> explicit philox_engine(Sseq& q);
+```
+*Effects:* With p = ⌈ w / 32 ⌉ and an array (or equivalent) `a` of
+length (n/2) ⋅ p, invokes `q.generate(a + 0, a + n / 2 * `p`)` and then
+iteratively for k = 0, …, n/2 - 1, sets Kₖ to
+$\left(\sum_{j = 0}^{p - 1} a_{k p + j} \cdot 2^{32j} \right) \mod 2^w$.
+All elements of sequence X are set to `0`. The value of i is set to
+n - 1.
+``` cpp
+void set_counter(const array<result_type, n>& c);
+```
+*Effects:* For j = 0, …, n - 1 sets Xⱼ to $C_{n - 1 - j} \mod 2^w$. The
+value of i is set to n - 1.
+[*Note 1*: The counter is the value Z introduced at the beginning of
+this subclause. — *end note*]
 ### Random number engine adaptor class templates <a id="rand.adapt">[[rand.adapt]]</a>
+#### General <a id="rand.adapt.general">[[rand.adapt.general]]</a>
+Each type instantiated from a class template specified in [[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 [[rand.adapt]] is constant.
+Except where specified otherwise, no function described in
+[[rand.adapt]] throws an exception.
+Every function described in [[rand.adapt]] that has a function parameter
+`q` of type `Sseq&` for a template type parameter named `Sseq` that is
+different from type `seed_seq` throws what and when the invocation of
+`q.generate` throws.
+Descriptions are provided in [[rand.adapt]] only for adaptor operations
+that are not described in subclause  [[rand.req.adapt]] or for
+operations where there is additional semantic information. In
+particular, declarations for copy constructors, for copy assignment
+operators, for streaming operators, and for equality and inequality
+operators are not shown in the synopses.
+Each template specified in [[rand.adapt]] requires one or more
+relationships, involving the value(s) of its constant template
 parameter(s), to hold. A program instantiating any of these templates is
 ill-formed if any such required relationship fails to hold.
 #### Class template `discard_block_engine` <a id="rand.adapt.disc">[[rand.adapt.disc]]</a>
 namespace std {
   template<class Engine, size_t p, size_t r>
   class discard_block_engine {
   public:
     // types
+    using result_type = Engine::result_type;
     // engine characteristics
     static constexpr size_t block_size = p;
     static constexpr size_t used_block = r;
     static constexpr result_type min() { return Engine::min(); }
     const Engine& base() const noexcept { return e; }
     // inserters and extractors
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const discard_block_engine& x);    // hosted
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, discard_block_engine& x);          // hosted
   private:
     Engine e;   // exposition only
     size_t n;   // exposition only
   };
  S = 2^{w₀ + 1} \cdot S + u \bmod 2^{w₀ + 1};
 }
 ```
 ``` cpp
+namespace std {
   template<class Engine, size_t w, class UIntType>
   class independent_bits_engine {
   public:
     // types
     using result_type = UIntType;
     const Engine& base() const noexcept { return e; }
     // inserters and extractors
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const independent_bits_engine& x); // hosted
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, independent_bits_engine& x);       // hosted
   private:
     Engine e;   // exposition only
   };
+}
 ```
 The following relations shall hold: `0 < w` and
 `w <= numeric_limits<result_type>::digits`.
 namespace std {
   template<class Engine, size_t k>
   class shuffle_order_engine {
   public:
     // types
+    using result_type = Engine::result_type;
     // engine characteristics
     static constexpr size_t table_size = k;
     static constexpr result_type min() { return Engine::min(); }
     static constexpr result_type max() { return Engine::max(); }
 inexpert, and/or lightweight use. Because different implementations can
 select different underlying engine types, code that uses this `typedef`
 need not generate identical sequences across
 implementations. — *end note*]
+``` cpp
+using philox4x32 =
+      philox_engine<uint_fast32_t, 32, 4, 10,
+       0xCD9E8D57, 0x9E3779B9, 0xD2511F53, 0xBB67AE85>;
+```
+*Required behavior:* The 10000ᵗʰ consecutive invocation a
+default-constructed object of type `philox4x32` produces the value
+1955073260.
+``` cpp
+using philox4x64 =
+      philox_engine<uint_fast64_t, 64, 4, 10,
+       0xCA5A826395121157, 0x9E3779B97F4A7C15, 0xD2E7470EE14C6C93, 0xBB67AE8584CAA73B>;
+```
+*Required behavior:* The 10000ᵗʰ consecutive invocation a
+default-constructed object of type `philox4x64` produces the value
+3409172418970261260.
 ### Class `random_device` <a id="rand.device">[[rand.device]]</a>
 A `random_device` uniform random bit generator produces nondeterministic
 random numbers.
 *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 digits, class URBG>
   RealType generate_canonical(URBG& g);
 ```
+Let
+- r be `numeric_limits<RealType>::radix`,
+- R be `g.max()` - `g.min()` + 1,
+- d be the smaller of `digits` and
+  `numeric_limits<RealType>::digits`,[^6]
+- k be the smallest integer such that Rᵏ ≥ rᵈ, and
+- x be ⌊ Rᵏ / rᵈ ⌋.
+An *attempt* is k invocations of `g()` to obtain values g₀, …, gₖ₋₁,
+respectively, and the calculation of a quantity S given by :
+*Effects:* Attempts are made until S < xrᵈ.
+[*Note 1*: When R is a power of r, precisely one attempt is
+made. — *end note*]
+*Returns:* ⌊ S / x ⌋ / rᵈ.
+[*Note 2*: The return value c satisfies 0 ≤ c < 1. — *end note*]
 *Throws:* What and when `g` throws.
+*Complexity:* Exactly k invocations of `g` per attempt.
+[*Note 3*: 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*]
+[*Note 4*: When R is a power of r, an implementation can avoid using an
+arithmetic type that is wider than the output when computing
+S. — *end note*]
 ### Random number distribution class templates <a id="rand.dist">[[rand.dist]]</a>
+#### General <a id="rand.dist.general">[[rand.dist.general]]</a>
+Each type instantiated from a class template specified in [[rand.dist]]
+meets the requirements of a random number distribution [[rand.req.dist]]
+type.
+Descriptions are provided in [[rand.dist]] only for distribution
+operations that are not described in [[rand.req.dist]] or for operations
+where there is additional semantic information. In particular,
+declarations for copy constructors, for copy assignment operators, for
+streaming operators, and for equality and inequality operators are not
+shown in the synopses.
 The algorithms for producing each of the specified distributions are
 *implementation-defined*.
 The value of each probability density function p(z) and of each discrete
 ##### 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 in .
 ``` cpp
 namespace std {
   template<class IntType = int>
   class uniform_int_distribution {
     result_type max() const;
     // inserters and extractors
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os,            // hosted
+                   const uniform_int_distribution& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is,            // hosted
+                   uniform_int_distribution& x);
   };
 }
 ```
 ``` cpp
 ##### 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 in .
 [*Note 1*: This implies that p(x | a,b) is undefined when
 `a == b`. — *end note*]
 ``` cpp
 #### 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 in .
 ``` cpp
 namespace std {
   class bernoulli_distribution {
   public:
 ##### 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
+in .
 ``` cpp
 namespace std {
   template<class IntType = int>
   class binomial_distribution {
 ##### 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
+in .
 ``` cpp
 namespace std {
   template<class IntType = int>
   class geometric_distribution {
 ##### 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 in .
 [*Note 1*: This implies that P(i | k,p) is undefined when
 `p == 1`. — *end note*]
 ``` cpp
 ##### 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
+in .
+The distribution parameter μ is also known as this distribution’s
+*mean*.
 ``` cpp
+namespace std {
   template<class IntType = int>
+  class poisson_distribution {
   public:
     // types
     using result_type = IntType;
     using param_type  = unspecified;
         operator<<(basic_ostream<charT, traits>& os, const poisson_distribution& x);
     template<class charT, class traits>
       friend basic_istream<charT, traits>&
         operator>>(basic_istream<charT, traits>& is, poisson_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit poisson_distribution(double mean);
 ```
 ##### 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
+in .
 ``` cpp
 namespace std {
   template<class RealType = double>
   class exponential_distribution {
 ##### 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
+in .
 ``` cpp
 namespace std {
   template<class RealType = double>
   class gamma_distribution {
 ##### 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
+in .
 ``` cpp
 namespace std {
   template<class RealType = double>
   class weibull_distribution {
 ##### 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 in .[^7]
 ``` cpp
 namespace std {
   template<class RealType = double>
   class extreme_value_distribution {
 #### Normal distributions <a id="rand.dist.norm">[[rand.dist.norm]]</a>
 ##### Class template `normal_distribution` <a id="rand.dist.norm.normal">[[rand.dist.norm.normal]]</a>
 A `normal_distribution` random number distribution produces random
+numbers x distributed according to the probability density function in .
+The distribution parameters μ and σ are also known as this
 distribution’s *mean* and *standard deviation*.
 ``` cpp
 namespace std {
   template<class RealType = double>
 ##### 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
+in .
 ``` cpp
 namespace std {
   template<class RealType = double>
   class lognormal_distribution {
 ##### 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
+in .
 ``` cpp
 namespace std {
   template<class RealType = double>
   class chi_squared_distribution {
 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 in .
 ``` cpp
 namespace std {
   template<class RealType = double>
   class cauchy_distribution {
 ##### 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
+in .
 ``` cpp
 namespace std {
   template<class RealType = double>
   class fisher_f_distribution {
 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 in .
 ``` cpp
 namespace std {
   template<class RealType = double>
   class student_t_distribution {
 ##### 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 in .
 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:
 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 .
 ``` cpp
 discrete_distribution(initializer_list<double> wl);
 ```
 ##### 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
+in .
 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:
 ##### 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 in .
 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,
 template<class InputIteratorB, class InputIteratorW>
   piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB,
                                 InputIteratorW firstW);
 ```
+*Mandates:* Both of
+- `is_convertible_v<iterator_traits<InputIteratorB>::value_type, double>`
+- `is_convertible_v<iterator_traits<InputIteratorW>::value_type, double>`
+are `true`.
 *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
 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.24.3

Diff to HTML by rtfpessoa