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

Files changed (1) hide show

tmp/tmpsfewi5k7/{from.md → to.md} +1771 -2318

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

@@ -5,118 +5,65 @@
 This Clause describes components that C++ programs may use to perform
 seminumerical operations.
 The following subclauses describe components for complex number types,
 random number generation, numeric ( *n*-at-a-time) arrays, generalized
-numeric algorithms, and mathematical functions for floating-point types,
-as summarized in Table  [[tab:numerics.lib.summary]].
-**Table: Numerics library summary** <a id="tab:numerics.lib.summary">[tab:numerics.lib.summary]</a>
 | Subclause                |                                                 | Header                 |
-| ------------------------ | ------------------------------ | ------------ |
-| [[numerics.defns]]       | Definitions                    |              |
 | [[numeric.requirements]] | Requirements                                    |                        |
 | [[cfenv]]                | Floating-point environment                      | `<cfenv>`              |
 | [[complex.numbers]]      | Complex numbers                                 | `<complex>`            |
 | [[rand]]                 | Random number generation                        | `<random>`             |
 | [[numarray]]             | Numeric arrays                                  | `<valarray>`           |
-| [[numeric.ops]] | Generalized numeric operations | `<numeric>` |
-| [[c.math]] | Mathematical functions for     | `<cmath>` |
-|                          | floating-point types           | `<cstdlib>`  |
-## Definitions <a id="numerics.defns">[[numerics.defns]]</a>
-Define `GENERALIZED_NONCOMMUTATIVE_SUM(op, a1, ..., aN)` as follows:
-- `a1` when `N` is `1`, otherwise
-- `op(GENERALIZED_NONCOMMUTATIVE_SUM(op, a1, ..., aK),`
-  `\phantom{op(}GENERALIZED_NONCOMMUTATIVE_SUM(op, aM, ..., aN))` for
-  any `K` where 1 < K+1 = M ≤ N.
-Define `GENERALIZED_SUM(op, a1, ..., aN)` as
-`GENERALIZED_NONCOMMUTATIVE_SUM(op, b1, ..., bN)`, where `b1, ..., bN`
-may be any permutation of `a1, ..., aN`.
 ## Numeric type requirements <a id="numeric.requirements">[[numeric.requirements]]</a>
 The `complex` and `valarray` components are parameterized by the type of
 information they contain and manipulate. A C++ program shall instantiate
-these components only with a type `T` that satisfies the following
-requirements:[^1]
-- `T` is not an abstract class (it has no pure virtual member
-  functions);
-- `T` is not a reference type;
-- `T` is not cv-qualified;
-- If `T` is a class, it has a public default constructor;
-- If `T` is a class, it has a public copy constructor with the signature
-  `T::T(const T&)`
-- If `T` is a class, it has a public destructor;
-- If `T` is a class, it has a public assignment operator whose signature
-  is either `T& T::operator=(const T&)` or `T& T::operator=(T)`
-- If `T` is a class, its assignment operator, copy and default
-  constructors, and destructor shall correspond to each other in the
-  following sense:
-  - Initialization of raw storage using the copy constructor on the
-    value of `T()`, however obtained, is semantically equivalent to
-    value-initialization of the same raw storage.
-  - Initialization of raw storage using the default constructor,
-    followed by assignment, is semantically equivalent to initialization
-    of raw storage using the copy constructor.
-  - Destruction of an object, followed by initialization of its raw
-    storage using the copy constructor, is semantically equivalent to
-    assignment to the original object.
-  \[*Note 1*:
-  This rule states, in part, that there shall not be any subtle
-  differences in the semantics of initialization versus assignment. This
-  gives an implementation considerable flexibility in how arrays are
-  initialized.
-  \[*Example 1*:
-  An implementation is allowed to initialize a `valarray` by allocating
-  storage using the `new` operator (which implies a call to the default
-  constructor for each element) and then assigning each element its
-  value. Or the implementation can allocate raw storage and use the copy
-  constructor to initialize each element.
-  — *end example*]
-  If the distinction between initialization and assignment is important
-  for a class, or if it fails to satisfy any of the other conditions
-  listed above, the programmer should use `vector` ([[vector]]) instead
-  of `valarray` for that class.
-  — *end note*]
-- If `T` is a class, it does not overload unary `operator&`.
 If any operation on `T` throws an exception the effects are undefined.
 In addition, many member and related functions of `valarray<T>` can be
 successfully instantiated and will exhibit well-defined behavior if and
-only if `T` satisfies additional requirements specified for each such
-member or related function.
-[*Example 2*: It is valid to instantiate `valarray<complex>`, but
 `operator>()` will not be successfully instantiated for
 `valarray<complex>` operands, since `complex` does not have any ordering
 operators. — *end example*]
 ## The floating-point environment <a id="cfenv">[[cfenv]]</a>
 ### Header `<cfenv>` synopsis <a id="cfenv.syn">[[cfenv.syn]]</a>
 ``` cpp
 #define FE_ALL_EXCEPT see below
-#define FE_DIVBYZERO see below
-#define FE_INEXACT see below
-#define FE_INVALID see below
-#define FE_OVERFLOW see below
-#define FE_UNDERFLOW see below
-#define FE_DOWNWARD see below
-#define FE_TONEAREST see below
-#define FE_TOWARDZERO see below
-#define FE_UPWARD see below
 #define FE_DFL_ENV see below
 namespace std {
   // types
@@ -141,125 +88,117 @@ namespace std {
 ```
 The contents and meaning of the header `<cfenv>` are the same as the C
 standard library header `<fenv.h>`.
-[*Note 1*: This International Standard does not require an
-implementation to support the `FENV_ACCESS` pragma; it is
-*implementation-defined* ([[cpp.pragma]]) whether the pragma is
-supported. As a consequence, it is *implementation-defined* whether
-these functions can be used to test floating-point status flags, set
-floating-point control modes, or run under non-default mode settings. If
-the pragma is used to enable control over the floating-point
-environment, this International Standard does not specify the effect on
-floating-point evaluation in constant expressions. — *end note*]
-The floating-point environment has thread storage duration (
-[[basic.stc.thread]]). The initial state for a thread’s floating-point
 environment is the state of the floating-point environment of the thread
-that constructs the corresponding `thread` object (
-[[thread.thread.class]]) at the time it constructed the object.
 [*Note 2*: That is, the child thread gets the floating-point state of
 the parent thread at the time of the child’s creation. — *end note*]
-A separate floating-point environment shall be maintained for each
-thread. Each function accesses the environment corresponding to its
-calling thread.
-ISO C 7.6
 ## Complex numbers <a id="complex.numbers">[[complex.numbers]]</a>
 The header `<complex>` defines a class template, and numerous functions
 for representing and manipulating complex numbers.
 The effect of instantiating the template `complex` for any type other
 than `float`, `double`, or `long double` is unspecified. The
 specializations `complex<float>`, `complex<double>`, and
-`complex<long double>` are literal types ([[basic.types]]).
 If the result of a function is not mathematically defined or not in the
 range of representable values for its type, the behavior is undefined.
-If `z` is an lvalue expression of type cv `complex<T>` then:
-- the expression `reinterpret_cast<cv T(&)[2]>(z)` shall be well-formed,
-- `reinterpret_cast<cv T(&)[2]>(z)[0]` shall designate the real part of
- `z`, and
-- `reinterpret_cast<cv T(&)[2]>(z)[1]` shall designate the imaginary
- part of `z`.
 Moreover, if `a` is an expression of type cv `complex<T>*` and the
 expression `a[i]` is well-defined for an integer expression `i`, then:
-- `reinterpret_cast<cv T*>(a)[2*i]` shall designate the real part of
- `a[i]`, and
-- `reinterpret_cast<cv T*>(a)[2*i + 1]` shall designate the imaginary
- part of `a[i]`.
 ### Header `<complex>` synopsis <a id="complex.syn">[[complex.syn]]</a>
 ``` cpp
 namespace std {
   template<class T> class complex;
   template<> class complex<float>;
   template<> class complex<double>;
   template<> class complex<long double>;
   // [complex.ops], operators
-  template<class T>
- complex<T> operator+(const complex<T>&, const complex<T>&);
-  template<class T> complex<T> operator+(const complex<T>&, const T&);
-  template<class T> complex<T> operator+(const T&, const complex<T>&);
-  template<class T> complex<T> operator-(
-    const complex<T>&, const complex<T>&);
-  template<class T> complex<T> operator-(const complex<T>&, const T&);
-  template<class T> complex<T> operator-(const T&, const complex<T>&);
-  template<class T> complex<T> operator*(
-    const complex<T>&, const complex<T>&);
-  template<class T> complex<T> operator*(const complex<T>&, const T&);
-  template<class T> complex<T> operator*(const T&, const complex<T>&);
-  template<class T> complex<T> operator/(
-    const complex<T>&, const complex<T>&);
-  template<class T> complex<T> operator/(const complex<T>&, const T&);
-  template<class T> complex<T> operator/(const T&, const complex<T>&);
-  template<class T> complex<T> operator+(const complex<T>&);
-  template<class T> complex<T> operator-(const complex<T>&);
-  template<class T> constexpr bool operator==(
-    const complex<T>&, const complex<T>&);
   template<class T> constexpr bool operator==(const complex<T>&, const T&);
-  template<class T> constexpr bool operator==(const T&, const complex<T>&);
-  template<class T> constexpr bool operator!=(const complex<T>&, const complex<T>&);
-  template<class T> constexpr bool operator!=(const complex<T>&, const T&);
-  template<class T> constexpr bool operator!=(const T&, const complex<T>&);
   template<class T, class charT, class traits>
- basic_istream<charT, traits>&
-  operator>>(basic_istream<charT, traits>&, complex<T>&);
   template<class T, class charT, class traits>
- basic_ostream<charT, traits>&
-  operator<<(basic_ostream<charT, traits>&, const complex<T>&);
   // [complex.value.ops], values
   template<class T> constexpr T real(const complex<T>&);
   template<class T> constexpr T imag(const complex<T>&);
   template<class T> T abs(const complex<T>&);
   template<class T> T arg(const complex<T>&);
-  template<class T> T norm(const complex<T>&);
-  template<class T> complex<T> conj(const complex<T>&);
   template<class T> complex<T> proj(const complex<T>&);
-  template<class T> complex<T> polar(const T&, const T& = 0);
   // [complex.transcendentals], transcendentals
   template<class T> complex<T> acos(const complex<T>&);
   template<class T> complex<T> asin(const complex<T>&);
   template<class T> complex<T> atan(const complex<T>&);
@@ -300,148 +239,148 @@ namespace std {
 ### Class template `complex` <a id="complex">[[complex]]</a>
 ``` cpp
 namespace std {
-  template<class T>
-  class complex {
   public:
     using value_type = T;
     constexpr complex(const T& re = T(), const T& im = T());
     constexpr complex(const complex&);
     template<class X> constexpr complex(const complex<X>&);
     constexpr T real() const;
-    void real(T);
     constexpr T imag() const;
-    void imag(T);
-    complex<T>& operator= (const T&);
-    complex<T>& operator+=(const T&);
-    complex<T>& operator-=(const T&);
-    complex<T>& operator*=(const T&);
-    complex<T>& operator/=(const T&);
-    complex& operator=(const complex&);
-    template<class X> complex<T>& operator= (const complex<X>&);
-    template<class X> complex<T>& operator+=(const complex<X>&);
-    template<class X> complex<T>& operator-=(const complex<X>&);
-    template<class X> complex<T>& operator*=(const complex<X>&);
-    template<class X> complex<T>& operator/=(const complex<X>&);
   };
 }
 ```
 The class `complex` describes an object that can store the Cartesian
 components, `real()` and `imag()`, of a complex number.
-### `complex` specializations <a id="complex.special">[[complex.special]]</a>
 ``` cpp
 namespace std {
   template<> class complex<float> {
   public:
     using value_type = float;
     constexpr complex(float re = 0.0f, float im = 0.0f);
     constexpr explicit complex(const complex<double>&);
     constexpr explicit complex(const complex<long double>&);
     constexpr float real() const;
-    void real(float);
     constexpr float imag() const;
-    void imag(float);
-    complex<float>& operator= (float);
-    complex<float>& operator+=(float);
-    complex<float>& operator-=(float);
-    complex<float>& operator*=(float);
-    complex<float>& operator/=(float);
-    complex<float>& operator=(const complex<float>&);
-    template<class X> complex<float>& operator= (const complex<X>&);
-    template<class X> complex<float>& operator+=(const complex<X>&);
-    template<class X> complex<float>& operator-=(const complex<X>&);
-    template<class X> complex<float>& operator*=(const complex<X>&);
-    template<class X> complex<float>& operator/=(const complex<X>&);
   };
   template<> class complex<double> {
   public:
     using value_type = double;
     constexpr complex(double re = 0.0, double im = 0.0);
     constexpr complex(const complex<float>&);
     constexpr explicit complex(const complex<long double>&);
     constexpr double real() const;
-    void real(double);
     constexpr double imag() const;
-    void imag(double);
-    complex<double>& operator= (double);
-    complex<double>& operator+=(double);
-    complex<double>& operator-=(double);
-    complex<double>& operator*=(double);
-    complex<double>& operator/=(double);
-    complex<double>& operator=(const complex<double>&);
-    template<class X> complex<double>& operator= (const complex<X>&);
-    template<class X> complex<double>& operator+=(const complex<X>&);
-    template<class X> complex<double>& operator-=(const complex<X>&);
-    template<class X> complex<double>& operator*=(const complex<X>&);
-    template<class X> complex<double>& operator/=(const complex<X>&);
   };
   template<> class complex<long double> {
   public:
     using value_type = long double;
     constexpr complex(long double re = 0.0L, long double im = 0.0L);
     constexpr complex(const complex<float>&);
     constexpr complex(const complex<double>&);
     constexpr long double real() const;
-    void real(long double);
     constexpr long double imag() const;
-    void imag(long double);
- complex<long double>& operator=(const complex<long double>&);
- complex<long double>& operator= (long double);
- complex<long double>& operator+=(long double);
- complex<long double>& operator-=(long double);
- complex<long double>& operator*=(long double);
-    complex<long double>& operator/=(long double);
- template<class X> complex<long double>& operator= (const complex<X>&);
-    template<class X> complex<long double>& operator+=(const complex<X>&);
-    template<class X> complex<long double>& operator-=(const complex<X>&);
-    template<class X> complex<long double>& operator*=(const complex<X>&);
-    template<class X> complex<long double>& operator/=(const complex<X>&);
   };
 }
 ```
-### `complex` member functions <a id="complex.members">[[complex.members]]</a>
 ``` cpp
 template<class T> constexpr complex(const T& re = T(), const T& im = T());
 ```
-*Effects:* Constructs an object of class `complex`.
-*Postconditions:* `real() == re && imag() == im`.
 ``` cpp
 constexpr T real() const;
 ```
 *Returns:* The value of the real component.
 ``` cpp
-void real(T val);
 ```
 *Effects:* Assigns `val` to the real component.
 ``` cpp
@@ -449,185 +388,170 @@ constexpr T imag() const;
 ```
 *Returns:* The value of the imaginary component.
 ``` cpp
-void imag(T val);
 ```
 *Effects:* Assigns `val` to the imaginary component.
-### `complex` member operators <a id="complex.member.ops">[[complex.member.ops]]</a>
 ``` cpp
-complex<T>& operator+=(const T& rhs);
 ```
 *Effects:* Adds the scalar value `rhs` to the real part of the complex
 value `*this` and stores the result in the real part of `*this`, leaving
 the imaginary part unchanged.
 *Returns:* `*this`.
 ``` cpp
-complex<T>& operator-=(const T& rhs);
 ```
 *Effects:* Subtracts the scalar value `rhs` from the real part of the
 complex value `*this` and stores the result in the real part of `*this`,
 leaving the imaginary part unchanged.
 *Returns:* `*this`.
 ``` cpp
-complex<T>& operator*=(const T& rhs);
 ```
 *Effects:* Multiplies the scalar value `rhs` by the complex value
 `*this` and stores the result in `*this`.
 *Returns:* `*this`.
 ``` cpp
-complex<T>& operator/=(const T& rhs);
 ```
 *Effects:* Divides the scalar value `rhs` into the complex value `*this`
 and stores the result in `*this`.
 *Returns:* `*this`.
 ``` cpp
-template<class X> complex<T>& operator+=(const complex<X>& rhs);
 ```
 *Effects:* Adds the complex value `rhs` to the complex value `*this` and
 stores the sum in `*this`.
 *Returns:* `*this`.
 ``` cpp
-template<class X> complex<T>& operator-=(const complex<X>& rhs);
 ```
 *Effects:* Subtracts the complex value `rhs` from the complex value
 `*this` and stores the difference in `*this`.
 *Returns:* `*this`.
 ``` cpp
-template<class X> complex<T>& operator*=(const complex<X>& rhs);
 ```
 *Effects:* Multiplies the complex value `rhs` by the complex value
 `*this` and stores the product in `*this`.
 *Returns:* `*this`.
 ``` cpp
-template<class X> complex<T>& operator/=(const complex<X>& rhs);
 ```
 *Effects:* Divides the complex value `rhs` into the complex value
 `*this` and stores the quotient in `*this`.
 *Returns:* `*this`.
-### `complex` non-member operations <a id="complex.ops">[[complex.ops]]</a>
 ``` cpp
-template<class T> complex<T> operator+(const complex<T>& lhs);
 ```
 *Returns:* `complex<T>(lhs)`.
-*Remarks:* unary operator.
 ``` cpp
-template<class T> complex<T> operator+(const complex<T>& lhs, const complex<T>& rhs);
-template<class T> complex<T> operator+(const complex<T>& lhs, const T& rhs);
-template<class T> complex<T> operator+(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `complex<T>(lhs) += rhs`.
 ``` cpp
-template<class T> complex<T> operator-(const complex<T>& lhs);
 ```
 *Returns:* `complex<T>(-lhs.real(),-lhs.imag())`.
-*Remarks:* unary operator.
 ``` cpp
-template<class T> complex<T> operator-(const complex<T>& lhs, const complex<T>& rhs);
-template<class T> complex<T> operator-(const complex<T>& lhs, const T& rhs);
-template<class T> complex<T> operator-(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `complex<T>(lhs) -= rhs`.
 ``` cpp
-template<class T> complex<T> operator*(const complex<T>& lhs, const complex<T>& rhs);
-template<class T> complex<T> operator*(const complex<T>& lhs, const T& rhs);
-template<class T> complex<T> operator*(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `complex<T>(lhs) *= rhs`.
 ``` cpp
-template<class T> complex<T> operator/(const complex<T>& lhs, const complex<T>& rhs);
-template<class T> complex<T> operator/(const complex<T>& lhs, const T& rhs);
-template<class T> complex<T> operator/(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `complex<T>(lhs) /= rhs`.
 ``` cpp
 template<class T> constexpr bool operator==(const complex<T>& lhs, const complex<T>& rhs);
 template<class T> constexpr bool operator==(const complex<T>& lhs, const T& rhs);
-template<class T> constexpr bool operator==(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `lhs.real() == rhs.real() && lhs.imag() == rhs.imag()`.
 *Remarks:* The imaginary part is assumed to be `T()`, or 0.0, for the
 `T` arguments.
-``` cpp
-template<class T> constexpr bool operator!=(const complex<T>& lhs, const complex<T>& rhs);
-template<class T> constexpr bool operator!=(const complex<T>& lhs, const T& rhs);
-template<class T> constexpr bool operator!=(const T& lhs, const complex<T>& rhs);
-```
-*Returns:* `rhs.real() != lhs.real() || rhs.imag() != lhs.imag()`.
 ``` cpp
 template<class T, class charT, class traits>
-basic_istream<charT, traits>&
-operator>>(basic_istream<charT, traits>& is, complex<T>& x);
 ```
-*Requires:* The input values shall be convertible to `T`.
 *Effects:* Extracts a complex number `x` of the form: `u`, `(u)`, or
 `(u,v)`, where `u` is the real part and `v` is the imaginary
-part ([[istream.formatted]]).
 If bad input is encountered, calls `is.setstate(ios_base::failbit)`
-(which may throw `ios::failure` ([[iostate.flags]])).
 *Returns:* `is`.
 *Remarks:* This extraction is performed as a series of simpler
 extractions. Therefore, the skipping of whitespace is specified to be
 the same for each of the simpler extractions.
 ``` cpp
 template<class T, class charT, class traits>
-basic_ostream<charT, traits>&
-operator<<(basic_ostream<charT, traits>& o, const complex<T>& x);
 ```
 *Effects:* Inserts the complex number `x` onto the stream `o` as if it
 were implemented as follows:
@@ -644,11 +568,11 @@ return o << s.str();
 character, the use of comma as a field separator can be ambiguous.
 Inserting `showpoint` into the output stream forces all outputs to show
 an explicit decimal point character; as a result, all inserted sequences
 of complex numbers can be extracted unambiguously. — *end note*]
-### `complex` value operations <a id="complex.value.ops">[[complex.value.ops]]</a>
 ``` cpp
 template<class T> constexpr T real(const complex<T>& x);
 ```
@@ -671,89 +595,94 @@ template<class T> T arg(const complex<T>& x);
 ```
 *Returns:* The phase angle of `x`, or `atan2(imag(x), real(x))`.
 ``` cpp
-template<class T> T norm(const complex<T>& x);
 ```
 *Returns:* The squared magnitude of `x`.
 ``` cpp
-template<class T> complex<T> conj(const complex<T>& x);
 ```
 *Returns:* The complex conjugate of `x`.
 ``` cpp
 template<class T> complex<T> proj(const complex<T>& x);
 ```
 *Returns:* The projection of `x` onto the Riemann sphere.
-*Remarks:* Behaves the same as the C function `cproj`, defined in
-7.3.9.4.
 ``` cpp
-template<class T> complex<T> polar(const T& rho, const T& theta = 0);
 ```
-*Requires:* `rho` shall be non-negative and non-NaN. `theta` shall be
-finite.
 *Returns:* The `complex` value corresponding to a complex number whose
 magnitude is `rho` and whose phase angle is `theta`.
-### `complex` transcendentals <a id="complex.transcendentals">[[complex.transcendentals]]</a>
 ``` cpp
 template<class T> complex<T> acos(const complex<T>& x);
 ```
 *Returns:* The complex arc cosine of `x`.
-*Remarks:* Behaves the same as C function `cacos`, defined in 7.3.5.1.
 ``` cpp
 template<class T> complex<T> asin(const complex<T>& x);
 ```
 *Returns:* The complex arc sine of `x`.
-*Remarks:* Behaves the same as C function `casin`, defined in 7.3.5.2.
 ``` cpp
 template<class T> complex<T> atan(const complex<T>& x);
 ```
 *Returns:* The complex arc tangent of `x`.
-*Remarks:* Behaves the same as C function `catan`, defined in 7.3.5.3.
 ``` cpp
 template<class T> complex<T> acosh(const complex<T>& x);
 ```
 *Returns:* The complex arc hyperbolic cosine of `x`.
-*Remarks:* Behaves the same as C function `cacosh`, defined in 7.3.6.1.
 ``` cpp
 template<class T> complex<T> asinh(const complex<T>& x);
 ```
 *Returns:* The complex arc hyperbolic sine of `x`.
-*Remarks:* Behaves the same as C function `casinh`, defined in 7.3.6.2.
 ``` cpp
 template<class T> complex<T> atanh(const complex<T>& x);
 ```
 *Returns:* The complex arc hyperbolic tangent of `x`.
-*Remarks:* Behaves the same as C function `catanh`, defined in 7.3.6.3.
 ``` cpp
 template<class T> complex<T> cos(const complex<T>& x);
 ```
@@ -774,12 +703,14 @@ template<class T> complex<T> exp(const complex<T>& x);
 ``` cpp
 template<class T> complex<T> log(const complex<T>& x);
 ```
 *Returns:* The complex natural (base-e) logarithm of `x`. For all `x`,
-`imag(log(x))` lies in the interval \[-π, π\], and when `x` is a
-negative real number, `imag(log(x))` is π.
 *Remarks:* The branch cuts are along the negative real axis.
 ``` cpp
 template<class T> complex<T> log10(const complex<T>& x);
@@ -817,12 +748,14 @@ template<class T> complex<T> sinh(const complex<T>& x);
 ``` cpp
 template<class T> complex<T> sqrt(const complex<T>& x);
 ```
 *Returns:* The complex square root of `x`, in the range of the right
-half-plane. If the argument is a negative real number, the value
-returned lies on the positive imaginary axis.
 *Remarks:* The branch cuts are along the negative real axis.
 ``` cpp
 template<class T> complex<T> tan(const complex<T>& x);
@@ -844,38 +777,40 @@ The following function templates shall have additional overloads:
 arg                   norm
 conj                  proj
 imag                  real
 ```
 The additional overloads shall be sufficient to ensure:
-1.  If the argument has type `long double`, then it is effectively cast
-    to `complex<long double>`.
-2.  Otherwise, if the argument has type `double` or an integer type,
-    then it is effectively cast to `complex<{}double>`.
-3.  Otherwise, if the argument has type `float`, then it is effectively
   cast to `complex<float>`.
 Function template `pow` shall have additional overloads sufficient to
 ensure, for a call with at least one argument of type `complex<T>`:
-1.  If either argument has type `complex<long double>` or type `long
           double`, then both arguments are effectively cast to
   `complex<long double>`.
-2.  Otherwise, if either argument has type `complex<double>`, `double`,
-    or an integer type, then both arguments are effectively cast to
   `complex<double>`.
-3.  Otherwise, if either argument has type `complex<float>` or `float`,
   then both arguments are effectively cast to `complex<float>`.
 ### Suffixes for complex number literals <a id="complex.literals">[[complex.literals]]</a>
-This section describes literal suffixes for constructing complex number
-literals. The suffixes `i`, `il`, and `if` create complex numbers of the
-types `complex<double>`, `complex<long double>`, and `complex<float>`
-respectively, with their imaginary part denoted by the given literal
-number and the real part being zero.
 ``` cpp
 constexpr complex<long double> operator""il(long double d);
 constexpr complex<long double> operator""il(unsigned long long d);
 ```
@@ -894,57 +829,482 @@ constexpr complex<float> operator""if(long double d);
 constexpr complex<float> operator""if(unsigned long long d);
 ```
 *Returns:* `complex<float>{0.0f, static_cast<float>(d)}`.
 ## Random number generation <a id="rand">[[rand]]</a>
 This subclause defines a facility for generating (pseudo-)random
 numbers.
 In addition to a few utilities, four categories of entities are
 described: *uniform random bit generators*, *random number engines*,
 *random number engine adaptors*, and *random number distributions*.
-These categorizations are applicable to types that satisfy the
 corresponding requirements, to objects instantiated from such types, and
 to templates producing such types when instantiated.
 [*Note 1*: These entities are specified in such a way as to permit the
 binding of any uniform random bit generator object `e` as the argument
 to any random number distribution object `d`, thus producing a
 zero-argument function object such as given by
 `bind(d,e)`. — *end note*]
 Each of the entities specified via this subclause has an associated
-arithmetic type ([[basic.fundamental]]) identified as `result_type`.
-With `T` as the `result_type` thus associated with such an entity, that
 entity is characterized:
 If integer-valued, an entity may optionally be further characterized as
 *signed* or *unsigned*, according to `numeric_limits<T>::is_signed`.
 Unless otherwise specified, all descriptions of calculations in this
 subclause use mathematical real numbers.
-Throughout this subclause, the operators , , and denote the respective
-conventional bitwise operations. Further:
 ### Requirements <a id="rand.req">[[rand.req]]</a>
 #### General requirements <a id="rand.req.genl">[[rand.req.genl]]</a>
 Throughout this subclause [[rand]], the effect of instantiating a
 template:
 Throughout this subclause [[rand]], phrases of the form “`x` is an
 iterator of a specific kind” shall be interpreted as equivalent to the
-more formal requirement that “`x` is a value of a type satisfying the
 requirements of the specified iterator type”.
 Throughout this subclause [[rand]], any constructor that can be called
-with a single argument and that satisfies a requirement specified in
-this subclause shall be declared `explicit`.
 #### Seed sequence requirements <a id="rand.req.seedseq">[[rand.req.seedseq]]</a>
 A *seed sequence* is an object that consumes a sequence of
 integer-valued data and produces a requested number of unsigned integer
@@ -953,61 +1313,105 @@ values i, 0 ≤ i < 2³², based on the consumed data.
 [*Note 1*: Such an object provides a mechanism to avoid replication of
 streams of random variates. This can be useful, for example, in
 applications requiring large numbers of random number
 engines. — *end note*]
-A class `S` satisfies the requirements of a seed sequence if the
-expressions shown in Table  [[tab:SeedSequence]] are valid and have the
-indicated semantics, and if `S` also satisfies all other requirements of
-this section [[rand.req.seedseq]]. In that Table and throughout this
-section:
 #### Uniform random bit generator requirements <a id="rand.req.urng">[[rand.req.urng]]</a>
 A *uniform random bit generator* `g` of type `G` is a function object
 returning unsigned integer values such that each value in the range of
 possible results has (ideally) equal probability of being returned.
 [*Note 1*: The degree to which `g`’s results approximate the ideal is
 often determined statistically. — *end note*]
-A class `G` satisfies the requirements of a *uniform random bit
-generator* if the expressions shown in Table
-[[tab:UniformRandomBitGenerator]] are valid and have the indicated
-semantics, and if `G` also satisfies all other requirements of this
-section [[rand.req.urng]]. In that Table and throughout this section:
-The following relation shall hold: `G::min() < G::max()`.
 #### Random number engine requirements <a id="rand.req.eng">[[rand.req.eng]]</a>
 A *random number engine* (commonly shortened to *engine*) `e` of type
 `E` is a uniform random bit generator that additionally meets the
 requirements (e.g., for seeding and for input/output) specified in this
-section.
 At any given time, `e` has a state eᵢ for some integer i ≥ 0. Upon
 construction, `e` has an initial state e₀. An engine’s state may be
 established via a constructor, a `seed` function, assignment, or a
 suitable `operator>>`.
 `E`’s specification shall define:
-A class `E` that satisfies the requirements of a uniform random bit
-generator ([[rand.req.urng]]) also satisfies the requirements of a
-*random number engine* if the expressions shown in Table
-[[tab:RandomEngine]] are valid and have the indicated semantics, and if
-`E` also satisfies all other requirements of this section
-[[rand.req.eng]]. In that Table and throughout this section:
-where `charT` and `traits` are constrained according to Clause
-[[strings]] and Clause  [[input.output]].
-`E` shall meet the requirements of `CopyConstructible` (Table
-[[tab:copyconstructible]]) and `CopyAssignable` (Table
-[[tab:copyassignable]]) types. These operations shall each be of
-complexity no worse than 𝑂(\mbox{size of state}).
 #### Random number engine adaptor requirements <a id="rand.req.adapt">[[rand.req.adapt]]</a>
 A *random number engine adaptor* (commonly shortened to *adaptor*) `a`
 of type `A` is a random number engine that takes values produced by some
@@ -1062,11 +1466,20 @@ void seed(result_type s);
 template<class Sseq> void seed(Sseq& q);
 ```
 *Effects:* With `b` as the base engine, invokes `b.seed(q)`.
-`A` shall also satisfy the following additional requirements:
 #### Random number distribution requirements <a id="rand.req.dist">[[rand.req.dist]]</a>
 A *random number distribution* (commonly shortened to *distribution*)
 `d` of type `D` is a function object returning values that are
@@ -1081,22 +1494,38 @@ distribution*. Such distribution parameters are identified in this
 context by writing, for example, p(z | a,b) or P(zᵢ | a,b), to name
 specific parameters, or by writing, for example, p(z |{`p`}) or
 P(zᵢ |{`p`}), to denote a distribution’s parameters `p` taken as a
 whole.
-A class `D` satisfies the requirements of a *random number distribution*
-if the expressions shown in Table  [[tab:RandomDistribution]] are valid
-and have the indicated semantics, and if `D` and its associated types
-also satisfy all other requirements of this section [[rand.req.dist]].
-In that Table and throughout this section,
-where `charT` and `traits` are constrained according to Clauses
-[[strings]] and [[input.output]].
-`D` shall satisfy the requirements of `CopyConstructible` (Table
-[[tab:copyconstructible]]) and `CopyAssignable` (Table
-[[tab:copyassignable]]) types.
 The sequence of numbers produced by repeated invocations of `d(g)` shall
 be independent of any invocation of `os << d` or of any `const` member
 function of `D` between any of the invocations `d(g)`.
@@ -1109,14 +1538,14 @@ produce the same sequence of numbers as would repeated invocations of
 It is unspecified whether `D::param_type` is declared as a (nested)
 `class` or via a `typedef`. In this subclause [[rand]], declarations of
 `D::param_type` are in the form of `typedef`s for convenience of
 exposition only.
-`P` shall satisfy the requirements of `CopyConstructible` (Table
-[[tab:copyconstructible]]), `CopyAssignable` (Table
-[[tab:copyassignable]]), and `EqualityComparable` (Table
-[[tab:equalitycomparable]]) types.
 For each of the constructors of `D` taking arguments corresponding to
 parameters of the distribution, `P` shall have a corresponding
 constructor subject to the same requirements and taking arguments
 identical in number, type, and default values. Moreover, for each of the
@@ -1128,178 +1557,41 @@ the identical name, type, and semantics.
 ``` cpp
 using distribution_type =  D;
 ```
-### Header `<random>` synopsis <a id="rand.synopsis">[[rand.synopsis]]</a>
-``` cpp
-#include <initializer_list>
-namespace std {
-  // [rand.eng.lcong], class template linear_congruential_engine
-  template<class UIntType, UIntType a, UIntType c, UIntType m>
-    class linear_congruential_engine;
-  // [rand.eng.mers], class template mersenne_twister_engine
-  template<class UIntType, size_t w, size_t n, size_t m, size_t r,
-           UIntType a, size_t u, UIntType d, size_t s,
-           UIntType b, size_t t,
-           UIntType c, size_t l, UIntType f>
-    class mersenne_twister_engine;
-  // [rand.eng.sub], class template subtract_with_carry_engine
-  template<class UIntType, size_t w, size_t s, size_t r>
-    class subtract_with_carry_engine;
-  // [rand.adapt.disc], class template discard_block_engine
-  template<class Engine, size_t p, size_t r>
-    class discard_block_engine;
-  // [rand.adapt.ibits], class template independent_bits_engine
-  template<class Engine, size_t w, class UIntType>
-    class independent_bits_engine;
-  // [rand.adapt.shuf], class template shuffle_order_engine
-  template<class Engine, size_t k>
-    class shuffle_order_engine;
-  // [rand.predef], engines and engine adaptors with predefined parameters
-  using minstd_rand0  = see below;
-  using minstd_rand   = see below;
-  using mt19937       = see below;
-  using mt19937_64    = see below;
-  using ranlux24_base = see below;
-  using ranlux48_base = see below;
-  using ranlux24      = see below;
-  using ranlux48      = see below;
-  using knuth_b       = see below;
-  using default_random_engine = see below;
-  // [rand.device], class random_device
-  class random_device;
-  // [rand.util.seedseq], class seed_seq
-  class seed_seq;
-  // [rand.util.canonical], function template generate_canonical
-  template<class RealType, size_t bits, class URBG>
-    RealType generate_canonical(URBG& g);
-  // [rand.dist.uni.int], class template uniform_int_distribution
-  template<class IntType = int>
-    class uniform_int_distribution;
-  // [rand.dist.uni.real], class template uniform_real_distribution
-  template<class RealType = double>
-    class uniform_real_distribution;
-  // [rand.dist.bern.bernoulli], class bernoulli_distribution
-  class bernoulli_distribution;
-  // [rand.dist.bern.bin], class template binomial_distribution
-  template<class IntType = int>
-    class binomial_distribution;
-  // [rand.dist.bern.geo], class template geometric_distribution
-  template<class IntType = int>
-    class geometric_distribution;
-  // [rand.dist.bern.negbin], class template negative_binomial_distribution
-  template<class IntType = int>
-    class negative_binomial_distribution;
-  // [rand.dist.pois.poisson], class template poisson_distribution
-  template<class IntType = int>
-    class poisson_distribution;
-  // [rand.dist.pois.exp], class template exponential_distribution
-  template<class RealType = double>
-    class exponential_distribution;
-  // [rand.dist.pois.gamma], class template gamma_distribution
-  template<class RealType = double>
-    class gamma_distribution;
-  // [rand.dist.pois.weibull], class template weibull_distribution
-  template<class RealType = double>
-    class weibull_distribution;
-  // [rand.dist.pois.extreme], class template extreme_value_distribution
-  template<class RealType = double>
-    class extreme_value_distribution;
-  // [rand.dist.norm.normal], class template normal_distribution
-  template<class RealType = double>
-    class normal_distribution;
-  // [rand.dist.norm.lognormal], class template lognormal_distribution
-  template<class RealType = double>
-    class lognormal_distribution;
-  // [rand.dist.norm.chisq], class template chi_squared_distribution
-  template<class RealType = double>
-    class chi_squared_distribution;
-  // [rand.dist.norm.cauchy], class template cauchy_distribution
-  template<class RealType = double>
-    class cauchy_distribution;
-  // [rand.dist.norm.f], class template fisher_f_distribution
-  template<class RealType = double>
-    class fisher_f_distribution;
-  // [rand.dist.norm.t], class template student_t_distribution
-  template<class RealType = double>
-    class student_t_distribution;
-  // [rand.dist.samp.discrete], class template discrete_distribution
-  template<class IntType = int>
-    class discrete_distribution;
-  // [rand.dist.samp.pconst], class template piecewise_constant_distribution
-  template<class RealType = double>
-    class piecewise_constant_distribution;
-  // [rand.dist.samp.plinear], class template piecewise_linear_distribution
-  template<class RealType = double>
-    class piecewise_linear_distribution;
-}
-```
 ### Random number engine class templates <a id="rand.eng">[[rand.eng]]</a>
-Each type instantiated from a class template specified in this section
-[[rand.eng]] satisfies the requirements of a random number engine (
-[[rand.req.eng]]) type.
 Except where specified otherwise, the complexity of each function
-specified in this section  [[rand.eng]] is constant.
-Except where specified otherwise, no function described in this section
-[[rand.eng]] throws an exception.
-Every function described in this section  [[rand.eng]] that has a
 function parameter `q` of type `Sseq&` for a template type parameter
 named `Sseq` that is different from type `seed_seq` throws what and when
 the invocation of `q.generate` throws.
-Descriptions are provided in this section  [[rand.eng]] only for engine
-operations that are not described in [[rand.req.eng]] or for operations
-where there is additional semantic information. In particular,
-declarations for copy constructors, for copy assignment operators, for
-streaming operators, and for equality and inequality operators are not
-shown in the synopses.
-Each template specified in this section  [[rand.eng]] requires one or
 more relationships, involving the value(s) of its non-type template
 parameter(s), to hold. A program instantiating any of these templates is
 ill-formed if any such required relationship fails to hold.
 For every random number engine and for every random number engine
-adaptor `X` defined in this subclause ([[rand.eng]]) and in subclause
 [[rand.adapt]]:
 - if the constructor
   ``` cpp
   template<class Sseq> explicit X(Sseq& q);
@@ -1343,11 +1635,12 @@ template<class UIntType, UIntType a, UIntType c, UIntType m>
     static constexpr result_type min() { return c == 0u ? 1u: 0u; }
     static constexpr result_type max() { return m - 1u; }
     static constexpr result_type default_seed = 1u;
     // constructors and seeding functions
- explicit linear_congruential_engine(result_type s = default_seed);
     template<class Sseq> explicit linear_congruential_engine(Sseq& q);
     void seed(result_type s = default_seed);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
@@ -1355,41 +1648,38 @@ template<class UIntType, UIntType a, UIntType c, UIntType m>
     void discard(unsigned long long z);
   };
 ```
 If the template parameter `m` is 0, the modulus m used throughout this
-section  [[rand.eng.lcong]] is `numeric_limits<result_type>::max()` plus
-1.
 [*Note 1*: m need not be representable as a value of type
 `result_type`. — *end note*]
 If the template parameter `m` is not 0, the following relations shall
 hold: `a < m` and `c < m`.
 The textual representation consists of the value of xᵢ.
 ``` cpp
-explicit linear_congruential_engine(result_type s = default_seed);
 ```
-*Effects:* Constructs a `linear_congruential_engine` object. If
-c  mod  m is 0 and `s`  mod  m is 0, sets the engine’s state to 1,
-otherwise sets the engine’s state to `s`  mod  m.
 ``` cpp
 template<class Sseq> explicit linear_congruential_engine(Sseq& q);
 ```
-*Effects:* Constructs a `linear_congruential_engine` object. With
-$k = \left\lceil \frac{\log_2 m}
-                        {32}
- \right\rceil$ and a an array (or equivalent) of length
-k + 3, invokes `q.generate(`a+0`, `a+k+3`)` and then computes
-$S = \left(\sum_{j=0}^{k-1}a_{j+3} \cdot 2^{32j} \right) \bmod m$. If
-c  mod  m is 0 and S is 0, sets the engine’s state to 1, else sets the
-engine’s state to S.
 #### Class template `mersenne_twister_engine` <a id="rand.eng.mers">[[rand.eng.mers]]</a>
 A `mersenne_twister_engine` random number engine[^2] produces unsigned
 integer random numbers in the closed interval [0,2ʷ-1]. The state xᵢ of
@@ -1399,21 +1689,31 @@ applied to X are to be taken modulo n.
 The transition algorithm employs a twisted generalized feedback shift
 register defined by shift values n and m, a twist value r, and a
 conditional xor-mask a. To improve the uniformity of the result, the
 bits of the raw shift register are additionally *tempered* (i.e.,
-scrambled) according to a bit-scrambling matrix defined by values
-u, d, s, b, t, c, and ℓ.
 The state transition is performed as follows:
 The sequence X is initialized with the help of an initialization
 multiplier f.
 The generation algorithm determines the unsigned integer values
 z₁, z₂, z₃, z₄ as follows, then delivers z₄ as its result:
 ``` cpp
 template<class UIntType, size_t w, size_t n, size_t m, size_t r,
          UIntType a, size_t u, UIntType d, size_t s,
          UIntType b, size_t t,
          UIntType c, size_t l, UIntType f>
@@ -1439,11 +1739,12 @@ template<class UIntType, size_t w, size_t n, size_t m, size_t r,
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return  2^w - 1; }
     static constexpr result_type default_seed = 5489u;
     // constructors and seeding functions
- explicit mersenne_twister_engine(result_type value = default_seed);
     template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
@@ -1457,18 +1758,18 @@ The following relations shall hold: `0 < m`, `m <= n`, `2u < w`,
 `w <= numeric_limits<UIntType>::digits`, `a <= (1u<<w) - 1u`,
 `b <= (1u<<w) - 1u`, `c <= (1u<<w) - 1u`, `d <= (1u<<w) - 1u`, and
 `f <= (1u<<w) - 1u`.
 The textual representation of xᵢ consists of the values of
-Xᵢ₋ₙ, …, Xᵢ₋₁, in that order.
 ``` cpp
-explicit mersenne_twister_engine(result_type value = default_seed);
 ```
-*Effects:* Constructs a `mersenne_twister_engine` object. Sets X₋ₙ to
-`value`  mod  2ʷ. Then, iteratively for i = 1-n,…,-1, sets Xᵢ to $$%
  \bigl[f \cdot
        \bigl(X_{i-1} \xor \bigl(X_{i-1} \rightshift (w-2)\bigr)
        \bigr)
        + i \bmod n
  \bigr] \bmod 2^w
@@ -1478,14 +1779,13 @@ explicit mersenne_twister_engine(result_type value = default_seed);
 ``` cpp
 template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
 ```
-*Effects:* Constructs a `mersenne_twister_engine` object. With
-k = ⌈ w / 32 ⌉ and a an array (or equivalent) of length n ⋅ k, invokes
-`q.generate(`a+0`, `a+n ⋅ k`)` and then, iteratively for i = -n,…,-1,
-sets Xᵢ to
 $\left(\sum_{j=0}^{k-1}a_{k(i+n)+j} \cdot 2^{32j} \right) \bmod 2^w$.
 Finally, if the most significant w-r bits of X₋ₙ are zero, and if each
 of the other resulting Xᵢ is 0, changes X₋ₙ to 2ʷ⁻¹.
 #### Class template `subtract_with_carry_engine` <a id="rand.eng.sub">[[rand.eng.sub]]</a>
@@ -1499,10 +1799,13 @@ all subscripts applied to X are to be taken modulo r. The state xᵢ
 additionally consists of an integer c (known as the *carry*) whose value
 is either 0 or 1.
 The state transition is performed as follows:
 [*Note 1*: This algorithm corresponds to a modular linear function of
 the form TA(xᵢ) = (a ⋅ xᵢ)  mod  b, where b is of the form mʳ - mˢ + 1
 and a = b - (b - 1) / m. — *end note*]
 The generation algorithm is given by GA(xᵢ) = y, where y is the value
@@ -1522,11 +1825,12 @@ template<class UIntType, size_t w, size_t s, size_t r>
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return m - 1; }
     static constexpr result_type default_seed = 19780503u;
     // constructors and seeding functions
- explicit subtract_with_carry_engine(result_type value = default_seed);
     template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
@@ -1540,16 +1844,15 @@ The following relations shall hold: `0u < s`, `s < r`, `0 < w`, and
 The textual representation consists of the values of Xᵢ₋ᵣ, …, Xᵢ₋₁, in
 that order, followed by c.
 ``` cpp
-explicit subtract_with_carry_engine(result_type value = default_seed);
 ```
-*Effects:* Constructs a `subtract_with_carry_engine` object. Sets the
-values of X₋ᵣ, …, X₋₁, in that order, as specified below. If X₋₁ is then
-0, sets c to 1; otherwise sets c to 0.
 To set the values Xₖ, first construct `e`, a
 `linear_congruential_engine` object, as if by the following definition:
 ``` cpp
@@ -1565,45 +1868,44 @@ $\left( \sum_{j=0}^{n-1} z_j \cdot 2^{32j}\right) \bmod m$.
 ``` cpp
 template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
 ```
-*Effects:* Constructs a `subtract_with_carry_engine` object. With
-k = ⌈ w / 32 ⌉ and a an array (or equivalent) of length r ⋅ k, invokes
-`q.generate(`a+0`, `a+r ⋅ k`)` and then, iteratively for i = -r, …, -1,
-sets Xᵢ to
 $\left(\sum_{j=0}^{k-1}a_{k(i+r)+j} \cdot 2^{32j} \right) \bmod m$. If
 X₋₁ is then 0, sets c to 1; otherwise sets c to 0.
 ### Random number engine adaptor class templates <a id="rand.adapt">[[rand.adapt]]</a>
 #### In general <a id="rand.adapt.general">[[rand.adapt.general]]</a>
-Each type instantiated from a class template specified in this section
-[[rand.adapt]] satisfies the requirements of a random number engine
-adaptor ([[rand.req.adapt]]) type.
 Except where specified otherwise, the complexity of each function
-specified in this section  [[rand.adapt]] is constant.
-Except where specified otherwise, no function described in this section
-[[rand.adapt]] throws an exception.
-Every function described in this section  [[rand.adapt]] that has a
 function parameter `q` of type `Sseq&` for a template type parameter
 named `Sseq` that is different from type `seed_seq` throws what and when
 the invocation of `q.generate` throws.
-Descriptions are provided in this section  [[rand.adapt]] only for
-adaptor operations that are not described in section  [[rand.req.adapt]]
-or for operations where there is additional semantic information. In
-particular, declarations for copy constructors, for copy assignment
-operators, for streaming operators, and for equality and inequality
-operators are not shown in the synopses.
-Each template specified in this section  [[rand.adapt]] requires one or
-more relationships, involving the value(s) of its non-type template
 parameter(s), to hold. A program instantiating any of these templates is
 ill-formed if any such required relationship fails to hold.
 #### Class template `discard_block_engine` <a id="rand.adapt.disc">[[rand.adapt.disc]]</a>
@@ -1661,11 +1963,11 @@ template<class Engine, size_t p, size_t r>
 The following relations shall hold: `0 < r` and `r <= p`.
 The textual representation consists of the textual representation of `e`
 followed by the value of `n`.
-In addition to its behavior pursuant to section  [[rand.req.adapt]],
 each constructor that is not a copy constructor sets `n` to 0.
 #### Class template `independent_bits_engine` <a id="rand.adapt.ibits">[[rand.adapt.ibits]]</a>
 An `independent_bits_engine` random number engine adaptor combines
@@ -1676,10 +1978,17 @@ state eᵢ of its base engine `e`; the size of the state is the size of
 e’s state.
 The transition and generation algorithms are described in terms of the
 following integral constants:
 [*Note 1*: The relation w = n₀ w₀ + (n - n₀)(w₀ + 1) always
 holds. — *end note*]
 The transition algorithm is carried out by invoking `e()` as often as
 needed to obtain n₀ values less than y₀ + `e.min()` and n - n₀ values
@@ -1751,10 +2060,15 @@ additional sequence V of k values also of the type delivered by `e`. The
 size of the state is the size of e’s state plus k + 1.
 The transition algorithm permutes the values produced by e. The state
 transition is performed as follows:
 The generation algorithm yields the last value of `Y` produced while
 advancing `e`’s state as described above.
 ``` cpp
 template<class Engine, size_t k>
@@ -1795,99 +2109,96 @@ template<class Engine, size_t k>
 The following relation shall hold: `0 < k`.
 The textual representation consists of the textual representation of
 `e`, followed by the `k` values of V, followed by the value of Y.
-In addition to its behavior pursuant to section  [[rand.req.adapt]],
 each constructor that is not a copy constructor initializes
 `V[0]`, …, `V[k-1]` and Y, in that order, with values returned by
 successive invocations of `e()`.
 ### Engines and engine adaptors with predefined parameters <a id="rand.predef">[[rand.predef]]</a>
 ``` cpp
 using minstd_rand0 =
-      linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `minstd_rand0` shall produce the
-value 1043618065.
 ``` cpp
 using minstd_rand =
-      linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `minstd_rand` shall produce the value
 399268537.
 ``` cpp
 using mt19937 =
-      mersenne_twister_engine<uint_fast32_t,
- 32,624,397,31,0x9908b0df,11,0xffffffff,7,0x9d2c5680,15,0xefc60000,18,1812433253>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `mt19937` shall produce the value
 4123659995.
 ``` cpp
 using mt19937_64 =
-      mersenne_twister_engine<uint_fast64_t,
- 64,312,156,31,0xb5026f5aa96619e9,29,
- 0x5555555555555555,17,
-       0x71d67fffeda60000,37,
-       0xfff7eee000000000,43,
-       6364136223846793005>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `mt19937_64` shall produce the value
 9981545732273789042.
 ``` cpp
 using ranlux24_base =
       subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `ranlux24_base` shall produce the
-value 7937952.
 ``` cpp
 using ranlux48_base =
       subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `ranlux48_base` shall produce the
-value 61839128582725.
 ``` cpp
 using ranlux24 = discard_block_engine<ranlux24_base, 223, 23>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `ranlux24` shall produce the value
 9901578.
 ``` cpp
 using ranlux48 = discard_block_engine<ranlux48_base, 389, 11>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `ranlux48` shall produce the value
 249142670248501.
 ``` cpp
 using knuth_b = shuffle_order_engine<minstd_rand0,256>;
 ```
-*Required behavior:* The $10000^{\,th}$ consecutive invocation of a
-default-constructed object of type `knuth_b` shall produce the value
 1112339016.
 ``` cpp
 using default_random_engine = implementation-defined;
 ```
@@ -1920,11 +2231,12 @@ public:
   // generator characteristics
   static constexpr result_type min() { return numeric_limits<result_type>::min(); }
   static constexpr result_type max() { return numeric_limits<result_type>::max(); }
   // constructors
- explicit random_device(const string& token = implementation-defined);
   // generating functions
   result_type operator()();
   // property functions
@@ -1935,16 +2247,15 @@ public:
   void operator=(const random_device&) = delete;
 };
 ```
 ``` cpp
-explicit random_device(const string& token = implementation-defined);
 ```
-*Effects:* Constructs a `random_device` nondeterministic uniform random
-bit generator object. The semantics and default value of the `token`
-parameter are *implementation-defined*. [^3]
 *Throws:* A value of an *implementation-defined* type derived from
 `exception` if the `random_device` could not be initialized.
 ``` cpp
@@ -1958,11 +2269,11 @@ returned by `operator()`, in the range `min()` to log₂( `max()`+1).
 ``` cpp
 result_type operator()();
 ```
 *Returns:* A nondeterministic random value, uniformly distributed
-between `min()` and `max()`, inclusive. It is *implementation-defined*
 how these values are generated.
 *Throws:* A value of an *implementation-defined* type derived from
 `exception` if a random number could not be obtained.
@@ -2003,35 +2314,35 @@ private:
 ``` cpp
 seed_seq();
 ```
-*Effects:* Constructs a `seed_seq` object as if by default-constructing
-its member `v`.
 *Throws:* Nothing.
 ``` cpp
 template<class T>
  seed_seq(initializer_list<T> il);
 ```
-*Requires:* `T` shall be an integer type.
 *Effects:* Same as `seed_seq(il.begin(), il.end())`.
 ``` cpp
 template<class InputIterator>
   seed_seq(InputIterator begin, InputIterator end);
 ```
-*Requires:* `InputIterator` shall satisfy the requirements of an input
-iterator (Table  [[tab:iterator.input.requirements]]) type. Moreover,
-`iterator_traits<InputIterator>::value_type` shall denote an integer
 type.
-*Effects:* Constructs a `seed_seq` object by the following algorithm:
 ``` cpp
 for (InputIterator s = begin; s != end; ++s)
  v.push_back((*s) mod  2³²);
 ```
@@ -2039,21 +2350,63 @@ for( InputIterator s = begin; s != end; ++s)
 ``` cpp
 template<class RandomAccessIterator>
   void generate(RandomAccessIterator begin, RandomAccessIterator end);
 ```
-*Requires:* `RandomAccessIterator` shall meet the requirements of a
-mutable random access iterator ([[random.access.iterators]]). Moreover,
-`iterator_traits<RandomAccessIterator>::value_type` shall denote an
 unsigned integer type capable of accommodating 32-bit quantities.
 *Effects:* Does nothing if `begin == end`. Otherwise, with
 s = `v.size()` and n = `end` - `begin`, fills the supplied range
 [`begin`,`end`) according to the following algorithm in which each
 operation is to be carried out modulo 2³², each indexing operator
 applied to `begin` is to be taken modulo n, and T(x) is defined as
-$x \, \xor \, (x \, \rightshift \, 27)$:
 *Throws:* What and when `RandomAccessIterator` operations of `begin` and
 `end` throw.
 ``` cpp
@@ -2068,13 +2421,15 @@ to `param()`.
 ``` cpp
 template<class OutputIterator>
   void param(OutputIterator dest) const;
 ```
-*Requires:* `OutputIterator` shall satisfy the requirements of an output
-iterator ([[output.iterators]]). Moreover, the expression `*dest = rt`
-shall be valid for a value `rt` of type `result_type`.
 *Effects:* Copies the sequence of prepared 32-bit units to the given
 destination, as if by executing the following statement:
 ``` cpp
@@ -2083,22 +2438,10 @@ copy(v.begin(), v.end(), dest);
 *Throws:* What and when `OutputIterator` operations of `dest` throw.
 #### Function template `generate_canonical` <a id="rand.util.canonical">[[rand.util.canonical]]</a>
-Each function instantiated from the template described in this section
-[[rand.util.canonical]] maps the result of one or more invocations of a
-supplied uniform random bit generator `g` to one member of the specified
-`RealType` such that, if the values gᵢ produced by `g` are uniformly
-distributed, the instantiation’s results tⱼ, 0 ≤ tⱼ < 1, are distributed
-as uniformly as possible as specified below.
-[*Note 1*: Obtaining a value in this way can be a useful step in the
-process of transforming a value generated by a uniform random bit
-generator into a value that can be delivered by a random number
-distribution. — *end note*]
 ``` cpp
 template<class RealType, size_t bits, class URBG>
   RealType generate_canonical(URBG& g);
 ```
@@ -2111,54 +2454,62 @@ respectively. Calculates a quantity
 $$S = \sum_{i=0}^{k-1} (g_i - \texttt{g.min()})
                         \cdot R^i$$ using arithmetic of type `RealType`.
 *Returns:* S / Rᵏ.
 *Throws:* What and when `g` throws.
 ### Random number distribution class templates <a id="rand.dist">[[rand.dist]]</a>
 #### In general <a id="rand.dist.general">[[rand.dist.general]]</a>
-Each type instantiated from a class template specified in this section
-[[rand.dist]] satisfies the requirements of a random number
-distribution ([[rand.req.dist]]) type.
-Descriptions are provided in this section  [[rand.dist]] only for
 distribution operations that are not described in [[rand.req.dist]] or
 for operations where there is additional semantic information. In
 particular, declarations for copy constructors, for copy assignment
 operators, for streaming operators, and for equality and inequality
 operators are not shown in the synopses.
 The algorithms for producing each of the specified distributions are
 *implementation-defined*.
 The value of each probability density function p(z) and of each discrete
-probability function P(zᵢ) specified in this section is 0 everywhere
 outside its stated domain.
 #### Uniform distributions <a id="rand.dist.uni">[[rand.dist.uni]]</a>
 ##### Class template `uniform_int_distribution` <a id="rand.dist.uni.int">[[rand.dist.uni.int]]</a>
 A `uniform_int_distribution` random number distribution produces random
 integers i, a ≤ i ≤ b, distributed according to the constant discrete
-probability function $$%
- P(i\,|\,a,b) = 1 / (b - a + 1)
-\; \mbox{.}$$
 ``` cpp
 template<class IntType = int>
   class uniform_int_distribution {
   public:
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
- explicit uniform_int_distribution(IntType a = 0, IntType b = numeric_limits<IntType>::max());
     explicit uniform_int_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
@@ -2175,17 +2526,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;
 ```
@@ -2201,13 +2552,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
@@ -2217,11 +2566,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>
@@ -2238,17 +2588,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;
 ```
@@ -2265,27 +2616,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>
@@ -2301,17 +2651,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;
 ```
@@ -2320,25 +2669,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>
@@ -2355,17 +2702,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;
 ```
@@ -2381,25 +2728,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>
@@ -2415,17 +2760,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;
 ```
@@ -2434,14 +2778,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
@@ -2451,11 +2793,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>
@@ -2472,17 +2815,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;
 ```
@@ -2500,16 +2843,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
   {
@@ -2517,11 +2856,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>
@@ -2537,17 +2877,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;
 ```
@@ -2556,25 +2895,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>
@@ -2590,17 +2927,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;
 ```
@@ -2609,26 +2945,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>
@@ -2645,17 +2980,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;
 ```
@@ -2671,27 +3006,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>
@@ -2708,17 +3042,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;
 ```
@@ -2734,28 +3068,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>
@@ -2772,17 +3103,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;
 ```
@@ -2808,11 +3139,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 {
@@ -2820,11 +3151,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>
@@ -2841,17 +3173,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;
 ```
@@ -2867,31 +3199,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>
@@ -2908,17 +3234,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;
 ```
@@ -2934,26 +3260,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>
@@ -2969,17 +3292,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;
 ```
@@ -2987,25 +3309,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>
@@ -3022,17 +3343,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;
 ```
@@ -3048,32 +3369,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>
@@ -3090,17 +3406,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;
 ```
@@ -3115,29 +3431,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>
@@ -3153,17 +3467,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;
 ```
@@ -3174,20 +3487,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:
@@ -3233,15 +3543,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
@@ -3253,22 +3566,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;
 ```
@@ -3279,27 +3592,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:
@@ -3347,59 +3654,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;
 ```
@@ -3417,29 +3725,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:
@@ -3486,58 +3789,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;
 ```
@@ -3553,12 +3853,12 @@ vector<result_type> densities() const;
 whose `operator[]` member returns ρₖ when invoked with argument k for
 k = 0, …, n.
 ### Low-quality random number generation <a id="c.math.rand">[[c.math.rand]]</a>
-[*Note 1*: The header `<cstdlib>` ([[cstdlib.syn]]) declares the
-functions described in this subclause. — *end note*]
 ``` cpp
 int rand();
 void srand(unsigned int seed);
 ```
@@ -3566,19 +3866,19 @@ void srand(unsigned int seed);
 *Effects:* The `rand` and `srand` functions have the semantics specified
 in the C standard library.
 *Remarks:* The implementation may specify that particular library
 functions may call `rand`. It is *implementation-defined* whether the
-`rand` function may introduce data races ([[res.on.data.races]]).
 [*Note 1*: The other random number generation facilities in this
-International Standard ([[rand]]) are often preferable to `rand`,
-because `rand`’s underlying algorithm is unspecified. Use of `rand`
-therefore continues to be non-portable, with unpredictable and
-oft-questionable quality and performance. — *end note*]
-ISO C 7.22.2
 ## Numeric arrays <a id="numarray">[[numarray]]</a>
 ### Header `<valarray>` synopsis <a id="valarray.syn">[[valarray.syn]]</a>
@@ -3595,101 +3895,133 @@ namespace std {
   template<class T> class indirect_array;   // an indirected array
   template<class T> void swap(valarray<T>&, valarray<T>&) noexcept;
   template<class T> valarray<T> operator* (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator* (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator* (const T&, const valarray<T>&);
   template<class T> valarray<T> operator/ (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator/ (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator/ (const T&, const valarray<T>&);
   template<class T> valarray<T> operator% (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator% (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator% (const T&, const valarray<T>&);
   template<class T> valarray<T> operator+ (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator+ (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator+ (const T&, const valarray<T>&);
   template<class T> valarray<T> operator- (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator- (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator- (const T&, const valarray<T>&);
   template<class T> valarray<T> operator^ (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator^ (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator^ (const T&, const valarray<T>&);
   template<class T> valarray<T> operator& (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator& (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator& (const T&, const valarray<T>&);
   template<class T> valarray<T> operator| (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator| (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator| (const T&, const valarray<T>&);
   template<class T> valarray<T> operator<<(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator<<(const valarray<T>&, const T&);
-  template<class T> valarray<T> operator<<(const T&, const valarray<T>&);
   template<class T> valarray<T> operator>>(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator>>(const valarray<T>&, const T&);
-  template<class T> valarray<T> operator>>(const T&, const valarray<T>&);
   template<class T> valarray<bool> operator&&(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator&&(const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator&&(const T&, const valarray<T>&);
   template<class T> valarray<bool> operator||(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator||(const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator||(const T&, const valarray<T>&);
-  template<class T>
- valarray<bool> operator==(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator==(const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator==(const T&, const valarray<T>&);
-  template<class T>
- valarray<bool> operator!=(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator!=(const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator!=(const T&, const valarray<T>&);
-  template<class T>
- valarray<bool> operator< (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator< (const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator< (const T&, const valarray<T>&);
-  template<class T>
- valarray<bool> operator> (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator> (const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator> (const T&, const valarray<T>&);
-  template<class T>
-    valarray<bool> operator<=(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator<=(const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator<=(const T&, const valarray<T>&);
-  template<class T>
- valarray<bool> operator>=(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator>=(const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator>=(const T&, const valarray<T>&);
   template<class T> valarray<T> abs  (const valarray<T>&);
   template<class T> valarray<T> acos (const valarray<T>&);
   template<class T> valarray<T> asin (const valarray<T>&);
   template<class T> valarray<T> atan (const valarray<T>&);
   template<class T> valarray<T> atan2(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> atan2(const valarray<T>&, const T&);
-  template<class T> valarray<T> atan2(const T&, const valarray<T>&);
   template<class T> valarray<T> cos  (const valarray<T>&);
   template<class T> valarray<T> cosh (const valarray<T>&);
   template<class T> valarray<T> exp  (const valarray<T>&);
   template<class T> valarray<T> log  (const valarray<T>&);
   template<class T> valarray<T> log10(const valarray<T>&);
   template<class T> valarray<T> pow(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> pow(const valarray<T>&, const T&);
-  template<class T> valarray<T> pow(const T&, const valarray<T>&);
   template<class T> valarray<T> sin  (const valarray<T>&);
   template<class T> valarray<T> sinh (const valarray<T>&);
   template<class T> valarray<T> sqrt (const valarray<T>&);
   template<class T> valarray<T> tan  (const valarray<T>&);
@@ -3718,28 +4050,28 @@ nested argument type.[^7]
 Implementations introducing such replacement types shall provide
 additional functions and operators as follows:
 - for every function taking a `const valarray<T>&` other than `begin`
-  and `end` ([[valarray.range]]), identical functions taking the
   replacement types shall be added;
 - for every function taking two `const valarray<T>&` arguments,
   identical functions taking every combination of `const valarray<T>&`
   and replacement types shall be added.
 In particular, an implementation shall allow a `valarray<T>` to be
 constructed from such replacement types and shall allow assignments and
 compound assignments of such types to `valarray<T>`, `slice_array<T>`,
 `gslice_array<T>`, `mask_array<T>` and `indirect_array<T>` objects.
-These library functions are permitted to throw a `bad_alloc` (
-[[bad.alloc]]) exception if there are not sufficient resources available
 to carry out the operation. Note that the exception is not mandated.
 ### Class template `valarray` <a id="template.valarray">[[template.valarray]]</a>
-#### Class template `valarray` overview <a id="template.valarray.overview">[[template.valarray.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class valarray {
   public:
@@ -3839,14 +4171,11 @@ object of type `valarray<T>` is referred to as an “array” throughout the
 remainder of  [[numarray]]. The illusion of higher dimensionality may be
 produced by the familiar idiom of computed indices, together with the
 powerful subsetting capabilities provided by the generalized subscript
 operators.[^8]
-An implementation is permitted to qualify any of the functions declared
-in `<valarray>` as `inline`.
-#### `valarray` constructors <a id="valarray.cons">[[valarray.cons]]</a>
 ``` cpp
 valarray();
 ```
@@ -3855,11 +4184,11 @@ valarray();
 ``` cpp
 explicit valarray(size_t n);
 ```
 *Effects:* Constructs a `valarray` that has length `n`. Each element of
-the array is value-initialized ([[dcl.init]]).
 ``` cpp
 valarray(const T& v, size_t n);
 ```
@@ -3868,12 +4197,11 @@ the array is initialized with `v`.
 ``` cpp
 valarray(const T* p, size_t n);
 ```
-*Requires:* `p` points to an array ([[dcl.array]]) of at least `n`
-elements.
 *Effects:* Constructs a `valarray` that has length `n`. The values of
 the elements of the array are initialized with the first `n` values
 pointed to by the first argument.[^10]
@@ -3916,11 +4244,11 @@ templates to a `valarray`.
 ```
 *Effects:* The destructor is applied to every element of `*this`; an
 implementation may return all allocated memory.
-#### `valarray` assignment <a id="valarray.assign">[[valarray.assign]]</a>
 ``` cpp
 valarray& operator=(const valarray& v);
 ```
@@ -3928,11 +4256,11 @@ valarray& operator=(const valarray& v);
 the corresponding element of `v`. If the length of `v` is not equal to
 the length of `*this`, resizes `*this` to make the two arrays the same
 length, as if by calling `resize(v.size())`, before performing the
 assignment.
-*Postconditions:* `size() == v.size()`.
 *Returns:* `*this`.
 ``` cpp
 valarray& operator=(valarray&& v) noexcept;
@@ -3964,63 +4292,64 @@ valarray& operator=(const slice_array<T>&);
 valarray& operator=(const gslice_array<T>&);
 valarray& operator=(const mask_array<T>&);
 valarray& operator=(const indirect_array<T>&);
 ```
-*Requires:* The length of the array to which the argument refers equals
-`size()`. The value of an element in the left-hand side of a `valarray`
-assignment operator does not depend on the value of another element in
-that left-hand side.
 These operators allow the results of a generalized subscripting
 operation to be assigned directly to a `valarray`.
-#### `valarray` element access <a id="valarray.access">[[valarray.access]]</a>
 ``` cpp
 const T&  operator[](size_t n) const;
 T& operator[](size_t n);
 ```
-*Requires:* `n < size()`.
 *Returns:* A reference to the corresponding element of the array.
 [*Note 1*: The expression `(a[i] = q, a[i]) == q` evaluates to `true`
 for any non-constant `valarray<T> a`, any `T q`, and for any `size_t i`
 such that the value of `i` is less than the length of
 `a`. — *end note*]
-*Remarks:* The expression `&a[i+j] == &a[i] + j` evaluates to `true` for
-all `size_t i` and `size_t j` such that `i+j < a.size()`.
-The expression `&a[i] != &b[j]` evaluates to `true` for any two arrays
-`a` and `b` and for any `size_t i` and `size_t j` such that
-`i < a.size()` and `j < b.size()`.
 [*Note 2*: This property indicates an absence of aliasing and may be
 used to advantage by optimizing compilers. Compilers may take advantage
 of inlining, constant propagation, loop fusion, tracking of pointers
 obtained from `operator new`, and other techniques to generate efficient
 `valarray`s. — *end note*]
 The reference returned by the subscript operator for an array shall be
-valid until the member function
-`resize(size_t, T)` ([[valarray.members]]) is called for that array or
-until the lifetime of that array ends, whichever happens first.
-#### `valarray` subset operations <a id="valarray.sub">[[valarray.sub]]</a>
 The member `operator[]` is overloaded to provide several ways to select
 sequences of elements from among those controlled by `*this`. Each of
 these operations returns a subset of the array. The const-qualified
 versions return this subset as a new `valarray` object. The non-const
 versions return a class template object which has reference semantics to
 the original array, working in conjunction with various overloads of
 `operator=` and other assigning operators to allow selective replacement
 (slicing) of the controlled sequence. In each case the selected
-element(s) must exist.
 ``` cpp
 valarray operator[](slice slicearr) const;
 ```
@@ -4167,30 +4496,29 @@ v0[valarray<size_t>(vi, 5)] = v1;
 // v0 == valarray<char>("abCDeBgAEjklmnop", 16)
 ```
 — *end example*]
-#### `valarray` unary operators <a id="valarray.unary">[[valarray.unary]]</a>
 ``` cpp
 valarray operator+() const;
 valarray operator-() const;
 valarray operator~() const;
 valarray<bool> operator!() const;
 ```
-*Requires:* Each of these operators may only be instantiated for a type
-`T` to which the indicated operator can be applied and for which the
-indicated operator returns a value which is of type `T` (`bool` for
-`operator!`) or which may be unambiguously implicitly converted to type
-`T` (`bool` for `operator!`).
 *Returns:* A `valarray` whose length is `size()`. Each element of the
 returned array is initialized with the result of applying the indicated
 operator to the corresponding element of the array.
-#### `valarray` compound assignment <a id="valarray.cassign">[[valarray.cassign]]</a>
 ``` cpp
 valarray& operator*= (const valarray& v);
 valarray& operator/= (const valarray& v);
 valarray& operator%= (const valarray& v);
@@ -4201,15 +4529,18 @@ valarray& operator&= (const valarray& v);
 valarray& operator|= (const valarray& v);
 valarray& operator<<=(const valarray& v);
 valarray& operator>>=(const valarray& v);
 ```
-*Requires:* `size() == v.size()`. Each of these operators may only be
-instantiated for a type `T` if the indicated operator can be applied to
-two operands of type `T`. The value of an element in the left-hand side
-of a valarray compound assignment operator does not depend on the value
-of another element in that left hand side.
 *Effects:* Each of these operators performs the indicated operation on
 each of the elements of `*this` and the corresponding element of `v`.
 *Returns:* `*this`.
@@ -4228,24 +4559,23 @@ valarray& operator&= (const T& v);
 valarray& operator|= (const T& v);
 valarray& operator<<=(const T& v);
 valarray& operator>>=(const T& v);
 ```
-*Requires:* Each of these operators may only be instantiated for a type
-`T` if the indicated operator can be applied to two operands of type
-`T`.
 *Effects:* Each of these operators applies the indicated operation to
 each element of `*this` and `v`.
 *Returns:* `*this`
 *Remarks:* The appearance of an array on the left-hand side of a
 compound assignment does not invalidate references or pointers to the
 elements of the array.
-#### `valarray` member functions <a id="valarray.members">[[valarray.members]]</a>
 ``` cpp
 void swap(valarray& v) noexcept;
 ```
@@ -4264,33 +4594,34 @@ size_t size() const;
 ``` cpp
 T sum() const;
 ```
-*Requires:* `size() > 0`. This function may only be instantiated for a
-type `T` to which `operator+=` can be applied.
 *Returns:* The sum of all the elements of the array. If the array has
 length 1, returns the value of element 0. Otherwise, the returned value
 is calculated by applying `operator+=` to a copy of an element of the
 array and all other elements of the array in an unspecified order.
 ``` cpp
 T min() const;
 ```
-*Requires:* `size() > 0`
 *Returns:* The minimum value contained in `*this`. For an array of
 length 1, the value of element 0 is returned. For all other array
 lengths, the determination is made using `operator<`.
 ``` cpp
 T max() const;
 ```
-*Requires:* `size() > 0`.
 *Returns:* The maximum value contained in `*this`. For an array of
 length 1, the value of element 0 is returned. For all other array
 lengths, the determination is made using `operator<`.
@@ -4305,13 +4636,13 @@ is `(*this)[`*`I`*` + n]` if *`I`*` + n` is non-negative and less than
 [*Note 1*: If element zero is taken as the leftmost element, a positive
 value of `n` shifts the elements left `n` places, with zero
 fill. — *end note*]
 [*Example 1*: If the argument has the value -2, the first two elements
-of the result will be value-initialized ([[dcl.init]]); the third
-element of the result will be assigned the value of the first element of
-the argument; etc. — *end example*]
 ``` cpp
 valarray cshift(int n) const;
 ```
@@ -4337,183 +4668,197 @@ void resize(size_t sz, T c = T());
 assigns to each element the value of the second argument. Resizing
 invalidates all pointers and references to elements in the array.
 ### `valarray` non-member operations <a id="valarray.nonmembers">[[valarray.nonmembers]]</a>
-#### `valarray` binary operators <a id="valarray.binary">[[valarray.binary]]</a>
 ``` cpp
-template<class T> valarray<T> operator*
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator/
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator%
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator+
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator-
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator^
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator&
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator|
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator<<
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator>>
-    (const valarray<T>&, const valarray<T>&);
 ```
-*Requires:* Each of these operators may only be instantiated for a type
-`T` to which the indicated operator can be applied and for which the
-indicated operator returns a value which is of type `T` or which can be
-unambiguously implicitly converted to type `T`. The argument arrays have
-the same length.
 *Returns:* A `valarray` whose length is equal to the lengths of the
 argument arrays. Each element of the returned array is initialized with
 the result of applying the indicated operator to the corresponding
 elements of the argument arrays.
 ``` cpp
-template<class T> valarray<T> operator* (const valarray<T>&, const T&);
-template<class T> valarray<T> operator* (const T&, const valarray<T>&);
-template<class T> valarray<T> operator/ (const valarray<T>&, const T&);
-template<class T> valarray<T> operator/ (const T&, const valarray<T>&);
-template<class T> valarray<T> operator% (const valarray<T>&, const T&);
-template<class T> valarray<T> operator% (const T&, const valarray<T>&);
-template<class T> valarray<T> operator+ (const valarray<T>&, const T&);
-template<class T> valarray<T> operator+ (const T&, const valarray<T>&);
-template<class T> valarray<T> operator- (const valarray<T>&, const T&);
-template<class T> valarray<T> operator- (const T&, const valarray<T>&);
-template<class T> valarray<T> operator^ (const valarray<T>&, const T&);
-template<class T> valarray<T> operator^ (const T&, const valarray<T>&);
-template<class T> valarray<T> operator& (const valarray<T>&, const T&);
-template<class T> valarray<T> operator& (const T&, const valarray<T>&);
-template<class T> valarray<T> operator| (const valarray<T>&, const T&);
-template<class T> valarray<T> operator| (const T&, const valarray<T>&);
-template<class T> valarray<T> operator<<(const valarray<T>&, const T&);
-template<class T> valarray<T> operator<<(const T&, const valarray<T>&);
-template<class T> valarray<T> operator>>(const valarray<T>&, const T&);
-template<class T> valarray<T> operator>>(const T&, const valarray<T>&);
 ```
-*Requires:* Each of these operators may only be instantiated for a type
-`T` to which the indicated operator can be applied and for which the
-indicated operator returns a value which is of type `T` or which can be
-unambiguously implicitly converted to type `T`.
 *Returns:* A `valarray` whose length is equal to the length of the array
 argument. Each element of the returned array is initialized with the
 result of applying the indicated operator to the corresponding element
 of the array argument and the non-array argument.
-#### `valarray` logical operators <a id="valarray.comparison">[[valarray.comparison]]</a>
 ``` cpp
-template<class T> valarray<bool> operator==
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator!=
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator<
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator>
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator<=
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator>=
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator&&
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator||
-    (const valarray<T>&, const valarray<T>&);
 ```
-*Requires:* Each of these operators may only be instantiated for a type
-`T` to which the indicated operator can be applied and for which the
-indicated operator returns a value which is of type `bool` or which can
-be unambiguously implicitly converted to type `bool`. The two array
-arguments have the same length.
 *Returns:* A `valarray<bool>` whose length is equal to the length of the
 array arguments. Each element of the returned array is initialized with
 the result of applying the indicated operator to the corresponding
 elements of the argument arrays.
 ``` cpp
-template<class T> valarray<bool> operator==(const valarray<T>&, const T&);
-template<class T> valarray<bool> operator==(const T&, const valarray<T>&);
-template<class T> valarray<bool> operator!=(const valarray<T>&, const T&);
-template<class T> valarray<bool> operator!=(const T&, const valarray<T>&);
-template<class T> valarray<bool> operator< (const valarray<T>&, const T&);
-template<class T> valarray<bool> operator< (const T&, const valarray<T>&);
-template<class T> valarray<bool> operator> (const valarray<T>&, const T&);
-template<class T> valarray<bool> operator> (const T&, const valarray<T>&);
-template<class T> valarray<bool> operator<=(const valarray<T>&, const T&);
-template<class T> valarray<bool> operator<=(const T&, const valarray<T>&);
-template<class T> valarray<bool> operator>=(const valarray<T>&, const T&);
-template<class T> valarray<bool> operator>=(const T&, const valarray<T>&);
-template<class T> valarray<bool> operator&&(const valarray<T>&, const T&);
-template<class T> valarray<bool> operator&&(const T&, const valarray<T>&);
-template<class T> valarray<bool> operator||(const valarray<T>&, const T&);
-template<class T> valarray<bool> operator||(const T&, const valarray<T>&);
 ```
-*Requires:* Each of these operators may only be instantiated for a type
-`T` to which the indicated operator can be applied and for which the
-indicated operator returns a value which is of type `bool` or which can
-be unambiguously implicitly converted to type `bool`.
 *Returns:* A `valarray<bool>` whose length is equal to the length of the
 array argument. Each element of the returned array is initialized with
 the result of applying the indicated operator to the corresponding
 element of the array and the non-array argument.
-#### `valarray` transcendentals <a id="valarray.transcend">[[valarray.transcend]]</a>
 ``` cpp
 template<class T> valarray<T> abs  (const valarray<T>&);
 template<class T> valarray<T> acos (const valarray<T>&);
 template<class T> valarray<T> asin (const valarray<T>&);
 template<class T> valarray<T> atan (const valarray<T>&);
-template<class T> valarray<T> atan2
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> atan2(const valarray<T>&, const T&);
-template<class T> valarray<T> atan2(const T&, const valarray<T>&);
 template<class T> valarray<T> cos  (const valarray<T>&);
 template<class T> valarray<T> cosh (const valarray<T>&);
 template<class T> valarray<T> exp  (const valarray<T>&);
 template<class T> valarray<T> log  (const valarray<T>&);
 template<class T> valarray<T> log10(const valarray<T>&);
-template<class T> valarray<T> pow
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> pow  (const valarray<T>&, const T&);
-template<class T> valarray<T> pow  (const T&, const valarray<T>&);
 template<class T> valarray<T> sin  (const valarray<T>&);
 template<class T> valarray<T> sinh (const valarray<T>&);
 template<class T> valarray<T> sqrt (const valarray<T>&);
 template<class T> valarray<T> tan  (const valarray<T>&);
 template<class T> valarray<T> tanh (const valarray<T>&);
 ```
-*Requires:* Each of these functions may only be instantiated for a type
-`T` to which a unique function with the indicated name can be applied
-(unqualified). This function shall return a value which is of type `T`
-or which can be unambiguously implicitly converted to type `T`.
-#### `valarray` specialized algorithms <a id="valarray.special">[[valarray.special]]</a>
 ``` cpp
 template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;
 ```
 *Effects:* Equivalent to `x.swap(y)`.
 ### Class `slice` <a id="class.slice">[[class.slice]]</a>
-#### Class `slice` overview <a id="class.slice.overview">[[class.slice.overview]]</a>
 ``` cpp
 namespace std {
   class slice {
   public:
@@ -4521,18 +4866,20 @@ namespace std {
     slice(size_t, size_t, size_t);
     size_t start() const;
     size_t size() const;
     size_t stride() const;
   };
 }
 ```
 The `slice` class represents a BLAS-like slice from an array. Such a
 slice is specified by a starting index, a length, and a stride.[^12]
-#### `slice` constructors <a id="cons.slice">[[cons.slice]]</a>
 ``` cpp
 slice();
 slice(size_t start, size_t length, size_t stride);
 slice(const slice&);
@@ -4542,13 +4889,13 @@ The default constructor is equivalent to `slice(0, 0, 0)`. A default
 constructor is provided only to permit the declaration of arrays of
 slices. The constructor with arguments for a slice takes a start,
 length, and stride parameter.
 [*Example 1*: `slice(3, 8, 2)` constructs a slice which selects
-elements 3, 5, 7, ... 17 from an array. — *end example*]
-#### `slice` access functions <a id="slice.access">[[slice.access]]</a>
 ``` cpp
 size_t start() const;
 size_t size() const;
 size_t stride() const;
@@ -4556,13 +4903,25 @@ size_t stride() const;
 *Returns:* The start, length, or stride specified by a `slice` object.
 *Complexity:* Constant time.
 ### Class template `slice_array` <a id="template.slice.array">[[template.slice.array]]</a>
-#### Class template `slice_array` overview <a id="template.slice.array.overview">[[template.slice.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class slice_array {
   public:
@@ -4588,37 +4947,37 @@ namespace std {
     slice_array() = delete;     // as implied by declaring copy constructor above
   };
 }
 ```
-The `slice_array` template is a helper template used by the `slice`
-subscript operator
 ``` cpp
 slice_array<T> valarray<T>::operator[](slice);
 ```
 It has reference semantics to a subset of an array specified by a
 `slice` object.
 [*Example 1*: The expression `a[slice(1, 5, 3)] = b;` has the effect of
 assigning the elements of `b` to a slice of the elements in `a`. For the
-slice shown, the elements selected from `a` are 1, 4, ...,
-13. — *end example*]
-#### `slice_array` assignment <a id="slice.arr.assign">[[slice.arr.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const slice_array& operator=(const slice_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
 `valarray<T>` object to which the `slice_array` object refers.
-#### `slice_array` compound assignment <a id="slice.arr.comp.assign">[[slice.arr.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
@@ -4634,11 +4993,11 @@ void operator>>=(const valarray<T>&) const;
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
 elements of the `valarray<T>` object to which the `slice_array` object
 refers.
-#### `slice_array` fill function <a id="slice.arr.fill">[[slice.arr.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
@@ -4646,11 +5005,11 @@ This function has reference semantics, assigning the value of its
 argument to the elements of the `valarray<T>` object to which the
 `slice_array` object refers.
 ### The `gslice` class <a id="class.gslice">[[class.gslice]]</a>
-#### The `gslice` class overview <a id="class.gslice.overview">[[class.gslice.overview]]</a>
 ``` cpp
 namespace std {
   class gslice {
   public:
@@ -4704,11 +5063,11 @@ If the stride parameters in the previous example are changed to {1, 1,
 — *end example*]
 If a degenerate slice is used as the argument to the non-`const` version
 of `operator[](const gslice&)`, the behavior is undefined.
-#### `gslice` constructors <a id="gslice.cons">[[gslice.cons]]</a>
 ``` cpp
 gslice();
 gslice(size_t start, const valarray<size_t>& lengths,
          const valarray<size_t>& strides);
@@ -4716,13 +5075,13 @@ gslice(const gslice&);
 ```
 The default constructor is equivalent to
 `gslice(0, valarray<size_t>(), valarray<size_t>())`. The constructor
 with arguments builds a `gslice` based on a specification of start,
-lengths, and strides, as explained in the previous section.
-#### `gslice` access functions <a id="gslice.access">[[gslice.access]]</a>
 ``` cpp
 size_t           start()  const;
 valarray<size_t> size() const;
 valarray<size_t> stride() const;
@@ -4734,11 +5093,11 @@ specified for the `gslice`.
 *Complexity:* `start()` is constant time. `size()` and `stride()` are
 linear in the number of strides.
 ### Class template `gslice_array` <a id="template.gslice.array">[[template.gslice.array]]</a>
-#### Class template `gslice_array` overview <a id="template.gslice.array.overview">[[template.gslice.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class gslice_array {
   public:
@@ -4764,36 +5123,34 @@ namespace std {
     gslice_array() = delete;    // as implied by declaring copy constructor above
   };
 }
 ```
-This template is a helper template used by the `slice` subscript
 operator
 ``` cpp
 gslice_array<T> valarray<T>::operator[](const gslice&);
 ```
 It has reference semantics to a subset of an array specified by a
-`gslice` object.
-Thus, the expression `a[gslice(1, length, stride)] = b` has the effect
-of assigning the elements of `b` to a generalized slice of the elements
-in `a`.
-#### `gslice_array` assignment <a id="gslice.array.assign">[[gslice.array.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const gslice_array& operator=(const gslice_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
 `valarray<T>` object to which the `gslice_array` refers.
-#### `gslice_array` compound assignment <a id="gslice.array.comp.assign">[[gslice.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
@@ -4809,11 +5166,11 @@ void operator>>=(const valarray<T>&) const;
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
 elements of the `valarray<T>` object to which the `gslice_array` object
 refers.
-#### `gslice_array` fill function <a id="gslice.array.fill">[[gslice.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
@@ -4821,11 +5178,11 @@ This function has reference semantics, assigning the value of its
 argument to the elements of the `valarray<T>` object to which the
 `gslice_array` object refers.
 ### Class template `mask_array` <a id="template.mask.array">[[template.mask.array]]</a>
-#### Class template `mask_array` overview <a id="template.mask.array.overview">[[template.mask.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class mask_array {
   public:
@@ -4860,24 +5217,24 @@ mask_array<T> valarray<T>::operator[](const valarray<bool>&).
 ```
 It has reference semantics to a subset of an array specified by a
 boolean mask. Thus, the expression `a[mask] = b;` has the effect of
 assigning the elements of `b` to the masked elements in `a` (those for
-which the corresponding element in `mask` is `true`.)
-#### `mask_array` assignment <a id="mask.array.assign">[[mask.array.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const mask_array& operator=(const mask_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
 `valarray<T>` object to which it refers.
-#### `mask_array` compound assignment <a id="mask.array.comp.assign">[[mask.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
@@ -4892,11 +5249,11 @@ void operator>>=(const valarray<T>&) const;
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
 elements of the `valarray<T>` object to which the mask object refers.
-#### `mask_array` fill function <a id="mask.array.fill">[[mask.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
@@ -4904,11 +5261,11 @@ This function has reference semantics, assigning the value of its
 argument to the elements of the `valarray<T>` object to which the
 `mask_array` object refers.
 ### Class template `indirect_array` <a id="template.indirect.array">[[template.indirect.array]]</a>
-#### Class template `indirect_array` overview <a id="template.indirect.array.overview">[[template.indirect.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class indirect_array {
   public:
@@ -4942,15 +5299,15 @@ operator
 ``` cpp
 indirect_array<T> valarray<T>::operator[](const valarray<size_t>&).
 ```
 It has reference semantics to a subset of an array specified by an
-`indirect_array`. Thus the expression `a[indirect] = b;` has the effect
-of assigning the elements of `b` to the elements in `a` whose indices
-appear in `indirect`.
-#### `indirect_array` assignment <a id="indirect.array.assign">[[indirect.array.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const indirect_array& operator=(const indirect_array&) const;
 ```
@@ -4974,11 +5331,11 @@ a[indirect] = b;
 results in undefined behavior since element 4 is specified twice in the
 indirection.
 — *end example*]
-#### `indirect_array` compound assignment <a id="indirect.array.comp.assign">[[indirect.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
@@ -4997,11 +5354,11 @@ elements of the `valarray<T>` object to which the `indirect_array`
 object refers.
 If the `indirect_array` specifies an element in the `valarray<T>` object
 to which it refers more than once, the behavior is undefined.
-#### `indirect_array` fill function <a id="indirect.array.fill">[[indirect.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
@@ -5010,22 +5367,22 @@ argument to the elements of the `valarray<T>` object to which the
 `indirect_array` object refers.
 ### `valarray` range access <a id="valarray.range">[[valarray.range]]</a>
 In the `begin` and `end` function templates that follow, *unspecified*1
-is a type that meets the requirements of a mutable random access
-iterator ([[random.access.iterators]]) and of a contiguous iterator (
-[[iterator.requirements.general]]) whose `value_type` is the template
-parameter `T` and whose `reference` type is `T&`. *unspecified*2 is a
-type that meets the requirements of a constant random access iterator (
-[[random.access.iterators]]) and of a contiguous iterator (
-[[iterator.requirements.general]]) whose `value_type` is the template
-parameter `T` and whose `reference` type is `const T&`.
 The iterators returned by `begin` and `end` for an array are guaranteed
-to be valid until the member function `resize(size_t, T)` (
-[[valarray.members]]) is called for that array or until the lifetime of
 that array ends, whichever happens first.
 ``` cpp
 template<class T> unspecified{1} begin(valarray<T>& v);
 template<class T> unspecified{2} begin(const valarray<T>& v);
@@ -5038,950 +5395,10 @@ template <class T> unspecified{1} end(valarray<T>& v);
 template<class T> unspecified{2} end(const valarray<T>& v);
 ```
 *Returns:* An iterator referencing one past the last value in the array.
-## Generalized numeric operations <a id="numeric.ops">[[numeric.ops]]</a>
-### Header `<numeric>` synopsis <a id="numeric.ops.overview">[[numeric.ops.overview]]</a>
-``` cpp
-namespace std {
-  // [accumulate], accumulate
-  template <class InputIterator, class T>
-    T accumulate(InputIterator first, InputIterator last, T init);
-  template <class InputIterator, class T, class BinaryOperation>
-    T accumulate(InputIterator first, InputIterator last, T init,
-                 BinaryOperation binary_op);
-  // [reduce], reduce
-  template<class InputIterator>
-    typename iterator_traits<InputIterator>::value_type
-      reduce(InputIterator first, InputIterator last);
-  template<class InputIterator, class T>
-    T reduce(InputIterator first, InputIterator last, T init);
-  template<class InputIterator, class T, class BinaryOperation>
-    T reduce(InputIterator first, InputIterator last, T init,
-             BinaryOperation binary_op);
-  template<class ExecutionPolicy, class ForwardIterator>
-    typename iterator_traits<ForwardIterator>::value_type
-      reduce(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-             ForwardIterator first, ForwardIterator last);
-  template<class ExecutionPolicy, class ForwardIterator, class T>
-    T reduce(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-             ForwardIterator first, ForwardIterator last, T init);
-  template<class ExecutionPolicy, class ForwardIterator, class T, class BinaryOperation>
-    T reduce(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-             ForwardIterator first, ForwardIterator last, T init,
-             BinaryOperation binary_op);
-  // [inner.product], inner product
-  template <class InputIterator1, class InputIterator2, class T>
-    T inner_product(InputIterator1 first1, InputIterator1 last1,
-                    InputIterator2 first2, T init);
-  template <class InputIterator1, class InputIterator2, class T,
-            class BinaryOperation1, class BinaryOperation2>
-    T inner_product(InputIterator1 first1, InputIterator1 last1,
-                    InputIterator2 first2, T init,
-                    BinaryOperation1 binary_op1,
-                    BinaryOperation2 binary_op2);
-  // [transform.reduce], transform reduce
-  template<class InputIterator1, class InputIterator2, class T>
-    T transform_reduce(InputIterator1 first1, InputIterator1 last1,
-                       InputIterator2 first2,
-                       T init);
-  template<class InputIterator1, class InputIterator2, class T,
-           class BinaryOperation1, class BinaryOperation2>
-    T transform_reduce(InputIterator1 first1, InputIterator1 last1,
-                       InputIterator2 first2,
-                       T init,
-                       BinaryOperation1 binary_op1,
-                       BinaryOperation2 binary_op2);
-  template<class InputIterator, class T,
-           class BinaryOperation, class UnaryOperation>
-    T transform_reduce(InputIterator first, InputIterator last,
-                       T init,
-                       BinaryOperation binary_op, UnaryOperation unary_op);
-  template<class ExecutionPolicy,
-           class ForwardIterator1, class ForwardIterator2, class T>
-    T transform_reduce(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                       ForwardIterator1 first1, ForwardIterator1 last1,
-                       ForwardIterator2 first2,
-                       T init);
-  template<class ExecutionPolicy,
-           class ForwardIterator1, class ForwardIterator2, class T,
-           class BinaryOperation1, class BinaryOperation2>
-    T transform_reduce(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                       ForwardIterator1 first1, ForwardIterator1 last1,
-                       ForwardIterator2 first2,
-                       T init,
-                       BinaryOperation1 binary_op1,
-                       BinaryOperation2 binary_op2);
-  template<class ExecutionPolicy,
-           class ForwardIterator, class T,
-           class BinaryOperation, class UnaryOperation>
-    T transform_reduce(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                       ForwardIterator first, ForwardIterator last,
-                       T init,
-                       BinaryOperation binary_op, UnaryOperation unary_op);
-  // [partial.sum], partial sum
-  template <class InputIterator, class OutputIterator>
-    OutputIterator partial_sum(InputIterator first,
-                               InputIterator last,
-                               OutputIterator result);
-  template <class InputIterator, class OutputIterator, class BinaryOperation>
-    OutputIterator partial_sum(InputIterator first,
-                               InputIterator last,
-                               OutputIterator result,
-                               BinaryOperation binary_op);
-  // [exclusive.scan], exclusive scan
-  template<class InputIterator, class OutputIterator, class T>
-    OutputIterator exclusive_scan(InputIterator first, InputIterator last,
-                                  OutputIterator result,
-                                  T init);
-  template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
-    OutputIterator exclusive_scan(InputIterator first, InputIterator last,
-                                  OutputIterator result,
-                                  T init, BinaryOperation binary_op);
-  template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
-    ForwardIterator2 exclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                    ForwardIterator1 first, ForwardIterator1 last,
-                                    ForwardIterator2 result,
-                                    T init);
-  template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T,
-           class BinaryOperation>
-    ForwardIterator2 exclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                    ForwardIterator1 first, ForwardIterator1 last,
-                                    ForwardIterator2 result,
-                                    T init, BinaryOperation binary_op);
-  // [inclusive.scan], inclusive scan
-  template<class InputIterator, class OutputIterator>
-    OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                                  OutputIterator result);
-  template<class InputIterator, class OutputIterator, class BinaryOperation>
-    OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                                  OutputIterator result,
-                                  BinaryOperation binary_op);
-  template<class InputIterator, class OutputIterator, class BinaryOperation, class T>
-    OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                                  OutputIterator result,
-                                  BinaryOperation binary_op, T init);
-  template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-    ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                    ForwardIterator1 first, ForwardIterator1 last,
-                                    ForwardIterator2 result);
-  template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
-           class BinaryOperation>
-    ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                    ForwardIterator1 first, ForwardIterator1 last,
-                                    ForwardIterator2 result,
-                                    BinaryOperation binary_op);
-  template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
-           class BinaryOperation, class T>
-    ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                    ForwardIterator1 first, ForwardIterator1 last,
-                                    ForwardIterator2 result,
-                                    BinaryOperation binary_op, T init);
-  // [transform.exclusive.scan], transform exclusive scan
-  template<class InputIterator, class OutputIterator, class T,
-           class BinaryOperation, class UnaryOperation>
-    OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
-                                            OutputIterator result,
-                                            T init,
-                                            BinaryOperation binary_op,
-                                            UnaryOperation unary_op);
-  template<class ExecutionPolicy,
-           class ForwardIterator1, class ForwardIterator2, class T,
-           class BinaryOperation, class UnaryOperation>
-    ForwardIterator2 transform_exclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                              ForwardIterator1 first, ForwardIterator1 last,
-                                              ForwardIterator2 result,
-                                              T init,
-                                              BinaryOperation binary_op,
-                                              UnaryOperation unary_op);
-  // [transform.inclusive.scan], transform inclusive scan
-  template<class InputIterator, class OutputIterator,
-           class BinaryOperation, class UnaryOperation>
-    OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
-                                            OutputIterator result,
-                                            BinaryOperation binary_op,
-                                            UnaryOperation unary_op);
-  template<class InputIterator, class OutputIterator,
-           class BinaryOperation, class UnaryOperation, class T>
-    OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
-                                            OutputIterator result,
-                                            BinaryOperation binary_op,
-                                            UnaryOperation unary_op,
-                                            T init);
-  template<class ExecutionPolicy,
-           class ForwardIterator1, class ForwardIterator2,
-           class BinaryOperation, class UnaryOperation>
-    ForwardIterator2 transform_inclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                              ForwardIterator1 first, ForwardIterator1 last,
-                                              ForwardIterator2 result,
-                                              BinaryOperation binary_op,
-                                              UnaryOperation unary_op);
-  template<class ExecutionPolicy,
-           class ForwardIterator1, class ForwardIterator2,
-           class BinaryOperation, class UnaryOperation, class T>
-    ForwardIterator2 transform_inclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                              ForwardIterator1 first, ForwardIterator1 last,
-                                              ForwardIterator2 result,
-                                              BinaryOperation binary_op,
-                                              UnaryOperation unary_op,
-                                              T init);
-  // [adjacent.difference], adjacent difference
-  template <class InputIterator, class OutputIterator>
-    OutputIterator adjacent_difference(InputIterator first,
-                                       InputIterator last,
-                                       OutputIterator result);
-  template <class InputIterator, class OutputIterator, class BinaryOperation>
-    OutputIterator adjacent_difference(InputIterator first,
-                                       InputIterator last,
-                                       OutputIterator result,
-                                       BinaryOperation binary_op);
-  template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-    ForwardIterator2 adjacent_difference(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                         ForwardIterator1 first,
-                                         ForwardIterator1 last,
-                                         ForwardIterator2 result);
-  template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
-            class BinaryOperation>
-    ForwardIterator2 adjacent_difference(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                         ForwardIterator1 first,
-                                         ForwardIterator1 last,
-                                         ForwardIterator2 result,
-                                         BinaryOperation binary_op);
-  // [numeric.iota], iota
-  template <class ForwardIterator, class T>
-    void iota(ForwardIterator first, ForwardIterator last, T value);
-  // [numeric.ops.gcd], greatest common divisor
-  template <class M, class N>
-    constexpr common_type_t<M,N> gcd(M m, N n);
-  // [numeric.ops.lcm], least common multiple
-  template <class M, class N>
-    constexpr common_type_t<M,N> lcm(M m, N n);
-}
-```
-The requirements on the types of algorithms’ arguments that are
-described in the introduction to Clause  [[algorithms]] also apply to
-the following algorithms.
-Throughout this subclause, the parameters `UnaryOperation`,
-`BinaryOperation`, `BinaryOperation1`, and `BinaryOperation2` are used
-whenever an algorithm expects a function object ([[function.objects]]).
-[*Note 1*: The use of closed ranges as well as semi-open ranges to
-specify requirements throughout this subclause is
-intentional. — *end note*]
-### Accumulate <a id="accumulate">[[accumulate]]</a>
-``` cpp
-template <class InputIterator, class T>
-  T accumulate(InputIterator first, InputIterator last, T init);
-template <class InputIterator, class T, class BinaryOperation>
-  T accumulate(InputIterator first, InputIterator last, T init,
-               BinaryOperation binary_op);
-```
-*Requires:* `T` shall meet the requirements of `CopyConstructible`
-(Table  [[tab:copyconstructible]]) and `CopyAssignable`
-(Table  [[tab:copyassignable]]) types. In the range \[`first`, `last`\],
-`binary_op` shall neither modify elements nor invalidate iterators or
-subranges.[^13]
-*Effects:* Computes its result by initializing the accumulator `acc`
-with the initial value `init` and then modifies it with `acc = acc + *i`
-or `acc = binary_op(acc, *i)` for every iterator `i` in the range
-\[`first`, `last`) in order.[^14]
-### Reduce <a id="reduce">[[reduce]]</a>
-``` cpp
-template<class InputIterator>
-  typename iterator_traits<InputIterator>::value_type
-    reduce(InputIterator first, InputIterator last);
-```
-*Effects:* Equivalent to:
-``` cpp
-return reduce(first, last,
-              typename iterator_traits<InputIterator>::value_type{});
-```
-``` cpp
-template<class ExecutionPolicy, class ForwardIterator>
-  typename iterator_traits<ForwardIterator>::value_type
-    reduce(ExecutionPolicy&& exec,
-           ForwardIterator first, ForwardIterator last);
-```
-*Effects:* Equivalent to:
-``` cpp
-return reduce(std::forward<ExecutionPolicy>(exec), first, last,
-              typename iterator_traits<ForwardIterator>::value_type{});
-```
-``` cpp
-template<class InputIterator, class T>
-  T reduce(InputIterator first, InputIterator last, T init);
-```
-*Effects:* Equivalent to:
-``` cpp
-return reduce(first, last, init, plus<>());
-```
-``` cpp
-template<class ExecutionPolicy, class ForwardIterator, class T>
-  T reduce(ExecutionPolicy&& exec,
-           ForwardIterator first, ForwardIterator last, T init);
-```
-*Effects:* Equivalent to:
-``` cpp
-return reduce(std::forward<ExecutionPolicy>(exec), first, last, init, plus<>());
-```
-``` cpp
-template<class InputIterator, class T, class BinaryOperation>
-  T reduce(InputIterator first, InputIterator last, T init,
-           BinaryOperation binary_op);
-template<class ExecutionPolicy, class ForwardIterator, class T, class BinaryOperation>
-  T reduce(ExecutionPolicy&& exec,
-           ForwardIterator first, ForwardIterator last, T init,
-           BinaryOperation binary_op);
-```
-*Requires:*
-- `T` shall be `MoveConstructible` (Table  [[tab:moveconstructible]]).
-- All of `binary_op(init, *first)`, `binary_op(*first, init)`,
-  `binary_op(init, init)`, and `binary_op(*first, *first)` shall be
-  convertible to `T`.
-- `binary_op` shall neither invalidate iterators or subranges, nor
-  modify elements in the range \[`first`, `last`\].
-*Returns:* *GENERALIZED_SUM*(binary_op, init, \*i, ...) for every `i` in
-\[`first`, `last`).
-*Complexity:* 𝑂(`last - first`) applications of `binary_op`.
-[*Note 1*: The difference between `reduce` and `accumulate` is that
-`reduce` applies `binary_op` in an unspecified order, which yields a
-nondeterministic result for non-associative or non-commutative
-`binary_op` such as floating-point addition. — *end note*]
-### Inner product <a id="inner.product">[[inner.product]]</a>
-``` cpp
-template <class InputIterator1, class InputIterator2, class T>
-  T inner_product(InputIterator1 first1, InputIterator1 last1,
-                  InputIterator2 first2, T init);
-template <class InputIterator1, class InputIterator2, class T,
-          class BinaryOperation1, class BinaryOperation2>
-  T inner_product(InputIterator1 first1, InputIterator1 last1,
-                  InputIterator2 first2, T init,
-                  BinaryOperation1 binary_op1,
-                  BinaryOperation2 binary_op2);
-```
-*Requires:* `T` shall meet the requirements of `CopyConstructible`
-(Table  [[tab:copyconstructible]]) and `CopyAssignable`
-(Table  [[tab:copyassignable]]) types. In the ranges \[`first1`,
-`last1`\] and \[`first2`, `first2 + (last1 - first1)`\] `binary_op1` and
-`binary_op2` shall neither modify elements nor invalidate iterators or
-subranges.[^15]
-*Effects:* Computes its result by initializing the accumulator `acc`
-with the initial value `init` and then modifying it with
-`acc = acc + (*i1) * (*i2)` or
-`acc = binary_op1(acc, binary_op2(*i1, *i2))` for every iterator `i1` in
-the range \[`first1`, `last1`) and iterator `i2` in the range
-\[`first2`, `first2 + (last1 - first1)`) in order.
-### Transform reduce <a id="transform.reduce">[[transform.reduce]]</a>
-``` cpp
-template <class InputIterator1, class InputIterator2, class T>
-  T transform_reduce(InputIterator1 first1, InputIterator1 last1,
-                     InputIterator2 first2,
-                     T init);
-template <class ExecutionPolicy,
-          class ForwardIterator1, class ForwardIterator2, class T>
-  T transform_reduce(ExecutionPolicy&& exec,
-                     ForwardIterator1 first1, ForwardIterator1 last1,
-                     ForwardIterator2 first2,
-                     T init);
-```
-*Effects:* Equivalent to:
-``` cpp
-return transform_reduce(first1, last1, first2, init, plus<>(), multiplies<>());
-```
-``` cpp
-template <class InputIterator1, class InputIterator2, class T,
-          class BinaryOperation1, class BinaryOperation2>
-  T transform_reduce(InputIterator1 first1, InputIterator1 last1,
-                     InputIterator2 first2,
-                     T init,
-                     BinaryOperation1 binary_op1,
-                     BinaryOperation2 binary_op2);
-template <class ExecutionPolicy,
-          class ForwardIterator1, class ForwardIterator2, class T,
-          class BinaryOperation1, class BinaryOperation2>
-  T transform_reduce(ExecutionPolicy&& exec,
-                     ForwardIterator1 first1, ForwardIterator1 last1,
-                     ForwardIterator2 first2,
-                     T init,
-                     BinaryOperation1 binary_op1,
-                     BinaryOperation2 binary_op2);
-```
-*Requires:*
-- `T` shall be `MoveConstructible` (Table  [[tab:moveconstructible]]).
-- All of
-  - `binary_op1(init, init)`,
-  - `binary_op1(init, binary_op2(*first1, *first2))`,
-  - `binary_op1(binary_op2(*first1, *first2), init)`, and
-  - `binary_op1(binary_op2(*first1, *first2), binary_op2(*first1, *first2))`
-  shall be convertible to `T`.
-- Neither `binary_op1` nor `binary_op2` shall invalidate subranges, or
-  modify elements in the ranges \[`first1`, `last1`\] and \[`first2`,
-  `first2 + (last1 - first1)`\].
-*Returns:*
-``` cpp
-GENERALIZED_SUM(binary_op1, init, binary_op2(*i, *(first2 + (i - first1))), ...)
-```
-for every iterator `i` in \[`first1`, `last1`).
-*Complexity:* 𝑂(`last1 - first1`) applications each of `binary_op1` and
-`binary_op2`.
-``` cpp
-template<class InputIterator, class T,
-         class BinaryOperation, class UnaryOperation>
-  T transform_reduce(InputIterator first, InputIterator last, T init,
-                     BinaryOperation binary_op, UnaryOperation unary_op);
-template<class ExecutionPolicy,
-         class ForwardIterator, class T,
-         class BinaryOperation, class UnaryOperation>
-  T transform_reduce(ExecutionPolicy&& exec,
-                     ForwardIterator first, ForwardIterator last,
-                     T init, BinaryOperation binary_op, UnaryOperation unary_op);
-```
-*Requires:*
-- `T` shall be `MoveConstructible` (Table  [[tab:moveconstructible]]).
-- All of
-  - `binary_op(init, init)`,
-  - `binary_op(init, unary_op(*first))`,
-  - `binary_op(unary_op(*first), init)`, and
-  - `binary_op(unary_op(*first), unary_op(*first))`
-  shall be convertible to `T`.
-- Neither `unary_op` nor `binary_op` shall invalidate subranges, or
-  modify elements in the range \[`first`, `last`\].
-*Returns:*
-``` cpp
-GENERALIZED_SUM(binary_op, init, unary_op(*i), ...)
-```
-for every iterator `i` in \[`first`, `last`).
-*Complexity:* 𝑂(`last - first`) applications each of `unary_op` and
-`binary_op`.
-[*Note 1*: `transform_reduce` does not apply `unary_op` to
-`init`. — *end note*]
-### Partial sum <a id="partial.sum">[[partial.sum]]</a>
-``` cpp
-template <class InputIterator, class OutputIterator>
-  OutputIterator partial_sum(
-    InputIterator first, InputIterator last,
-    OutputIterator result);
-template <class InputIterator, class OutputIterator, class BinaryOperation>
-  OutputIterator partial_sum(
-    InputIterator first, InputIterator last,
-    OutputIterator result, BinaryOperation binary_op);
-```
-*Requires:* `InputIterator`’s value type shall be constructible from the
-type of `*first`. The result of the expression `acc + *i` or
-`binary_op(acc, *i)` shall be implicitly convertible to
-`InputIterator`’s value type. `acc` shall be
-writable ([[iterator.requirements.general]]) to the `result` output
-iterator. In the ranges \[`first`, `last`\] and \[`result`,
-`result + (last - first)`\] `binary_op` shall neither modify elements
-nor invalidate iterators or subranges.[^16]
-*Effects:* For a non-empty range, the function creates an accumulator
-`acc` whose type is `InputIterator`’s value type, initializes it with
-`*first`, and assigns the result to `*result`. For every iterator `i` in
-\[`first + 1`, `last`) in order, `acc` is then modified by
-`acc = acc + *i` or `acc = binary_op(acc, *i)` and the result is
-assigned to `*(result + (i - first))`.
-*Returns:* `result + (last - first)`.
-*Complexity:* Exactly `(last - first) - 1` applications of the binary
-operation.
-*Remarks:* `result` may be equal to `first`.
-### Exclusive scan <a id="exclusive.scan">[[exclusive.scan]]</a>
-``` cpp
-template<class InputIterator, class OutputIterator, class T>
-  OutputIterator exclusive_scan(InputIterator first, InputIterator last,
-                                OutputIterator result,
-                                T init);
-```
-*Effects:* Equivalent to:
-``` cpp
-return exclusive_scan(first, last, result, init, plus<>());
-```
-``` cpp
-template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
-  ForwardIterator2 exclusive_scan(ExecutionPolicy&& exec,
-                                  ForwardIterator1 first, ForwardIterator1 last,
-                                  ForwardIterator2 result,
-                                  T init);
-```
-*Effects:* Equivalent to:
-``` cpp
-return exclusive_scan(std::forward<ExecutionPolicy>(exec),
-                      first, last, result, init, plus<>());
-```
-``` cpp
-template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
-  OutputIterator exclusive_scan(InputIterator first, InputIterator last,
-                                OutputIterator result,
-                                T init, BinaryOperation binary_op);
-template<class ExecutionPolicy,
-         class ForwardIterator1, class ForwardIterator2, class T, class BinaryOperation>
-  ForwardIterator2 exclusive_scan(ExecutionPolicy&& exec,
-                                  ForwardIterator1 first, ForwardIterator1 last,
-                                  ForwardIterator2 result,
-                                  T init, BinaryOperation binary_op);
-```
-*Requires:*
-- `T` shall be `MoveConstructible` (Table  [[tab:moveconstructible]]).
-- All of `binary_op(init, init)`, `binary_op(init, *first)`, and
-  `binary_op(*first, *first)` shall be convertible to `T`.
-- `binary_op` shall neither invalidate iterators or subranges, nor
-  modify elements in the ranges \[`first`, `last`\] or \[`result`,
-  `result + (last - first)`\].
-*Effects:* For each integer `K` in \[`0`, `last - first`) assigns
-through `result + K` the value of:
-``` cpp
-GENERALIZED_NONCOMMUTATIVE_SUM(
-    binary_op, init, *(first + 0), *(first + 1), ..., *(first + K - 1))
-```
-*Returns:* The end of the resulting range beginning at `result`.
-*Complexity:* 𝑂(`last - first`) applications of `binary_op`.
-*Remarks:* `result` may be equal to `first`.
-[*Note 1*: The difference between `exclusive_scan` and `inclusive_scan`
-is that `exclusive_scan` excludes the `i`th input element from the `i`th
-sum. If `binary_op` is not mathematically associative, the behavior of
-`exclusive_scan` may be nondeterministic. — *end note*]
-### Inclusive scan <a id="inclusive.scan">[[inclusive.scan]]</a>
-``` cpp
-template<class InputIterator, class OutputIterator>
-  OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                                OutputIterator result);
-```
-*Effects:* Equivalent to:
-``` cpp
-return inclusive_scan(first, last, result, plus<>());
-```
-``` cpp
-template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-  ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec,
-                                ForwardIterator1 first, ForwardIterator1 last,
-                                ForwardIterator2 result);
-```
-*Effects:* Equivalent to:
-``` cpp
-return inclusive_scan(std::forward<ExecutionPolicy>(exec), first, last, result, plus<>());
-```
-``` cpp
-template<class InputIterator, class OutputIterator, class BinaryOperation>
-  OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                                OutputIterator result,
-                                BinaryOperation binary_op);
-template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
-         class BinaryOperation>
-  ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec,
-                                  ForwardIterator1 first, ForwardIterator1 last,
-                                  ForwardIterator2 result,
-                                  BinaryOperation binary_op);
-template<class InputIterator, class OutputIterator, class BinaryOperation, class T>
-  OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                                OutputIterator result,
-                                BinaryOperation binary_op, T init);
-template<class ExecutionPolicy,
-         class ForwardIterator1, class ForwardIterator2, class BinaryOperation, class T>
-  ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec,
-                                  ForwardIterator1 first, ForwardIterator1 last,
-                                  ForwardIterator2 result,
-                                  BinaryOperation binary_op, T init);
-```
-*Requires:*
-- If `init` is provided, `T` shall be `MoveConstructible`
-  (Table  [[tab:moveconstructible]]); otherwise, `ForwardIterator1`’s
-  value type shall be `MoveConstructible`.
-- If `init` is provided, all of `binary_op(init, init)`,
-  `binary_op(init, *first)`, and `binary_op(*first, *first)` shall be
-  convertible to `T`; otherwise, `binary_op(*first, *first)` shall be
-  convertible to `ForwardIterator1`’s value type.
-- `binary_op` shall neither invalidate iterators or subranges, nor
-  modify elements in the ranges \[`first`, `last`\] or \[`result`,
-  `result + (last - first)`\].
-*Effects:* For each integer `K` in \[`0`, `last - first`) assigns
-through `result + K` the value of
-- *GENERALIZED_NONCOMMUTATIVE_SUM*(
-      binary_op, init, \*(first + 0), \*(first + 1), ..., \*(first +
-  K))
-  if `init` is provided, or
-- *GENERALIZED_NONCOMMUTATIVE_SUM*(
-      binary_op, \*(first + 0), \*(first + 1), ..., \*(first + K))
-  otherwise.
-*Returns:* The end of the resulting range beginning at `result`.
-*Complexity:* 𝑂(`last - first`) applications of `binary_op`.
-*Remarks:* `result` may be equal to `first`.
-[*Note 1*: The difference between `exclusive_scan` and `inclusive_scan`
-is that `inclusive_scan` includes the `i`th input element in the `i`th
-sum. If `binary_op` is not mathematically associative, the behavior of
-`inclusive_scan` may be nondeterministic. — *end note*]
-### Transform exclusive scan <a id="transform.exclusive.scan">[[transform.exclusive.scan]]</a>
-``` cpp
-template<class InputIterator, class OutputIterator, class T,
-         class BinaryOperation, class UnaryOperation>
-  OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
-                                          OutputIterator result,
-                                          T init,
-                                          BinaryOperation binary_op,
-                                          UnaryOperation unary_op);
-template<class ExecutionPolicy,
-         class ForwardIterator1, class ForwardIterator2, class T,
-         class BinaryOperation, class UnaryOperation>
-  ForwardIterator2 transform_exclusive_scan(ExecutionPolicy&& exec,
-                                            ForwardIterator1 first, ForwardIterator1 last,
-                                            ForwardIterator2 result,
-                                            T init,
-                                            BinaryOperation binary_op,
-                                            UnaryOperation unary_op);
-```
-*Requires:*
-- `T` shall be `MoveConstructible` (Table  [[tab:moveconstructible]]).
-- All of
-  - `binary_op(init, init)`,
-  - `binary_op(init, unary_op(*first))`, and
-  - `binary_op(unary_op(*first), unary_op(*first))`
-  shall be convertible to `T`.
-- Neither `unary_op` nor `binary_op` shall invalidate iterators or
-  subranges, or modify elements in the ranges \[`first`, `last`\] or
-  \[`result`, `result + (last - first)`\].
-*Effects:* For each integer `K` in \[`0`, `last - first`) assigns
-through `result + K` the value of:
-``` cpp
-GENERALIZED_NONCOMMUTATIVE_SUM(
-    binary_op, init,
-    unary_op(*(first + 0)), unary_op(*(first + 1)), ..., unary_op(*(first + K - 1)))
-```
-*Returns:* The end of the resulting range beginning at `result`.
-*Complexity:* 𝑂(`last - first`) applications each of `unary_op` and
-`binary_op`.
-*Remarks:* `result` may be equal to `first`.
-[*Note 1*: The difference between `transform_exclusive_scan` and
-`transform_inclusive_scan` is that `transform_exclusive_scan` excludes
-the iᵗʰ input element from the iᵗʰ sum. If `binary_op` is not
-mathematically associative, the behavior of `transform_exclusive_scan`
-may be nondeterministic. `transform_exclusive_scan` does not apply
-`unary_op` to `init`. — *end note*]
-### Transform inclusive scan <a id="transform.inclusive.scan">[[transform.inclusive.scan]]</a>
-``` cpp
-template<class InputIterator, class OutputIterator,
-         class BinaryOperation, class UnaryOperation>
-  OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
-                                          OutputIterator result,
-                                          BinaryOperation binary_op,
-                                          UnaryOperation unary_op);
-template<class ExecutionPolicy,
-         class ForwardIterator1, class ForwardIterator2,
-         class BinaryOperation, class UnaryOperation>
-  ForwardIterator2 transform_inclusive_scan(ExecutionPolicy&& exec,
-                                            ForwardIterator1 first, ForwardIterator1 last,
-                                            ForwardIterator2 result,
-                                            BinaryOperation binary_op,
-                                            UnaryOperation unary_op);
-template<class InputIterator, class OutputIterator,
-         class BinaryOperation, class UnaryOperation, class T>
-  OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
-                                          OutputIterator result,
-                                          BinaryOperation binary_op,
-                                          UnaryOperation unary_op,
-                                          T init);
-template<class ExecutionPolicy,
-         class ForwardIterator1, class ForwardIterator2,
-         class BinaryOperation, class UnaryOperation, class T>
-  ForwardIterator2 transform_inclusive_scan(ExecutionPolicy&& exec,
-                                            ForwardIterator1 first, ForwardIterator1 last,
-                                            ForwardIterator2 result,
-                                            BinaryOperation binary_op,
-                                            UnaryOperation unary_op,
-                                            T init);
-```
-*Requires:*
-- If `init` is provided, `T` shall be `MoveConstructible`
-  (Table  [[tab:moveconstructible]]); otherwise, `ForwardIterator1`’s
-  value type shall be `MoveConstructible`.
-- If `init` is provided, all of
-  - `binary_op(init, init)`,
-  - `binary_op(init, unary_op(*first))`, and
-  - `binary_op(unary_op(*first), unary_op(*first))`
-  shall be convertible to `T`; otherwise,
-  `binary_op(unary_op(*first), unary_op(*first))` shall be convertible
-  to `ForwardIterator1`’s value type.
-- Neither `unary_op` nor `binary_op` shall invalidate iterators or
-  subranges, nor modify elements in the ranges \[`first`, `last`\] or
-  \[`result`, `result + (last - first)`\].
-*Effects:* For each integer `K` in \[`0`, `last - first`) assigns
-through `result + K` the value of
-- *GENERALIZED_NONCOMMUTATIVE_SUM*(
-      binary_op, init,
-      unary_op(\*(first + 0)), unary_op(\*(first + 1)), ...,
-  unary_op(\*(first + K)))
-  if `init` is provided, or
-- *GENERALIZED_NONCOMMUTATIVE_SUM*(
-      binary_op,
-      unary_op(\*(first + 0)), unary_op(\*(first + 1)), ...,
-  unary_op(\*(first + K)))
-  otherwise.
-*Returns:* The end of the resulting range beginning at `result`.
-*Complexity:* 𝑂(`last - first`) applications each of `unary_op` and
-`binary_op`.
-*Remarks:* `result` may be equal to `first`.
-[*Note 1*: The difference between `transform_exclusive_scan` and
-`transform_inclusive_scan` is that `transform_inclusive_scan` includes
-the iᵗʰ input element in the iᵗʰ sum. If `binary_op` is not
-mathematically associative, the behavior of `transform_inclusive_scan`
-may be nondeterministic. `transform_inclusive_scan` does not apply
-`unary_op` to `init`. — *end note*]
-### Adjacent difference <a id="adjacent.difference">[[adjacent.difference]]</a>
-``` cpp
-template <class InputIterator, class OutputIterator>
-  OutputIterator
-    adjacent_difference(InputIterator first, InputIterator last,
-                        OutputIterator result);
-template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-  ForwardIterator2
-    adjacent_difference(ExecutionPolicy&& exec,
-                        ForwardIterator1 first, ForwardIterator1 last,
-                        ForwardIterator2 result);
-template <class InputIterator, class OutputIterator, class BinaryOperation>
-  OutputIterator
-    adjacent_difference(InputIterator first, InputIterator last,
-                        OutputIterator result,
-                        BinaryOperation binary_op);
-template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
-          class BinaryOperation>
-  ForwardIterator2
-    adjacent_difference(ExecutionPolicy&& exec,
-                        ForwardIterator1 first, ForwardIterator1 last,
-                        ForwardIterator2 result,
-                        BinaryOperation binary_op);
-```
-*Requires:*
-- For the overloads with no `ExecutionPolicy`, `InputIterator`’s value
-  type shall be `MoveAssignable` (Table  [[tab:moveassignable]]) and
-  shall be constructible from the type of `*first`. `acc` (defined
-  below) shall be writable ([[iterator.requirements.general]]) to the
-  `result` output iterator. The result of the expression `val - acc` or
-  `binary_op(val, acc)` shall be writable to the `result` output
-  iterator.
-- For the overloads with an `ExecutionPolicy`, the value type of
-  `ForwardIterator1` shall be `CopyConstructible`
-  (Table  [[tab:copyconstructible]]), constructible from the expression
-  `*first - *first` or `binary_op(*first, *first)`, and assignable to
-  the value type of `ForwardIterator2`.
-- For all overloads, in the ranges \[`first`, `last`\] and \[`result`,
-  `result + (last - first)`\], `binary_op` shall neither modify elements
-  nor invalidate iterators or subranges.[^17]
-*Effects:* For the overloads with no `ExecutionPolicy` and a non-empty
-range, the function creates an accumulator `acc` whose type is
-`InputIterator`’s value type, initializes it with `*first`, and assigns
-the result to `*result`. For every iterator `i` in \[`first + 1`,
-`last`) in order, creates an object `val` whose type is
-`InputIterator`’s value type, initializes it with `*i`, computes
-`val - acc` or `binary_op(val, acc)`, assigns the result to
-`*(result + (i - first))`, and move assigns from `val` to `acc`.
-For the overloads with an `ExecutionPolicy` and a non-empty range, first
-the function creates an object whose type is `ForwardIterator1`’s value
-type, initializes it with `*first`, and assigns the result to `*result`.
-Then for every `d` in \[`1`, `last - first - 1`\], creates an object
-`val` whose type is `ForwardIterator1`’s value type, initializes it with
-`*(first + d) - *(first + d - 1)` or
-`binary_op(*(first + d), *(first + d - 1))`, and assigns the result to
-`*(result + d)`.
-*Returns:* `result + (last - first)`.
-*Complexity:* Exactly `(last - first) - 1` applications of the binary
-operation.
-*Remarks:* For the overloads with no `ExecutionPolicy`, `result` may be
-equal to `first`. For the overloads with an `ExecutionPolicy`, the
-ranges \[`first`, `last`) and \[`result`, `result + (last - first)`)
-shall not overlap.
-### Iota <a id="numeric.iota">[[numeric.iota]]</a>
-``` cpp
-template <class ForwardIterator, class T>
-  void iota(ForwardIterator first, ForwardIterator last, T value);
-```
-*Requires:* `T` shall be convertible to `ForwardIterator`’s value type.
-The expression `++val`, where `val` has type `T`, shall be well formed.
-*Effects:* For each element referred to by the iterator `i` in the range
-\[`first`, `last`), assigns `*i = value` and increments `value` as if by
-`++value`.
-*Complexity:* Exactly `last - first` increments and assignments.
-### Greatest common divisor <a id="numeric.ops.gcd">[[numeric.ops.gcd]]</a>
-``` cpp
-template <class M, class N>
-  constexpr common_type_t<M,N> gcd(M m, N n);
-```
-*Requires:* `|m|` and `|n|` shall be representable as a value of
-`common_type_t<M, N>`.
-[*Note 1*: These requirements ensure, for example, that
-`gcd(m, m) = |m|` is representable as a value of type
-`M`. — *end note*]
-*Remarks:* If either `M` or `N` is not an integer type, or if either is
-cv `bool`, the program is ill-formed.
-*Returns:* Zero when `m` and `n` are both zero. Otherwise, returns the
-greatest common divisor of `|m|` and `|n|`.
-*Throws:* Nothing.
-### Least common multiple <a id="numeric.ops.lcm">[[numeric.ops.lcm]]</a>
-``` cpp
-template <class M, class N>
-  constexpr common_type_t<M,N> lcm(M m, N n);
-```
-*Requires:* `|m|` and `|n|` shall be representable as a value of
-`common_type_t<M, N>`. The least common multiple of `|m|` and `|n|`
-shall be representable as a value of type `common_type_t<M,N>`.
-*Remarks:* If either `M` or `N` is not an integer type, or if either is
-cv `bool` the program is ill-formed.
-*Returns:* Zero when either `m` or `n` is zero. Otherwise, returns the
-least common multiple of `|m|` and `|n|`.
-*Throws:* Nothing.
 ## Mathematical functions for floating-point types <a id="c.math">[[c.math]]</a>
 ### Header `<cmath>` synopsis <a id="cmath.syn">[[cmath.syn]]</a>
 ``` cpp
@@ -6193,11 +5610,11 @@ namespace std {
   float fabsf(float x);
   long double fabsl(long double x);
   float hypot(float x, float y);        // see [library.c]
   double hypot(double x, double y);
-  long double hypot(double x, double y);  // see [library.c]
   float hypotf(float x, float y);
   long double hypotl(long double x, long double y);
   // [c.math.hypot3], three-dimensional hypotenuse
   float hypot(float x, float y, float z);
@@ -6362,123 +5779,128 @@ namespace std {
   double fma(double x, double y, double z);
   long double fma(long double x, long double y, long double z); // see [library.c]
   float fmaf(float x, float y, float z);
   long double fmal(long double x, long double y, long double z);
   // [c.math.fpclass], classification / comparison functions
   int fpclassify(float x);
   int fpclassify(double x);
   int fpclassify(long double x);
- int isfinite(float x);
- int isfinite(double x);
- int isfinite(long double x);
- int isinf(float x);
- int isinf(double x);
- int isinf(long double x);
- int isnan(float x);
- int isnan(double x);
- int isnan(long double x);
- int isnormal(float x);
- int isnormal(double x);
- int isnormal(long double x);
- int signbit(float x);
- int signbit(double x);
- int signbit(long double x);
- int isgreater(float x, float y);
- int isgreater(double x, double y);
- int isgreater(long double x, long double y);
- int isgreaterequal(float x, float y);
- int isgreaterequal(double x, double y);
- int isgreaterequal(long double x, long double y);
- int isless(float x, float y);
- int isless(double x, double y);
- int isless(long double x, long double y);
- int islessequal(float x, float y);
- int islessequal(double x, double y);
- int islessequal(long double x, long double y);
- int islessgreater(float x, float y);
- int islessgreater(double x, double y);
- int islessgreater(long double x, long double y);
- int isunordered(float x, float y);
- int isunordered(double x, double y);
- int isunordered(long double x, long double y);
   // [sf.cmath], mathematical special functions
-  // [sf.cmath.assoc_laguerre], associated Laguerre polynomials
   double       assoc_laguerre(unsigned n, unsigned m, double x);
   float        assoc_laguerref(unsigned n, unsigned m, float x);
   long double  assoc_laguerrel(unsigned n, unsigned m, long double x);
-  // [sf.cmath.assoc_legendre], associated Legendre functions
   double       assoc_legendre(unsigned l, unsigned m, double x);
   float        assoc_legendref(unsigned l, unsigned m, float x);
   long double  assoc_legendrel(unsigned l, unsigned m, long double x);
   // [sf.cmath.beta], beta function
   double       beta(double x, double y);
   float        betaf(float x, float y);
   long double  betal(long double x, long double y);
-  // [sf.cmath.comp_ellint_1], complete elliptic integral of the first kind
   double       comp_ellint_1(double k);
   float        comp_ellint_1f(float k);
   long double  comp_ellint_1l(long double k);
-  // [sf.cmath.comp_ellint_2], complete elliptic integral of the second kind
   double       comp_ellint_2(double k);
   float        comp_ellint_2f(float k);
   long double  comp_ellint_2l(long double k);
-  // [sf.cmath.comp_ellint_3], complete elliptic integral of the third kind
   double       comp_ellint_3(double k, double nu);
   float        comp_ellint_3f(float k, float nu);
   long double  comp_ellint_3l(long double k, long double nu);
-  // [sf.cmath.cyl_bessel_i], regular modified cylindrical Bessel functions
   double       cyl_bessel_i(double nu, double x);
   float        cyl_bessel_if(float nu, float x);
   long double  cyl_bessel_il(long double nu, long double x);
-  // [sf.cmath.cyl_bessel_j], cylindrical Bessel functions of the first kind
   double       cyl_bessel_j(double nu, double x);
   float        cyl_bessel_jf(float nu, float x);
   long double  cyl_bessel_jl(long double nu, long double x);
-  // [sf.cmath.cyl_bessel_k], irregular modified cylindrical Bessel functions
   double       cyl_bessel_k(double nu, double x);
   float        cyl_bessel_kf(float nu, float x);
   long double  cyl_bessel_kl(long double nu, long double x);
-  // [sf.cmath.cyl_neumann], cylindrical Neumann functions;
   // cylindrical Bessel functions of the second kind
   double       cyl_neumann(double nu, double x);
   float        cyl_neumannf(float nu, float x);
   long double  cyl_neumannl(long double nu, long double x);
-  // [sf.cmath.ellint_1], incomplete elliptic integral of the first kind
   double       ellint_1(double k, double phi);
   float        ellint_1f(float k, float phi);
   long double  ellint_1l(long double k, long double phi);
-  // [sf.cmath.ellint_2], incomplete elliptic integral of the second kind
   double       ellint_2(double k, double phi);
   float        ellint_2f(float k, float phi);
   long double  ellint_2l(long double k, long double phi);
-  // [sf.cmath.ellint_3], incomplete elliptic integral of the third kind
   double       ellint_3(double k, double nu, double phi);
   float        ellint_3f(float k, float nu, float phi);
   long double  ellint_3l(long double k, long double nu, long double phi);
   // [sf.cmath.expint], exponential integral
@@ -6499,27 +5921,27 @@ namespace std {
   // [sf.cmath.legendre], Legendre polynomials
   double       legendre(unsigned l, double x);
   float        legendref(unsigned l, float x);
   long double  legendrel(unsigned l, long double x);
-  // [sf.cmath.riemann_zeta], Riemann zeta function
   double       riemann_zeta(double x);
   float        riemann_zetaf(float x);
   long double  riemann_zetal(long double x);
-  // [sf.cmath.sph_bessel], spherical Bessel functions of the first kind
   double       sph_bessel(unsigned n, double x);
   float        sph_besself(unsigned n, float x);
   long double  sph_bessell(unsigned n, long double x);
-  // [sf.cmath.sph_legendre], spherical associated Legendre functions
   double       sph_legendre(unsigned l, unsigned m, double theta);
   float        sph_legendref(unsigned l, unsigned m, float theta);
   long double  sph_legendrel(unsigned l, unsigned m, long double theta);
-  // [sf.cmath.sph_neumann], spherical Neumann functions;
-  // spherical Bessel functions of the second kind:
   double       sph_neumann(unsigned n, double x);
   float        sph_neumannf(unsigned n, float x);
   long double  sph_neumannl(unsigned n, long double x);
 }
 ```
@@ -6528,38 +5950,37 @@ The contents and meaning of the header `<cmath>` are the same as the C
 standard library header `<math.h>`, with the addition of a
 three-dimensional hypotenuse function ([[c.math.hypot3]]) and the
 mathematical special functions described in [[sf.cmath]].
 [*Note 1*: Several functions have additional overloads in this
-International Standard, but they have the same behavior as in the C
-standard library ([[library.c]]). — *end note*]
 For each set of overloaded functions within `<cmath>`, with the
 exception of `abs`, there shall be additional overloads sufficient to
 ensure:
-1.  If any argument of arithmetic type corresponding to a `double`
   parameter has type `long double`, then all arguments of arithmetic
- type ([[basic.fundamental]]) corresponding to `double` parameters
-    are effectively cast to `long double`.
-2.  Otherwise, if any argument of arithmetic type corresponding to a
   `double` parameter has type `double` or an integer type, then all
- arguments of arithmetic type corresponding to `double` parameters
-    are effectively cast to `double`.
-3.  Otherwise, all arguments of arithmetic type corresponding to
- `double` parameters have type `float`.
-[*Note 2*: `abs` is exempted from these rules in order to stay
 compatible with C. — *end note*]
 ISO C 7.12
 ### Absolute values <a id="c.math.abs">[[c.math.abs]]</a>
-[*Note 1*: The headers `<cstdlib>` ([[cstdlib.syn]]) and `<cmath>` (
-[[cmath.syn]]) declare the functions described in this
-subclause. — *end note*]
 ``` cpp
 int abs(int j);
 long int abs(long int j);
 long long int abs(long long int j);
@@ -6572,16 +5993,16 @@ long double abs(long double j);
 standard library for the functions `abs`, `labs`, `llabs`, `fabsf`,
 `fabs`, and `fabsl`.
 *Remarks:* If `abs()` is called with an argument of type `X` for which
 `is_unsigned_v<X>` is `true` and if `X` cannot be converted to `int` by
-integral promotion ([[conv.prom]]), the program is ill-formed.
 [*Note 1*: Arguments that can be promoted to `int` are permitted for
 compatibility with C. — *end note*]
-ISO C 7.12.7.2, 7.22.6.1
 ### Three-dimensional hypotenuse <a id="c.math.hypot3">[[c.math.hypot3]]</a>
 ``` cpp
 float hypot(float x, float y, float z);
@@ -6589,10 +6010,34 @@ double hypot(double x, double y, double z);
 long double hypot(long double x, long double y, long double z);
 ```
 *Returns:* $\sqrt{x^2+y^2+z^2}$.
 ### Classification / comparison functions <a id="c.math.fpclass">[[c.math.fpclass]]</a>
 The classification / comparison functions behave the same as the C
 macros with the corresponding names defined in the C standard library.
 Each function is overloaded for the three floating-point types.
@@ -6609,54 +6054,48 @@ a domain error for just those argument values for which:
 - the function description’s *Returns:* clause explicitly specifies a
   domain and those argument values fall outside the specified domain, or
 - the corresponding mathematical function value has a nonzero imaginary
   component, or
 - the corresponding mathematical function is not mathematically
-  defined.[^18]
 Unless otherwise specified, each function is defined for all finite
 values, for negative infinity, and for positive infinity.
-#### Associated Laguerre polynomials <a id="sf.cmath.assoc_laguerre">[[sf.cmath.assoc_laguerre]]</a>
 ``` cpp
 double       assoc_laguerre(unsigned n, unsigned m, double x);
 float        assoc_laguerref(unsigned n, unsigned m, float x);
 long double  assoc_laguerrel(unsigned n, unsigned m, long double x);
 ```
 *Effects:* These functions compute the associated Laguerre polynomials
 of their respective arguments `n`, `m`, and `x`.
-*Returns:* $$%
- \mathsf{L}_n^m(x) =
-  (-1)^m \frac{\mathsf{d} ^ m}
-       {\mathsf{d}x ^ m} \, \mathsf{L}_{n+m}(x),
-       \quad \mbox{for $x \ge 0$}$$ where n is `n`, m is `m`, and x is
 `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128` or if `m >= 128`.
-#### Associated Legendre functions <a id="sf.cmath.assoc_legendre">[[sf.cmath.assoc_legendre]]</a>
 ``` cpp
 double       assoc_legendre(unsigned l, unsigned m, double x);
 float        assoc_legendref(unsigned l, unsigned m, float x);
 long double  assoc_legendrel(unsigned l, unsigned m, long double x);
 ```
 *Effects:* These functions compute the associated Legendre functions of
 their respective arguments `l`, `m`, and `x`.
-*Returns:* $$%
- \mathsf{P}_\ell^m(x) =
-  (1 - x^2) ^ {m/2}
-  \:
-  \frac{ \mathsf{d} ^ m}
-       { \mathsf{d}x ^ m} \, \mathsf{P}_\ell(x),
-       \quad \mbox{for $|x| \le 1$}$$ where l is `l`, m is `m`, and x is
 `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `l >= 128`.
@@ -6669,115 +6108,105 @@ long double  betal(long double x, long double y);
 ```
 *Effects:* These functions compute the beta function of their respective
 arguments `x` and `y`.
-*Returns:* $$%
- \mathsf{B}(x, y) =
- \frac{ \Gamma(x) \, \Gamma(y) }
-       { \Gamma(x+y) },
-       \quad \mbox{for $x > 0$,\, $y > 0$}$$ where x is `x` and y is
-`y`.
-#### Complete elliptic integral of the first kind <a id="sf.cmath.comp_ellint_1">[[sf.cmath.comp_ellint_1]]</a>
 ``` cpp
 double       comp_ellint_1(double k);
 float        comp_ellint_1f(float k);
 long double  comp_ellint_1l(long double k);
 ```
 *Effects:* These functions compute the complete elliptic integral of the
 first kind of their respective arguments `k`.
-*Returns:* $$%
- \mathsf{K}(k) =
-  \mathsf{F}(k, \pi / 2),
-              \quad \mbox{for $|k| \le 1$}$$ where k is `k`.
-See also [[sf.cmath.ellint_1]].
-#### Complete elliptic integral of the second kind <a id="sf.cmath.comp_ellint_2">[[sf.cmath.comp_ellint_2]]</a>
 ``` cpp
 double       comp_ellint_2(double k);
 float        comp_ellint_2f(float k);
 long double  comp_ellint_2l(long double k);
 ```
 *Effects:* These functions compute the complete elliptic integral of the
 second kind of their respective arguments `k`.
-*Returns:* $$%
- \mathsf{E}(k) =
-  \mathsf{E}(k, \pi / 2),
-\quad \mbox{for $|k| \le 1$}$$ where k is `k`.
-See also [[sf.cmath.ellint_2]].
-#### Complete elliptic integral of the third kind <a id="sf.cmath.comp_ellint_3">[[sf.cmath.comp_ellint_3]]</a>
 ``` cpp
 double       comp_ellint_3(double k, double nu);
 float        comp_ellint_3f(float k, float nu);
 long double  comp_ellint_3l(long double k, long double nu);
 ```
 *Effects:* These functions compute the complete elliptic integral of the
 third kind of their respective arguments `k` and `nu`.
-*Returns:* $$%
- \mathsf{\Pi}(\nu, k) = \mathsf{\Pi}(\nu, k, \pi / 2),
-        \quad \mbox{for $|k| \le 1$}$$ where k is `k` and $\nu$ is `nu`.
-See also [[sf.cmath.ellint_3]].
-#### Regular modified cylindrical Bessel functions <a id="sf.cmath.cyl_bessel_i">[[sf.cmath.cyl_bessel_i]]</a>
 ``` cpp
 double       cyl_bessel_i(double nu, double x);
 float        cyl_bessel_if(float nu, float x);
 long double  cyl_bessel_il(long double nu, long double x);
 ```
 *Effects:* These functions compute the regular modified cylindrical
 Bessel functions of their respective arguments `nu` and `x`.
-*Returns:* $$%
- \mathsf{I}_\nu(x) =
-  i^{-\nu} \mathsf{J}_\nu(ix)
-  =
-  \sum_{k=0}^\infty \frac{(x/2)^{\nu+2k}}
-             {k! \: \Gamma(\nu+k+1)},
-       \quad \mbox{for $x \ge 0$}$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
-See also [[sf.cmath.cyl_bessel_j]].
-#### Cylindrical Bessel functions of the first kind <a id="sf.cmath.cyl_bessel_j">[[sf.cmath.cyl_bessel_j]]</a>
 ``` cpp
 double       cyl_bessel_j(double nu, double x);
 float        cyl_bessel_jf(float nu, float x);
 long double  cyl_bessel_jl(long double nu, long double x);
 ```
 *Effects:* These functions compute the cylindrical Bessel functions of
 the first kind of their respective arguments `nu` and `x`.
-*Returns:* $$%
- \mathsf{J}_\nu(x) =
- \sum_{k=0}^\infty \frac{(-1)^k (x/2)^{\nu+2k}}
-             {k! \: \Gamma(\nu+k+1)},
-       \quad \mbox{for $x \ge 0$}$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
-#### Irregular modified cylindrical Bessel functions <a id="sf.cmath.cyl_bessel_k">[[sf.cmath.cyl_bessel_k]]</a>
 ``` cpp
 double       cyl_bessel_k(double nu, double x);
 float        cyl_bessel_kf(float nu, float x);
 long double  cyl_bessel_kl(long double nu, long double x);
@@ -6810,14 +6239,14 @@ Bessel functions of their respective arguments `nu` and `x`.
   \right.$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
-See also [[sf.cmath.cyl_bessel_i]], [[sf.cmath.cyl_bessel_j]],
-[[sf.cmath.cyl_neumann]].
-#### Cylindrical Neumann functions <a id="sf.cmath.cyl_neumann">[[sf.cmath.cyl_neumann]]</a>
 ``` cpp
 double       cyl_neumann(double nu, double x);
 float        cyl_neumannf(float nu, float x);
 long double  cyl_neumannl(long double nu, long double x);
@@ -6845,13 +6274,13 @@ their respective arguments `nu` and `x`.
   \right.$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
-See also [[sf.cmath.cyl_bessel_j]].
-#### Incomplete elliptic integral of the first kind <a id="sf.cmath.ellint_1">[[sf.cmath.ellint_1]]</a>
 ``` cpp
 double       ellint_1(double k, double phi);
 float        ellint_1f(float k, float phi);
 long double  ellint_1l(long double k, long double phi);
@@ -6859,17 +6288,15 @@ long double  ellint_1l(long double k, long double phi);
 *Effects:* These functions compute the incomplete elliptic integral of
 the first kind of their respective arguments `k` and `phi` (`phi`
 measured in radians).
-*Returns:* $$%
- \mathsf{F}(k, \phi) =
- \int_0^\phi \! \frac{\mathsf{d}\theta}
-                      {\sqrt{1 - k^2 \sin^2 \theta}},
-       \quad \mbox{for $|k| \le 1$}$$ where k is `k` and φ is `phi`.
-#### Incomplete elliptic integral of the second kind <a id="sf.cmath.ellint_2">[[sf.cmath.ellint_2]]</a>
 ``` cpp
 double       ellint_2(double k, double phi);
 float        ellint_2f(float k, float phi);
 long double  ellint_2l(long double k, long double phi);
@@ -6877,16 +6304,15 @@ long double  ellint_2l(long double k, long double phi);
 *Effects:* These functions compute the incomplete elliptic integral of
 the second kind of their respective arguments `k` and `phi` (`phi`
 measured in radians).
-*Returns:* $$%
- \mathsf{E}(k, \phi) =
- \int_0^\phi \! \sqrt{1 - k^2 \sin^2 \theta} \, \mathsf{d}\theta,
-       \quad \mbox{for $|k| \le 1$}$$ where k is `k` and φ is `phi`.
-#### Incomplete elliptic integral of the third kind <a id="sf.cmath.ellint_3">[[sf.cmath.ellint_3]]</a>
 ``` cpp
 double       ellint_3(double k, double nu, double phi);
 float        ellint_3f(float k, float nu, float phi);
 long double  ellint_3l(long double k, long double nu, long double phi);
@@ -6894,16 +6320,13 @@ long double  ellint_3l(long double k, long double nu, long double phi);
 *Effects:* These functions compute the incomplete elliptic integral of
 the third kind of their respective arguments `k`, `nu`, and `phi` (`phi`
 measured in radians).
-*Returns:* $$%
- \mathsf{\Pi}(\nu, k, \phi) =
-  \int_0^\phi \! \frac{ \mathsf{d}\theta }
-                      { (1 - \nu \, \sin^2 \theta) \sqrt{1 - k^2 \sin^2 \theta} },
-       \quad \mbox{for $|k| \le 1$}$$ where $\nu$ is `nu`, k is `k`, and
-φ is `phi`.
 #### Exponential integral <a id="sf.cmath.expint">[[sf.cmath.expint]]</a>
 ``` cpp
 double       expint(double x);
@@ -6949,15 +6372,13 @@ long double  laguerrel(unsigned n, long double x);
 ```
 *Effects:* These functions compute the Laguerre polynomials of their
 respective arguments `n` and `x`.
-*Returns:* $$%
- \mathsf{L}_n(x) =
- \frac{e^x}{n!} \frac{ \mathsf{d} ^ n}
-            { \mathsf{d}x ^ n} \, (x^n e^{-x}),
-       \quad \mbox{for $x \ge 0$}$$ where n is `n` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128`.
 #### Legendre polynomials <a id="sf.cmath.legendre">[[sf.cmath.legendre]]</a>
@@ -6969,22 +6390,19 @@ long double  legendrel(unsigned l, long double x);
 ```
 *Effects:* These functions compute the Legendre polynomials of their
 respective arguments `l` and `x`.
-*Returns:* $$%
- \mathsf{P}_\ell(x) =
- \frac{1}
-       {2^\ell \, \ell!}
-  \frac{ \mathsf{d} ^ \ell}
-       { \mathsf{d}x ^ \ell} \, (x^2 - 1) ^ \ell,
-       \quad \mbox{for $|x| \le 1$}$$ where l is `l` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `l >= 128`.
-#### Riemann zeta function <a id="sf.cmath.riemann_zeta">[[sf.cmath.riemann_zeta]]</a>
 ``` cpp
 double       riemann_zeta(double x);
 float        riemann_zetaf(float x);
 long double  riemann_zetal(long double x);
@@ -7014,32 +6432,31 @@ respective arguments `x`.
   & \mbox{for $x < 0$}
   \end{array}
   \right.
 \;$$ where x is `x`.
-#### Spherical Bessel functions of the first kind <a id="sf.cmath.sph_bessel">[[sf.cmath.sph_bessel]]</a>
 ``` cpp
 double       sph_bessel(unsigned n, double x);
 float        sph_besself(unsigned n, float x);
 long double  sph_bessell(unsigned n, long double x);
 ```
 *Effects:* These functions compute the spherical Bessel functions of the
 first kind of their respective arguments `n` and `x`.
-*Returns:* $$%
- \mathsf{j}_n(x) =
-  (\pi/2x)^{1\!/\!2} \mathsf{J}_{n + 1\!/\!2}(x),
-       \quad \mbox{for $x \ge 0$}$$ where n is `n` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128`.
-See also [[sf.cmath.cyl_bessel_j]].
-#### Spherical associated Legendre functions <a id="sf.cmath.sph_legendre">[[sf.cmath.sph_legendre]]</a>
 ``` cpp
 double       sph_legendre(unsigned l, unsigned m, double theta);
 float        sph_legendref(unsigned l, unsigned m, float theta);
 long double  sph_legendrel(unsigned l, unsigned m, long double theta);
@@ -7047,30 +6464,23 @@ long double  sph_legendrel(unsigned l, unsigned m, long double theta);
 *Effects:* These functions compute the spherical associated Legendre
 functions of their respective arguments `l`, `m`, and `theta` (`theta`
 measured in radians).
-*Returns:* $$%
- \mathsf{Y}_\ell^m(\theta, 0)
-\;$$ where $$%
- \mathsf{Y}_\ell^m(\theta, \phi) =
-  (-1)^m \left[ \frac{(2 \ell + 1)}
-                     {4 \pi}
-            \frac{(\ell - m)!}
-                 {(\ell + m)!}
-         \right]^{1/2}
-     \mathsf{P}_\ell^m
-     ( \cos\theta ) e ^ {i m \phi},
-       \quad \mbox{for $|m| \le \ell$}$$ and l is `l`, m is `m`, and θ
 is `theta`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `l >= 128`.
-See also [[sf.cmath.assoc_legendre]].
-#### Spherical Neumann functions <a id="sf.cmath.sph_neumann">[[sf.cmath.sph_neumann]]</a>
 ``` cpp
 double       sph_neumann(unsigned n, double x);
 float        sph_neumannf(unsigned n, float x);
 long double  sph_neumannl(unsigned n, long double x);
@@ -7078,32 +6488,103 @@ long double  sph_neumannl(unsigned n, long double x);
 *Effects:* These functions compute the spherical Neumann functions, also
 known as the spherical Bessel functions of the second kind, of their
 respective arguments `n` and `x`.
-*Returns:* $$%
- \mathsf{n}_n(x) =
-  (\pi/2x)^{1\!/\!2} \mathsf{N}_{n + 1\!/\!2}(x),
-       \quad \mbox{for $x \ge 0$}$$ where n is `n` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128`.
-See also [[sf.cmath.cyl_neumann]].
 <!-- Link reference definitions -->
-[accumulate]: #accumulate
-[adjacent.difference]: #adjacent.difference
-[algorithms]: algorithms.md#algorithms
-[bad.alloc]: language.md#bad.alloc
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.types]: basic.md#basic.types
 [c.math]: #c.math
 [c.math.abs]: #c.math.abs
 [c.math.fpclass]: #c.math.fpclass
 [c.math.hypot3]: #c.math.hypot3
 [c.math.rand]: #c.math.rand
 [cfenv]: #cfenv
 [cfenv.syn]: #cfenv.syn
 [class.gslice]: #class.gslice
 [class.gslice.overview]: #class.gslice.overview
@@ -7120,49 +6601,47 @@ See also [[sf.cmath.cyl_neumann]].
 [complex.special]: #complex.special
 [complex.syn]: #complex.syn
 [complex.transcendentals]: #complex.transcendentals
 [complex.value.ops]: #complex.value.ops
 [cons.slice]: #cons.slice
-[conv.prom]: conv.md#conv.prom
 [cpp.pragma]: cpp.md#cpp.pragma
-[cstdlib.syn]: language.md#cstdlib.syn
-[dcl.array]: dcl.md#dcl.array
 [dcl.init]: dcl.md#dcl.init
-[exclusive.scan]: #exclusive.scan
-[function.objects]: utilities.md#function.objects
 [gslice.access]: #gslice.access
 [gslice.array.assign]: #gslice.array.assign
 [gslice.array.comp.assign]: #gslice.array.comp.assign
 [gslice.array.fill]: #gslice.array.fill
 [gslice.cons]: #gslice.cons
 [implimits]: limits.md#implimits
-[inclusive.scan]: #inclusive.scan
 [indirect.array.assign]: #indirect.array.assign
 [indirect.array.comp.assign]: #indirect.array.comp.assign
 [indirect.array.fill]: #indirect.array.fill
-[inner.product]: #inner.product
 [input.iterators]: iterators.md#input.iterators
 [input.output]: input.md#input.output
 [iostate.flags]: input.md#iostate.flags
 [istream.formatted]: input.md#istream.formatted
 [iterator.requirements.general]: iterators.md#iterator.requirements.general
 [library.c]: library.md#library.c
 [mask.array.assign]: #mask.array.assign
 [mask.array.comp.assign]: #mask.array.comp.assign
 [mask.array.fill]: #mask.array.fill
 [numarray]: #numarray
-[numeric.iota]: #numeric.iota
-[numeric.ops]: #numeric.ops
-[numeric.ops.gcd]: #numeric.ops.gcd
-[numeric.ops.lcm]: #numeric.ops.lcm
-[numeric.ops.overview]: #numeric.ops.overview
 [numeric.requirements]: #numeric.requirements
 [numerics]: #numerics
-[numerics.defns]: #numerics.defns
 [numerics.general]: #numerics.general
 [output.iterators]: iterators.md#output.iterators
-[partial.sum]: #partial.sum
 [rand]: #rand
 [rand.adapt]: #rand.adapt
 [rand.adapt.disc]: #rand.adapt.disc
 [rand.adapt.general]: #rand.adapt.general
 [rand.adapt.ibits]: #rand.adapt.ibits
@@ -7210,64 +6689,52 @@ See also [[sf.cmath.cyl_neumann]].
 [rand.synopsis]: #rand.synopsis
 [rand.util]: #rand.util
 [rand.util.canonical]: #rand.util.canonical
 [rand.util.seedseq]: #rand.util.seedseq
 [random.access.iterators]: iterators.md#random.access.iterators
-[reduce]: #reduce
 [res.on.data.races]: library.md#res.on.data.races
 [sf.cmath]: #sf.cmath
-[sf.cmath.assoc_laguerre]: #sf.cmath.assoc_laguerre
-[sf.cmath.assoc_legendre]: #sf.cmath.assoc_legendre
 [sf.cmath.beta]: #sf.cmath.beta
-[sf.cmath.comp_ellint_1]: #sf.cmath.comp_ellint_1
-[sf.cmath.comp_ellint_2]: #sf.cmath.comp_ellint_2
-[sf.cmath.comp_ellint_3]: #sf.cmath.comp_ellint_3
-[sf.cmath.cyl_bessel_i]: #sf.cmath.cyl_bessel_i
-[sf.cmath.cyl_bessel_j]: #sf.cmath.cyl_bessel_j
-[sf.cmath.cyl_bessel_k]: #sf.cmath.cyl_bessel_k
-[sf.cmath.cyl_neumann]: #sf.cmath.cyl_neumann
-[sf.cmath.ellint_1]: #sf.cmath.ellint_1
-[sf.cmath.ellint_2]: #sf.cmath.ellint_2
-[sf.cmath.ellint_3]: #sf.cmath.ellint_3
 [sf.cmath.expint]: #sf.cmath.expint
 [sf.cmath.hermite]: #sf.cmath.hermite
 [sf.cmath.laguerre]: #sf.cmath.laguerre
 [sf.cmath.legendre]: #sf.cmath.legendre
-[sf.cmath.riemann_zeta]: #sf.cmath.riemann_zeta
-[sf.cmath.sph_bessel]: #sf.cmath.sph_bessel
-[sf.cmath.sph_legendre]: #sf.cmath.sph_legendre
-[sf.cmath.sph_neumann]: #sf.cmath.sph_neumann
 [slice.access]: #slice.access
 [slice.arr.assign]: #slice.arr.assign
 [slice.arr.comp.assign]: #slice.arr.comp.assign
 [slice.arr.fill]: #slice.arr.fill
 [strings]: strings.md#strings
-[tab:RandomDistribution]: #tab:RandomDistribution
-[tab:RandomEngine]: #tab:RandomEngine
-[tab:SeedSequence]: #tab:SeedSequence
-[tab:UniformRandomBitGenerator]: #tab:UniformRandomBitGenerator
-[tab:copyassignable]: #tab:copyassignable
-[tab:copyconstructible]: #tab:copyconstructible
-[tab:equalitycomparable]: #tab:equalitycomparable
-[tab:iterator.input.requirements]: iterators.md#tab:iterator.input.requirements
-[tab:moveassignable]: #tab:moveassignable
-[tab:moveconstructible]: #tab:moveconstructible
-[tab:numerics.lib.summary]: #tab:numerics.lib.summary
 [template.gslice.array]: #template.gslice.array
 [template.gslice.array.overview]: #template.gslice.array.overview
 [template.indirect.array]: #template.indirect.array
 [template.indirect.array.overview]: #template.indirect.array.overview
 [template.mask.array]: #template.mask.array
 [template.mask.array.overview]: #template.mask.array.overview
 [template.slice.array]: #template.slice.array
 [template.slice.array.overview]: #template.slice.array.overview
 [template.valarray]: #template.valarray
 [template.valarray.overview]: #template.valarray.overview
 [thread.thread.class]: thread.md#thread.thread.class
-[transform.exclusive.scan]: #transform.exclusive.scan
-[transform.inclusive.scan]: #transform.inclusive.scan
-[transform.reduce]: #transform.reduce
 [valarray.access]: #valarray.access
 [valarray.assign]: #valarray.assign
 [valarray.binary]: #valarray.binary
 [valarray.cassign]: #valarray.cassign
 [valarray.comparison]: #valarray.comparison
@@ -7278,11 +6745,10 @@ See also [[sf.cmath.cyl_neumann]].
 [valarray.special]: #valarray.special
 [valarray.sub]: #valarray.sub
 [valarray.syn]: #valarray.syn
 [valarray.transcend]: #valarray.transcend
 [valarray.unary]: #valarray.unary
-[vector]: containers.md#vector
 [^1]: In other words, value types. These include arithmetic types,
     pointers, the library class `complex`, and instantiations of
     `valarray` for value types.
@@ -7303,17 +6769,17 @@ See also [[sf.cmath.cyl_neumann]].
 [^6]: The distribution corresponding to this probability density
     function is also known (with a possible change of variable) as the
     Gumbel Type I, the log-Weibull, or the Fisher-Tippett Type I
     distribution.
-[^7]: Annex  [[implimits]] recommends a minimum number of recursively
- nested template instantiations. This requirement thus indirectly
- suggests a minimum allowable complexity for valarray expressions.
 [^8]: The intent is to specify an array template that has the minimum
     functionality necessary to address aliasing ambiguities and the
-    proliferation of temporaries. Thus, the `valarray` template is
     neither a matrix class nor a field class. However, it is a very
     useful building block for designing such classes.
 [^9]: This default constructor is essential, since arrays of `valarray`
     may be useful. After initialization, the length of an empty array
@@ -7322,32 +6788,19 @@ See also [[sf.cmath.cyl_neumann]].
 [^10]: This constructor is the preferred method for converting a C array
     to a `valarray` object.
 [^11]: This copy constructor creates a distinct array rather than an
     alias. Implementations in which arrays share storage are permitted,
-    but they shall implement a copy-on-reference mechanism to ensure
-    that arrays are conceptually distinct.
 [^12]: BLAS stands for *Basic Linear Algebra Subprograms.* C++ programs
     may instantiate this class. See, for example, Dongarra, Du Croz,
     Duff, and Hammerling: *A set of Level 3 Basic Linear Algebra
     Subprograms*; Technical Report MCS-P1-0888, Argonne National
     Laboratory (USA), Mathematics and Computer Science Division, August,
     1988.
-[^13]: The use of fully closed ranges is intentional.
-[^14]: `accumulate` is similar to the APL reduction operator and Common
-    Lisp reduce function, but it avoids the difficulty of defining the
-    result of reduction on an empty sequence by always requiring an
-    initial value.
-[^15]: The use of fully closed ranges is intentional.
-[^16]: The use of fully closed ranges is intentional.
-[^17]: The use of fully closed ranges is intentional.
-[^18]: A mathematical function is mathematically defined for a given set
     of argument values (a) if it is explicitly defined for that set of
     argument values, or (b) if its limiting value exists and does not
     depend on the direction of approach.

 This Clause describes components that C++ programs may use to perform
 seminumerical operations.
 The following subclauses describe components for complex number types,
 random number generation, numeric ( *n*-at-a-time) arrays, generalized
+numeric algorithms, and mathematical constants and functions for
+floating-point types, as summarized in [[numerics.summary]].
+**Table: Numerics library summary** <a id="numerics.summary">[numerics.summary]</a>
 | Subclause                |                                                 | Header                 |
+| ------------------------ | ----------------------------------------------- | ---------------------- |
 | [[numeric.requirements]] | Requirements                                    |                        |
 | [[cfenv]]                | Floating-point environment                      | `<cfenv>`              |
 | [[complex.numbers]]      | Complex numbers                                 | `<complex>`            |
+| [[bit]]                  | Bit manipulation                                | `<bit>`                |
 | [[rand]]                 | Random number generation                        | `<random>`             |
 | [[numarray]]             | Numeric arrays                                  | `<valarray>`           |
+| [[c.math]] | Mathematical functions for floating-point types | `<cmath>`, `<cstdlib>` |
+| [[numbers]] | Numbers                                         | `<numbers>` |
 ## Numeric type requirements <a id="numeric.requirements">[[numeric.requirements]]</a>
 The `complex` and `valarray` components are parameterized by the type of
 information they contain and manipulate. A C++ program shall instantiate
+these components only with a numeric type. A *numeric type* is a
+cv-unqualified object type `T` that meets the
+*Cpp17DefaultConstructible*, *Cpp17CopyConstructible*,
+*Cpp17CopyAssignable*, and *Cpp17Destructible* requirements
+[[utility.arg.requirements]]. [^1]
 If any operation on `T` throws an exception the effects are undefined.
 In addition, many member and related functions of `valarray<T>` can be
 successfully instantiated and will exhibit well-defined behavior if and
+only if `T` meets additional requirements specified for each such member
+or related function.
+[*Example 1*: It is valid to instantiate `valarray<complex>`, but
 `operator>()` will not be successfully instantiated for
 `valarray<complex>` operands, since `complex` does not have any ordering
 operators. — *end example*]
 ## The floating-point environment <a id="cfenv">[[cfenv]]</a>
 ### Header `<cfenv>` synopsis <a id="cfenv.syn">[[cfenv.syn]]</a>
 ``` cpp
 #define FE_ALL_EXCEPT see below
+#define FE_DIVBYZERO see below    // optional
+#define FE_INEXACT see below      // optional
+#define FE_INVALID see below      // optional
+#define FE_OVERFLOW see below     // optional
+#define FE_UNDERFLOW see below    // optional
+#define FE_DOWNWARD see below     // optional
+#define FE_TONEAREST see below    // optional
+#define FE_TOWARDZERO see below   // optional
+#define FE_UPWARD see below       // optional
 #define FE_DFL_ENV see below
 namespace std {
   // types
 ```
 The contents and meaning of the header `<cfenv>` are the same as the C
 standard library header `<fenv.h>`.
+[*Note 1*: This document does not require an implementation to support
+the `FENV_ACCESS` pragma; it is *implementation-defined* [[cpp.pragma]]
+whether the pragma is supported. As a consequence, it is
+*implementation-defined* whether these functions can be used to test
+floating-point status flags, set floating-point control modes, or run
+under non-default mode settings. If the pragma is used to enable control
+over the floating-point environment, this document does not specify the
+effect on floating-point evaluation in constant
+expressions. — *end note*]
+The floating-point environment has thread storage duration
+[[basic.stc.thread]]. The initial state for a thread’s floating-point
 environment is the state of the floating-point environment of the thread
+that constructs the corresponding `thread` object
+[[thread.thread.class]] or `jthread` object [[thread.jthread.class]] at
+the time it constructed the object.
 [*Note 2*: That is, the child thread gets the floating-point state of
 the parent thread at the time of the child’s creation. — *end note*]
+A separate floating-point environment is maintained for each thread.
+Each function accesses the environment corresponding to its calling
+thread.
+See also: ISO C 7.6
 ## Complex numbers <a id="complex.numbers">[[complex.numbers]]</a>
 The header `<complex>` defines a class template, and numerous functions
 for representing and manipulating complex numbers.
 The effect of instantiating the template `complex` for any type other
 than `float`, `double`, or `long double` is unspecified. The
 specializations `complex<float>`, `complex<double>`, and
+`complex<long double>` are literal types [[basic.types]].
 If the result of a function is not mathematically defined or not in the
 range of representable values for its type, the behavior is undefined.
+If `z` is an lvalue of type cv `complex<T>` then:
+- the expression `reinterpret_cast<cv T(&)[2]>(z)` is well-formed,
+- `reinterpret_cast<cv T(&)[2]>(z)[0]` designates the real part of `z`,
+  and
+- `reinterpret_cast<cv T(&)[2]>(z)[1]` designates the imaginary part of
+  `z`.
 Moreover, if `a` is an expression of type cv `complex<T>*` and the
 expression `a[i]` is well-defined for an integer expression `i`, then:
+- `reinterpret_cast<cv T*>(a)[2*i]` designates the real part of `a[i]`,
+  and
+- `reinterpret_cast<cv T*>(a)[2*i + 1]` designates the imaginary part of
+  `a[i]`.
 ### Header `<complex>` synopsis <a id="complex.syn">[[complex.syn]]</a>
 ``` cpp
 namespace std {
+  // [complex], class template complex
   template<class T> class complex;
+  // [complex.special], specializations
   template<> class complex<float>;
   template<> class complex<double>;
   template<> class complex<long double>;
   // [complex.ops], operators
+  template<class T> constexpr complex<T> operator+(const complex<T>&, const complex<T>&);
+  template<class T> constexpr complex<T> operator+(const complex<T>&, const T&);
+  template<class T> constexpr complex<T> operator+(const T&, const complex<T>&);
+  template<class T> constexpr complex<T> operator-(const complex<T>&, const complex<T>&);
+  template<class T> constexpr complex<T> operator-(const complex<T>&, const T&);
+  template<class T> constexpr complex<T> operator-(const T&, const complex<T>&);
+  template<class T> constexpr complex<T> operator*(const complex<T>&, const complex<T>&);
+  template<class T> constexpr complex<T> operator*(const complex<T>&, const T&);
+  template<class T> constexpr complex<T> operator*(const T&, const complex<T>&);
+  template<class T> constexpr complex<T> operator/(const complex<T>&, const complex<T>&);
+  template<class T> constexpr complex<T> operator/(const complex<T>&, const T&);
+  template<class T> constexpr complex<T> operator/(const T&, const complex<T>&);
+  template<class T> constexpr complex<T> operator+(const complex<T>&);
+  template<class T> constexpr complex<T> operator-(const complex<T>&);
+  template<class T> constexpr bool operator==(const complex<T>&, const complex<T>&);
   template<class T> constexpr bool operator==(const complex<T>&, const T&);
   template<class T, class charT, class traits>
+ basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&, complex<T>&);
   template<class T, class charT, class traits>
+ basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, const complex<T>&);
   // [complex.value.ops], values
   template<class T> constexpr T real(const complex<T>&);
   template<class T> constexpr T imag(const complex<T>&);
   template<class T> T abs(const complex<T>&);
   template<class T> T arg(const complex<T>&);
+  template<class T> constexpr T norm(const complex<T>&);
+  template<class T> constexpr complex<T> conj(const complex<T>&);
   template<class T> complex<T> proj(const complex<T>&);
+  template<class T> complex<T> polar(const T&, const T& = T());
   // [complex.transcendentals], transcendentals
   template<class T> complex<T> acos(const complex<T>&);
   template<class T> complex<T> asin(const complex<T>&);
   template<class T> complex<T> atan(const complex<T>&);
 ### Class template `complex` <a id="complex">[[complex]]</a>
 ``` cpp
 namespace std {
+  template<class T> class complex {
   public:
     using value_type = T;
     constexpr complex(const T& re = T(), const T& im = T());
     constexpr complex(const complex&);
     template<class X> constexpr complex(const complex<X>&);
     constexpr T real() const;
+ constexpr void real(T);
     constexpr T imag() const;
+ constexpr void imag(T);
+ constexpr complex& operator= (const T&);
+ constexpr complex& operator+=(const T&);
+ constexpr complex& operator-=(const T&);
+ constexpr complex& operator*=(const T&);
+ constexpr complex& operator/=(const T&);
+ constexpr complex& operator=(const complex&);
+    template<class X> constexpr complex& operator= (const complex<X>&);
+    template<class X> constexpr complex& operator+=(const complex<X>&);
+    template<class X> constexpr complex& operator-=(const complex<X>&);
+    template<class X> constexpr complex& operator*=(const complex<X>&);
+    template<class X> constexpr complex& operator/=(const complex<X>&);
   };
 }
 ```
 The class `complex` describes an object that can store the Cartesian
 components, `real()` and `imag()`, of a complex number.
+### Specializations <a id="complex.special">[[complex.special]]</a>
 ``` cpp
 namespace std {
   template<> class complex<float> {
   public:
     using value_type = float;
     constexpr complex(float re = 0.0f, float im = 0.0f);
+    constexpr complex(const complex<float>&) = default;
     constexpr explicit complex(const complex<double>&);
     constexpr explicit complex(const complex<long double>&);
     constexpr float real() const;
+ constexpr void real(float);
     constexpr float imag() const;
+ constexpr void imag(float);
+ constexpr complex& operator= (float);
+ constexpr complex& operator+=(float);
+ constexpr complex& operator-=(float);
+ constexpr complex& operator*=(float);
+ constexpr complex& operator/=(float);
+ constexpr complex& operator=(const complex&);
+    template<class X> constexpr complex& operator= (const complex<X>&);
+    template<class X> constexpr complex& operator+=(const complex<X>&);
+    template<class X> constexpr complex& operator-=(const complex<X>&);
+    template<class X> constexpr complex& operator*=(const complex<X>&);
+    template<class X> constexpr complex& operator/=(const complex<X>&);
   };
   template<> class complex<double> {
   public:
     using value_type = double;
     constexpr complex(double re = 0.0, double im = 0.0);
     constexpr complex(const complex<float>&);
+    constexpr complex(const complex<double>&) = default;
     constexpr explicit complex(const complex<long double>&);
     constexpr double real() const;
+ constexpr void real(double);
     constexpr double imag() const;
+ constexpr void imag(double);
+ constexpr complex& operator= (double);
+ constexpr complex& operator+=(double);
+ constexpr complex& operator-=(double);
+ constexpr complex& operator*=(double);
+ constexpr complex& operator/=(double);
+ constexpr complex& operator=(const complex&);
+    template<class X> constexpr complex& operator= (const complex<X>&);
+    template<class X> constexpr complex& operator+=(const complex<X>&);
+    template<class X> constexpr complex& operator-=(const complex<X>&);
+    template<class X> constexpr complex& operator*=(const complex<X>&);
+    template<class X> constexpr complex& operator/=(const complex<X>&);
   };
   template<> class complex<long double> {
   public:
     using value_type = long double;
     constexpr complex(long double re = 0.0L, long double im = 0.0L);
     constexpr complex(const complex<float>&);
     constexpr complex(const complex<double>&);
+    constexpr complex(const complex<long double>&) = default;
     constexpr long double real() const;
+ constexpr void real(long double);
     constexpr long double imag() const;
+ constexpr void imag(long double);
+ constexpr complex& operator= (long double);
+ constexpr complex& operator+=(long double);
+ constexpr complex& operator-=(long double);
+ constexpr complex& operator*=(long double);
+ constexpr complex& operator/=(long double);
+ constexpr complex& operator=(const complex&);
+    template<class X> constexpr complex& operator= (const complex<X>&);
+    template<class X> constexpr complex& operator+=(const complex<X>&);
+    template<class X> constexpr complex& operator-=(const complex<X>&);
+    template<class X> constexpr complex& operator*=(const complex<X>&);
+    template<class X> constexpr complex& operator/=(const complex<X>&);
   };
 }
 ```
+### Member functions <a id="complex.members">[[complex.members]]</a>
 ``` cpp
 template<class T> constexpr complex(const T& re = T(), const T& im = T());
 ```
+*Ensures:* `real() == re && imag() == im` is `true`.
 ``` cpp
 constexpr T real() const;
 ```
 *Returns:* The value of the real component.
 ``` cpp
+constexpr void real(T val);
 ```
 *Effects:* Assigns `val` to the real component.
 ``` cpp
 ```
 *Returns:* The value of the imaginary component.
 ``` cpp
+constexpr void imag(T val);
 ```
 *Effects:* Assigns `val` to the imaginary component.
+### Member operators <a id="complex.member.ops">[[complex.member.ops]]</a>
 ``` cpp
+constexpr complex& operator+=(const T& rhs);
 ```
 *Effects:* Adds the scalar value `rhs` to the real part of the complex
 value `*this` and stores the result in the real part of `*this`, leaving
 the imaginary part unchanged.
 *Returns:* `*this`.
 ``` cpp
+constexpr complex& operator-=(const T& rhs);
 ```
 *Effects:* Subtracts the scalar value `rhs` from the real part of the
 complex value `*this` and stores the result in the real part of `*this`,
 leaving the imaginary part unchanged.
 *Returns:* `*this`.
 ``` cpp
+constexpr complex& operator*=(const T& rhs);
 ```
 *Effects:* Multiplies the scalar value `rhs` by the complex value
 `*this` and stores the result in `*this`.
 *Returns:* `*this`.
 ``` cpp
+constexpr complex& operator/=(const T& rhs);
 ```
 *Effects:* Divides the scalar value `rhs` into the complex value `*this`
 and stores the result in `*this`.
 *Returns:* `*this`.
 ``` cpp
+template<class X> constexpr complex& operator+=(const complex<X>& rhs);
 ```
 *Effects:* Adds the complex value `rhs` to the complex value `*this` and
 stores the sum in `*this`.
 *Returns:* `*this`.
 ``` cpp
+template<class X> constexpr complex& operator-=(const complex<X>& rhs);
 ```
 *Effects:* Subtracts the complex value `rhs` from the complex value
 `*this` and stores the difference in `*this`.
 *Returns:* `*this`.
 ``` cpp
+template<class X> constexpr complex& operator*=(const complex<X>& rhs);
 ```
 *Effects:* Multiplies the complex value `rhs` by the complex value
 `*this` and stores the product in `*this`.
 *Returns:* `*this`.
 ``` cpp
+template<class X> constexpr complex& operator/=(const complex<X>& rhs);
 ```
 *Effects:* Divides the complex value `rhs` into the complex value
 `*this` and stores the quotient in `*this`.
 *Returns:* `*this`.
+### Non-member operations <a id="complex.ops">[[complex.ops]]</a>
 ``` cpp
+template<class T> constexpr complex<T> operator+(const complex<T>& lhs);
 ```
 *Returns:* `complex<T>(lhs)`.
 ``` cpp
+template<class T> constexpr complex<T> operator+(const complex<T>& lhs, const complex<T>& rhs);
+template<class T> constexpr complex<T> operator+(const complex<T>& lhs, const T& rhs);
+template<class T> constexpr complex<T> operator+(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `complex<T>(lhs) += rhs`.
 ``` cpp
+template<class T> constexpr complex<T> operator-(const complex<T>& lhs);
 ```
 *Returns:* `complex<T>(-lhs.real(),-lhs.imag())`.
 ``` cpp
+template<class T> constexpr complex<T> operator-(const complex<T>& lhs, const complex<T>& rhs);
+template<class T> constexpr complex<T> operator-(const complex<T>& lhs, const T& rhs);
+template<class T> constexpr complex<T> operator-(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `complex<T>(lhs) -= rhs`.
 ``` cpp
+template<class T> constexpr complex<T> operator*(const complex<T>& lhs, const complex<T>& rhs);
+template<class T> constexpr complex<T> operator*(const complex<T>& lhs, const T& rhs);
+template<class T> constexpr complex<T> operator*(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `complex<T>(lhs) *= rhs`.
 ``` cpp
+template<class T> constexpr complex<T> operator/(const complex<T>& lhs, const complex<T>& rhs);
+template<class T> constexpr complex<T> operator/(const complex<T>& lhs, const T& rhs);
+template<class T> constexpr complex<T> operator/(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `complex<T>(lhs) /= rhs`.
 ``` cpp
 template<class T> constexpr bool operator==(const complex<T>& lhs, const complex<T>& rhs);
 template<class T> constexpr bool operator==(const complex<T>& lhs, const T& rhs);
 ```
 *Returns:* `lhs.real() == rhs.real() && lhs.imag() == rhs.imag()`.
 *Remarks:* The imaginary part is assumed to be `T()`, or 0.0, for the
 `T` arguments.
 ``` cpp
 template<class T, class charT, class traits>
+ basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, complex<T>& x);
 ```
+*Preconditions:* The input values are convertible to `T`.
 *Effects:* Extracts a complex number `x` of the form: `u`, `(u)`, or
 `(u,v)`, where `u` is the real part and `v` is the imaginary
+part [[istream.formatted]].
 If bad input is encountered, calls `is.setstate(ios_base::failbit)`
+(which may throw `ios_base::failure` [[iostate.flags]]).
 *Returns:* `is`.
 *Remarks:* This extraction is performed as a series of simpler
 extractions. Therefore, the skipping of whitespace is specified to be
 the same for each of the simpler extractions.
 ``` cpp
 template<class T, class charT, class traits>
+ basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& o, const complex<T>& x);
 ```
 *Effects:* Inserts the complex number `x` onto the stream `o` as if it
 were implemented as follows:
 character, the use of comma as a field separator can be ambiguous.
 Inserting `showpoint` into the output stream forces all outputs to show
 an explicit decimal point character; as a result, all inserted sequences
 of complex numbers can be extracted unambiguously. — *end note*]
+### Value operations <a id="complex.value.ops">[[complex.value.ops]]</a>
 ``` cpp
 template<class T> constexpr T real(const complex<T>& x);
 ```
 ```
 *Returns:* The phase angle of `x`, or `atan2(imag(x), real(x))`.
 ``` cpp
+template<class T> constexpr T norm(const complex<T>& x);
 ```
 *Returns:* The squared magnitude of `x`.
 ``` cpp
+template<class T> constexpr complex<T> conj(const complex<T>& x);
 ```
 *Returns:* The complex conjugate of `x`.
 ``` cpp
 template<class T> complex<T> proj(const complex<T>& x);
 ```
 *Returns:* The projection of `x` onto the Riemann sphere.
+*Remarks:* Behaves the same as the C function `cproj`. See also: ISO C
+7.3.9.5
 ``` cpp
+template<class T> complex<T> polar(const T& rho, const T& theta = T());
 ```
+*Preconditions:* `rho` is non-negative and non-NaN. `theta` is finite.
 *Returns:* The `complex` value corresponding to a complex number whose
 magnitude is `rho` and whose phase angle is `theta`.
+### Transcendentals <a id="complex.transcendentals">[[complex.transcendentals]]</a>
 ``` cpp
 template<class T> complex<T> acos(const complex<T>& x);
 ```
 *Returns:* The complex arc cosine of `x`.
+*Remarks:* Behaves the same as the C function `cacos`. See also: ISO C
+7.3.5.1
 ``` cpp
 template<class T> complex<T> asin(const complex<T>& x);
 ```
 *Returns:* The complex arc sine of `x`.
+*Remarks:* Behaves the same as the C function `casin`. See also: ISO C
+7.3.5.2
 ``` cpp
 template<class T> complex<T> atan(const complex<T>& x);
 ```
 *Returns:* The complex arc tangent of `x`.
+*Remarks:* Behaves the same as the C function `catan`. See also: ISO C
+7.3.5.3
 ``` cpp
 template<class T> complex<T> acosh(const complex<T>& x);
 ```
 *Returns:* The complex arc hyperbolic cosine of `x`.
+*Remarks:* Behaves the same as the C function `cacosh`. See also: ISO C
+7.3.6.1
 ``` cpp
 template<class T> complex<T> asinh(const complex<T>& x);
 ```
 *Returns:* The complex arc hyperbolic sine of `x`.
+*Remarks:* Behaves the same as the C function `casinh`. See also: ISO C
+7.3.6.2
 ``` cpp
 template<class T> complex<T> atanh(const complex<T>& x);
 ```
 *Returns:* The complex arc hyperbolic tangent of `x`.
+*Remarks:* Behaves the same as the C function `catanh`. See also: ISO C
+7.3.6.3
 ``` cpp
 template<class T> complex<T> cos(const complex<T>& x);
 ```
 ``` cpp
 template<class T> complex<T> log(const complex<T>& x);
 ```
 *Returns:* The complex natural (base-e) logarithm of `x`. For all `x`,
+`imag(log(x))` lies in the interval \[-π, π\].
+[*Note 1*: The semantics of this function are intended to be the same
+in C++ as they are for `clog` in C. — *end note*]
 *Remarks:* The branch cuts are along the negative real axis.
 ``` cpp
 template<class T> complex<T> log10(const complex<T>& x);
 ``` cpp
 template<class T> complex<T> sqrt(const complex<T>& x);
 ```
 *Returns:* The complex square root of `x`, in the range of the right
+half-plane.
+[*Note 2*: The semantics of this function are intended to be the same
+in C++ as they are for `csqrt` in C. — *end note*]
 *Remarks:* The branch cuts are along the negative real axis.
 ``` cpp
 template<class T> complex<T> tan(const complex<T>& x);
 arg                   norm
 conj                  proj
 imag                  real
 ```
+where `norm`, `conj`, `imag`, and `real` are `constexpr` overloads.
 The additional overloads shall be sufficient to ensure:
+- If the argument has type `long double`, then it is effectively cast to
+ `complex<long double>`.
+- Otherwise, if the argument has type `double` or an integer type, then
+ it is effectively cast to `complex<{}double>`.
+- Otherwise, if the argument has type `float`, then it is effectively
   cast to `complex<float>`.
 Function template `pow` shall have additional overloads sufficient to
 ensure, for a call with at least one argument of type `complex<T>`:
+- If either argument has type `complex<long double>` or type `long
           double`, then both arguments are effectively cast to
   `complex<long double>`.
+- Otherwise, if either argument has type `complex<double>`, `double`, or
+ an integer type, then both arguments are effectively cast to
   `complex<double>`.
+- Otherwise, if either argument has type `complex<float>` or `float`,
   then both arguments are effectively cast to `complex<float>`.
 ### Suffixes for complex number literals <a id="complex.literals">[[complex.literals]]</a>
+This subclause describes literal suffixes for constructing complex
+number literals. The suffixes `i`, `il`, and `if` create complex numbers
+of the types `complex<double>`, `complex<long double>`, and
+`complex<float>` respectively, with their imaginary part denoted by the
+given literal number and the real part being zero.
 ``` cpp
 constexpr complex<long double> operator""il(long double d);
 constexpr complex<long double> operator""il(unsigned long long d);
 ```
 constexpr complex<float> operator""if(unsigned long long d);
 ```
 *Returns:* `complex<float>{0.0f, static_cast<float>(d)}`.
+## Bit manipulation <a id="bit">[[bit]]</a>
+### General <a id="bit.general">[[bit.general]]</a>
+The header `<bit>` provides components to access, manipulate and process
+both individual bits and bit sequences.
+### Header `<bit>` synopsis <a id="bit.syn">[[bit.syn]]</a>
+``` cpp
+namespace std {
+  // [bit.cast], bit_cast
+  template<class To, class From>
+    constexpr To bit_cast(const From& from) noexcept;
+  // [bit.pow.two], integral powers of 2
+  template<class T>
+    constexpr bool has_single_bit(T x) noexcept;
+  template<class T>
+    constexpr T bit_ceil(T x);
+  template<class T>
+    constexpr T bit_floor(T x) noexcept;
+  template<class T>
+    constexpr T bit_width(T x) noexcept;
+  // [bit.rotate], rotating
+  template<class T>
+    [[nodiscard]] constexpr T rotl(T x, int s) noexcept;
+  template<class T>
+    [[nodiscard]] constexpr T rotr(T x, int s) noexcept;
+  // [bit.count], counting
+  template<class T>
+    constexpr int countl_zero(T x) noexcept;
+  template<class T>
+    constexpr int countl_one(T x) noexcept;
+  template<class T>
+    constexpr int countr_zero(T x) noexcept;
+  template<class T>
+    constexpr int countr_one(T x) noexcept;
+  template<class T>
+    constexpr int popcount(T x) noexcept;
+  // [bit.endian], endian
+  enum class endian {
+    little = see below,
+    big    = see below,
+    native = see below
+  };
+}
+```
+### Function template `bit_cast` <a id="bit.cast">[[bit.cast]]</a>
+``` cpp
+template<class To, class From>
+  constexpr To bit_cast(const From& from) noexcept;
+```
+*Constraints:*
+- `sizeof(To) == sizeof(From)` is `true`;
+- `is_trivially_copyable_v<To>` is `true`; and
+- `is_trivially_copyable_v<From>` is `true`.
+*Returns:* An object of type `To`. Implicitly creates objects nested
+within the result [[intro.object]]. Each bit of the value representation
+of the result is equal to the corresponding bit in the object
+representation of `from`. Padding bits of the result are unspecified.
+For the result and each object created within it, if there is no value
+of the object’s type corresponding to the value representation produced,
+the behavior is undefined. If there are multiple such values, which
+value is produced is unspecified.
+*Remarks:* This function is `constexpr` if and only if `To`, `From`, and
+the types of all subobjects of `To` and `From` are types `T` such that:
+- `is_union_v<T>` is `false`;
+- `is_pointer_v<T>` is `false`;
+- `is_member_pointer_v<T>` is `false`;
+- `is_volatile_v<T>` is `false`; and
+- `T` has no non-static data members of reference type.
+### Integral powers of 2 <a id="bit.pow.two">[[bit.pow.two]]</a>
+``` cpp
+template<class T>
+  constexpr bool has_single_bit(T x) noexcept;
+```
+*Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
+*Returns:* `true` if `x` is an integral power of two; `false` otherwise.
+``` cpp
+template<class T>
+  constexpr T bit_ceil(T x);
+```
+Let N be the smallest power of 2 greater than or equal to `x`.
+*Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
+*Preconditions:* N is representable as a value of type `T`.
+*Returns:* N.
+*Throws:* Nothing.
+*Remarks:* A function call expression that violates the precondition in
+the *Preconditions:* element is not a core constant
+expression [[expr.const]].
+``` cpp
+template<class T>
+  constexpr T bit_floor(T x) noexcept;
+```
+*Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
+*Returns:* If `x == 0`, `0`; otherwise the maximal value `y` such that
+`has_single_bit(y)` is `true` and `y <= x`.
+``` cpp
+template<class T>
+  constexpr T bit_width(T x) noexcept;
+```
+*Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
+*Returns:* If `x == 0`, `0`; otherwise one plus the base-2 logarithm of
+`x`, with any fractional part discarded.
+### Rotating <a id="bit.rotate">[[bit.rotate]]</a>
+In the following descriptions, let `N` denote
+`numeric_limits<T>::digits`.
+``` cpp
+template<class T>
+  [[nodiscard]] constexpr T rotl(T x, int s) noexcept;
+```
+*Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
+Let `r` be `s % N`.
+*Returns:* If `r` is `0`, `x`; if `r` is positive,
+`(x << r) | (x >> (N - r))`; if `r` is negative, `rotr(x, -r)`.
+``` cpp
+template<class T>
+  [[nodiscard]] constexpr T rotr(T x, int s) noexcept;
+```
+*Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
+Let `r` be `s % N`.
+*Returns:* If `r` is `0`, `x`; if `r` is positive,
+`(x >> r) | (x << (N - r))`; if `r` is negative, `rotl(x, -r)`.
+### Counting <a id="bit.count">[[bit.count]]</a>
+In the following descriptions, let `N` denote
+`numeric_limits<T>::digits`.
+``` cpp
+template<class T>
+  constexpr int countl_zero(T x) noexcept;
+```
+*Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
+*Returns:* The number of consecutive `0` bits in the value of `x`,
+starting from the most significant bit.
+[*Note 1*: Returns `N` if `x == 0`. — *end note*]
+``` cpp
+template<class T>
+  constexpr int countl_one(T x) noexcept;
+```
+*Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
+*Returns:* The number of consecutive `1` bits in the value of `x`,
+starting from the most significant bit.
+[*Note 2*: Returns `N` if
+`x == numeric_limits<T>::max()`. — *end note*]
+``` cpp
+template<class T>
+  constexpr int countr_zero(T x) noexcept;
+```
+*Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
+*Returns:* The number of consecutive `0` bits in the value of `x`,
+starting from the least significant bit.
+[*Note 3*: Returns `N` if `x == 0`. — *end note*]
+``` cpp
+template<class T>
+  constexpr int countr_one(T x) noexcept;
+```
+*Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
+*Returns:* The number of consecutive `1` bits in the value of `x`,
+starting from the least significant bit.
+[*Note 4*: Returns `N` if
+`x == numeric_limits<T>::max()`. — *end note*]
+``` cpp
+template<class T>
+  constexpr int popcount(T x) noexcept;
+```
+*Constraints:* `T` is an unsigned integer type [[basic.fundamental]].
+*Returns:* The number of `1` bits in the value of `x`.
+### Endian <a id="bit.endian">[[bit.endian]]</a>
+Two common methods of byte ordering in multibyte scalar types are
+big-endian and little-endian in the execution environment. Big-endian is
+a format for storage of binary data in which the most significant byte
+is placed first, with the rest in descending order. Little-endian is a
+format for storage of binary data in which the least significant byte is
+placed first, with the rest in ascending order. This subclause describes
+the endianness of the scalar types of the execution environment.
+``` cpp
+enum class endian {
+  little = see below,
+  big    = see below,
+  native = see below
+};
+```
+If all scalar types have size 1 byte, then all of `endian::little`,
+`endian::big`, and `endian::native` have the same value. Otherwise,
+`endian::little` is not equal to `endian::big`. If all scalar types are
+big-endian, `endian::native` is equal to `endian::big`. If all scalar
+types are little-endian, `endian::native` is equal to `endian::little`.
+Otherwise, `endian::native` is not equal to either `endian::big` or
+`endian::little`.
 ## Random number generation <a id="rand">[[rand]]</a>
 This subclause defines a facility for generating (pseudo-)random
 numbers.
 In addition to a few utilities, four categories of entities are
 described: *uniform random bit generators*, *random number engines*,
 *random number engine adaptors*, and *random number distributions*.
+These categorizations are applicable to types that meet the
 corresponding requirements, to objects instantiated from such types, and
 to templates producing such types when instantiated.
 [*Note 1*: These entities are specified in such a way as to permit the
 binding of any uniform random bit generator object `e` as the argument
 to any random number distribution object `d`, thus producing a
 zero-argument function object such as given by
 `bind(d,e)`. — *end note*]
 Each of the entities specified via this subclause has an associated
+arithmetic type [[basic.fundamental]] identified as `result_type`. With
+`T` as the `result_type` thus associated with such an entity, that
 entity is characterized:
+- as *boolean* or equivalently as *boolean-valued*, if `T` is `bool`;
+- otherwise as *integral* or equivalently as *integer-valued*, if
+  `numeric_limits<T>::is_integer` is `true`;
+- otherwise as *floating-point* or equivalently as *real-valued*.
 If integer-valued, an entity may optionally be further characterized as
 *signed* or *unsigned*, according to `numeric_limits<T>::is_signed`.
 Unless otherwise specified, all descriptions of calculations in this
 subclause use mathematical real numbers.
+Throughout this subclause, the operators , , and \xor denote the
+respective conventional bitwise operations. Further:
+- the operator \rightshift denotes a bitwise right shift with
+  zero-valued bits appearing in the high bits of the result, and
+- the operator denotes a bitwise left shift with zero-valued bits
+  appearing in the low bits of the result, and whose result is always
+  taken modulo 2ʷ.
+### Header `<random>` synopsis <a id="rand.synopsis">[[rand.synopsis]]</a>
+``` cpp
+#include <initializer_list>
+namespace std {
+  // [rand.req.urng], uniform random bit generator requirements
+  template<class G>
+    concept uniform_random_bit_generator = see below;
+  // [rand.eng.lcong], class template linear_congruential_engine
+  template<class UIntType, UIntType a, UIntType c, UIntType m>
+    class linear_congruential_engine;
+  // [rand.eng.mers], class template mersenne_twister_engine
+  template<class UIntType, size_t w, size_t n, size_t m, size_t r,
+           UIntType a, size_t u, UIntType d, size_t s,
+           UIntType b, size_t t,
+           UIntType c, size_t l, UIntType f>
+    class mersenne_twister_engine;
+  // [rand.eng.sub], class template subtract_with_carry_engine
+  template<class UIntType, size_t w, size_t s, size_t r>
+    class subtract_with_carry_engine;
+  // [rand.adapt.disc], class template discard_block_engine
+  template<class Engine, size_t p, size_t r>
+    class discard_block_engine;
+  // [rand.adapt.ibits], class template independent_bits_engine
+  template<class Engine, size_t w, class UIntType>
+    class independent_bits_engine;
+  // [rand.adapt.shuf], class template shuffle_order_engine
+  template<class Engine, size_t k>
+    class shuffle_order_engine;
+  // [rand.predef], engines and engine adaptors with predefined parameters
+  using minstd_rand0  = see below;
+  using minstd_rand   = see below;
+  using mt19937       = see below;
+  using mt19937_64    = see below;
+  using ranlux24_base = see below;
+  using ranlux48_base = see below;
+  using ranlux24      = see below;
+  using ranlux48      = see below;
+  using knuth_b       = see below;
+  using default_random_engine = see below;
+  // [rand.device], class random_device
+  class random_device;
+  // [rand.util.seedseq], class seed_seq
+  class seed_seq;
+  // [rand.util.canonical], function template generate_canonical
+  template<class RealType, size_t bits, class URBG>
+    RealType generate_canonical(URBG& g);
+  // [rand.dist.uni.int], class template uniform_int_distribution
+  template<class IntType = int>
+    class uniform_int_distribution;
+  // [rand.dist.uni.real], class template uniform_real_distribution
+  template<class RealType = double>
+    class uniform_real_distribution;
+  // [rand.dist.bern.bernoulli], class bernoulli_distribution
+  class bernoulli_distribution;
+  // [rand.dist.bern.bin], class template binomial_distribution
+  template<class IntType = int>
+    class binomial_distribution;
+  // [rand.dist.bern.geo], class template geometric_distribution
+  template<class IntType = int>
+    class geometric_distribution;
+  // [rand.dist.bern.negbin], class template negative_binomial_distribution
+  template<class IntType = int>
+    class negative_binomial_distribution;
+  // [rand.dist.pois.poisson], class template poisson_distribution
+  template<class IntType = int>
+    class poisson_distribution;
+  // [rand.dist.pois.exp], class template exponential_distribution
+  template<class RealType = double>
+    class exponential_distribution;
+  // [rand.dist.pois.gamma], class template gamma_distribution
+  template<class RealType = double>
+    class gamma_distribution;
+  // [rand.dist.pois.weibull], class template weibull_distribution
+  template<class RealType = double>
+    class weibull_distribution;
+  // [rand.dist.pois.extreme], class template extreme_value_distribution
+  template<class RealType = double>
+    class extreme_value_distribution;
+  // [rand.dist.norm.normal], class template normal_distribution
+  template<class RealType = double>
+    class normal_distribution;
+  // [rand.dist.norm.lognormal], class template lognormal_distribution
+  template<class RealType = double>
+    class lognormal_distribution;
+  // [rand.dist.norm.chisq], class template chi_squared_distribution
+  template<class RealType = double>
+    class chi_squared_distribution;
+  // [rand.dist.norm.cauchy], class template cauchy_distribution
+  template<class RealType = double>
+    class cauchy_distribution;
+  // [rand.dist.norm.f], class template fisher_f_distribution
+  template<class RealType = double>
+    class fisher_f_distribution;
+  // [rand.dist.norm.t], class template student_t_distribution
+  template<class RealType = double>
+    class student_t_distribution;
+  // [rand.dist.samp.discrete], class template discrete_distribution
+  template<class IntType = int>
+    class discrete_distribution;
+  // [rand.dist.samp.pconst], class template piecewise_constant_distribution
+  template<class RealType = double>
+    class piecewise_constant_distribution;
+  // [rand.dist.samp.plinear], class template piecewise_linear_distribution
+  template<class RealType = double>
+    class piecewise_linear_distribution;
+}
+```
 ### Requirements <a id="rand.req">[[rand.req]]</a>
 #### General requirements <a id="rand.req.genl">[[rand.req.genl]]</a>
 Throughout this subclause [[rand]], the effect of instantiating a
 template:
+- that has a template type parameter named `Sseq` is undefined unless
+  the corresponding template argument is cv-unqualified and meets the
+  requirements of seed sequence [[rand.req.seedseq]].
+- that has a template type parameter named `URBG` is undefined unless
+  the corresponding template argument is cv-unqualified and meets the
+  requirements of uniform random bit generator [[rand.req.urng]].
+- that has a template type parameter named `Engine` is undefined unless
+  the corresponding template argument is cv-unqualified and meets the
+  requirements of random number engine [[rand.req.eng]].
+- that has a template type parameter named `RealType` is undefined
+  unless the corresponding template argument is cv-unqualified and is
+  one of `float`, `double`, or `long double`.
+- that has a template type parameter named `IntType` is undefined unless
+  the corresponding template argument is cv-unqualified and is one of
+  `short`, `int`, `long`, `long long`, `unsigned short`, `unsigned int`,
+  `unsigned long`, or `unsigned long long`.
+- that has a template type parameter named `UIntType` is undefined
+  unless the corresponding template argument is cv-unqualified and is
+  one of `unsigned short`, `unsigned int`, `unsigned long`, or
+  `unsigned long long`.
 Throughout this subclause [[rand]], phrases of the form “`x` is an
 iterator of a specific kind” shall be interpreted as equivalent to the
+more formal requirement that “`x` is a value of a type meeting the
 requirements of the specified iterator type”.
 Throughout this subclause [[rand]], any constructor that can be called
+with a single argument and that meets a requirement specified in this
+subclause shall be declared `explicit`.
 #### Seed sequence requirements <a id="rand.req.seedseq">[[rand.req.seedseq]]</a>
 A *seed sequence* is an object that consumes a sequence of
 integer-valued data and produces a requested number of unsigned integer
 [*Note 1*: Such an object provides a mechanism to avoid replication of
 streams of random variates. This can be useful, for example, in
 applications requiring large numbers of random number
 engines. — *end note*]
+A class `S` meets the requirements of a seed sequence if the expressions
+shown in [[rand.req.seedseq]] are valid and have the indicated
+semantics, and if `S` also meets all other requirements of this
+subclause [[rand.req.seedseq]]. In that Table and throughout this
+subclause:
+- `T` is the type named by `S`’s associated `result_type`;
+- `q` is a value of `S` and `r` is a possibly const value of `S`;
+- `ib` and `ie` are input iterators with an unsigned integer
+  `value_type` of at least 32 bits;
+- `rb` and `re` are mutable random access iterators with an unsigned
+  integer `value_type` of at least 32 bits;
+- `ob` is an output iterator; and
+- `il` is a value of `initializer_list<T>`.
 #### Uniform random bit generator requirements <a id="rand.req.urng">[[rand.req.urng]]</a>
 A *uniform random bit generator* `g` of type `G` is a function object
 returning unsigned integer values such that each value in the range of
 possible results has (ideally) equal probability of being returned.
 [*Note 1*: The degree to which `g`’s results approximate the ideal is
 often determined statistically. — *end note*]
+``` cpp
+template<class G>
+  concept uniform_random_bit_generator =
+    invocable<G&> && unsigned_integral<invoke_result_t<G&>> &&
+    requires {
+      { G::min() } -> same_as<invoke_result_t<G&>>;
+      { G::max() } -> same_as<invoke_result_t<G&>>;
+      requires bool_constant<(G::min() < G::max())>::value;
+    };
+```
+Let `g` be an object of type `G`. `G` models
+`uniform_random_bit_generator` only if
+- `G::min() <= g()`,
+- `g() <= G::max()`, and
+- `g()` has amortized constant complexity.
+A class `G` meets the *uniform random bit generator* requirements if `G`
+models `uniform_random_bit_generator`, `invoke_result_t<G&>` is an
+unsigned integer type [[basic.fundamental]], and `G` provides a nested
+*typedef-name* `result_type` that denotes the same type as
+`invoke_result_t<G&>`.
 #### Random number engine requirements <a id="rand.req.eng">[[rand.req.eng]]</a>
 A *random number engine* (commonly shortened to *engine*) `e` of type
 `E` is a uniform random bit generator that additionally meets the
 requirements (e.g., for seeding and for input/output) specified in this
+subclause.
 At any given time, `e` has a state eᵢ for some integer i ≥ 0. Upon
 construction, `e` has an initial state e₀. An engine’s state may be
 established via a constructor, a `seed` function, assignment, or a
 suitable `operator>>`.
 `E`’s specification shall define:
+- the size of `E`’s state in multiples of the size of `result_type`,
+  given as an integral constant expression;
+- the *transition algorithm* TA by which `e`’s state eᵢ is advanced to
+  its *successor state* eᵢ₊₁; and
+- the *generation algorithm* GA by which an engine’s state is mapped to
+  a value of type `result_type`.
+A class `E` that meets the requirements of a uniform random bit
+generator [[rand.req.urng]] also meets the requirements of a *random
+number engine* if the expressions shown in [[rand.req.eng]] are valid
+and have the indicated semantics, and if `E` also meets all other
+requirements of this subclause [[rand.req.eng]]. In that Table and
+throughout this subclause:
+- `T` is the type named by `E`’s associated `result_type`;
+- `e` is a value of `E`, `v` is an lvalue of `E`, `x` and `y` are
+  (possibly `const`) values of `E`;
+- `s` is a value of `T`;
+- `q` is an lvalue meeting the requirements of a seed sequence
+  [[rand.req.seedseq]];
+- `z` is a value of type `unsigned long long`;
+- `os` is an lvalue of the type of some class template specialization
+  `basic_ostream<charT,` `traits>`; and
+- `is` is an lvalue of the type of some class template specialization
+  `basic_istream<charT,` `traits>`;
+where `charT` and `traits` are constrained according to [[strings]] and
+[[input.output]].
+`E` shall meet the *Cpp17CopyConstructible* (
+[[cpp17.copyconstructible]]) and *Cpp17CopyAssignable* (
+[[cpp17.copyassignable]]) requirements. These operations shall each be
+of complexity no worse than 𝑂(\text{size of state}).
 #### Random number engine adaptor requirements <a id="rand.req.adapt">[[rand.req.adapt]]</a>
 A *random number engine adaptor* (commonly shortened to *adaptor*) `a`
 of type `A` is a random number engine that takes values produced by some
 template<class Sseq> void seed(Sseq& q);
 ```
 *Effects:* With `b` as the base engine, invokes `b.seed(q)`.
+`A` shall also meet the following additional requirements:
+- The complexity of each function shall not exceed the complexity of the
+  corresponding function applied to the base engine.
+- The state of `A` shall include the state of its base engine. The size
+  of `A`’s state shall be no less than the size of the base engine.
+- Copying `A`’s state (e.g., during copy construction or copy
+  assignment) shall include copying the state of the base engine of `A`.
+- The textual representation of `A` shall include the textual
+  representation of its base engine.
 #### Random number distribution requirements <a id="rand.req.dist">[[rand.req.dist]]</a>
 A *random number distribution* (commonly shortened to *distribution*)
 `d` of type `D` is a function object returning values that are
 context by writing, for example, p(z | a,b) or P(zᵢ | a,b), to name
 specific parameters, or by writing, for example, p(z |{`p`}) or
 P(zᵢ |{`p`}), to denote a distribution’s parameters `p` taken as a
 whole.
+A class `D` meets the requirements of a *random number distribution* if
+the expressions shown in [[rand.req.dist]] are valid and have the
+indicated semantics, and if `D` and its associated types also meet all
+other requirements of this subclause [[rand.req.dist]]. In that Table
+and throughout this subclause,
+- `T` is the type named by `D`’s associated `result_type`;
+- `P` is the type named by `D`’s associated `param_type`;
+- `d` is a value of `D`, and `x` and `y` are (possibly `const`) values
+  of `D`;
+- `glb` and `lub` are values of `T` respectively corresponding to the
+  greatest lower bound and the least upper bound on the values
+  potentially returned by `d`’s `operator()`, as determined by the
+  current values of `d`’s parameters;
+- `p` is a (possibly `const`) value of `P`;
+- `g`, `g1`, and `g2` are lvalues of a type meeting the requirements of
+  a uniform random bit generator [[rand.req.urng]];
+- `os` is an lvalue of the type of some class template specialization
+  `basic_ostream<charT,` `traits>`; and
+- `is` is an lvalue of the type of some class template specialization
+  `basic_istream<charT,` `traits>`;
+where `charT` and `traits` are constrained according to [[strings]] and
+[[input.output]].
+`D` shall meet the *Cpp17CopyConstructible* (
+[[cpp17.copyconstructible]]) and *Cpp17CopyAssignable* (
+[[cpp17.copyassignable]]) requirements.
 The sequence of numbers produced by repeated invocations of `d(g)` shall
 be independent of any invocation of `os << d` or of any `const` member
 function of `D` between any of the invocations `d(g)`.
 It is unspecified whether `D::param_type` is declared as a (nested)
 `class` or via a `typedef`. In this subclause [[rand]], declarations of
 `D::param_type` are in the form of `typedef`s for convenience of
 exposition only.
+`P` shall meet the *Cpp17CopyConstructible* (
+[[cpp17.copyconstructible]]), *Cpp17CopyAssignable* (
+[[cpp17.copyassignable]]), and *Cpp17EqualityComparable* (
+[[cpp17.equalitycomparable]]) requirements.
 For each of the constructors of `D` taking arguments corresponding to
 parameters of the distribution, `P` shall have a corresponding
 constructor subject to the same requirements and taking arguments
 identical in number, type, and default values. Moreover, for each of the
 ``` cpp
 using distribution_type =  D;
 ```
 ### Random number engine class templates <a id="rand.eng">[[rand.eng]]</a>
+Each type instantiated from a class template specified in this
+subclause  [[rand.eng]] meets the requirements of a random number engine
+[[rand.req.eng]] type.
 Except where specified otherwise, the complexity of each function
+specified in this subclause  [[rand.eng]] is constant.
+Except where specified otherwise, no function described in this
+subclause  [[rand.eng]] throws an exception.
+Every function described in this subclause  [[rand.eng]] that has a
 function parameter `q` of type `Sseq&` for a template type parameter
 named `Sseq` that is different from type `seed_seq` throws what and when
 the invocation of `q.generate` throws.
+Descriptions are provided in this subclause  [[rand.eng]] only for
+engine operations that are not described in [[rand.req.eng]] or for
+operations where there is additional semantic information. In
+particular, declarations for copy constructors, for copy assignment
+operators, for streaming operators, and for equality and inequality
+operators are not shown in the synopses.
+Each template specified in this subclause  [[rand.eng]] requires one or
 more relationships, involving the value(s) of its non-type template
 parameter(s), to hold. A program instantiating any of these templates is
 ill-formed if any such required relationship fails to hold.
 For every random number engine and for every random number engine
+adaptor `X` defined in this subclause [[rand.eng]] and in subclause
 [[rand.adapt]]:
 - if the constructor
   ``` cpp
   template<class Sseq> explicit X(Sseq& q);
     static constexpr result_type min() { return c == 0u ? 1u: 0u; }
     static constexpr result_type max() { return m - 1u; }
     static constexpr result_type default_seed = 1u;
     // constructors and seeding functions
+    linear_congruential_engine() : linear_congruential_engine(default_seed) {}
+    explicit linear_congruential_engine(result_type s);
     template<class Sseq> explicit linear_congruential_engine(Sseq& q);
     void seed(result_type s = default_seed);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
     void discard(unsigned long long z);
   };
 ```
 If the template parameter `m` is 0, the modulus m used throughout this
+subclause  [[rand.eng.lcong]] is `numeric_limits<result_type>::max()`
+plus 1.
 [*Note 1*: m need not be representable as a value of type
 `result_type`. — *end note*]
 If the template parameter `m` is not 0, the following relations shall
 hold: `a < m` and `c < m`.
 The textual representation consists of the value of xᵢ.
 ``` cpp
+explicit linear_congruential_engine(result_type s);
 ```
+*Effects:* If c  mod  m is 0 and `s`  mod  m is 0, sets the engine’s
+state to 1, otherwise sets the engine’s state to `s`  mod  m.
 ``` cpp
 template<class Sseq> explicit linear_congruential_engine(Sseq& q);
 ```
+*Effects:* With $k = \left\lceil \frac{\log_2 m}{32} \right\rceil$ and a
+an array (or equivalent) of length k + 3, invokes
+`q.generate(`a + 0`, `a + k + 3`)` and then computes
+$S = \left(\sum_{j = 0}^{k - 1} a_{j + 3} \cdot 2^{32j} \right) \bmod m$.
+If c  mod  m is 0 and S is 0, sets the engine’s state to 1, else sets
+the engine’s state to S.
 #### Class template `mersenne_twister_engine` <a id="rand.eng.mers">[[rand.eng.mers]]</a>
 A `mersenne_twister_engine` random number engine[^2] produces unsigned
 integer random numbers in the closed interval [0,2ʷ-1]. The state xᵢ of
 The transition algorithm employs a twisted generalized feedback shift
 register defined by shift values n and m, a twist value r, and a
 conditional xor-mask a. To improve the uniformity of the result, the
 bits of the raw shift register are additionally *tempered* (i.e.,
+scrambled) according to a bit-scrambling matrix defined by values u, d,
+s, b, t, c, and ℓ.
 The state transition is performed as follows:
+- Concatenate the upper w-r bits of Xᵢ₋ₙ with the lower r bits of
+  $X_{i+1-n}$ to obtain an unsigned integer value Y.
+- With $\alpha = a \cdot (Y \bitand 1)$, set Xᵢ to
+  $X_{i+m-n} \xor (Y \rightshift 1) \xor \alpha$.
 The sequence X is initialized with the help of an initialization
 multiplier f.
 The generation algorithm determines the unsigned integer values
 z₁, z₂, z₃, z₄ as follows, then delivers z₄ as its result:
+- Let $z_1 = X_i \xor \bigl(( X_i \rightshift u ) \bitand d\bigr)$.
+- Let $z_2 = z_1 \xor \bigl( (z_1 \leftshift{w} s) \bitand b \bigr)$.
+- Let $z_3 = z_2 \xor \bigl( (z_2 \leftshift{w} t) \bitand c \bigr)$.
+- Let $z_4 = z_3 \xor ( z_3 \rightshift \ell )$.
 ``` cpp
 template<class UIntType, size_t w, size_t n, size_t m, size_t r,
          UIntType a, size_t u, UIntType d, size_t s,
          UIntType b, size_t t,
          UIntType c, size_t l, UIntType f>
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return  2^w - 1; }
     static constexpr result_type default_seed = 5489u;
     // constructors and seeding functions
+    mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
+    explicit mersenne_twister_engine(result_type value);
     template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
 `w <= numeric_limits<UIntType>::digits`, `a <= (1u<<w) - 1u`,
 `b <= (1u<<w) - 1u`, `c <= (1u<<w) - 1u`, `d <= (1u<<w) - 1u`, and
 `f <= (1u<<w) - 1u`.
 The textual representation of xᵢ consists of the values of
+$X_{i - n}, \dotsc, X_{i - 1}$, in that order.
 ``` cpp
+explicit mersenne_twister_engine(result_type value);
 ```
+*Effects:* Sets X₋ₙ to `value`  mod  2ʷ. Then, iteratively for
+i = 1 - n, …, -1, sets Xᵢ to $$%
  \bigl[f \cdot
        \bigl(X_{i-1} \xor \bigl(X_{i-1} \rightshift (w-2)\bigr)
        \bigr)
        + i \bmod n
  \bigr] \bmod 2^w
 ``` cpp
 template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
 ```
+*Effects:* With k = ⌈ w / 32 ⌉ and a an array (or equivalent) of length
+n ⋅ k, invokes `q.generate(`a+0`, `a+n ⋅ k`)` and then, iteratively for
+i = -n,…,-1, sets Xᵢ to
 $\left(\sum_{j=0}^{k-1}a_{k(i+n)+j} \cdot 2^{32j} \right) \bmod 2^w$.
 Finally, if the most significant w-r bits of X₋ₙ are zero, and if each
 of the other resulting Xᵢ is 0, changes X₋ₙ to 2ʷ⁻¹.
 #### Class template `subtract_with_carry_engine` <a id="rand.eng.sub">[[rand.eng.sub]]</a>
 additionally consists of an integer c (known as the *carry*) whose value
 is either 0 or 1.
 The state transition is performed as follows:
+- Let Y = Xᵢ₋ₛ - Xᵢ₋ᵣ - c.
+- Set Xᵢ to y = Y  mod  m. Set c to 1 if Y < 0, otherwise set c to 0.
 [*Note 1*: This algorithm corresponds to a modular linear function of
 the form TA(xᵢ) = (a ⋅ xᵢ)  mod  b, where b is of the form mʳ - mˢ + 1
 and a = b - (b - 1) / m. — *end note*]
 The generation algorithm is given by GA(xᵢ) = y, where y is the value
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return m - 1; }
     static constexpr result_type default_seed = 19780503u;
     // constructors and seeding functions
+    subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
+    explicit subtract_with_carry_engine(result_type value);
     template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
 The textual representation consists of the values of Xᵢ₋ᵣ, …, Xᵢ₋₁, in
 that order, followed by c.
 ``` cpp
+explicit subtract_with_carry_engine(result_type value);
 ```
+*Effects:* Sets the values of X₋ᵣ, …, X₋₁, in that order, as specified
+below. If X₋₁ is then 0, sets c to 1; otherwise sets c to 0.
 To set the values Xₖ, first construct `e`, a
 `linear_congruential_engine` object, as if by the following definition:
 ``` cpp
 ``` cpp
 template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
 ```
+*Effects:* With k = ⌈ w / 32 ⌉ and a an array (or equivalent) of length
+r ⋅ k, invokes `q.generate(`a + 0`, `a + r ⋅ k`)` and then, iteratively
+for i = -r, …, -1, sets Xᵢ to
 $\left(\sum_{j=0}^{k-1}a_{k(i+r)+j} \cdot 2^{32j} \right) \bmod m$. If
 X₋₁ is then 0, sets c to 1; otherwise sets c to 0.
 ### Random number engine adaptor class templates <a id="rand.adapt">[[rand.adapt]]</a>
 #### In general <a id="rand.adapt.general">[[rand.adapt.general]]</a>
+Each type instantiated from a class template specified in this
+subclause  [[rand.adapt]] meets the requirements of a random number
+engine adaptor [[rand.req.adapt]] type.
 Except where specified otherwise, the complexity of each function
+specified in this subclause  [[rand.adapt]] is constant.
+Except where specified otherwise, no function described in this
+subclause  [[rand.adapt]] throws an exception.
+Every function described in this subclause  [[rand.adapt]] that has a
 function parameter `q` of type `Sseq&` for a template type parameter
 named `Sseq` that is different from type `seed_seq` throws what and when
 the invocation of `q.generate` throws.
+Descriptions are provided in this subclause  [[rand.adapt]] only for
+adaptor operations that are not described in subclause
+[[rand.req.adapt]] or for operations where there is additional semantic
+information. In particular, declarations for copy constructors, for copy
+assignment operators, for streaming operators, and for equality and
+inequality operators are not shown in the synopses.
+Each template specified in this subclause  [[rand.adapt]] requires one
+or more relationships, involving the value(s) of its non-type template
 parameter(s), to hold. A program instantiating any of these templates is
 ill-formed if any such required relationship fails to hold.
 #### Class template `discard_block_engine` <a id="rand.adapt.disc">[[rand.adapt.disc]]</a>
 The following relations shall hold: `0 < r` and `r <= p`.
 The textual representation consists of the textual representation of `e`
 followed by the value of `n`.
+In addition to its behavior pursuant to subclause  [[rand.req.adapt]],
 each constructor that is not a copy constructor sets `n` to 0.
 #### Class template `independent_bits_engine` <a id="rand.adapt.ibits">[[rand.adapt.ibits]]</a>
 An `independent_bits_engine` random number engine adaptor combines
 e’s state.
 The transition and generation algorithms are described in terms of the
 following integral constants:
+- Let R = `e.max() - e.min() + 1` and m = ⌊ log₂ R ⌋.
+- With n as determined below, let w₀ = ⌊ w / n ⌋, n₀ = n - w  mod  n,
+  $y_0 = 2^{w_0} \left\lfloor R / 2^{w_0} \right\rfloor$, and
+  $y_1 = 2^{w_0 + 1} \left\lfloor R / 2^{w_0 + 1} \right\rfloor$.
+- Let n = ⌈ w / m ⌉ if and only if the relation R - y₀ ≤ ⌊ y₀ / n ⌋
+  holds as a result. Otherwise let n = 1 + ⌈ w / m ⌉.
 [*Note 1*: The relation w = n₀ w₀ + (n - n₀)(w₀ + 1) always
 holds. — *end note*]
 The transition algorithm is carried out by invoking `e()` as often as
 needed to obtain n₀ values less than y₀ + `e.min()` and n - n₀ values
 size of the state is the size of e’s state plus k + 1.
 The transition algorithm permutes the values produced by e. The state
 transition is performed as follows:
+- Calculate an integer $j = \left\lfloor \frac{k \cdot (Y - e_{\min})}
+                            {e_{\max} - e_{\min} +1}
+          \right\rfloor$ .
+- Set Y to Vⱼ and then set Vⱼ to `e()`.
 The generation algorithm yields the last value of `Y` produced while
 advancing `e`’s state as described above.
 ``` cpp
 template<class Engine, size_t k>
 The following relation shall hold: `0 < k`.
 The textual representation consists of the textual representation of
 `e`, followed by the `k` values of V, followed by the value of Y.
+In addition to its behavior pursuant to subclause  [[rand.req.adapt]],
 each constructor that is not a copy constructor initializes
 `V[0]`, …, `V[k-1]` and Y, in that order, with values returned by
 successive invocations of `e()`.
 ### Engines and engine adaptors with predefined parameters <a id="rand.predef">[[rand.predef]]</a>
 ``` cpp
 using minstd_rand0 =
+      linear_congruential_engine<uint_fast32_t, 16'807, 0, 2'147'483'647>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `minstd_rand0` produces the value
+1043618065.
 ``` cpp
 using minstd_rand =
+      linear_congruential_engine<uint_fast32_t, 48'271, 0, 2'147'483'647>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `minstd_rand` produces the value
 399268537.
 ``` cpp
 using mt19937 =
+      mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
+ 0x9908'b0df, 11, 0xffff'ffff, 7, 0x9d2c'5680, 15, 0xefc6'0000, 18, 1'812'433'253>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `mt19937` produces the value
 4123659995.
 ``` cpp
 using mt19937_64 =
+      mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
+ 0xb502'6f5a'a966'19e9, 29, 0x5555'5555'5555'5555, 17,
+ 0x71d6'7fff'eda6'0000, 37, 0xfff7'eee0'0000'0000, 43, 6'364'136'223'846'793'005>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `mt19937_64` produces the value
 9981545732273789042.
 ``` cpp
 using ranlux24_base =
       subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `ranlux24_base` produces the value
+7937952.
 ``` cpp
 using ranlux48_base =
       subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `ranlux48_base` produces the value
+61839128582725.
 ``` cpp
 using ranlux24 = discard_block_engine<ranlux24_base, 223, 23>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `ranlux24` produces the value
 9901578.
 ``` cpp
 using ranlux48 = discard_block_engine<ranlux48_base, 389, 11>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `ranlux48` produces the value
 249142670248501.
 ``` cpp
 using knuth_b = shuffle_order_engine<minstd_rand0,256>;
 ```
+*Required behavior:* The 10000ᵗʰ consecutive invocation of a
+default-constructed object of type `knuth_b` produces the value
 1112339016.
 ``` cpp
 using default_random_engine = implementation-defined;
 ```
   // generator characteristics
   static constexpr result_type min() { return numeric_limits<result_type>::min(); }
   static constexpr result_type max() { return numeric_limits<result_type>::max(); }
   // constructors
+  random_device() : random_device(implementation-defined) {}
+  explicit random_device(const string& token);
   // generating functions
   result_type operator()();
   // property functions
   void operator=(const random_device&) = delete;
 };
 ```
 ``` cpp
+explicit random_device(const string& token);
 ```
+*Remarks:* The semantics of the `token` parameter and the token value
+used by the default constructor are *implementation-defined*. [^3]
 *Throws:* A value of an *implementation-defined* type derived from
 `exception` if the `random_device` could not be initialized.
 ``` cpp
 ``` cpp
 result_type operator()();
 ```
 *Returns:* A nondeterministic random value, uniformly distributed
+between `min()` and `max()` (inclusive). It is *implementation-defined*
 how these values are generated.
 *Throws:* A value of an *implementation-defined* type derived from
 `exception` if a random number could not be obtained.
 ``` cpp
 seed_seq();
 ```
+*Ensures:* `v.empty()` is `true`.
 *Throws:* Nothing.
 ``` cpp
 template<class T>
  seed_seq(initializer_list<T> il);
 ```
+*Mandates:* `T` is an integer type.
 *Effects:* Same as `seed_seq(il.begin(), il.end())`.
 ``` cpp
 template<class InputIterator>
   seed_seq(InputIterator begin, InputIterator end);
 ```
+*Mandates:* `iterator_traits<InputIterator>::value_type` is an integer
 type.
+*Preconditions:* `InputIterator` meets the *Cpp17InputIterator*
+requirements [[input.iterators]].
+*Effects:* Initializes `v` by the following algorithm:
 ``` cpp
 for (InputIterator s = begin; s != end; ++s)
  v.push_back((*s) mod  2³²);
 ```
 ``` cpp
 template<class RandomAccessIterator>
   void generate(RandomAccessIterator begin, RandomAccessIterator end);
 ```
+*Mandates:* `iterator_traits<RandomAccessIterator>::value_type` is an
 unsigned integer type capable of accommodating 32-bit quantities.
+*Preconditions:* `RandomAccessIterator` meets the
+*Cpp17RandomAccessIterator* requirements [[random.access.iterators]] and
+the requirements of a mutable iterator.
 *Effects:* Does nothing if `begin == end`. Otherwise, with
 s = `v.size()` and n = `end` - `begin`, fills the supplied range
 [`begin`,`end`) according to the following algorithm in which each
 operation is to be carried out modulo 2³², each indexing operator
 applied to `begin` is to be taken modulo n, and T(x) is defined as
+$x \xor (x \rightshift 27)$:
+- By way of initialization, set each element of the range to the value
+  `0x8b8b8b8b`. Additionally, for use in subsequent steps, let
+  p = (n - t) / 2 and let q = p + t, where $$%
+       t = (n \ge 623) \mbox{ ? } 11 \mbox{ : } (n \ge 68) \mbox{ ? } 7 \mbox{ : } (n \ge 39) \mbox{ ? } 5 \mbox{ : } (n \ge 7) \mbox{ ? } 3 \mbox{ : } (n - 1)/2;$$
+- With m as the larger of s + 1 and n, transform the elements of the
+  range: iteratively for k = 0, …, m - 1, calculate values
+  $$\begin{aligned}
+       r_1 & = &
+         1664525 \cdot T(    \texttt{begin[}k\texttt{]}
+                        \xor \texttt{begin[}k+p\texttt{]}
+                        \xor \texttt{begin[}k-1 \texttt{]}
+                        )
+       \\
+       r_2 & = & r_1 + \left\{
+         \begin{array}{cl}
+           s                                  & \mbox{,  } k = 0
+           \\
+           k \bmod n + \texttt{v[}k-1\texttt{]} & \mbox{,  } 0 < k \le s
+           \\
+           k \bmod n                          & \mbox{,  } s < k
+         \end{array}
+       \right.
+  \end{aligned}$$ and, in order, increment `begin[`k+p`]` by r₁,
+  increment `begin[`k+q`]` by r₂, and set `begin[`k`]` to r₂.
+- Transform the elements of the range again, beginning where the
+  previous step ended: iteratively for k = m, …, m + n - 1, calculate
+  values $$\begin{aligned}
+       r_3 & = &
+         1566083941 \cdot T( \texttt{begin[}k  \texttt{]}
+                           + \texttt{begin[}k+p\texttt{]}
+                           + \texttt{begin[}k-1\texttt{]}
+                           )
+       \\
+       r_4 & = & r_3 - (k \bmod n)
+  \end{aligned}$$ and, in order, update `begin[`k+p`]` by xoring it with
+  r₃, update `begin[`k+q`]` by xoring it with r₄, and set `begin[`k`]`
+  to r₄.
 *Throws:* What and when `RandomAccessIterator` operations of `begin` and
 `end` throw.
 ``` cpp
 ``` cpp
 template<class OutputIterator>
   void param(OutputIterator dest) const;
 ```
+*Mandates:* Values of type `result_type` are
+writable [[iterator.requirements.general]] to `dest`.
+*Preconditions:* `OutputIterator` meets the *Cpp17OutputIterator*
+requirements [[output.iterators]].
 *Effects:* Copies the sequence of prepared 32-bit units to the given
 destination, as if by executing the following statement:
 ``` cpp
 *Throws:* What and when `OutputIterator` operations of `dest` throw.
 #### Function template `generate_canonical` <a id="rand.util.canonical">[[rand.util.canonical]]</a>
 ``` cpp
 template<class RealType, size_t bits, class URBG>
   RealType generate_canonical(URBG& g);
 ```
 $$S = \sum_{i=0}^{k-1} (g_i - \texttt{g.min()})
                         \cdot R^i$$ using arithmetic of type `RealType`.
 *Returns:* S / Rᵏ.
+[*Note 1*: 0 ≤ S / Rᵏ < 1. — *end note*]
 *Throws:* What and when `g` throws.
+[*Note 2*: If the values gᵢ produced by `g` are uniformly distributed,
+the instantiation’s results are distributed as uniformly as possible.
+Obtaining a value in this way can be a useful step in the process of
+transforming a value generated by a uniform random bit generator into a
+value that can be delivered by a random number
+distribution. — *end note*]
 ### Random number distribution class templates <a id="rand.dist">[[rand.dist]]</a>
 #### In general <a id="rand.dist.general">[[rand.dist.general]]</a>
+Each type instantiated from a class template specified in this
+subclause  [[rand.dist]] meets the requirements of a random number
+distribution [[rand.req.dist]] type.
+Descriptions are provided in this subclause  [[rand.dist]] only for
 distribution operations that are not described in [[rand.req.dist]] or
 for operations where there is additional semantic information. In
 particular, declarations for copy constructors, for copy assignment
 operators, for streaming operators, and for equality and inequality
 operators are not shown in the synopses.
 The algorithms for producing each of the specified distributions are
 *implementation-defined*.
 The value of each probability density function p(z) and of each discrete
+probability function P(zᵢ) specified in this subclause is 0 everywhere
 outside its stated domain.
 #### Uniform distributions <a id="rand.dist.uni">[[rand.dist.uni]]</a>
 ##### Class template `uniform_int_distribution` <a id="rand.dist.uni.int">[[rand.dist.uni.int]]</a>
 A `uniform_int_distribution` random number distribution produces random
 integers i, a ≤ i ≤ b, distributed according to the constant discrete
+probability function $$P(i\,|\,a,b) = 1 / (b - a + 1) \text{ .}$$
 ``` cpp
 template<class IntType = int>
   class uniform_int_distribution {
   public:
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
+    uniform_int_distribution() : uniform_int_distribution(0) {}
+    explicit uniform_int_distribution(IntType a, IntType b = numeric_limits<IntType>::max());
     explicit uniform_int_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit uniform_int_distribution(IntType a, IntType b = numeric_limits<IntType>::max());
 ```
+*Preconditions:* `a` ≤ `b`.
+*Remarks:* `a` and `b` correspond to the respective parameters of the
+distribution.
 ``` cpp
 result_type a() const;
 ```
 ##### Class template `uniform_real_distribution` <a id="rand.dist.uni.real">[[rand.dist.uni.real]]</a>
 A `uniform_real_distribution` random number distribution produces random
 numbers x, a ≤ x < b, distributed according to the constant probability
+density function $$p(x\,|\,a,b) = 1 / (b - a) \text{ .}$$
 [*Note 1*: This implies that p(x | a,b) is undefined when
 `a == b`. — *end note*]
 ``` cpp
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructors and reset functions
+    uniform_real_distribution() : uniform_real_distribution(0.0) {}
+    explicit uniform_real_distribution(RealType a, RealType b = 1.0);
     explicit uniform_real_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit uniform_real_distribution(RealType a, RealType b = 1.0);
 ```
+*Preconditions:* `a` ≤ `b` and
+`b` - `a` ≤ `numeric_limits<RealType>::max()`.
+*Remarks:* `a` and `b` correspond to the respective parameters of the
+distribution.
 ``` cpp
 result_type a() const;
 ```
 #### Bernoulli distributions <a id="rand.dist.bern">[[rand.dist.bern]]</a>
 ##### Class `bernoulli_distribution` <a id="rand.dist.bern.bernoulli">[[rand.dist.bern.bernoulli]]</a>
 A `bernoulli_distribution` random number distribution produces `bool`
+values b distributed according to the discrete probability function
+$$P(b\,|\,p) = \left\{ \begin{array}{ll}
+                          p     & \text{ if $b = \tcode{true}$, or} \\
+                          1 - p & \text{ if $b = \tcode{false}$.}
+ \end{array}\right.$$
 ``` cpp
 class bernoulli_distribution {
 public:
   // types
   using result_type = bool;
   using param_type  = unspecified;
   // constructors and reset functions
+  bernoulli_distribution() : bernoulli_distribution(0.5) {}
+  explicit bernoulli_distribution(double p);
   explicit bernoulli_distribution(const param_type& parm);
   void reset();
   // generating functions
   template<class URBG>
   result_type max() const;
 };
 ```
 ``` cpp
+explicit bernoulli_distribution(double p);
 ```
+*Preconditions:* 0 ≤ `p` ≤ 1.
+*Remarks:* `p` corresponds to the parameter of the distribution.
 ``` cpp
 double p() const;
 ```
 ##### Class template `binomial_distribution` <a id="rand.dist.bern.bin">[[rand.dist.bern.bin]]</a>
 A `binomial_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
+$$P(i\,|\,t,p) = \binom{t}{i} \cdot p^i \cdot (1-p)^{t-i} \text{ .}$$
 ``` cpp
 template<class IntType = int>
   class binomial_distribution {
   public:
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
+    binomial_distribution() : binomial_distribution(1) {}
+    explicit binomial_distribution(IntType t, double p = 0.5);
     explicit binomial_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit binomial_distribution(IntType t, double p = 0.5);
 ```
+*Preconditions:* 0 ≤ `p` ≤ 1 and 0 ≤ `t`.
+*Remarks:* `t` and `p` correspond to the respective parameters of the
+distribution.
 ``` cpp
 IntType t() const;
 ```
 ##### Class template `geometric_distribution` <a id="rand.dist.bern.geo">[[rand.dist.bern.geo]]</a>
 A `geometric_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
+$$P(i\,|\,p) = p \cdot (1-p)^{i} \text{ .}$$
 ``` cpp
 template<class IntType = int>
   class geometric_distribution {
   public:
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
+    geometric_distribution() : geometric_distribution(0.5) {}
+    explicit geometric_distribution(double p);
     explicit geometric_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit geometric_distribution(double p);
 ```
+*Preconditions:* 0 < `p` < 1.
+*Remarks:* `p` corresponds to the parameter of the distribution.
 ``` cpp
 double p() const;
 ```
 ##### Class template `negative_binomial_distribution` <a id="rand.dist.bern.negbin">[[rand.dist.bern.negbin]]</a>
 A `negative_binomial_distribution` random number distribution produces
 random integers i ≥ 0 distributed according to the discrete probability
+function
+$$P(i\,|\,k,p) = \binom{k+i-1}{i} \cdot p^k \cdot (1-p)^i \text{ .}$$
 [*Note 1*: This implies that P(i | k,p) is undefined when
 `p == 1`. — *end note*]
 ``` cpp
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructor and reset functions
+    negative_binomial_distribution() : negative_binomial_distribution(1) {}
+    explicit negative_binomial_distribution(IntType k, double p = 0.5);
     explicit negative_binomial_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit negative_binomial_distribution(IntType k, double p = 0.5);
 ```
+*Preconditions:* 0 < `p` ≤ 1 and 0 < `k`.
+*Remarks:* `k` and `p` correspond to the respective parameters of the
+distribution.
 ``` cpp
 IntType k() const;
 ```
 ##### Class template `poisson_distribution` <a id="rand.dist.pois.poisson">[[rand.dist.pois.poisson]]</a>
 A `poisson_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
+$$P(i\,|\,\mu) = \frac{e^{-\mu} \mu^{i}}{i\,!} \text{ .}$$ The
+distribution parameter μ is also known as this distribution’s *mean* .
 ``` cpp
 template<class IntType = int>
   class poisson_distribution
   {
     // types
     using result_type = IntType;
     using param_type  = unspecified;
     // constructors and reset functions
+    poisson_distribution() : poisson_distribution(1.0) {}
+    explicit poisson_distribution(double mean);
     explicit poisson_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit poisson_distribution(double mean);
 ```
+*Preconditions:* 0 < `mean`.
+*Remarks:* `mean` corresponds to the parameter of the distribution.
 ``` cpp
 double mean() const;
 ```
 ##### Class template `exponential_distribution` <a id="rand.dist.pois.exp">[[rand.dist.pois.exp]]</a>
 An `exponential_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
+$$p(x\,|\,\lambda) = \lambda e^{-\lambda x} \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class exponential_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructors and reset functions
+    exponential_distribution() : exponential_distribution(1.0) {}
+    explicit exponential_distribution(RealType lambda);
     explicit exponential_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit exponential_distribution(RealType lambda);
 ```
+*Preconditions:* 0 < `lambda`.
+*Remarks:* `lambda` corresponds to the parameter of the distribution.
 ``` cpp
 RealType lambda() const;
 ```
 ##### Class template `gamma_distribution` <a id="rand.dist.pois.gamma">[[rand.dist.pois.gamma]]</a>
 A `gamma_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
+$$p(x\,|\,\alpha,\beta) =
+     \frac{e^{-x/\beta}}{\beta^{\alpha} \cdot \Gamma(\alpha)} \, \cdot \, x^{\, \alpha-1}
+ \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class gamma_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructors and reset functions
+    gamma_distribution() : gamma_distribution(1.0) {}
+    explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
     explicit gamma_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
 ```
+*Preconditions:* 0 < `alpha` and 0 < `beta`.
+*Remarks:* `alpha` and `beta` correspond to the parameters of the
+distribution.
 ``` cpp
 RealType alpha() const;
 ```
 ##### Class template `weibull_distribution` <a id="rand.dist.pois.weibull">[[rand.dist.pois.weibull]]</a>
 A `weibull_distribution` random number distribution produces random
 numbers x ≥ 0 distributed according to the probability density function
+$$p(x\,|\,a,b) = \frac{a}{b}
      \cdot \left(\frac{x}{b}\right)^{a-1}
      \cdot \, \exp\left( -\left(\frac{x}{b}\right)^a\right)
+ \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class weibull_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    weibull_distribution() : weibull_distribution(1.0) {}
+    explicit weibull_distribution(RealType a, RealType b = 1.0);
     explicit weibull_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit weibull_distribution(RealType a, RealType b = 1.0);
 ```
+*Preconditions:* 0 < `a` and 0 < `b`.
+*Remarks:* `a` and `b` correspond to the respective parameters of the
+distribution.
 ``` cpp
 RealType a() const;
 ```
 ##### Class template `extreme_value_distribution` <a id="rand.dist.pois.extreme">[[rand.dist.pois.extreme]]</a>
 An `extreme_value_distribution` random number distribution produces
 random numbers x distributed according to the probability density
+function[^6] $$p(x\,|\,a,b) = \frac{1}{b}
+     \cdot \exp\left(\frac{a-x}{b} - \exp\left(\frac{a-x}{b}\right)\right)
+ \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class extreme_value_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    extreme_value_distribution() : extreme_value_distribution(0.0) {}
+    explicit extreme_value_distribution(RealType a, RealType b = 1.0);
     explicit extreme_value_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit extreme_value_distribution(RealType a, RealType b = 1.0);
 ```
+*Preconditions:* 0 < `b`.
+*Remarks:* `a` and `b` correspond to the respective parameters of the
+distribution.
 ``` cpp
 RealType a() const;
 ```
         % e^{-(x-\mu)^2 / (2\sigma^2)}
         \exp{\left(- \, \frac{(x - \mu)^2}
                              {2 \sigma^2}
              \right)
             }
+ \text{ .}$$ The distribution parameters μ and σ are also known as this
 distribution’s *mean* and *standard deviation* .
 ``` cpp
 template<class RealType = double>
   class normal_distribution {
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructors and reset functions
+    normal_distribution() : normal_distribution(0.0) {}
+    explicit normal_distribution(RealType mean, RealType stddev = 1.0);
     explicit normal_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit normal_distribution(RealType mean, RealType stddev = 1.0);
 ```
+*Preconditions:* 0 < `stddev`.
+*Remarks:* `mean` and `stddev` correspond to the respective parameters
+of the distribution.
 ``` cpp
 RealType mean() const;
 ```
 ##### Class template `lognormal_distribution` <a id="rand.dist.norm.lognormal">[[rand.dist.norm.lognormal]]</a>
 A `lognormal_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
+$$p(x\,|\,m,s) = \frac{1}{s x \sqrt{2 \pi}}
+     \cdot \exp{\left(-\frac{(\ln{x} - m)^2}{2 s^2}\right)}
+ \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class lognormal_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    lognormal_distribution() : lognormal_distribution(0.0) {}
+    explicit lognormal_distribution(RealType m, RealType s = 1.0);
     explicit lognormal_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit lognormal_distribution(RealType m, RealType s = 1.0);
 ```
+*Preconditions:* 0 < `s`.
+*Remarks:* `m` and `s` correspond to the respective parameters of the
+distribution.
 ``` cpp
 RealType m() const;
 ```
 ##### Class template `chi_squared_distribution` <a id="rand.dist.norm.chisq">[[rand.dist.norm.chisq]]</a>
 A `chi_squared_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
+$$p(x\,|\,n) = \frac{x^{(n/2)-1} \cdot e^{-x/2}}{\Gamma(n/2) \cdot 2^{n/2}} \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class chi_squared_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    chi_squared_distribution() : chi_squared_distribution(1.0) {}
+    explicit chi_squared_distribution(RealType n);
     explicit chi_squared_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit chi_squared_distribution(RealType n);
 ```
+*Preconditions:* 0 < `n`.
+*Remarks:* `n` corresponds to the parameter of the distribution.
 ``` cpp
 RealType n() const;
 ```
 constructed.
 ##### Class template `cauchy_distribution` <a id="rand.dist.norm.cauchy">[[rand.dist.norm.cauchy]]</a>
 A `cauchy_distribution` random number distribution produces random
+numbers x distributed according to the probability density function
+$$p(x\,|\,a,b) = \left(\pi b \left(1 + \left(\frac{x-a}{b} \right)^2 \, \right)\right)^{-1} \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class cauchy_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    cauchy_distribution() : cauchy_distribution(0.0) {}
+    explicit cauchy_distribution(RealType a, RealType b = 1.0);
     explicit cauchy_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit cauchy_distribution(RealType a, RealType b = 1.0);
 ```
+*Preconditions:* 0 < `b`.
+*Remarks:* `a` and `b` correspond to the respective parameters of the
+distribution.
 ``` cpp
 RealType a() const;
 ```
 ##### Class template `fisher_f_distribution` <a id="rand.dist.norm.f">[[rand.dist.norm.f]]</a>
 A `fisher_f_distribution` random number distribution produces random
 numbers x ≥ 0 distributed according to the probability density function
+$$p(x\,|\,m,n) = \frac{\Gamma\big((m+n)/2\big)}{\Gamma(m/2) \; \Gamma(n/2)}
+     \cdot \left(\frac{m}{n}\right)^{m/2}
+ \cdot x^{(m/2)-1}
+ \cdot \left(1 + \frac{m x}{n}\right)^{-(m + n)/2}
+ \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class fisher_f_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    fisher_f_distribution() : fisher_f_distribution(1.0) {}
+    explicit fisher_f_distribution(RealType m, RealType n = 1.0);
     explicit fisher_f_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit fisher_f_distribution(RealType m, RealType n = 1);
 ```
+*Preconditions:* 0 < `m` and 0 < `n`.
+*Remarks:* `m` and `n` correspond to the respective parameters of the
+distribution.
 ``` cpp
 RealType m() const;
 ```
 constructed.
 ##### Class template `student_t_distribution` <a id="rand.dist.norm.t">[[rand.dist.norm.t]]</a>
 A `student_t_distribution` random number distribution produces random
+numbers x distributed according to the probability density function
+$$p(x\,|\,n) = \frac{1}{\sqrt{n \pi}}
+ \cdot \frac{\Gamma\big((n+1)/2\big)}{\Gamma(n/2)}
      \cdot \left(1 + \frac{x^2}{n} \right)^{-(n+1)/2}
+ \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class student_t_distribution {
   public:
     // types
     using result_type = RealType;
     using param_type  = unspecified;
     // constructor and reset functions
+    student_t_distribution() : student_t_distribution(1.0) {}
+    explicit student_t_distribution(RealType n);
     explicit student_t_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
     result_type max() const;
   };
 ```
 ``` cpp
+explicit student_t_distribution(RealType n);
 ```
+*Preconditions:* 0 < `n`.
+*Remarks:* `n` corresponds to the parameter of the distribution.
 ``` cpp
 RealType n() const;
 ```
 ##### Class template `discrete_distribution` <a id="rand.dist.samp.discrete">[[rand.dist.samp.discrete]]</a>
 A `discrete_distribution` random number distribution produces random
 integers i, 0 ≤ i < n, distributed according to the discrete probability
+function $$P(i \,|\, p_0, \dotsc, p_{n-1}) = p_i \text{ .}$$
 Unless specified otherwise, the distribution parameters are calculated
+as: pₖ = {wₖ / S} for k = 0, …, n - 1, in which the values wₖ, commonly
+known as the *weights* , shall be non-negative, non-NaN, and
+non-infinity. Moreover, the following relation shall hold:
+$0 < S = w_0 + \dotsb + w_{n - 1}$.
 ``` cpp
 template<class IntType = int>
   class discrete_distribution {
   public:
 ``` cpp
 template<class InputIterator>
   discrete_distribution(InputIterator firstW, InputIterator lastW);
 ```
+*Mandates:*
+`is_convertible_v<iterator_traits<InputIterator>::value_type, double>`
+is `true`.
+*Preconditions:* `InputIterator` meets the *Cpp17InputIterator*
+requirements [[input.iterators]]. If `firstW == lastW`, let n = 1 and
+w₀ = 1. Otherwise, [`firstW`, `lastW`) forms a sequence w of length
+n > 0.
 *Effects:* Constructs a `discrete_distribution` object with
 probabilities given by the formula above.
 ``` cpp
 ``` cpp
 template<class UnaryOperation>
   discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);
 ```
+*Mandates:* `is_invocable_r_v<double, UnaryOperation&, double>` is
+`true`.
+*Preconditions:* If `nw` = 0, let n = 1, otherwise let n = `nw`. The
+relation 0 < δ = (`xmax` - `xmin`) / n holds.
 *Effects:* Constructs a `discrete_distribution` object with
 probabilities given by the formula above, using the following values: If
 `nw` = 0, let w₀ = 1. Otherwise, let wₖ = `fw`(`xmin` + k ⋅ δ + δ / 2)
 for k = 0, …, n - 1.
+*Complexity:* The number of invocations of `fw` does not exceed n.
 ``` cpp
 vector<double> probabilities() const;
 ```
 ##### Class template `piecewise_constant_distribution` <a id="rand.dist.samp.pconst">[[rand.dist.samp.pconst]]</a>
 A `piecewise_constant_distribution` random number distribution produces
 random numbers x, b₀ ≤ x < bₙ, uniformly distributed over each
 subinterval [ bᵢ, bᵢ₊₁ ) according to the probability density function
+$$p(x \,|\, b_0, \dotsc, b_n, \; \rho_0, \dotsc, \rho_{n-1}) = \rho_i
+ \text{ , for $b_i \le x < b_{i+1}$.}$$
 The n + 1 distribution parameters bᵢ, also known as this distribution’s
+*interval boundaries* , shall satisfy the relation $b_i < b_{i + 1}$ for
+i = 0, …, n - 1. Unless specified otherwise, the remaining n
+distribution parameters are calculated as:
+$$\rho_k = \frac{w_k}{S \cdot (b_{k+1}-b_k)} \text{ for } k = 0, \dotsc, n - 1 \text{ ,}$$
+in which the values wₖ, commonly known as the *weights* , shall be
+non-negative, non-NaN, and non-infinity. Moreover, the following
+relation shall hold: 0 < S = w₀ + … + wₙ₋₁.
 ``` cpp
 template<class RealType = double>
   class piecewise_constant_distribution {
   public:
 template<class InputIteratorB, class InputIteratorW>
  piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB,
                                  InputIteratorW firstW);
 ```
+*Mandates:* Both of
+- `is_convertible_v<iterator_traits<InputIteratorB>::value_type, double>`
+- `is_convertible_v<iterator_traits<InputIteratorW>::value_type, double>`
+are `true`.
+*Preconditions:* `InputIteratorB` and `InputIteratorW` each meet the
+*Cpp17InputIterator* requirements [[input.iterators]]. If
+`firstB == lastB` or `++firstB == lastB`, let n = 1, w₀ = 1, b₀ = 0, and
+b₁ = 1. Otherwise, [`firstB`, `lastB`) forms a sequence b of length n+1,
+the length of the sequence w starting from `firstW` is at least n, and
+any wₖ for k ≥ n are ignored by the distribution.
 *Effects:* Constructs a `piecewise_constant_distribution` object with
 parameters as specified above.
 ``` cpp
 template<class UnaryOperation>
  piecewise_constant_distribution(initializer_list<RealType> bl, UnaryOperation fw);
 ```
+*Mandates:* `is_invocable_r_v<double, UnaryOperation&, double>` is
+`true`.
 *Effects:* Constructs a `piecewise_constant_distribution` object with
 parameters taken or calculated from the following values: If
 `bl.size()` < 2, let n = 1, w₀ = 1, b₀ = 0, and b₁ = 1. Otherwise, let
 [`bl.begin()`, `bl.end()`) form a sequence b₀, …, bₙ, and let
 wₖ = `fw`((bₖ₊₁ + bₖ) / 2) for k = 0, …, n - 1.
+*Complexity:* The number of invocations of `fw` does not exceed n.
 ``` cpp
 template<class UnaryOperation>
  piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
 ```
+*Mandates:* `is_invocable_r_v<double, UnaryOperation&, double>` is
+`true`.
+*Preconditions:* If `nw` = 0, let n = 1, otherwise let n = `nw`. The
+relation 0 < δ = (`xmax` - `xmin`) / n holds.
 *Effects:* Constructs a `piecewise_constant_distribution` object with
 parameters taken or calculated from the following values: Let
 bₖ = `xmin` + k ⋅ δ for k = 0, …, n, and wₖ = `fw`(bₖ + δ / 2) for
 k = 0, …, n - 1.
+*Complexity:* The number of invocations of `fw` does not exceed n.
 ``` cpp
 vector<result_type> intervals() const;
 ```
 ##### Class template `piecewise_linear_distribution` <a id="rand.dist.samp.plinear">[[rand.dist.samp.plinear]]</a>
 A `piecewise_linear_distribution` random number distribution produces
 random numbers x, b₀ ≤ x < bₙ, distributed over each subinterval
+[bᵢ, bᵢ₊₁) according to the probability density function
+$$p(x \,|\, b_0, \dotsc, b_n, \; \rho_0, \dotsc, \rho_n)
+ = \rho_{i}   \cdot {\frac{b_{i+1} - x}{b_{i+1} - b_i}}
      + \rho_{i+1} \cdot {\frac{x - b_i}{b_{i+1} - b_i}}
+ \text{ , for $b_i \le x < b_{i+1}$.}$$
 The n + 1 distribution parameters bᵢ, also known as this distribution’s
 *interval boundaries* , shall satisfy the relation bᵢ < bᵢ₊₁ for
 i = 0, …, n - 1. Unless specified otherwise, the remaining n + 1
+distribution parameters are calculated as ρₖ = {wₖ / S} for k = 0, …, n,
+in which the values wₖ, commonly known as the *weights at boundaries* ,
+shall be non-negative, non-NaN, and non-infinity. Moreover, the
+following relation shall hold:
+$$0 < S = \frac{1}{2} \cdot \sum_{k=0}^{n-1} (w_k + w_{k+1}) \cdot (b_{k+1} - b_k) \text{ .}$$
 ``` cpp
 template<class RealType = double>
   class piecewise_linear_distribution {
   public:
 template<class InputIteratorB, class InputIteratorW>
  piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB,
                                InputIteratorW firstW);
 ```
+*Mandates:* `is_invocable_r_v<double, UnaryOperation&, double>` is
+`true`.
+*Preconditions:* `InputIteratorB` and `InputIteratorW` each meet the
+*Cpp17InputIterator* requirements [[input.iterators]]. If
+`firstB == lastB` or `++firstB == lastB`, let n = 1, ρ₀ = ρ₁ = 1,
+b₀ = 0, and b₁ = 1. Otherwise, [`firstB`, `lastB`) forms a sequence b of
+length n+1, the length of the sequence w starting from `firstW` is at
+least n+1, and any wₖ for k ≥ n + 1 are ignored by the distribution.
 *Effects:* Constructs a `piecewise_linear_distribution` object with
 parameters as specified above.
 ``` cpp
 template<class UnaryOperation>
  piecewise_linear_distribution(initializer_list<RealType> bl, UnaryOperation fw);
 ```
+*Mandates:* `is_invocable_r_v<double, UnaryOperation&, double>` is
+`true`.
 *Effects:* Constructs a `piecewise_linear_distribution` object with
 parameters taken or calculated from the following values: If
 `bl.size()` < 2, let n = 1, ρ₀ = ρ₁ = 1, b₀ = 0, and b₁ = 1. Otherwise,
 let [`bl.begin(),` `bl.end()`) form a sequence b₀, …, bₙ, and let
 wₖ = `fw`(bₖ) for k = 0, …, n.
+*Complexity:* The number of invocations of `fw` does not exceed n+1.
 ``` cpp
 template<class UnaryOperation>
  piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
 ```
+*Mandates:* `is_invocable_r_v<double, UnaryOperation&, double>` is
+`true`.
+*Preconditions:* If `nw` = 0, let n = 1, otherwise let n = `nw`. The
+relation 0 < δ = (`xmax` - `xmin`) / n holds.
 *Effects:* Constructs a `piecewise_linear_distribution` object with
 parameters taken or calculated from the following values: Let
 bₖ = `xmin` + k ⋅ δ for k = 0, …, n, and wₖ = `fw`(bₖ) for k = 0, …, n.
+*Complexity:* The number of invocations of `fw` does not exceed n+1.
 ``` cpp
 vector<result_type> intervals() const;
 ```
 whose `operator[]` member returns ρₖ when invoked with argument k for
 k = 0, …, n.
 ### Low-quality random number generation <a id="c.math.rand">[[c.math.rand]]</a>
+[*Note 1*: The header `<cstdlib>` declares the functions described in
+this subclause. — *end note*]
 ``` cpp
 int rand();
 void srand(unsigned int seed);
 ```
 *Effects:* The `rand` and `srand` functions have the semantics specified
 in the C standard library.
 *Remarks:* The implementation may specify that particular library
 functions may call `rand`. It is *implementation-defined* whether the
+`rand` function may introduce data races [[res.on.data.races]].
 [*Note 1*: The other random number generation facilities in this
+document [[rand]] are often preferable to `rand`, because `rand`’s
+underlying algorithm is unspecified. Use of `rand` therefore continues
+to be non-portable, with unpredictable and oft-questionable quality and
+performance. — *end note*]
+See also: ISO C 7.22.2
 ## Numeric arrays <a id="numarray">[[numarray]]</a>
 ### Header `<valarray>` synopsis <a id="valarray.syn">[[valarray.syn]]</a>
   template<class T> class indirect_array;   // an indirected array
   template<class T> void swap(valarray<T>&, valarray<T>&) noexcept;
   template<class T> valarray<T> operator* (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator* (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator* (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator/ (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator/ (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator/ (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator% (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator% (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator% (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator+ (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator+ (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator+ (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator- (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator- (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator- (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator^ (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator^ (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator^ (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator& (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator& (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator& (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator| (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator| (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator| (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator<<(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator<<(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator<<(const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator>>(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator>>(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator>>(const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<bool> operator&&(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator&&(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator&&(const typename valarray<T>::value_type&,
+                                              const valarray<T>&);
   template<class T> valarray<bool> operator||(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator||(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator||(const typename valarray<T>::value_type&,
+                                              const valarray<T>&);
+  template<class T> valarray<bool> operator==(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator==(const valarray<T>&,
+                                              const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator==(const typename valarray<T>::value_type&,
+                                              const valarray<T>&);
+  template<class T> valarray<bool> operator!=(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator!=(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator!=(const typename valarray<T>::value_type&,
+                                              const valarray<T>&);
+  template<class T> valarray<bool> operator< (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator< (const valarray<T>&,
+                                              const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator< (const typename valarray<T>::value_type&,
+                                              const valarray<T>&);
+  template<class T> valarray<bool> operator> (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator> (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator> (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+  template<class T> valarray<bool> operator<=(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator<=(const valarray<T>&,
+                                              const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator<=(const typename valarray<T>::value_type&,
+ const valarray<T>&);
+  template<class T> valarray<bool> operator>=(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator>=(const valarray<T>&,
+                                              const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator>=(const typename valarray<T>::value_type&,
+                                              const valarray<T>&);
   template<class T> valarray<T> abs  (const valarray<T>&);
   template<class T> valarray<T> acos (const valarray<T>&);
   template<class T> valarray<T> asin (const valarray<T>&);
   template<class T> valarray<T> atan (const valarray<T>&);
   template<class T> valarray<T> atan2(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> atan2(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> atan2(const typename valarray<T>::value_type&,
+                                      const valarray<T>&);
   template<class T> valarray<T> cos  (const valarray<T>&);
   template<class T> valarray<T> cosh (const valarray<T>&);
   template<class T> valarray<T> exp  (const valarray<T>&);
   template<class T> valarray<T> log  (const valarray<T>&);
   template<class T> valarray<T> log10(const valarray<T>&);
   template<class T> valarray<T> pow(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> pow(const valarray<T>&, const typename valarray<T>::value_type&);
+  template<class T> valarray<T> pow(const typename valarray<T>::value_type&, const valarray<T>&);
   template<class T> valarray<T> sin  (const valarray<T>&);
   template<class T> valarray<T> sinh (const valarray<T>&);
   template<class T> valarray<T> sqrt (const valarray<T>&);
   template<class T> valarray<T> tan  (const valarray<T>&);
 Implementations introducing such replacement types shall provide
 additional functions and operators as follows:
 - for every function taking a `const valarray<T>&` other than `begin`
+  and `end` [[valarray.range]], identical functions taking the
   replacement types shall be added;
 - for every function taking two `const valarray<T>&` arguments,
   identical functions taking every combination of `const valarray<T>&`
   and replacement types shall be added.
 In particular, an implementation shall allow a `valarray<T>` to be
 constructed from such replacement types and shall allow assignments and
 compound assignments of such types to `valarray<T>`, `slice_array<T>`,
 `gslice_array<T>`, `mask_array<T>` and `indirect_array<T>` objects.
+These library functions are permitted to throw a `bad_alloc`
+[[bad.alloc]] exception if there are not sufficient resources available
 to carry out the operation. Note that the exception is not mandated.
 ### Class template `valarray` <a id="template.valarray">[[template.valarray]]</a>
+#### Overview <a id="template.valarray.overview">[[template.valarray.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class valarray {
   public:
 remainder of  [[numarray]]. The illusion of higher dimensionality may be
 produced by the familiar idiom of computed indices, together with the
 powerful subsetting capabilities provided by the generalized subscript
 operators.[^8]
+#### Constructors <a id="valarray.cons">[[valarray.cons]]</a>
 ``` cpp
 valarray();
 ```
 ``` cpp
 explicit valarray(size_t n);
 ```
 *Effects:* Constructs a `valarray` that has length `n`. Each element of
+the array is value-initialized [[dcl.init]].
 ``` cpp
 valarray(const T& v, size_t n);
 ```
 ``` cpp
 valarray(const T* p, size_t n);
 ```
+*Preconditions:* \[`p`, `p + n`) is a valid range.
 *Effects:* Constructs a `valarray` that has length `n`. The values of
 the elements of the array are initialized with the first `n` values
 pointed to by the first argument.[^10]
 ```
 *Effects:* The destructor is applied to every element of `*this`; an
 implementation may return all allocated memory.
+#### Assignment <a id="valarray.assign">[[valarray.assign]]</a>
 ``` cpp
 valarray& operator=(const valarray& v);
 ```
 the corresponding element of `v`. If the length of `v` is not equal to
 the length of `*this`, resizes `*this` to make the two arrays the same
 length, as if by calling `resize(v.size())`, before performing the
 assignment.
+*Ensures:* `size() == v.size()`.
 *Returns:* `*this`.
 ``` cpp
 valarray& operator=(valarray&& v) noexcept;
 valarray& operator=(const gslice_array<T>&);
 valarray& operator=(const mask_array<T>&);
 valarray& operator=(const indirect_array<T>&);
 ```
+*Preconditions:* The length of the array to which the argument refers
+equals `size()`. The value of an element in the left-hand side of a
+`valarray` assignment operator does not depend on the value of another
+element in that left-hand side.
 These operators allow the results of a generalized subscripting
 operation to be assigned directly to a `valarray`.
+#### Element access <a id="valarray.access">[[valarray.access]]</a>
 ``` cpp
 const T&  operator[](size_t n) const;
 T& operator[](size_t n);
 ```
+*Preconditions:* `n < size()` is `true`.
 *Returns:* A reference to the corresponding element of the array.
 [*Note 1*: The expression `(a[i] = q, a[i]) == q` evaluates to `true`
 for any non-constant `valarray<T> a`, any `T q`, and for any `size_t i`
 such that the value of `i` is less than the length of
 `a`. — *end note*]
+*Remarks:* The expression `addressof(a[i+j]) == addressof(a[i]) + j`
+evaluates to `true` for all `size_t i` and `size_t j` such that
+`i+j < a.size()`.
+The expression `addressof(a[i]) != addressof(b[j])` evaluates to `true`
+for any two arrays `a` and `b` and for any `size_t i` and `size_t j`
+such that `i < a.size()` and `j < b.size()`.
 [*Note 2*: This property indicates an absence of aliasing and may be
 used to advantage by optimizing compilers. Compilers may take advantage
 of inlining, constant propagation, loop fusion, tracking of pointers
 obtained from `operator new`, and other techniques to generate efficient
 `valarray`s. — *end note*]
 The reference returned by the subscript operator for an array shall be
+valid until the member function `resize(size_t, T)` [[valarray.members]]
+is called for that array or until the lifetime of that array ends,
+whichever happens first.
+#### Subset operations <a id="valarray.sub">[[valarray.sub]]</a>
 The member `operator[]` is overloaded to provide several ways to select
 sequences of elements from among those controlled by `*this`. Each of
 these operations returns a subset of the array. The const-qualified
 versions return this subset as a new `valarray` object. The non-const
 versions return a class template object which has reference semantics to
 the original array, working in conjunction with various overloads of
 `operator=` and other assigning operators to allow selective replacement
 (slicing) of the controlled sequence. In each case the selected
+element(s) shall exist.
 ``` cpp
 valarray operator[](slice slicearr) const;
 ```
 // v0 == valarray<char>("abCDeBgAEjklmnop", 16)
 ```
 — *end example*]
+#### Unary operators <a id="valarray.unary">[[valarray.unary]]</a>
 ``` cpp
 valarray operator+() const;
 valarray operator-() const;
 valarray operator~() const;
 valarray<bool> operator!() const;
 ```
+*Mandates:* The indicated operator can be applied to operands of type
+`T` and returns a value of type `T` (`bool` for `operator!`) or which
+may be unambiguously implicitly converted to type `T` (`bool` for
+`operator!`).
 *Returns:* A `valarray` whose length is `size()`. Each element of the
 returned array is initialized with the result of applying the indicated
 operator to the corresponding element of the array.
+#### Compound assignment <a id="valarray.cassign">[[valarray.cassign]]</a>
 ``` cpp
 valarray& operator*= (const valarray& v);
 valarray& operator/= (const valarray& v);
 valarray& operator%= (const valarray& v);
 valarray& operator|= (const valarray& v);
 valarray& operator<<=(const valarray& v);
 valarray& operator>>=(const valarray& v);
 ```
+*Mandates:* The indicated operator can be applied to two operands of
+type `T`.
+*Preconditions:* `size() == v.size()` is `true`.
+The value of an element in the left-hand side of a valarray compound
+assignment operator does not depend on the value of another element in
+that left hand side.
 *Effects:* Each of these operators performs the indicated operation on
 each of the elements of `*this` and the corresponding element of `v`.
 *Returns:* `*this`.
 valarray& operator|= (const T& v);
 valarray& operator<<=(const T& v);
 valarray& operator>>=(const T& v);
 ```
+*Mandates:* The indicated operator can be applied to two operands of
+type `T`.
 *Effects:* Each of these operators applies the indicated operation to
 each element of `*this` and `v`.
 *Returns:* `*this`
 *Remarks:* The appearance of an array on the left-hand side of a
 compound assignment does not invalidate references or pointers to the
 elements of the array.
+#### Member functions <a id="valarray.members">[[valarray.members]]</a>
 ``` cpp
 void swap(valarray& v) noexcept;
 ```
 ``` cpp
 T sum() const;
 ```
+*Mandates:* `operator+=` can be applied to operands of type `T`.
+*Preconditions:* `size() > 0` is `true`.
 *Returns:* The sum of all the elements of the array. If the array has
 length 1, returns the value of element 0. Otherwise, the returned value
 is calculated by applying `operator+=` to a copy of an element of the
 array and all other elements of the array in an unspecified order.
 ``` cpp
 T min() const;
 ```
+*Preconditions:* `size() > 0` is `true`.
 *Returns:* The minimum value contained in `*this`. For an array of
 length 1, the value of element 0 is returned. For all other array
 lengths, the determination is made using `operator<`.
 ``` cpp
 T max() const;
 ```
+*Preconditions:* `size() > 0` is `true`.
 *Returns:* The maximum value contained in `*this`. For an array of
 length 1, the value of element 0 is returned. For all other array
 lengths, the determination is made using `operator<`.
 [*Note 1*: If element zero is taken as the leftmost element, a positive
 value of `n` shifts the elements left `n` places, with zero
 fill. — *end note*]
 [*Example 1*: If the argument has the value -2, the first two elements
+of the result will be value-initialized [[dcl.init]]; the third element
+of the result will be assigned the value of the first element of the
+argument; etc. — *end example*]
 ``` cpp
 valarray cshift(int n) const;
 ```
 assigns to each element the value of the second argument. Resizing
 invalidates all pointers and references to elements in the array.
 ### `valarray` non-member operations <a id="valarray.nonmembers">[[valarray.nonmembers]]</a>
+#### Binary operators <a id="valarray.binary">[[valarray.binary]]</a>
 ``` cpp
+template<class T> valarray<T> operator* (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator/ (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator% (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator+ (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator- (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator^ (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator& (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator| (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator<<(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator>>(const valarray<T>&, const valarray<T>&);
 ```
+*Mandates:* The indicated operator can be applied to operands of type
+`T` and returns a value of type `T` or which can be unambiguously
+implicitly converted to `T`.
+*Preconditions:* The argument arrays have the same length.
 *Returns:* A `valarray` whose length is equal to the lengths of the
 argument arrays. Each element of the returned array is initialized with
 the result of applying the indicated operator to the corresponding
 elements of the argument arrays.
 ``` cpp
+template<class T> valarray<T> operator* (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator* (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<T> operator/ (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator/ (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<T> operator% (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator% (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<T> operator+ (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator+ (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<T> operator- (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator- (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<T> operator^ (const valarray<T>&,
+                                         const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator^ (const typename valarray<T>::value_type&,
+                                         const valarray<T>&);
+template<class T> valarray<T> operator& (const valarray<T>&,
+                                         const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator& (const typename valarray<T>::value_type&,
+                                         const valarray<T>&);
+template<class T> valarray<T> operator| (const valarray<T>&,
+                                         const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator| (const typename valarray<T>::value_type&,
+                                         const valarray<T>&);
+template<class T> valarray<T> operator<<(const valarray<T>&,
+                                         const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator<<(const typename valarray<T>::value_type&,
+                                         const valarray<T>&);
+template<class T> valarray<T> operator>>(const valarray<T>&,
+                                         const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator>>(const typename valarray<T>::value_type&,
+                                         const valarray<T>&);
 ```
+*Mandates:* The indicated operator can be applied to operands of type
+`T` and returns a value of type `T` or which can be unambiguously
+implicitly converted to `T`.
 *Returns:* A `valarray` whose length is equal to the length of the array
 argument. Each element of the returned array is initialized with the
 result of applying the indicated operator to the corresponding element
 of the array argument and the non-array argument.
+#### Logical operators <a id="valarray.comparison">[[valarray.comparison]]</a>
 ``` cpp
+template<class T> valarray<bool> operator==(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator!=(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator< (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator> (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator<=(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator>=(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator&&(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator||(const valarray<T>&, const valarray<T>&);
 ```
+*Mandates:* The indicated operator can be applied to operands of type
+`T` and returns a value of type `bool` or which can be unambiguously
+implicitly converted to `bool`.
+*Preconditions:* The two array arguments have the same length.
 *Returns:* A `valarray<bool>` whose length is equal to the length of the
 array arguments. Each element of the returned array is initialized with
 the result of applying the indicated operator to the corresponding
 elements of the argument arrays.
 ``` cpp
+template<class T> valarray<bool> operator==(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator==(const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<bool> operator!=(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator!=(const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<bool> operator< (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator< (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<bool> operator> (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator> (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<bool> operator<=(const valarray<T>&,
+                                            const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator<=(const typename valarray<T>::value_type&,
+                                            const valarray<T>&);
+template<class T> valarray<bool> operator>=(const valarray<T>&,
+                                            const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator>=(const typename valarray<T>::value_type&,
+                                            const valarray<T>&);
+template<class T> valarray<bool> operator&&(const valarray<T>&,
+                                            const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator&&(const typename valarray<T>::value_type&,
+                                            const valarray<T>&);
+template<class T> valarray<bool> operator||(const valarray<T>&,
+                                            const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator||(const typename valarray<T>::value_type&,
+                                            const valarray<T>&);
 ```
+*Mandates:* The indicated operator can be applied to operands of type
+`T` and returns a value of type `bool` or which can be unambiguously
+implicitly converted to `bool`.
 *Returns:* A `valarray<bool>` whose length is equal to the length of the
 array argument. Each element of the returned array is initialized with
 the result of applying the indicated operator to the corresponding
 element of the array and the non-array argument.
+#### Transcendentals <a id="valarray.transcend">[[valarray.transcend]]</a>
 ``` cpp
 template<class T> valarray<T> abs  (const valarray<T>&);
 template<class T> valarray<T> acos (const valarray<T>&);
 template<class T> valarray<T> asin (const valarray<T>&);
 template<class T> valarray<T> atan (const valarray<T>&);
+template<class T> valarray<T> atan2(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> atan2(const valarray<T>&, const typename valarray<T>::value_type&);
+template<class T> valarray<T> atan2(const typename valarray<T>::value_type&, const valarray<T>&);
 template<class T> valarray<T> cos  (const valarray<T>&);
 template<class T> valarray<T> cosh (const valarray<T>&);
 template<class T> valarray<T> exp  (const valarray<T>&);
 template<class T> valarray<T> log  (const valarray<T>&);
 template<class T> valarray<T> log10(const valarray<T>&);
+template<class T> valarray<T> pow  (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> pow  (const valarray<T>&, const typename valarray<T>::value_type&);
+template<class T> valarray<T> pow  (const typename valarray<T>::value_type&, const valarray<T>&);
 template<class T> valarray<T> sin  (const valarray<T>&);
 template<class T> valarray<T> sinh (const valarray<T>&);
 template<class T> valarray<T> sqrt (const valarray<T>&);
 template<class T> valarray<T> tan  (const valarray<T>&);
 template<class T> valarray<T> tanh (const valarray<T>&);
 ```
+*Mandates:* A unique function with the indicated name can be applied
+(unqualified) to an operand of type `T`. This function returns a value
+of type `T` or which can be unambiguously implicitly converted to type
+`T`.
+#### Specialized algorithms <a id="valarray.special">[[valarray.special]]</a>
 ``` cpp
 template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;
 ```
 *Effects:* Equivalent to `x.swap(y)`.
 ### Class `slice` <a id="class.slice">[[class.slice]]</a>
+#### Overview <a id="class.slice.overview">[[class.slice.overview]]</a>
 ``` cpp
 namespace std {
   class slice {
   public:
     slice(size_t, size_t, size_t);
     size_t start() const;
     size_t size() const;
     size_t stride() const;
+    friend bool operator==(const slice& x, const slice& y);
   };
 }
 ```
 The `slice` class represents a BLAS-like slice from an array. Such a
 slice is specified by a starting index, a length, and a stride.[^12]
+#### Constructors <a id="cons.slice">[[cons.slice]]</a>
 ``` cpp
 slice();
 slice(size_t start, size_t length, size_t stride);
 slice(const slice&);
 constructor is provided only to permit the declaration of arrays of
 slices. The constructor with arguments for a slice takes a start,
 length, and stride parameter.
 [*Example 1*: `slice(3, 8, 2)` constructs a slice which selects
+elements 3, 5, 7, …, 17 from an array. — *end example*]
+#### Access functions <a id="slice.access">[[slice.access]]</a>
 ``` cpp
 size_t start() const;
 size_t size() const;
 size_t stride() const;
 *Returns:* The start, length, or stride specified by a `slice` object.
 *Complexity:* Constant time.
+#### Operators <a id="slice.ops">[[slice.ops]]</a>
+``` cpp
+friend bool operator==(const slice& x, const slice& y);
+```
+*Effects:* Equivalent to:
+``` cpp
+return x.start() == y.start() && x.size() == y.size() && x.stride() == y.stride();
+```
 ### Class template `slice_array` <a id="template.slice.array">[[template.slice.array]]</a>
+#### Overview <a id="template.slice.array.overview">[[template.slice.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class slice_array {
   public:
     slice_array() = delete;     // as implied by declaring copy constructor above
   };
 }
 ```
+This template is a helper template used by the `slice` subscript
+operator
 ``` cpp
 slice_array<T> valarray<T>::operator[](slice);
 ```
 It has reference semantics to a subset of an array specified by a
 `slice` object.
 [*Example 1*: The expression `a[slice(1, 5, 3)] = b;` has the effect of
 assigning the elements of `b` to a slice of the elements in `a`. For the
+slice shown, the elements selected from `a` are
+1, 4, …, 13. — *end example*]
+#### Assignment <a id="slice.arr.assign">[[slice.arr.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const slice_array& operator=(const slice_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
 `valarray<T>` object to which the `slice_array` object refers.
+#### Compound assignment <a id="slice.arr.comp.assign">[[slice.arr.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
 elements of the `valarray<T>` object to which the `slice_array` object
 refers.
+#### Fill function <a id="slice.arr.fill">[[slice.arr.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
 argument to the elements of the `valarray<T>` object to which the
 `slice_array` object refers.
 ### The `gslice` class <a id="class.gslice">[[class.gslice]]</a>
+#### Overview <a id="class.gslice.overview">[[class.gslice.overview]]</a>
 ``` cpp
 namespace std {
   class gslice {
   public:
 — *end example*]
 If a degenerate slice is used as the argument to the non-`const` version
 of `operator[](const gslice&)`, the behavior is undefined.
+#### Constructors <a id="gslice.cons">[[gslice.cons]]</a>
 ``` cpp
 gslice();
 gslice(size_t start, const valarray<size_t>& lengths,
          const valarray<size_t>& strides);
 ```
 The default constructor is equivalent to
 `gslice(0, valarray<size_t>(), valarray<size_t>())`. The constructor
 with arguments builds a `gslice` based on a specification of start,
+lengths, and strides, as explained in the previous subclause.
+#### Access functions <a id="gslice.access">[[gslice.access]]</a>
 ``` cpp
 size_t           start()  const;
 valarray<size_t> size() const;
 valarray<size_t> stride() const;
 *Complexity:* `start()` is constant time. `size()` and `stride()` are
 linear in the number of strides.
 ### Class template `gslice_array` <a id="template.gslice.array">[[template.gslice.array]]</a>
+#### Overview <a id="template.gslice.array.overview">[[template.gslice.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class gslice_array {
   public:
     gslice_array() = delete;    // as implied by declaring copy constructor above
   };
 }
 ```
+This template is a helper template used by the `gslice` subscript
 operator
 ``` cpp
 gslice_array<T> valarray<T>::operator[](const gslice&);
 ```
 It has reference semantics to a subset of an array specified by a
+`gslice` object. Thus, the expression `a[gslice(1, length, stride)] = b`
+has the effect of assigning the elements of `b` to a generalized slice
+of the elements in `a`.
+#### Assignment <a id="gslice.array.assign">[[gslice.array.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const gslice_array& operator=(const gslice_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
 `valarray<T>` object to which the `gslice_array` refers.
+#### Compound assignment <a id="gslice.array.comp.assign">[[gslice.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
 elements of the `valarray<T>` object to which the `gslice_array` object
 refers.
+#### Fill function <a id="gslice.array.fill">[[gslice.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
 argument to the elements of the `valarray<T>` object to which the
 `gslice_array` object refers.
 ### Class template `mask_array` <a id="template.mask.array">[[template.mask.array]]</a>
+#### Overview <a id="template.mask.array.overview">[[template.mask.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class mask_array {
   public:
 ```
 It has reference semantics to a subset of an array specified by a
 boolean mask. Thus, the expression `a[mask] = b;` has the effect of
 assigning the elements of `b` to the masked elements in `a` (those for
+which the corresponding element in `mask` is `true`).
+#### Assignment <a id="mask.array.assign">[[mask.array.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const mask_array& operator=(const mask_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
 `valarray<T>` object to which it refers.
+#### Compound assignment <a id="mask.array.comp.assign">[[mask.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
 elements of the `valarray<T>` object to which the mask object refers.
+#### Fill function <a id="mask.array.fill">[[mask.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
 argument to the elements of the `valarray<T>` object to which the
 `mask_array` object refers.
 ### Class template `indirect_array` <a id="template.indirect.array">[[template.indirect.array]]</a>
+#### Overview <a id="template.indirect.array.overview">[[template.indirect.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class indirect_array {
   public:
 ``` cpp
 indirect_array<T> valarray<T>::operator[](const valarray<size_t>&).
 ```
 It has reference semantics to a subset of an array specified by an
+`indirect_array`. Thus, the expression `a[{}indirect] = b;` has the
+effect of assigning the elements of `b` to the elements in `a` whose
+indices appear in `indirect`.
+#### Assignment <a id="indirect.array.assign">[[indirect.array.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const indirect_array& operator=(const indirect_array&) const;
 ```
 results in undefined behavior since element 4 is specified twice in the
 indirection.
 — *end example*]
+#### Compound assignment <a id="indirect.array.comp.assign">[[indirect.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
 object refers.
 If the `indirect_array` specifies an element in the `valarray<T>` object
 to which it refers more than once, the behavior is undefined.
+#### Fill function <a id="indirect.array.fill">[[indirect.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
 `indirect_array` object refers.
 ### `valarray` range access <a id="valarray.range">[[valarray.range]]</a>
 In the `begin` and `end` function templates that follow, *unspecified*1
+is a type that meets the requirements of a mutable
+*Cpp17RandomAccessIterator* [[random.access.iterators]] and models
+`contiguous_iterator` [[iterator.concept.contiguous]], whose
+`value_type` is the template parameter `T` and whose `reference` type is
+`T&`. *unspecified*2 is a type that meets the requirements of a constant
+*Cpp17RandomAccessIterator* and models `contiguous_iterator`, whose
+`value_type` is the template parameter `T` and whose `reference` type is
+`const T&`.
 The iterators returned by `begin` and `end` for an array are guaranteed
+to be valid until the member function `resize(size_t, T)`
+[[valarray.members]] is called for that array or until the lifetime of
 that array ends, whichever happens first.
 ``` cpp
 template<class T> unspecified{1} begin(valarray<T>& v);
 template<class T> unspecified{2} begin(const valarray<T>& v);
 template<class T> unspecified{2} end(const valarray<T>& v);
 ```
 *Returns:* An iterator referencing one past the last value in the array.
 ## Mathematical functions for floating-point types <a id="c.math">[[c.math]]</a>
 ### Header `<cmath>` synopsis <a id="cmath.syn">[[cmath.syn]]</a>
 ``` cpp
   float fabsf(float x);
   long double fabsl(long double x);
   float hypot(float x, float y);        // see [library.c]
   double hypot(double x, double y);
+  long double hypot(long double x, long double y);  // see [library.c]
   float hypotf(float x, float y);
   long double hypotl(long double x, long double y);
   // [c.math.hypot3], three-dimensional hypotenuse
   float hypot(float x, float y, float z);
   double fma(double x, double y, double z);
   long double fma(long double x, long double y, long double z); // see [library.c]
   float fmaf(float x, float y, float z);
   long double fmal(long double x, long double y, long double z);
+  // [c.math.lerp], linear interpolation
+  constexpr float lerp(float a, float b, float t) noexcept;
+  constexpr double lerp(double a, double b, double t) noexcept;
+  constexpr long double lerp(long double a, long double b, long double t) noexcept;
   // [c.math.fpclass], classification / comparison functions
   int fpclassify(float x);
   int fpclassify(double x);
   int fpclassify(long double x);
+ bool isfinite(float x);
+ bool isfinite(double x);
+ bool isfinite(long double x);
+ bool isinf(float x);
+ bool isinf(double x);
+ bool isinf(long double x);
+ bool isnan(float x);
+ bool isnan(double x);
+ bool isnan(long double x);
+ bool isnormal(float x);
+ bool isnormal(double x);
+ bool isnormal(long double x);
+ bool signbit(float x);
+ bool signbit(double x);
+ bool signbit(long double x);
+ bool isgreater(float x, float y);
+ bool isgreater(double x, double y);
+ bool isgreater(long double x, long double y);
+ bool isgreaterequal(float x, float y);
+ bool isgreaterequal(double x, double y);
+ bool isgreaterequal(long double x, long double y);
+ bool isless(float x, float y);
+ bool isless(double x, double y);
+ bool isless(long double x, long double y);
+ bool islessequal(float x, float y);
+ bool islessequal(double x, double y);
+ bool islessequal(long double x, long double y);
+ bool islessgreater(float x, float y);
+ bool islessgreater(double x, double y);
+ bool islessgreater(long double x, long double y);
+ bool isunordered(float x, float y);
+ bool isunordered(double x, double y);
+ bool isunordered(long double x, long double y);
   // [sf.cmath], mathematical special functions
+  // [sf.cmath.assoc.laguerre], associated Laguerre polynomials
   double       assoc_laguerre(unsigned n, unsigned m, double x);
   float        assoc_laguerref(unsigned n, unsigned m, float x);
   long double  assoc_laguerrel(unsigned n, unsigned m, long double x);
+  // [sf.cmath.assoc.legendre], associated Legendre functions
   double       assoc_legendre(unsigned l, unsigned m, double x);
   float        assoc_legendref(unsigned l, unsigned m, float x);
   long double  assoc_legendrel(unsigned l, unsigned m, long double x);
   // [sf.cmath.beta], beta function
   double       beta(double x, double y);
   float        betaf(float x, float y);
   long double  betal(long double x, long double y);
+  // [sf.cmath.comp.ellint.1], complete elliptic integral of the first kind
   double       comp_ellint_1(double k);
   float        comp_ellint_1f(float k);
   long double  comp_ellint_1l(long double k);
+  // [sf.cmath.comp.ellint.2], complete elliptic integral of the second kind
   double       comp_ellint_2(double k);
   float        comp_ellint_2f(float k);
   long double  comp_ellint_2l(long double k);
+  // [sf.cmath.comp.ellint.3], complete elliptic integral of the third kind
   double       comp_ellint_3(double k, double nu);
   float        comp_ellint_3f(float k, float nu);
   long double  comp_ellint_3l(long double k, long double nu);
+  // [sf.cmath.cyl.bessel.i], regular modified cylindrical Bessel functions
   double       cyl_bessel_i(double nu, double x);
   float        cyl_bessel_if(float nu, float x);
   long double  cyl_bessel_il(long double nu, long double x);
+  // [sf.cmath.cyl.bessel.j], cylindrical Bessel functions of the first kind
   double       cyl_bessel_j(double nu, double x);
   float        cyl_bessel_jf(float nu, float x);
   long double  cyl_bessel_jl(long double nu, long double x);
+  // [sf.cmath.cyl.bessel.k], irregular modified cylindrical Bessel functions
   double       cyl_bessel_k(double nu, double x);
   float        cyl_bessel_kf(float nu, float x);
   long double  cyl_bessel_kl(long double nu, long double x);
+  // [sf.cmath.cyl.neumann], cylindrical Neumann functions;
   // cylindrical Bessel functions of the second kind
   double       cyl_neumann(double nu, double x);
   float        cyl_neumannf(float nu, float x);
   long double  cyl_neumannl(long double nu, long double x);
+  // [sf.cmath.ellint.1], incomplete elliptic integral of the first kind
   double       ellint_1(double k, double phi);
   float        ellint_1f(float k, float phi);
   long double  ellint_1l(long double k, long double phi);
+  // [sf.cmath.ellint.2], incomplete elliptic integral of the second kind
   double       ellint_2(double k, double phi);
   float        ellint_2f(float k, float phi);
   long double  ellint_2l(long double k, long double phi);
+  // [sf.cmath.ellint.3], incomplete elliptic integral of the third kind
   double       ellint_3(double k, double nu, double phi);
   float        ellint_3f(float k, float nu, float phi);
   long double  ellint_3l(long double k, long double nu, long double phi);
   // [sf.cmath.expint], exponential integral
   // [sf.cmath.legendre], Legendre polynomials
   double       legendre(unsigned l, double x);
   float        legendref(unsigned l, float x);
   long double  legendrel(unsigned l, long double x);
+  // [sf.cmath.riemann.zeta], Riemann zeta function
   double       riemann_zeta(double x);
   float        riemann_zetaf(float x);
   long double  riemann_zetal(long double x);
+  // [sf.cmath.sph.bessel], spherical Bessel functions of the first kind
   double       sph_bessel(unsigned n, double x);
   float        sph_besself(unsigned n, float x);
   long double  sph_bessell(unsigned n, long double x);
+  // [sf.cmath.sph.legendre], spherical associated Legendre functions
   double       sph_legendre(unsigned l, unsigned m, double theta);
   float        sph_legendref(unsigned l, unsigned m, float theta);
   long double  sph_legendrel(unsigned l, unsigned m, long double theta);
+  // [sf.cmath.sph.neumann], spherical Neumann functions;
+  // spherical Bessel functions of the second kind
   double       sph_neumann(unsigned n, double x);
   float        sph_neumannf(unsigned n, float x);
   long double  sph_neumannl(unsigned n, long double x);
 }
 ```
 standard library header `<math.h>`, with the addition of a
 three-dimensional hypotenuse function ([[c.math.hypot3]]) and the
 mathematical special functions described in [[sf.cmath]].
 [*Note 1*: Several functions have additional overloads in this
+document, but they have the same behavior as in the C standard library
+[[library.c]]. — *end note*]
 For each set of overloaded functions within `<cmath>`, with the
 exception of `abs`, there shall be additional overloads sufficient to
 ensure:
+- If any argument of arithmetic type corresponding to a `double`
   parameter has type `long double`, then all arguments of arithmetic
+ type [[basic.fundamental]] corresponding to `double` parameters are
+ effectively cast to `long double`.
+- Otherwise, if any argument of arithmetic type corresponding to a
   `double` parameter has type `double` or an integer type, then all
+ arguments of arithmetic type corresponding to `double` parameters are
+ effectively cast to `double`.
+- \[*Note 2*: Otherwise, all arguments of arithmetic type corresponding
+  to `double` parameters have type `float`. — *end note*]
+[*Note 3*: `abs` is exempted from these rules in order to stay
 compatible with C. — *end note*]
 ISO C 7.12
 ### Absolute values <a id="c.math.abs">[[c.math.abs]]</a>
+[*Note 1*: The headers `<cstdlib>` and `<cmath>` declare the functions
+described in this subclause. — *end note*]
 ``` cpp
 int abs(int j);
 long int abs(long int j);
 long long int abs(long long int j);
 standard library for the functions `abs`, `labs`, `llabs`, `fabsf`,
 `fabs`, and `fabsl`.
 *Remarks:* If `abs()` is called with an argument of type `X` for which
 `is_unsigned_v<X>` is `true` and if `X` cannot be converted to `int` by
+integral promotion [[conv.prom]], the program is ill-formed.
 [*Note 1*: Arguments that can be promoted to `int` are permitted for
 compatibility with C. — *end note*]
+See also: ISO C 7.12.7.2, 7.22.6.1
 ### Three-dimensional hypotenuse <a id="c.math.hypot3">[[c.math.hypot3]]</a>
 ``` cpp
 float hypot(float x, float y, float z);
 long double hypot(long double x, long double y, long double z);
 ```
 *Returns:* $\sqrt{x^2+y^2+z^2}$.
+### Linear interpolation <a id="c.math.lerp">[[c.math.lerp]]</a>
+``` cpp
+constexpr float lerp(float a, float b, float t) noexcept;
+constexpr double lerp(double a, double b, double t) noexcept;
+constexpr long double lerp(long double a, long double b, long double t) noexcept;
+```
+*Returns:* a+t(b-a).
+*Remarks:* Let `r` be the value returned. If
+`isfinite(a) && isfinite(b)`, then:
+- If `t == 0`, then `r == a`.
+- If `t == 1`, then `r == b`.
+- If `t >= 0 && t <= 1`, then `isfinite(r)`.
+- If `isfinite(t) && a == b`, then `r == a`.
+- If `isfinite(t) || !isnan(t) && b-a != 0`, then `!isnan(r)`.
+Let *`CMP`*`(x,y)` be `1` if `x > y`, `-1` if `x < y`, and `0`
+otherwise. For any `t1` and `t2`, the product of
+*`CMP`*`(lerp(a, b, t2), lerp(a, b, t1))`, *`CMP`*`(t2, t1)`, and
+*`CMP`*`(b, a)` is non-negative.
 ### Classification / comparison functions <a id="c.math.fpclass">[[c.math.fpclass]]</a>
 The classification / comparison functions behave the same as the C
 macros with the corresponding names defined in the C standard library.
 Each function is overloaded for the three floating-point types.
 - the function description’s *Returns:* clause explicitly specifies a
   domain and those argument values fall outside the specified domain, or
 - the corresponding mathematical function value has a nonzero imaginary
   component, or
 - the corresponding mathematical function is not mathematically
+  defined.[^13]
 Unless otherwise specified, each function is defined for all finite
 values, for negative infinity, and for positive infinity.
+#### Associated Laguerre polynomials <a id="sf.cmath.assoc.laguerre">[[sf.cmath.assoc.laguerre]]</a>
 ``` cpp
 double       assoc_laguerre(unsigned n, unsigned m, double x);
 float        assoc_laguerref(unsigned n, unsigned m, float x);
 long double  assoc_laguerrel(unsigned n, unsigned m, long double x);
 ```
 *Effects:* These functions compute the associated Laguerre polynomials
 of their respective arguments `n`, `m`, and `x`.
+*Returns:* $$\mathsf{L}_n^m(x) =
+   (-1)^m \frac{\mathsf{d} ^ m}{\mathsf{d}x ^ m} \, \mathsf{L}_{n+m}(x)
+ \text{ ,\quad for $x \ge 0$,}$$ where n is `n`, m is `m`, and x is
 `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128` or if `m >= 128`.
+#### Associated Legendre functions <a id="sf.cmath.assoc.legendre">[[sf.cmath.assoc.legendre]]</a>
 ``` cpp
 double       assoc_legendre(unsigned l, unsigned m, double x);
 float        assoc_legendref(unsigned l, unsigned m, float x);
 long double  assoc_legendrel(unsigned l, unsigned m, long double x);
 ```
 *Effects:* These functions compute the associated Legendre functions of
 their respective arguments `l`, `m`, and `x`.
+*Returns:* $$\mathsf{P}_\ell^m(x) = (1 - x^2) ^ {m/2} \:
+ \frac{\mathsf{d} ^ m}{\mathsf{d}x ^ m} \, \mathsf{P}_\ell(x)
+   \text{ ,\quad for $|x| \le 1$,}$$ where l is `l`, m is `m`, and x is
 `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `l >= 128`.
 ```
 *Effects:* These functions compute the beta function of their respective
 arguments `x` and `y`.
+*Returns:*
+$$\mathsf{B}(x, y) = \frac{\Gamma(x) \, \Gamma(y)}{\Gamma(x + y)}
+ \text{ ,\quad for $x > 0$,\, $y > 0$,}$$ where x is `x` and y is `y`.
+#### Complete elliptic integral of the first kind <a id="sf.cmath.comp.ellint.1">[[sf.cmath.comp.ellint.1]]</a>
 ``` cpp
 double       comp_ellint_1(double k);
 float        comp_ellint_1f(float k);
 long double  comp_ellint_1l(long double k);
 ```
 *Effects:* These functions compute the complete elliptic integral of the
 first kind of their respective arguments `k`.
+*Returns:*
+$$\mathsf{K}(k) = \mathsf{F}(k, \pi / 2) \text{ ,\quad for $|k| \le 1$,}$$
+where k is `k`.
+See also [[sf.cmath.ellint.1]].
+#### Complete elliptic integral of the second kind <a id="sf.cmath.comp.ellint.2">[[sf.cmath.comp.ellint.2]]</a>
 ``` cpp
 double       comp_ellint_2(double k);
 float        comp_ellint_2f(float k);
 long double  comp_ellint_2l(long double k);
 ```
 *Effects:* These functions compute the complete elliptic integral of the
 second kind of their respective arguments `k`.
+*Returns:*
+$$\mathsf{E}(k) = \mathsf{E}(k, \pi / 2) \text{ ,\quad for $|k| \le 1$,}$$
+where k is `k`.
+See also [[sf.cmath.ellint.2]].
+#### Complete elliptic integral of the third kind <a id="sf.cmath.comp.ellint.3">[[sf.cmath.comp.ellint.3]]</a>
 ``` cpp
 double       comp_ellint_3(double k, double nu);
 float        comp_ellint_3f(float k, float nu);
 long double  comp_ellint_3l(long double k, long double nu);
 ```
 *Effects:* These functions compute the complete elliptic integral of the
 third kind of their respective arguments `k` and `nu`.
+*Returns:*
+$$\mathsf{\Pi}(\nu, k) = \mathsf{\Pi}(\nu, k, \pi / 2) \text{ ,\quad for $|k| \le 1$,}$$
+where k is `k` and $\nu$ is `nu`.
+See also [[sf.cmath.ellint.3]].
+#### Regular modified cylindrical Bessel functions <a id="sf.cmath.cyl.bessel.i">[[sf.cmath.cyl.bessel.i]]</a>
 ``` cpp
 double       cyl_bessel_i(double nu, double x);
 float        cyl_bessel_if(float nu, float x);
 long double  cyl_bessel_il(long double nu, long double x);
 ```
 *Effects:* These functions compute the regular modified cylindrical
 Bessel functions of their respective arguments `nu` and `x`.
+*Returns:* $$\mathsf{I}_\nu(x) =
+     i^{-\nu} \mathsf{J}_\nu(ix) =
+     \sum_{k=0}^\infty \frac{(x/2)^{\nu+2k}}{k! \: \Gamma(\nu+k+1)}
+     \text{ ,\quad for $x \ge 0$,}$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
+See also [[sf.cmath.cyl.bessel.j]].
+#### Cylindrical Bessel functions of the first kind <a id="sf.cmath.cyl.bessel.j">[[sf.cmath.cyl.bessel.j]]</a>
 ``` cpp
 double       cyl_bessel_j(double nu, double x);
 float        cyl_bessel_jf(float nu, float x);
 long double  cyl_bessel_jl(long double nu, long double x);
 ```
 *Effects:* These functions compute the cylindrical Bessel functions of
 the first kind of their respective arguments `nu` and `x`.
+*Returns:* $$\mathsf{J}_\nu(x) =
+ \sum_{k=0}^\infty \frac{(-1)^k (x/2)^{\nu+2k}}{k! \: \Gamma(\nu+k+1)}
+ \text{ ,\quad for $x \ge 0$,}$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
+#### Irregular modified cylindrical Bessel functions <a id="sf.cmath.cyl.bessel.k">[[sf.cmath.cyl.bessel.k]]</a>
 ``` cpp
 double       cyl_bessel_k(double nu, double x);
 float        cyl_bessel_kf(float nu, float x);
 long double  cyl_bessel_kl(long double nu, long double x);
   \right.$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
+See also [[sf.cmath.cyl.bessel.i]], [[sf.cmath.cyl.bessel.j]],
+[[sf.cmath.cyl.neumann]].
+#### Cylindrical Neumann functions <a id="sf.cmath.cyl.neumann">[[sf.cmath.cyl.neumann]]</a>
 ``` cpp
 double       cyl_neumann(double nu, double x);
 float        cyl_neumannf(float nu, float x);
 long double  cyl_neumannl(long double nu, long double x);
   \right.$$ where $\nu$ is `nu` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `nu >= 128`.
+See also [[sf.cmath.cyl.bessel.j]].
+#### Incomplete elliptic integral of the first kind <a id="sf.cmath.ellint.1">[[sf.cmath.ellint.1]]</a>
 ``` cpp
 double       ellint_1(double k, double phi);
 float        ellint_1f(float k, float phi);
 long double  ellint_1l(long double k, long double phi);
 *Effects:* These functions compute the incomplete elliptic integral of
 the first kind of their respective arguments `k` and `phi` (`phi`
 measured in radians).
+*Returns:* $$\mathsf{F}(k, \phi) =
+ \int_0^\phi \! \frac{\mathsf{d}\theta}{\sqrt{1 - k^2 \sin^2 \theta}}
+ \text{ ,\quad for $|k| \le 1$,}$$ where k is `k` and φ is `phi`.
+#### Incomplete elliptic integral of the second kind <a id="sf.cmath.ellint.2">[[sf.cmath.ellint.2]]</a>
 ``` cpp
 double       ellint_2(double k, double phi);
 float        ellint_2f(float k, float phi);
 long double  ellint_2l(long double k, long double phi);
 *Effects:* These functions compute the incomplete elliptic integral of
 the second kind of their respective arguments `k` and `phi` (`phi`
 measured in radians).
+*Returns:*
+$$\mathsf{E}(k, \phi) = \int_0^\phi \! \sqrt{1 - k^2 \sin^2 \theta} \, \mathsf{d}\theta
+ \text{ ,\quad for $|k| \le 1$,}$$ where k is `k` and φ is `phi`.
+#### Incomplete elliptic integral of the third kind <a id="sf.cmath.ellint.3">[[sf.cmath.ellint.3]]</a>
 ``` cpp
 double       ellint_3(double k, double nu, double phi);
 float        ellint_3f(float k, float nu, float phi);
 long double  ellint_3l(long double k, long double nu, long double phi);
 *Effects:* These functions compute the incomplete elliptic integral of
 the third kind of their respective arguments `k`, `nu`, and `phi` (`phi`
 measured in radians).
+*Returns:* $$\mathsf{\Pi}(\nu, k, \phi) = \int_0^\phi \!
+ \frac{ \mathsf{d}\theta }{ (1 - \nu \, \sin^2 \theta) \sqrt{1 - k^2 \sin^2 \theta} } \text{ ,\quad for $|k| \le 1$,}$$
+where $\nu$ is `nu`, k is `k`, and φ is `phi`.
 #### Exponential integral <a id="sf.cmath.expint">[[sf.cmath.expint]]</a>
 ``` cpp
 double       expint(double x);
 ```
 *Effects:* These functions compute the Laguerre polynomials of their
 respective arguments `n` and `x`.
+*Returns:* $$\mathsf{L}_n(x) =
+ \frac{e^x}{n!} \frac{\mathsf{d}^n}{\mathsf{d}x^n} \, (x^n e^{-x})
+ \text{ ,\quad for $x \ge 0$,}$$ where n is `n` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128`.
 #### Legendre polynomials <a id="sf.cmath.legendre">[[sf.cmath.legendre]]</a>
 ```
 *Effects:* These functions compute the Legendre polynomials of their
 respective arguments `l` and `x`.
+*Returns:* $$\mathsf{P}_\ell(x) =
+ \frac{1}{2^\ell \, \ell!}
+ \frac{\mathsf{d}^\ell}{\mathsf{d}x^\ell} \, (x^2 - 1) ^ \ell
+ \text{ ,\quad for $|x| \le 1$,}$$ where l is `l` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `l >= 128`.
+#### Riemann zeta function <a id="sf.cmath.riemann.zeta">[[sf.cmath.riemann.zeta]]</a>
 ``` cpp
 double       riemann_zeta(double x);
 float        riemann_zetaf(float x);
 long double  riemann_zetal(long double x);
   & \mbox{for $x < 0$}
   \end{array}
   \right.
 \;$$ where x is `x`.
+#### Spherical Bessel functions of the first kind <a id="sf.cmath.sph.bessel">[[sf.cmath.sph.bessel]]</a>
 ``` cpp
 double       sph_bessel(unsigned n, double x);
 float        sph_besself(unsigned n, float x);
 long double  sph_bessell(unsigned n, long double x);
 ```
 *Effects:* These functions compute the spherical Bessel functions of the
 first kind of their respective arguments `n` and `x`.
+*Returns:*
+$$\mathsf{j}_n(x) = (\pi/2x)^{1\!/\!2} \mathsf{J}_{n + 1\!/\!2}(x) \text{ ,\quad for $x \ge 0$,}$$
+where n is `n` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128`.
+See also [[sf.cmath.cyl.bessel.j]].
+#### Spherical associated Legendre functions <a id="sf.cmath.sph.legendre">[[sf.cmath.sph.legendre]]</a>
 ``` cpp
 double       sph_legendre(unsigned l, unsigned m, double theta);
 float        sph_legendref(unsigned l, unsigned m, float theta);
 long double  sph_legendrel(unsigned l, unsigned m, long double theta);
 *Effects:* These functions compute the spherical associated Legendre
 functions of their respective arguments `l`, `m`, and `theta` (`theta`
 measured in radians).
+*Returns:* $$\mathsf{Y}_\ell^m(\theta, 0)$$ where
+$$\mathsf{Y}_\ell^m(\theta, \phi) =
+     (-1)^m \left[\frac{(2 \ell + 1)}{4 \pi} \frac{(\ell - m)!}{(\ell + m)!}\right]^{1/2}
+ \mathsf{P}_\ell^m (\cos\theta) e^{i m \phi}
+     \text{ ,\quad for $|m| \le \ell$,}$$ and l is `l`, m is `m`, and θ
 is `theta`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `l >= 128`.
+See also [[sf.cmath.assoc.legendre]].
+#### Spherical Neumann functions <a id="sf.cmath.sph.neumann">[[sf.cmath.sph.neumann]]</a>
 ``` cpp
 double       sph_neumann(unsigned n, double x);
 float        sph_neumannf(unsigned n, float x);
 long double  sph_neumannl(unsigned n, long double x);
 *Effects:* These functions compute the spherical Neumann functions, also
 known as the spherical Bessel functions of the second kind, of their
 respective arguments `n` and `x`.
+*Returns:*
+$$\mathsf{n}_n(x) = (\pi/2x)^{1\!/\!2} \mathsf{N}_{n + 1\!/\!2}(x)
+ \text{ ,\quad for $x \ge 0$,}$$ where n is `n` and x is `x`.
 *Remarks:* The effect of calling each of these functions is
 *implementation-defined* if `n >= 128`.
+See also [[sf.cmath.cyl.neumann]].
+## Numbers <a id="numbers">[[numbers]]</a>
+### Header `<numbers>` synopsis <a id="numbers.syn">[[numbers.syn]]</a>
+``` cpp
+namespace std::numbers {
+  template<class T> inline constexpr T e_v          = unspecified;
+  template<class T> inline constexpr T log2e_v      = unspecified;
+  template<class T> inline constexpr T log10e_v     = unspecified;
+  template<class T> inline constexpr T pi_v         = unspecified;
+  template<class T> inline constexpr T inv_pi_v     = unspecified;
+  template<class T> inline constexpr T inv_sqrtpi_v = unspecified;
+  template<class T> inline constexpr T ln2_v        = unspecified;
+  template<class T> inline constexpr T ln10_v       = unspecified;
+  template<class T> inline constexpr T sqrt2_v      = unspecified;
+  template<class T> inline constexpr T sqrt3_v      = unspecified;
+  template<class T> inline constexpr T inv_sqrt3_v  = unspecified;
+  template<class T> inline constexpr T egamma_v     = unspecified;
+  template<class T> inline constexpr T phi_v        = unspecified;
+  template<floating_point T> inline constexpr T e_v<T>          = see below;
+  template<floating_point T> inline constexpr T log2e_v<T>      = see below;
+  template<floating_point T> inline constexpr T log10e_v<T>     = see below;
+  template<floating_point T> inline constexpr T pi_v<T>         = see below;
+  template<floating_point T> inline constexpr T inv_pi_v<T>     = see below;
+  template<floating_point T> inline constexpr T inv_sqrtpi_v<T> = see below;
+  template<floating_point T> inline constexpr T ln2_v<T>        = see below;
+  template<floating_point T> inline constexpr T ln10_v<T>       = see below;
+  template<floating_point T> inline constexpr T sqrt2_v<T>      = see below;
+  template<floating_point T> inline constexpr T sqrt3_v<T>      = see below;
+  template<floating_point T> inline constexpr T inv_sqrt3_v<T>  = see below;
+  template<floating_point T> inline constexpr T egamma_v<T>     = see below;
+  template<floating_point T> inline constexpr T phi_v<T>        = see below;
+  inline constexpr double e          = e_v<double>;
+  inline constexpr double log2e      = log2e_v<double>;
+  inline constexpr double log10e     = log10e_v<double>;
+  inline constexpr double pi         = pi_v<double>;
+  inline constexpr double inv_pi     = inv_pi_v<double>;
+  inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
+  inline constexpr double ln2        = ln2_v<double>;
+  inline constexpr double ln10       = ln10_v<double>;
+  inline constexpr double sqrt2      = sqrt2_v<double>;
+  inline constexpr double sqrt3      = sqrt3_v<double>;
+  inline constexpr double inv_sqrt3  = inv_sqrt3_v<double>;
+  inline constexpr double egamma     = egamma_v<double>;
+  inline constexpr double phi        = phi_v<double>;
+}
+```
+### Mathematical constants <a id="math.constants">[[math.constants]]</a>
+The library-defined partial specializations of mathematical constant
+variable templates are initialized with the nearest representable values
+of e, log₂ e, log₁₀ e, π, $\frac{1}{\pi}$, $\frac{1}{\sqrt{\pi}}$,
+$\ln 2$, $\ln 10$, $\sqrt{2}$, $\sqrt{3}$, $\frac{1}{\sqrt{3}}$, the
+Euler-Mascheroni γ constant, and the golden ratio φ constant
+$\frac{1+\sqrt{5}}{2}$, respectively.
+Pursuant to [[namespace.std]], a program may partially or explicitly
+specialize a mathematical constant variable template provided that the
+specialization depends on a program-defined type.
+A program that instantiates a primary template of a mathematical
+constant variable template is ill-formed.
 <!-- Link reference definitions -->
+[bad.alloc]: support.md#bad.alloc
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.types]: basic.md#basic.types
+[bit]: #bit
+[bit.cast]: #bit.cast
+[bit.count]: #bit.count
+[bit.endian]: #bit.endian
+[bit.general]: #bit.general
+[bit.pow.two]: #bit.pow.two
+[bit.rotate]: #bit.rotate
+[bit.syn]: #bit.syn
 [c.math]: #c.math
 [c.math.abs]: #c.math.abs
 [c.math.fpclass]: #c.math.fpclass
 [c.math.hypot3]: #c.math.hypot3
+[c.math.lerp]: #c.math.lerp
 [c.math.rand]: #c.math.rand
 [cfenv]: #cfenv
 [cfenv.syn]: #cfenv.syn
 [class.gslice]: #class.gslice
 [class.gslice.overview]: #class.gslice.overview
 [complex.special]: #complex.special
 [complex.syn]: #complex.syn
 [complex.transcendentals]: #complex.transcendentals
 [complex.value.ops]: #complex.value.ops
 [cons.slice]: #cons.slice
+[conv.prom]: expr.md#conv.prom
 [cpp.pragma]: cpp.md#cpp.pragma
+[cpp17.copyassignable]: #cpp17.copyassignable
+[cpp17.copyconstructible]: #cpp17.copyconstructible
+[cpp17.equalitycomparable]: #cpp17.equalitycomparable
 [dcl.init]: dcl.md#dcl.init
+[expr.const]: expr.md#expr.const
 [gslice.access]: #gslice.access
 [gslice.array.assign]: #gslice.array.assign
 [gslice.array.comp.assign]: #gslice.array.comp.assign
 [gslice.array.fill]: #gslice.array.fill
 [gslice.cons]: #gslice.cons
 [implimits]: limits.md#implimits
 [indirect.array.assign]: #indirect.array.assign
 [indirect.array.comp.assign]: #indirect.array.comp.assign
 [indirect.array.fill]: #indirect.array.fill
 [input.iterators]: iterators.md#input.iterators
 [input.output]: input.md#input.output
+[intro.object]: basic.md#intro.object
 [iostate.flags]: input.md#iostate.flags
 [istream.formatted]: input.md#istream.formatted
+[iterator.concept.contiguous]: iterators.md#iterator.concept.contiguous
 [iterator.requirements.general]: iterators.md#iterator.requirements.general
 [library.c]: library.md#library.c
 [mask.array.assign]: #mask.array.assign
 [mask.array.comp.assign]: #mask.array.comp.assign
 [mask.array.fill]: #mask.array.fill
+[math.constants]: #math.constants
+[namespace.std]: library.md#namespace.std
 [numarray]: #numarray
+[numbers]: #numbers
+[numbers.syn]: #numbers.syn
 [numeric.requirements]: #numeric.requirements
 [numerics]: #numerics
 [numerics.general]: #numerics.general
+[numerics.summary]: #numerics.summary
 [output.iterators]: iterators.md#output.iterators
 [rand]: #rand
 [rand.adapt]: #rand.adapt
 [rand.adapt.disc]: #rand.adapt.disc
 [rand.adapt.general]: #rand.adapt.general
 [rand.adapt.ibits]: #rand.adapt.ibits
 [rand.synopsis]: #rand.synopsis
 [rand.util]: #rand.util
 [rand.util.canonical]: #rand.util.canonical
 [rand.util.seedseq]: #rand.util.seedseq
 [random.access.iterators]: iterators.md#random.access.iterators
 [res.on.data.races]: library.md#res.on.data.races
 [sf.cmath]: #sf.cmath
+[sf.cmath.assoc.laguerre]: #sf.cmath.assoc.laguerre
+[sf.cmath.assoc.legendre]: #sf.cmath.assoc.legendre
 [sf.cmath.beta]: #sf.cmath.beta
+[sf.cmath.comp.ellint.1]: #sf.cmath.comp.ellint.1
+[sf.cmath.comp.ellint.2]: #sf.cmath.comp.ellint.2
+[sf.cmath.comp.ellint.3]: #sf.cmath.comp.ellint.3
+[sf.cmath.cyl.bessel.i]: #sf.cmath.cyl.bessel.i
+[sf.cmath.cyl.bessel.j]: #sf.cmath.cyl.bessel.j
+[sf.cmath.cyl.bessel.k]: #sf.cmath.cyl.bessel.k
+[sf.cmath.cyl.neumann]: #sf.cmath.cyl.neumann
+[sf.cmath.ellint.1]: #sf.cmath.ellint.1
+[sf.cmath.ellint.2]: #sf.cmath.ellint.2
+[sf.cmath.ellint.3]: #sf.cmath.ellint.3
 [sf.cmath.expint]: #sf.cmath.expint
 [sf.cmath.hermite]: #sf.cmath.hermite
 [sf.cmath.laguerre]: #sf.cmath.laguerre
 [sf.cmath.legendre]: #sf.cmath.legendre
+[sf.cmath.riemann.zeta]: #sf.cmath.riemann.zeta
+[sf.cmath.sph.bessel]: #sf.cmath.sph.bessel
+[sf.cmath.sph.legendre]: #sf.cmath.sph.legendre
+[sf.cmath.sph.neumann]: #sf.cmath.sph.neumann
 [slice.access]: #slice.access
 [slice.arr.assign]: #slice.arr.assign
 [slice.arr.comp.assign]: #slice.arr.comp.assign
 [slice.arr.fill]: #slice.arr.fill
+[slice.ops]: #slice.ops
 [strings]: strings.md#strings
 [template.gslice.array]: #template.gslice.array
 [template.gslice.array.overview]: #template.gslice.array.overview
 [template.indirect.array]: #template.indirect.array
 [template.indirect.array.overview]: #template.indirect.array.overview
 [template.mask.array]: #template.mask.array
 [template.mask.array.overview]: #template.mask.array.overview
 [template.slice.array]: #template.slice.array
 [template.slice.array.overview]: #template.slice.array.overview
 [template.valarray]: #template.valarray
 [template.valarray.overview]: #template.valarray.overview
+[thread.jthread.class]: thread.md#thread.jthread.class
 [thread.thread.class]: thread.md#thread.thread.class
+[utility.arg.requirements]: library.md#utility.arg.requirements
 [valarray.access]: #valarray.access
 [valarray.assign]: #valarray.assign
 [valarray.binary]: #valarray.binary
 [valarray.cassign]: #valarray.cassign
 [valarray.comparison]: #valarray.comparison
 [valarray.special]: #valarray.special
 [valarray.sub]: #valarray.sub
 [valarray.syn]: #valarray.syn
 [valarray.transcend]: #valarray.transcend
 [valarray.unary]: #valarray.unary
 [^1]: In other words, value types. These include arithmetic types,
     pointers, the library class `complex`, and instantiations of
     `valarray` for value types.
 [^6]: The distribution corresponding to this probability density
     function is also known (with a possible change of variable) as the
     Gumbel Type I, the log-Weibull, or the Fisher-Tippett Type I
     distribution.
+[^7]: [[implimits]] recommends a minimum number of recursively nested
+    template instantiations. This requirement thus indirectly suggests a
+    minimum allowable complexity for valarray expressions.
 [^8]: The intent is to specify an array template that has the minimum
     functionality necessary to address aliasing ambiguities and the
+    proliferation of temporary objects. Thus, the `valarray` template is
     neither a matrix class nor a field class. However, it is a very
     useful building block for designing such classes.
 [^9]: This default constructor is essential, since arrays of `valarray`
     may be useful. After initialization, the length of an empty array
 [^10]: This constructor is the preferred method for converting a C array
     to a `valarray` object.
 [^11]: This copy constructor creates a distinct array rather than an
     alias. Implementations in which arrays share storage are permitted,
+    but they would need to implement a copy-on-reference mechanism to
+ ensure that arrays are conceptually distinct.
 [^12]: BLAS stands for *Basic Linear Algebra Subprograms.* C++ programs
     may instantiate this class. See, for example, Dongarra, Du Croz,
     Duff, and Hammerling: *A set of Level 3 Basic Linear Algebra
     Subprograms*; Technical Report MCS-P1-0888, Argonne National
     Laboratory (USA), Mathematics and Computer Science Division, August,
     1988.
+[^13]: A mathematical function is mathematically defined for a given set
     of argument values (a) if it is explicitly defined for that set of
     argument values, or (b) if its limiting value exists and does not
     depend on the direction of approach.

Diff to HTML by rtfpessoa