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

Files changed (1) hide show

tmp/tmpw5eghois/{from.md → to.md} +217 -269

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

@@ -1,47 +1,46 @@
 ### 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>
@@ -58,17 +57,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;
 ```
@@ -84,13 +83,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
@@ -100,11 +97,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>
@@ -121,17 +119,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;
 ```
@@ -148,27 +147,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>
@@ -184,17 +182,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;
 ```
@@ -203,25 +200,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>
@@ -238,17 +233,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;
 ```
@@ -264,25 +259,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>
@@ -298,17 +291,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;
 ```
@@ -317,14 +309,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
@@ -334,11 +324,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>
@@ -355,17 +346,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;
 ```
@@ -383,16 +374,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
   {
@@ -400,11 +387,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>
@@ -420,17 +408,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;
 ```
@@ -439,25 +426,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>
@@ -473,17 +458,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;
 ```
@@ -492,26 +476,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>
@@ -528,17 +511,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;
 ```
@@ -554,27 +537,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>
@@ -591,17 +573,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;
 ```
@@ -617,28 +599,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>
@@ -655,17 +634,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;
 ```
@@ -691,11 +670,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 {
@@ -703,11 +682,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>
@@ -724,17 +704,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;
 ```
@@ -750,31 +730,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>
@@ -791,17 +765,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;
 ```
@@ -817,26 +791,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>
@@ -852,17 +823,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;
 ```
@@ -870,25 +840,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>
@@ -905,17 +874,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;
 ```
@@ -931,32 +900,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>
@@ -973,17 +937,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;
 ```
@@ -998,29 +962,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>
@@ -1036,17 +998,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;
 ```
@@ -1057,20 +1018,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:
@@ -1116,15 +1074,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
@@ -1136,22 +1097,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;
 ```
@@ -1162,27 +1123,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:
@@ -1230,59 +1185,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;
 ```
@@ -1300,29 +1256,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:
@@ -1369,58 +1320,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;
 ```

 ### 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;
 ```

Diff to HTML by rtfpessoa