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

Files changed (1) hide show

tmp/tmpx1kzy_5v/{from.md → to.md} +742 -872

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

@@ -15,11 +15,10 @@ floating-point types, as summarized in [[numerics.summary]].
 | 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>`            |
@@ -98,35 +97,40 @@ 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:
@@ -150,15 +154,10 @@ expression `a[i]` is well-defined for an integer expression `i`, then:
 ``` 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>&);
@@ -244,12 +243,12 @@ 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);
@@ -271,108 +270,29 @@ namespace std {
 ```
 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.
@@ -558,11 +478,11 @@ were implemented as follows:
 ``` cpp
 basic_ostringstream<charT, traits> s;
 s.flags(o.flags());
 s.imbue(o.getloc());
 s.precision(o.precision());
-s << '(' << x.real() << "," << x.imag() << ')';
 return o << s.str();
 ```
 [*Note 1*: In a locale in which comma is used as a decimal point
 character, the use of comma as a field separator can be ambiguous.
@@ -781,28 +701,20 @@ 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
@@ -829,265 +741,15 @@ 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)}`.
-## 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*.
@@ -1099,39 +761,39 @@ to templates producing such types when instantiated.
 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;
@@ -1320,17 +982,18 @@ 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
@@ -1391,22 +1054,22 @@ 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}).
@@ -1502,17 +1165,17 @@ 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
@@ -1525,11 +1188,11 @@ where `charT` and `traits` are constrained according to [[strings]] and
 [[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)`.
 If a textual representation is written using `os << x` and that
 representation is restored into the same or a different object `y` of
 the same type using `is >> y`, repeated invocations of `y(g)` shall
 produce the same sequence of numbers as would repeated invocations of
@@ -1559,40 +1222,39 @@ the identical name, type, and semantics.
 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);
   ```
@@ -1620,10 +1282,11 @@ object `x` is of size 1 and consists of a single integer. The transition
 algorithm is a modular linear function of the form
 TA(xᵢ) = (a ⋅ xᵢ + c)  mod  m; the generation algorithm is
 GA(xᵢ) = xᵢ₊₁.
 ``` cpp
   template<class UIntType, UIntType a, UIntType c, UIntType m>
   class linear_congruential_engine {
   public:
     // types
     using result_type = UIntType;
@@ -1641,14 +1304,27 @@ template<class UIntType, UIntType a, UIntType c, UIntType m>
     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
     result_type operator()();
     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.
@@ -1679,15 +1355,16 @@ $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
-a `mersenne_twister_engine` object `x` is of size n and consists of a
-sequence X of n values of the type delivered by `x`; all subscripts
-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.,
@@ -1711,10 +1388,11 @@ z₁, z₂, z₃, z₄ as follows, then delivers z₄ as its result:
 - 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>
   class mersenne_twister_engine {
@@ -1745,14 +1423,26 @@ template<class UIntType, size_t w, size_t n, size_t m, size_t r,
     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
     result_type operator()();
     void discard(unsigned long long z);
   };
 ```
 The following relations shall hold: `0 < m`, `m <= n`, `2u < w`,
 `r <= w`, `u <= w`, `s <= w`, `t <= w`, `l <= w`,
 `w <= numeric_limits<UIntType>::digits`, `a <= (1u<<w) - 1u`,
@@ -1810,10 +1500,11 @@ and a = b - (b - 1) / m. — *end note*]
 The generation algorithm is given by GA(xᵢ) = y, where y is the value
 produced as a result of advancing the engine’s state as described above.
 ``` cpp
   template<class UIntType, size_t w, size_t s, size_t r>
   class subtract_with_carry_engine {
   public:
     // types
     using result_type = UIntType;
@@ -1831,14 +1522,27 @@ template<class UIntType, size_t w, size_t s, size_t r>
     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
     result_type operator()();
     void discard(unsigned long long z);
   };
 ```
 The following relations shall hold: `0u < s`, `s < r`, `0 < w`, and
 `w <= numeric_limits<UIntType>::digits`.
@@ -1859,11 +1563,11 @@ To set the values Xₖ, first construct `e`, a
 linear_congruential_engine<result_type,
                           40014u,0u,2147483563u> e(value == 0u ? default_seed : value);
 ```
 Then, to set each Xₖ, obtain new values z₀, …, zₙ₋₁ from n = ⌈ w/32 ⌉
-successive invocations of `e` taken modulo 2³². Set Xₖ to
 $\left( \sum_{j=0}^{n-1} z_j \cdot 2^{32j}\right) \bmod m$.
 *Complexity:* Exactly n ⋅ `r` invocations of `e`.
 ``` cpp
@@ -1923,10 +1627,11 @@ state eⱼ to eⱼ₊₁.
 The generation algorithm yields the value returned by the last
 invocation of `e()` while advancing `e`’s state as described above.
 ``` cpp
   template<class Engine, size_t p, size_t r>
   class discard_block_engine {
   public:
     // types
     using result_type = typename Engine::result_type;
@@ -1945,21 +1650,33 @@ template<class Engine, size_t p, size_t r>
     template<class Sseq> explicit discard_block_engine(Sseq& q);
     void seed();
     void seed(result_type s);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
     // property functions
-    const Engine& base() const noexcept { return e; };
   private:
     Engine e;   // exposition only
- int n; // exposition only
   };
 ```
 The following relations shall hold: `0 < r` and `r <= p`.
 The textual representation consists of the textual representation of `e`
@@ -2029,16 +1746,27 @@ template<class Engine, size_t w, class UIntType>
     template<class Sseq> explicit independent_bits_engine(Sseq& q);
     void seed();
     void seed(result_type s);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
     // property functions
-    const Engine& base() const noexcept { return e; };
   private:
     Engine e;   // exposition only
   };
 ```
@@ -2069,10 +1797,11 @@ 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>
   class shuffle_order_engine {
   public:
     // types
     using result_type = typename Engine::result_type;
@@ -2090,22 +1819,34 @@ template<class Engine, size_t k>
     template<class Sseq> explicit shuffle_order_engine(Sseq& q);
     void seed();
     void seed(result_type s);
     template<class Sseq> void seed(Sseq& q);
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
     // property functions
-    const Engine& base() const noexcept { return e; };
   private:
     Engine e;           // exposition only
     result_type V[k];   // exposition only
     result_type Y;      // exposition only
   };
 ```
 The following relation shall hold: `0 < k`.
 The textual representation consists of the textual representation of
@@ -2204,14 +1945,14 @@ using default_random_engine = implementation-defined;
 ```
 *Remarks:* The choice of engine type named by this `typedef` is
 *implementation-defined*.
-[*Note 1*: The implementation may select this type on the basis of
 performance, size, quality, or any combination of such factors, so as to
 provide at least acceptable engine behavior for relatively casual,
-inexpert, and/or lightweight use. Because different implementations may
 select different underlying engine types, code that uses this `typedef`
 need not generate identical sequences across
 implementations. — *end note*]
 ### Class `random_device` <a id="rand.device">[[rand.device]]</a>
@@ -2221,10 +1962,11 @@ random numbers.
 If implementation limitations prevent generating nondeterministic random
 numbers, the implementation may employ a random number engine.
 ``` cpp
   class random_device {
   public:
     // types
     using result_type = unsigned int;
@@ -2244,53 +1986,57 @@ public:
     // no copy functions
     random_device(const random_device&) = delete;
     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
 double entropy() const noexcept;
 ```
 *Returns:* If the implementation employs a random number engine, returns
-0.0. Otherwise, returns an entropy estimate[^4] for the random numbers
-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.
 ### Utilities <a id="rand.util">[[rand.util]]</a>
 #### Class `seed_seq` <a id="rand.util.seedseq">[[rand.util.seedseq]]</a>
 ``` cpp
   class seed_seq {
   public:
     // types
     using result_type = uint_least32_t;
     // constructors
- seed_seq();
     template<class T>
       seed_seq(initializer_list<T> il);
     template<class InputIterator>
       seed_seq(InputIterator begin, InputIterator end);
@@ -2308,26 +2054,25 @@ public:
     void operator=(const seed_seq&) = delete;
   private:
     vector<result_type> v;      // exposition only
   };
 ```
 ``` 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>
@@ -2443,14 +2188,10 @@ copy(v.begin(), v.end(), dest);
 ``` cpp
 template<class RealType, size_t bits, class URBG>
   RealType generate_canonical(URBG& g);
 ```
-*Complexity:* Exactly k = max(1, ⌈ b / log₂ R ⌉) invocations of `g`,
-where b[^5] is the lesser of `numeric_limits<RealType>::digits` and
-`bits`, and R is the value of `g.max()` - `g.min()` + 1.
 *Effects:* Invokes `g()` k times to obtain values g₀, …, gₖ₋₁,
 respectively. Calculates a quantity
 $$S = \sum_{i=0}^{k-1} (g_i - \texttt{g.min()})
                         \cdot R^i$$ using arithmetic of type `RealType`.
@@ -2458,10 +2199,16 @@ $$S = \sum_{i=0}^{k-1} (g_i - \texttt{g.min()})
 [*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
@@ -2496,10 +2243,11 @@ outside its stated domain.
 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;
@@ -2509,10 +2257,13 @@ template<class IntType = int>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -2522,11 +2273,20 @@ template<class IntType = int>
     result_type b() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit uniform_int_distribution(IntType a, IntType b = numeric_limits<IntType>::max());
 ```
@@ -2558,10 +2318,11 @@ 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
   template<class RealType = double>
   class uniform_real_distribution {
   public:
     // types
     using result_type = RealType;
@@ -2571,10 +2332,14 @@ template<class RealType = double>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -2584,11 +2349,20 @@ template<class RealType = double>
     result_type b() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit uniform_real_distribution(RealType a, RealType b = 1.0);
 ```
@@ -2623,10 +2397,11 @@ $$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;
@@ -2635,10 +2410,13 @@ public:
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -2647,11 +2425,20 @@ public:
     double p() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit bernoulli_distribution(double p);
 ```
@@ -2672,10 +2459,11 @@ constructed.
 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;
@@ -2685,10 +2473,13 @@ template<class IntType = int>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -2698,11 +2489,20 @@ template<class IntType = int>
     double p() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit binomial_distribution(IntType t, double p = 0.5);
 ```
@@ -2731,10 +2531,11 @@ constructed.
 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;
@@ -2744,10 +2545,13 @@ template<class IntType = int>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -2756,11 +2560,20 @@ template<class IntType = int>
     double p() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit geometric_distribution(double p);
 ```
@@ -2785,10 +2598,11 @@ $$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
   template<class IntType = int>
   class negative_binomial_distribution {
   public:
     // types
     using result_type = IntType;
@@ -2798,10 +2612,14 @@ template<class IntType = int>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -2811,11 +2629,20 @@ template<class IntType = int>
     double p() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit negative_binomial_distribution(IntType k, double p = 0.5);
 ```
@@ -2861,10 +2688,13 @@ template<class IntType = int>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -2873,10 +2703,18 @@ template<class IntType = int>
     double mean() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit poisson_distribution(double mean);
@@ -2898,10 +2736,11 @@ constructed.
 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;
@@ -2911,10 +2750,13 @@ template<class RealType = double>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -2923,11 +2765,20 @@ template<class RealType = double>
     RealType lambda() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit exponential_distribution(RealType lambda);
 ```
@@ -2950,10 +2801,11 @@ 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;
@@ -2963,10 +2815,13 @@ template<class RealType = double>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -2976,11 +2831,20 @@ template<class RealType = double>
     RealType beta() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
 ```
@@ -3012,10 +2876,11 @@ $$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;
@@ -3025,10 +2890,13 @@ template<class RealType = double>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -3038,11 +2906,20 @@ template<class RealType = double>
     RealType b() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit weibull_distribution(RealType a, RealType b = 1.0);
 ```
@@ -3068,15 +2945,18 @@ 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)
      \text{ .}$$
 ``` cpp
   template<class RealType = double>
   class extreme_value_distribution {
   public:
     // types
     using result_type = RealType;
@@ -3086,10 +2966,14 @@ template<class RealType = double>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -3099,11 +2983,20 @@ template<class RealType = double>
     RealType b() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit extreme_value_distribution(RealType a, RealType b = 1.0);
 ```
@@ -3143,10 +3036,11 @@ numbers x distributed according to the probability density function $$%
             }
  \text{ .}$$ The distribution parameters μ and σ are also known as this
 distribution’s *mean* and *standard deviation*.
 ``` cpp
   template<class RealType = double>
   class normal_distribution {
   public:
     // types
     using result_type = RealType;
@@ -3156,10 +3050,13 @@ template<class RealType = double>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -3169,11 +3066,20 @@ template<class RealType = double>
     RealType stddev() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit normal_distribution(RealType mean, RealType stddev = 1.0);
 ```
@@ -3204,10 +3110,11 @@ 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;
@@ -3217,10 +3124,13 @@ template<class RealType = double>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -3230,11 +3140,20 @@ template<class RealType = double>
     RealType s() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit lognormal_distribution(RealType m, RealType s = 1.0);
 ```
@@ -3263,10 +3182,11 @@ constructed.
 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;
@@ -3276,10 +3196,13 @@ template<class RealType = double>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -3288,11 +3211,20 @@ template<class RealType = double>
     RealType n() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit chi_squared_distribution(RealType n);
 ```
@@ -3313,10 +3245,11 @@ constructed.
 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;
@@ -3326,10 +3259,13 @@ template<class RealType = double>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -3339,11 +3275,20 @@ template<class RealType = double>
     RealType b() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit cauchy_distribution(RealType a, RealType b = 1.0);
 ```
@@ -3376,10 +3321,11 @@ $$p(x\,|\,m,n) = \frac{\Gamma\big((m+n)/2\big)}{\Gamma(m/2) \; \Gamma(n/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;
@@ -3389,10 +3335,13 @@ template<class RealType = double>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -3402,11 +3351,20 @@ template<class RealType = double>
     RealType n() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit fisher_f_distribution(RealType m, RealType n = 1);
 ```
@@ -3438,10 +3396,11 @@ $$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;
@@ -3451,10 +3410,13 @@ template<class RealType = double>
     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 operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -3463,11 +3425,20 @@ template<class RealType = double>
     RealType n() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 explicit student_t_distribution(RealType n);
 ```
@@ -3496,10 +3467,11 @@ 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:
     // types
     using result_type = IntType;
@@ -3513,10 +3485,13 @@ template<class IntType = int>
     template<class UnaryOperation>
       discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);
     explicit discrete_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -3525,11 +3500,20 @@ template<class IntType = int>
     vector<double> probabilities() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 discrete_distribution();
 ```
@@ -3605,10 +3589,11 @@ $$\rho_k = \frac{w_k}{S \cdot (b_{k+1}-b_k)} \text{ for } k = 0, \dotsc, 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:
     // types
     using result_type = RealType;
@@ -3625,10 +3610,14 @@ template<class RealType = double>
       piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax,
                                       UnaryOperation fw);
     explicit piecewise_constant_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -3638,11 +3627,20 @@ template<class RealType = double>
     vector<result_type> densities() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 piecewise_constant_distribution();
 ```
@@ -3741,10 +3739,11 @@ 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:
     // types
     using result_type = RealType;
@@ -3760,10 +3759,14 @@ template<class RealType = double>
     template<class UnaryOperation>
       piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
     explicit piecewise_linear_distribution(const param_type& parm);
     void reset();
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
@@ -3773,11 +3776,20 @@ template<class RealType = double>
     vector<result_type> densities() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
   };
 ```
 ``` cpp
 piecewise_linear_distribution();
 ```
@@ -3881,11 +3893,11 @@ See also: ISO C 7.22.2
 ## Numeric arrays <a id="numarray">[[numarray]]</a>
 ### Header `<valarray>` synopsis <a id="valarray.syn">[[valarray.syn]]</a>
 ``` cpp
-#include <initializer_list>
 namespace std {
   template<class T> class valarray;         // An array of type T
   class slice;                              // a BLAS-like slice out of an array
   template<class T> class slice_array;
@@ -4044,11 +4056,11 @@ aliasing, thus allowing operations on these classes to be optimized.
 Any function returning a `valarray<T>` is permitted to return an object
 of another type, provided all the const member functions of
 `valarray<T>` are also applicable to this type. This return type shall
 not add more than two levels of template nesting over the most deeply
-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`
@@ -4169,19 +4181,19 @@ elements numbered sequentially from zero. It is a representation of the
 mathematical concept of an ordered set of values. For convenience, an
 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]
 #### Constructors <a id="valarray.cons">[[valarray.cons]]</a>
 ``` cpp
 valarray();
 ```
-*Effects:* Constructs a `valarray` that has zero length.[^9]
 ``` cpp
 explicit valarray(size_t n);
 ```
@@ -4201,19 +4213,19 @@ 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]
 ``` cpp
 valarray(const valarray& v);
 ```
 *Effects:* Constructs a `valarray` that has the same length as `v`. The
 elements are initialized with the values of the corresponding elements
-of `v`.[^11]
 ``` cpp
 valarray(valarray&& v) noexcept;
 ```
@@ -4324,12 +4336,12 @@ evaluates to `true` for all `size_t i` and `size_t j` such that
 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
@@ -4637,12 +4649,12 @@ is `(*this)[`*`I`*` + n]` if *`I`*` + n` is non-negative and less than
 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;
 ```
@@ -4862,10 +4874,11 @@ template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;
 namespace std {
   class slice {
   public:
     slice();
     slice(size_t, size_t, size_t);
     size_t start() const;
     size_t size() const;
     size_t stride() const;
@@ -4873,18 +4886,17 @@ namespace std {
   };
 }
 ```
 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&);
 ```
 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,
@@ -5069,11 +5081,10 @@ of `operator[](const gslice&)`, the behavior is undefined.
 ``` cpp
 gslice();
 gslice(size_t start, const valarray<size_t>& lengths,
        const valarray<size_t>& strides);
-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,
@@ -5211,11 +5222,11 @@ namespace std {
 ```
 This template is a helper template used by the mask subscript operator:
 ``` cpp
-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
@@ -5228,11 +5239,11 @@ 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;
@@ -5247,11 +5258,12 @@ 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;
@@ -5295,11 +5307,11 @@ namespace std {
 This template is a helper template used by the indirect subscript
 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
@@ -5426,600 +5438,457 @@ namespace std {
 #define MATH_ERREXCEPT see below
 #define math_errhandling see below
 namespace std {
- float acos(float x);  // see [library.c]
-  double acos(double x);
-  long double acos(long double x);  // see [library.c]
   float acosf(float x);
   long double acosl(long double x);
- float asin(float x);  // see [library.c]
-  double asin(double x);
-  long double asin(long double x);  // see [library.c]
   float asinf(float x);
   long double asinl(long double x);
- float atan(float x);                  // see [library.c]
-  double atan(double x);
-  long double atan(long double x);      // see [library.c]
   float atanf(float x);
   long double atanl(long double x);
- float atan2(float y, float x);        // see [library.c]
-  double atan2(double y, double x);
-  long double atan2(long double y, long double x);  // see [library.c]
   float atan2f(float y, float x);
   long double atan2l(long double y, long double x);
- float cos(float x);                   // see [library.c]
-  double cos(double x);
-  long double cos(long double x);       // see [library.c]
   float cosf(float x);
   long double cosl(long double x);
- float sin(float x);                   // see [library.c]
-  double sin(double x);
-  long double sin(long double x);       // see [library.c]
   float sinf(float x);
   long double sinl(long double x);
- float tan(float x);                   // see [library.c]
-  double tan(double x);
-  long double tan(long double x);       // see [library.c]
   float tanf(float x);
   long double tanl(long double x);
- float acosh(float x);                 // see [library.c]
-  double acosh(double x);
-  long double acosh(long double x);     // see [library.c]
   float acoshf(float x);
   long double acoshl(long double x);
- float asinh(float x);                 // see [library.c]
-  double asinh(double x);
-  long double asinh(long double x);     // see [library.c]
   float asinhf(float x);
   long double asinhl(long double x);
- float atanh(float x);                 // see [library.c]
-  double atanh(double x);
-  long double atanh(long double x);     // see [library.c]
   float atanhf(float x);
   long double atanhl(long double x);
- float cosh(float x);                  // see [library.c]
-  double cosh(double x);
-  long double cosh(long double x);      // see [library.c]
   float coshf(float x);
   long double coshl(long double x);
- float sinh(float x);                  // see [library.c]
-  double sinh(double x);
-  long double sinh(long double x);      // see [library.c]
   float sinhf(float x);
   long double sinhl(long double x);
- float tanh(float x);                  // see [library.c]
-  double tanh(double x);
-  long double tanh(long double x);      // see [library.c]
   float tanhf(float x);
   long double tanhl(long double x);
- float exp(float x);                   // see [library.c]
-  double exp(double x);
-  long double exp(long double x);       // see [library.c]
   float expf(float x);
   long double expl(long double x);
- float exp2(float x);                  // see [library.c]
-  double exp2(double x);
-  long double exp2(long double x);      // see [library.c]
   float exp2f(float x);
   long double exp2l(long double x);
- float expm1(float x);                 // see [library.c]
-  double expm1(double x);
-  long double expm1(long double x);     // see [library.c]
   float expm1f(float x);
   long double expm1l(long double x);
- float frexp(float value, int* exp);   // see [library.c]
- double frexp(double value, int* exp);
-  long double frexp(long double value, int* exp);   // see [library.c]
-  float frexpf(float value, int* exp);
-  long double frexpl(long double value, int* exp);
-  int ilogb(float x);                   // see [library.c]
-  int ilogb(double x);
-  int ilogb(long double x);             // see [library.c]
-  int ilogbf(float x);
-  int ilogbl(long double x);
- float ldexp(float x, int exp);        // see [library.c]
- double ldexp(double x, int exp);
-  long double ldexp(long double x, int exp);    // see [library.c]
-  float ldexpf(float x, int exp);
-  long double ldexpl(long double x, int exp);
- float log(float x);                   // see [library.c]
-  double log(double x);
-  long double log(long double x);       // see [library.c]
   float logf(float x);
   long double logl(long double x);
- float log10(float x);                 // see [library.c]
-  double log10(double x);
-  long double log10(long double x);     // see [library.c]
   float log10f(float x);
   long double log10l(long double x);
- float log1p(float x);                 // see [library.c]
-  double log1p(double x);
-  long double log1p(long double x);     // see [library.c]
   float log1pf(float x);
   long double log1pl(long double x);
- float log2(float x);                  // see [library.c]
-  double log2(double x);
-  long double log2(long double x);      // see [library.c]
   float log2f(float x);
   long double log2l(long double x);
- float logb(float x);                  // see [library.c]
- double logb(double x);
-  long double logb(long double x);      // see [library.c]
-  float logbf(float x);
-  long double logbl(long double x);
- float modf(float value, float* iptr); // see [library.c]
- double modf(double value, double* iptr);
-  long double modf(long double value, long double* iptr);   // see [library.c]
-  float modff(float value, float* iptr);
-  long double modfl(long double value, long double* iptr);
- float scalbn(float x, int n);         // see [library.c]
- double scalbn(double x, int n);
-  long double scalbn(long double x, int n);     // see [library.c]
-  float scalbnf(float x, int n);
-  long double scalbnl(long double x, int n);
- float scalbln(float x, long int n);   // see [library.c]
- double scalbln(double x, long int n);
-  long double scalbln(long double x, long int n);   // see [library.c]
-  float scalblnf(float x, long int n);
-  long double scalblnl(long double x, long int n);
- float cbrt(float x);                  // see [library.c]
-  double cbrt(double x);
-  long double cbrt(long double x);      // see [library.c]
   float cbrtf(float x);
   long double cbrtl(long double x);
   // [c.math.abs], absolute values
-  int abs(int j);
-  long int abs(long int j);
-  long long int abs(long long int j);
- float abs(float j);
-  double abs(double j);
-  long double abs(long double j);
- float fabs(float x);                  // see [library.c]
- double fabs(double x);
-  long double fabs(long double x);      // see [library.c]
-  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 hypot(double x, double y, double z);
-  long double hypot(long double x, long double y, long double z);
- float pow(float x, float y);          // see [library.c]
-  double pow(double x, double y);
-  long double pow(long double x, long double y);    // see [library.c]
   float powf(float x, float y);
   long double powl(long double x, long double y);
- float sqrt(float x);                  // see [library.c]
-  double sqrt(double x);
-  long double sqrt(long double x);      // see [library.c]
   float sqrtf(float x);
   long double sqrtl(long double x);
- float erf(float x);                   // see [library.c]
-  double erf(double x);
-  long double erf(long double x);       // see [library.c]
   float erff(float x);
   long double erfl(long double x);
- float erfc(float x);                  // see [library.c]
-  double erfc(double x);
-  long double erfc(long double x);      // see [library.c]
   float erfcf(float x);
   long double erfcl(long double x);
- float lgamma(float x);                // see [library.c]
-  double lgamma(double x);
-  long double lgamma(long double x);    // see [library.c]
   float lgammaf(float x);
   long double lgammal(long double x);
- float tgamma(float x);                // see [library.c]
-  double tgamma(double x);
-  long double tgamma(long double x);    // see [library.c]
   float tgammaf(float x);
   long double tgammal(long double x);
- float ceil(float x);                  // see [library.c]
- double ceil(double x);
-  long double ceil(long double x);      // see [library.c]
-  float ceilf(float x);
-  long double ceill(long double x);
- float floor(float x);                 // see [library.c]
- double floor(double x);
-  long double floor(long double x);     // see [library.c]
-  float floorf(float x);
-  long double floorl(long double x);
- float nearbyint(float x);             // see [library.c]
-  double nearbyint(double x);
-  long double nearbyint(long double x); // see [library.c]
   float nearbyintf(float x);
   long double nearbyintl(long double x);
- float rint(float x);                  // see [library.c]
-  double rint(double x);
-  long double rint(long double x);      // see [library.c]
   float rintf(float x);
   long double rintl(long double x);
-  long int lrint(float x);              // see [library.c]
-  long int lrint(double x);
-  long int lrint(long double x);        // see [library.c]
   long int lrintf(float x);
   long int lrintl(long double x);
-  long long int llrint(float x);        // see [library.c]
-  long long int llrint(double x);
-  long long int llrint(long double x);  // see [library.c]
   long long int llrintf(float x);
   long long int llrintl(long double x);
- float round(float x);                 // see [library.c]
- double round(double x);
-  long double round(long double x);     // see [library.c]
-  float roundf(float x);
-  long double roundl(long double x);
-  long int lround(float x);             // see [library.c]
-  long int lround(double x);
-  long int lround(long double x);       // see [library.c]
-  long int lroundf(float x);
-  long int lroundl(long double x);
-  long long int llround(float x);       // see [library.c]
-  long long int llround(double x);
-  long long int llround(long double x); // see [library.c]
-  long long int llroundf(float x);
-  long long int llroundl(long double x);
- float trunc(float x);                 // see [library.c]
- double trunc(double x);
-  long double trunc(long double x);     // see [library.c]
-  float truncf(float x);
-  long double truncl(long double x);
- float fmod(float x, float y);         // see [library.c]
- double fmod(double x, double y);
-  long double fmod(long double x, long double y);   // see [library.c]
-  float fmodf(float x, float y);
-  long double fmodl(long double x, long double y);
- float remainder(float x, float y);    // see [library.c]
- double remainder(double x, double y);
-  long double remainder(long double x, long double y);  // see [library.c]
-  float remainderf(float x, float y);
-  long double remainderl(long double x, long double y);
- float remquo(float x, float y, int* quo);     // see [library.c]
- double remquo(double x, double y, int* quo);
-  long double remquo(long double x, long double y, int* quo);   // see [library.c]
-  float remquof(float x, float y, int* quo);
-  long double remquol(long double x, long double y, int* quo);
- float copysign(float x, float y);     // see [library.c]
- double copysign(double x, double y);
-  long double copysign(long double x, long double y);   // see [library.c]
-  float copysignf(float x, float y);
-  long double copysignl(long double x, long double y);
   double nan(const char* tagp);
   float nanf(const char* tagp);
   long double nanl(const char* tagp);
- float nextafter(float x, float y);    // see [library.c]
- double nextafter(double x, double y);
-  long double nextafter(long double x, long double y);  // see [library.c]
-  float nextafterf(float x, float y);
-  long double nextafterl(long double x, long double y);
- float nexttoward(float x, long double y);     // see [library.c]
- double nexttoward(double x, long double y);
-  long double nexttoward(long double x, long double y);     // see [library.c]
-  float nexttowardf(float x, long double y);
-  long double nexttowardl(long double x, long double y);
- float fdim(float x, float y);         // see [library.c]
- double fdim(double x, double y);
-  long double fdim(long double x, long double y);   // see [library.c]
-  float fdimf(float x, float y);
-  long double fdiml(long double x, long double y);
- float fmax(float x, float y);         // see [library.c]
- double fmax(double x, double y);
-  long double fmax(long double x, long double y);   // see [library.c]
-  float fmaxf(float x, float y);
-  long double fmaxl(long double x, long double y);
- float fmin(float x, float y);         // see [library.c]
- double fmin(double x, double y);
-  long double fmin(long double x, long double y);   // see [library.c]
-  float fminf(float x, float y);
-  long double fminl(long double x, long double y);
- float fma(float x, float y, float z); // see [library.c]
-  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
- double       expint(double x);
   float        expintf(float x);
   long double  expintl(long double x);
   // [sf.cmath.hermite], Hermite polynomials
- double       hermite(unsigned n, double x);
   float        hermitef(unsigned n, float x);
   long double  hermitel(unsigned n, long double x);
   // [sf.cmath.laguerre], Laguerre polynomials
- double       laguerre(unsigned n, double x);
   float        laguerref(unsigned n, float x);
   long double  laguerrel(unsigned n, long double x);
   // [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);
 }
 ```
 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
 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);
-float abs(float j);
-double abs(double j);
-long double abs(long double j);
 ```
-*Effects:* The `abs` functions have the semantics specified in the C
-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);
-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}$.
 ### 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
@@ -6038,35 +5907,36 @@ otherwise. For any `t1` and `t2`, the product of
 ### 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.
-ISO C 7.12.3, 7.12.4
 ### Mathematical special functions <a id="sf.cmath">[[sf.cmath]]</a>
-If any argument value to any of the functions specified in this
-subclause is a NaN (Not a Number), the function shall return a NaN but
-it shall not report a domain error. Otherwise, the function shall report
-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.[^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
@@ -6081,11 +5951,11 @@ of their respective arguments `n`, `m`, and `x`.
 *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
@@ -6100,11 +5970,11 @@ their respective arguments `l`, `m`, and `x`.
 *implementation-defined* if `l >= 128`.
 #### Beta function <a id="sf.cmath.beta">[[sf.cmath.beta]]</a>
 ``` cpp
-double       beta(double x, double y);
 float        betaf(float x, float y);
 long double  betal(long double x, long double y);
 ```
 *Effects:* These functions compute the beta function of their respective
@@ -6115,11 +5985,11 @@ $$\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
@@ -6132,11 +6002,11 @@ 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
@@ -6149,11 +6019,11 @@ 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
@@ -6166,11 +6036,11 @@ 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
@@ -6187,11 +6057,11 @@ Bessel functions of their respective arguments `nu` and `x`.
 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
@@ -6205,11 +6075,11 @@ the first kind of their respective arguments `nu` and `x`.
 *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);
 ```
 *Effects:* These functions compute the irregular modified cylindrical
@@ -6245,11 +6115,11 @@ 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);
 ```
 *Effects:* These functions compute the cylindrical Neumann functions,
@@ -6279,11 +6149,11 @@ their respective arguments `nu` and `x`.
 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
@@ -6295,11 +6165,11 @@ measured in radians).
      \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
@@ -6311,11 +6181,12 @@ $$\mathsf{E}(k, \phi) = \int_0^\phi \! \sqrt{1 - k^2 \sin^2 \theta} \, \mathsf{d
    \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
@@ -6327,11 +6198,11 @@ measured in radians).
 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);
 float        expintf(float x);
 long double  expintl(long double x);
 ```
 *Effects:* These functions compute the exponential integral of their
@@ -6344,11 +6215,11 @@ respective arguments `x`.
 \;$$ where x is `x`.
 #### Hermite polynomials <a id="sf.cmath.hermite">[[sf.cmath.hermite]]</a>
 ``` cpp
-double       hermite(unsigned n, double x);
 float        hermitef(unsigned n, float x);
 long double  hermitel(unsigned n, long double x);
 ```
 *Effects:* These functions compute the Hermite polynomials of their
@@ -6364,11 +6235,11 @@ respective arguments `n` and `x`.
 *implementation-defined* if `n >= 128`.
 #### Laguerre polynomials <a id="sf.cmath.laguerre">[[sf.cmath.laguerre]]</a>
 ``` cpp
-double       laguerre(unsigned n, double x);
 float        laguerref(unsigned n, float x);
 long double  laguerrel(unsigned n, long double x);
 ```
 *Effects:* These functions compute the Laguerre polynomials of their
@@ -6382,11 +6253,11 @@ respective arguments `n` and `x`.
 *implementation-defined* if `n >= 128`.
 #### Legendre polynomials <a id="sf.cmath.legendre">[[sf.cmath.legendre]]</a>
 ``` cpp
-double       legendre(unsigned l, double x);
 float        legendref(unsigned l, float x);
 long double  legendrel(unsigned l, long double x);
 ```
 *Effects:* These functions compute the Legendre polynomials of their
@@ -6401,11 +6272,11 @@ respective arguments `l` and `x`.
 *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);
 ```
 *Effects:* These functions compute the Riemann zeta function of their
@@ -6435,11 +6306,11 @@ respective arguments `x`.
 \;$$ 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
@@ -6455,11 +6326,11 @@ where n is `n` and x is `x`.
 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
@@ -6479,11 +6350,11 @@ is `theta`.
 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
@@ -6503,37 +6374,37 @@ See also [[sf.cmath.cyl.neumann]].
 ### 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>;
@@ -6567,27 +6438,19 @@ 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
 [class.slice]: #class.slice
 [class.slice.overview]: #class.slice.overview
 [cmath.syn]: #cmath.syn
@@ -6595,23 +6458,22 @@ constant variable template is ill-formed.
 [complex]: #complex
 [complex.literals]: #complex.literals
 [complex.member.ops]: #complex.member.ops
 [complex.members]: #complex.members
 [complex.numbers]: #complex.numbers
 [complex.ops]: #complex.ops
-[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
@@ -6619,11 +6481,10 @@ constant variable template is ill-formed.
 [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
@@ -6638,10 +6499,11 @@ constant variable template is ill-formed.
 [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
@@ -6673,13 +6535,15 @@ constant variable template is ill-formed.
 [rand.dist.samp.plinear]: #rand.dist.samp.plinear
 [rand.dist.uni]: #rand.dist.uni
 [rand.dist.uni.int]: #rand.dist.uni.int
 [rand.dist.uni.real]: #rand.dist.uni.real
 [rand.eng]: #rand.eng
 [rand.eng.lcong]: #rand.eng.lcong
 [rand.eng.mers]: #rand.eng.mers
 [rand.eng.sub]: #rand.eng.sub
 [rand.predef]: #rand.predef
 [rand.req]: #rand.req
 [rand.req.adapt]: #rand.req.adapt
 [rand.req.dist]: #rand.req.dist
 [rand.req.eng]: #rand.req.eng
@@ -6705,10 +6569,11 @@ constant variable template is ill-formed.
 [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
@@ -6728,10 +6593,11 @@ constant variable template is ill-formed.
 [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
@@ -6750,57 +6616,61 @@ constant variable template is ill-formed.
 [^1]: In other words, value types. These include arithmetic types,
     pointers, the library class `complex`, and instantiations of
     `valarray` for value types.
-[^2]: The name of this engine refers, in part, to a property of its
     period: For properly-selected values of the parameters, the period
     is closely related to a large Mersenne prime number.
-[^3]: The parameter is intended to allow an implementation to
     differentiate between different sources of randomness.
-[^4]: If a device has n states whose respective probabilities are
     P₀, …, Pₙ₋₁, the device entropy S is defined as
     $S = - \sum_{i=0}^{n-1} P_i \cdot \log P_i$.
-[^5]: b is introduced to avoid any attempt to produce more bits of
     randomness than can be held in `RealType`.
-[^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
     can be increased with the `resize` member function.
-[^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.

 | Subclause                |                                                 | Header                 |
 | ------------------------ | ----------------------------------------------- | ---------------------- |
 | [[numeric.requirements]] | Requirements                                    |                        |
 | [[cfenv]]                | Floating-point environment                      | `<cfenv>`              |
 | [[complex.numbers]]      | Complex numbers                                 | `<complex>`            |
 | [[rand]]                 | Random number generation                        | `<random>`             |
 | [[numarray]]             | Numeric arrays                                  | `<valarray>`           |
 | [[c.math]]               | Mathematical functions for floating-point types | `<cmath>`, `<cstdlib>` |
 | [[numbers]]              | Numbers                                         | `<numbers>`            |
 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*]
+See also: ISO C 7.6
+### Threads <a id="cfenv.thread">[[cfenv.thread]]</a>
 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 1*: 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.
 ## Complex numbers <a id="complex.numbers">[[complex.numbers]]</a>
+### General <a id="complex.numbers.general">[[complex.numbers.general]]</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 that is
+not a cv-unqualified floating-point type [[basic.fundamental]] is
+unspecified. Specializations of `complex` for cv-unqualified
+floating-point types are trivially-copyable literal types
+[[term.literal.type]].
 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:
 ``` cpp
 namespace std {
   // [complex], class template complex
   template<class T> class complex;
   // [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> class complex {
   public:
     using value_type = T;
     constexpr complex(const T& re = T(), const T& im = T());
+    constexpr complex(const complex&) = default;
+    template<class X> constexpr explicit(see below) complex(const complex<X>&);
     constexpr T real() const;
     constexpr void real(T);
     constexpr T imag() const;
     constexpr void imag(T);
 ```
 The class `complex` describes an object that can store the Cartesian
 components, `real()` and `imag()`, of a complex number.
 ### Member functions <a id="complex.members">[[complex.members]]</a>
 ``` cpp
+constexpr complex(const T& re = T(), const T& im = T());
 ```
 *Ensures:* `real() == re && imag() == im` is `true`.
+``` cpp
+template<class X> constexpr explicit(see below) complex(const complex<X>& other);
+```
+*Effects:* Initializes the real part with `other.real()` and the
+imaginary part with `other.imag()`.
+*Remarks:* The expression inside `explicit` evaluates to `false` if and
+only if the floating-point conversion rank of `T` is greater than or
+equal to the floating-point conversion rank of `X`.
 ``` cpp
 constexpr T real() const;
 ```
 *Returns:* The value of the real component.
 ``` cpp
 basic_ostringstream<charT, traits> s;
 s.flags(o.flags());
 s.imbue(o.getloc());
 s.precision(o.precision());
+s << '(' << x.real() << ',' << x.imag() << ')';
 return o << s.str();
 ```
 [*Note 1*: In a locale in which comma is used as a decimal point
 character, the use of comma as a field separator can be ambiguous.
 where `norm`, `conj`, `imag`, and `real` are `constexpr` overloads.
 The additional overloads shall be sufficient to ensure:
+- If the argument has a floating-point type `T`, then it is effectively
+ cast to `complex<T>`.
+- Otherwise, if the argument has integer type, then it is effectively
+  cast to `complex<double>`.
+Function template `pow` has additional overloads sufficient to ensure,
+for a call with one argument of type `complex<T1>` and the other
+argument of type `T2` or `complex<T2>`, both arguments are effectively
+cast to `complex<common_type_t<T1, T2>>`. If `common_type_t<T1, T2>` is
+not well-formed, then the program is ill-formed.
 ### 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
 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>
+### General <a id="rand.general">[[rand.general]]</a>
+Subclause [[rand]] 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*.
 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 in [[rand]] 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 [[rand]]
+use mathematical real numbers.
+Throughout [[rand]], 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>     // see [initializer.list.syn]
 namespace std {
   // [rand.req.urng], uniform random bit generator requirements
   template<class G>
     concept uniform_random_bit_generator = see below;
 semantics, and if `S` also meets all other requirements of this
 subclause [[rand.req.seedseq]]. In that Table and throughout this
 subclause:
 - `T` is the type named by `S`’s associated `result_type`;
+- `q` is a value of type `S` and `r` is a value of type `S` or
+  `const S`;
 - `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 type `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
 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]].[^2]
 `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}).
 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
 [[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 of `d(g)`.
 If a textual representation is written using `os << x` and that
 representation is restored into the same or a different object `y` of
 the same type using `is >> y`, repeated invocations of `y(g)` shall
 produce the same sequence of numbers as would repeated invocations of
 using distribution_type =  D;
 ```
 ### Random number engine class templates <a id="rand.eng">[[rand.eng]]</a>
+#### General <a id="rand.eng.general">[[rand.eng.general]]</a>
+Each type instantiated from a class template specified in [[rand.eng]]
+meets the requirements of a random number engine [[rand.req.eng]] type.
 Except where specified otherwise, the complexity of each function
+specified in [[rand.eng]] is constant.
+Except where specified otherwise, no function described in [[rand.eng]]
+throws an exception.
+Every function described in [[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 [[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 [[rand.eng]] requires one or more
+relationships, involving the value(s) of its non-type template
 parameter(s), to hold. A program instantiating any of these templates is
 ill-formed if any such required relationship fails to hold.
 For every random number engine and for every random number engine
+adaptor `X` defined in [[rand.eng]] and in [[rand.adapt]]:
 - if the constructor
   ``` cpp
   template<class Sseq> explicit X(Sseq& q);
   ```
 algorithm is a modular linear function of the form
 TA(xᵢ) = (a ⋅ xᵢ + c)  mod  m; the generation algorithm is
 GA(xᵢ) = xᵢ₊₁.
 ``` cpp
+namespace std {
   template<class UIntType, UIntType a, UIntType c, UIntType m>
   class linear_congruential_engine {
   public:
     // types
     using result_type = UIntType;
     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);
+    // equality operators
+    friend bool operator==(const linear_congruential_engine& x,
+                           const linear_congruential_engine& y);
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const linear_congruential_engine& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, linear_congruential_engine& x);
   };
+}
 ```
 If the template parameter `m` is 0, the modulus m used throughout this
 subclause  [[rand.eng.lcong]] is `numeric_limits<result_type>::max()`
 plus 1.
 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[^3]
+produces unsigned integer random numbers in the closed interval
+[0,2ʷ-1]. The state xᵢ of a `mersenne_twister_engine` object `x` is of
+size n and consists of a sequence X of n values of the type delivered by
+`x`; all subscripts 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.,
 - 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
+namespace std {
   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 {
     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);
+    // equality operators
+    friend bool operator==(const mersenne_twister_engine& x, const mersenne_twister_engine& y);
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const mersenne_twister_engine& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, mersenne_twister_engine& x);
   };
+}
 ```
 The following relations shall hold: `0 < m`, `m <= n`, `2u < w`,
 `r <= w`, `u <= w`, `s <= w`, `t <= w`, `l <= w`,
 `w <= numeric_limits<UIntType>::digits`, `a <= (1u<<w) - 1u`,
 The generation algorithm is given by GA(xᵢ) = y, where y is the value
 produced as a result of advancing the engine’s state as described above.
 ``` cpp
+namespace std {
   template<class UIntType, size_t w, size_t s, size_t r>
   class subtract_with_carry_engine {
   public:
     // types
     using result_type = UIntType;
     explicit subtract_with_carry_engine(result_type value);
     template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
+    // equality operators
+    friend bool operator==(const subtract_with_carry_engine& x,
+                           const subtract_with_carry_engine& y);
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const subtract_with_carry_engine& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, subtract_with_carry_engine& x);
   };
+}
 ```
 The following relations shall hold: `0u < s`, `s < r`, `0 < w`, and
 `w <= numeric_limits<UIntType>::digits`.
 linear_congruential_engine<result_type,
                           40014u,0u,2147483563u> e(value == 0u ? default_seed : value);
 ```
 Then, to set each Xₖ, obtain new values z₀, …, zₙ₋₁ from n = ⌈ w/32 ⌉
+successive invocations of `e`. Set Xₖ to
 $\left( \sum_{j=0}^{n-1} z_j \cdot 2^{32j}\right) \bmod m$.
 *Complexity:* Exactly n ⋅ `r` invocations of `e`.
 ``` cpp
 The generation algorithm yields the value returned by the last
 invocation of `e()` while advancing `e`’s state as described above.
 ``` cpp
+namespace std {
   template<class Engine, size_t p, size_t r>
   class discard_block_engine {
   public:
     // types
     using result_type = typename Engine::result_type;
     template<class Sseq> explicit discard_block_engine(Sseq& q);
     void seed();
     void seed(result_type s);
     template<class Sseq> void seed(Sseq& q);
+    // equality operators
+    friend bool operator==(const discard_block_engine& x, const discard_block_engine& y);
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
     // property functions
+    const Engine& base() const noexcept { return e; }
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const discard_block_engine& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, discard_block_engine& x);
   private:
     Engine e;   // exposition only
+ size_t n; // exposition only
   };
+}
 ```
 The following relations shall hold: `0 < r` and `r <= p`.
 The textual representation consists of the textual representation of `e`
     template<class Sseq> explicit independent_bits_engine(Sseq& q);
     void seed();
     void seed(result_type s);
     template<class Sseq> void seed(Sseq& q);
+    // equality operators
+    friend bool operator==(const independent_bits_engine& x, const independent_bits_engine& y);
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
     // property functions
+    const Engine& base() const noexcept { return e; }
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const independent_bits_engine& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, independent_bits_engine& x);
   private:
     Engine e;   // exposition only
   };
 ```
 The generation algorithm yields the last value of `Y` produced while
 advancing `e`’s state as described above.
 ``` cpp
+namespace std {
   template<class Engine, size_t k>
   class shuffle_order_engine {
   public:
     // types
     using result_type = typename Engine::result_type;
     template<class Sseq> explicit shuffle_order_engine(Sseq& q);
     void seed();
     void seed(result_type s);
     template<class Sseq> void seed(Sseq& q);
+    // equality operators
+    friend bool operator==(const shuffle_order_engine& x, const shuffle_order_engine& y);
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
     // property functions
+    const Engine& base() const noexcept { return e; }
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const shuffle_order_engine& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, shuffle_order_engine& x);
   private:
     Engine e;           // exposition only
     result_type V[k];   // exposition only
     result_type Y;      // exposition only
   };
+}
 ```
 The following relation shall hold: `0 < k`.
 The textual representation consists of the textual representation of
 ```
 *Remarks:* The choice of engine type named by this `typedef` is
 *implementation-defined*.
+[*Note 1*: The implementation can select this type on the basis of
 performance, size, quality, or any combination of such factors, so as to
 provide at least acceptable engine behavior for relatively casual,
+inexpert, and/or lightweight use. Because different implementations can
 select different underlying engine types, code that uses this `typedef`
 need not generate identical sequences across
 implementations. — *end note*]
 ### Class `random_device` <a id="rand.device">[[rand.device]]</a>
 If implementation limitations prevent generating nondeterministic random
 numbers, the implementation may employ a random number engine.
 ``` cpp
+namespace std {
   class random_device {
   public:
     // types
     using result_type = unsigned int;
     // no copy functions
     random_device(const random_device&) = delete;
     void operator=(const random_device&) = delete;
   };
+}
 ```
 ``` cpp
 explicit random_device(const string& token);
 ```
+*Throws:* A value of an *implementation-defined* type derived from
+`exception` if the `random_device` cannot be initialized.
 *Remarks:* The semantics of the `token` parameter and the token value
+used by the default constructor are *implementation-defined*.[^4]
 ``` cpp
 double entropy() const noexcept;
 ```
 *Returns:* If the implementation employs a random number engine, returns
+0.0. Otherwise, returns an entropy estimate[^5]
+for the random numbers 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 cannot be obtained.
 ### Utilities <a id="rand.util">[[rand.util]]</a>
 #### Class `seed_seq` <a id="rand.util.seedseq">[[rand.util.seedseq]]</a>
 ``` cpp
+namespace std {
   class seed_seq {
   public:
     // types
     using result_type = uint_least32_t;
     // constructors
+ seed_seq() noexcept;
     template<class T>
       seed_seq(initializer_list<T> il);
     template<class InputIterator>
       seed_seq(InputIterator begin, InputIterator end);
     void operator=(const seed_seq&) = delete;
   private:
     vector<result_type> v;      // exposition only
   };
+}
 ```
 ``` cpp
+seed_seq() noexcept;
 ```
 *Ensures:* `v.empty()` is `true`.
 ``` cpp
 template<class T>
   seed_seq(initializer_list<T> il);
 ```
+*Constraints:* `T` is an integer type.
 *Effects:* Same as `seed_seq(il.begin(), il.end())`.
 ``` cpp
 template<class InputIterator>
 ``` cpp
 template<class RealType, size_t bits, class URBG>
   RealType generate_canonical(URBG& g);
 ```
 *Effects:* Invokes `g()` k times to obtain values g₀, …, gₖ₋₁,
 respectively. Calculates a quantity
 $$S = \sum_{i=0}^{k-1} (g_i - \texttt{g.min()})
                         \cdot R^i$$ using arithmetic of type `RealType`.
 [*Note 1*: 0 ≤ S / Rᵏ < 1. — *end note*]
 *Throws:* What and when `g` throws.
+*Complexity:* Exactly k = max(1, ⌈ b / log₂ R ⌉) invocations of `g`,
+where b[^6]
+is the lesser of `numeric_limits<RealType>::digits` and `bits`, and R is
+the value of `g.max()` - `g.min()` + 1.
 [*Note 2*: If the values gᵢ produced by `g` are uniformly distributed,
 the instantiation’s results are distributed as uniformly as possible.
 Obtaining a value in this way can be a useful step in the process of
 transforming a value generated by a uniform random bit generator into a
 value that can be delivered by a random number
 A `uniform_int_distribution` random number distribution produces random
 integers i, a ≤ i ≤ b, distributed according to the constant discrete
 probability function $$P(i\,|\,a,b) = 1 / (b - a + 1) \text{ .}$$
 ``` cpp
+namespace std {
   template<class IntType = int>
   class uniform_int_distribution {
   public:
     // types
     using result_type = IntType;
     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();
+    // equality operators
+    friend bool operator==(const uniform_int_distribution& x, const uniform_int_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     result_type b() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const uniform_int_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, uniform_int_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit uniform_int_distribution(IntType a, IntType b = numeric_limits<IntType>::max());
 ```
 [*Note 1*: This implies that p(x | a,b) is undefined when
 `a == b`. — *end note*]
 ``` cpp
+namespace std {
   template<class RealType = double>
   class uniform_real_distribution {
   public:
     // types
     using result_type = RealType;
     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();
+    // equality operators
+    friend bool operator==(const uniform_real_distribution& x,
+                           const uniform_real_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     result_type b() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const uniform_real_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, uniform_real_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit uniform_real_distribution(RealType a, RealType b = 1.0);
 ```
                           p     & \text{ if $b = \tcode{true}$, or} \\
                           1 - p & \text{ if $b = \tcode{false}$.}
                           \end{array}\right.$$
 ``` cpp
+namespace std {
   class bernoulli_distribution {
   public:
     // types
     using result_type = bool;
     using param_type  = unspecified;
     bernoulli_distribution() : bernoulli_distribution(0.5) {}
     explicit bernoulli_distribution(double p);
     explicit bernoulli_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const bernoulli_distribution& x, const bernoulli_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     double p() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const bernoulli_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, bernoulli_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit bernoulli_distribution(double p);
 ```
 A `binomial_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
 $$P(i\,|\,t,p) = \binom{t}{i} \cdot p^i \cdot (1-p)^{t-i} \text{ .}$$
 ``` cpp
+namespace std {
   template<class IntType = int>
   class binomial_distribution {
   public:
     // types
     using result_type = IntType;
     binomial_distribution() : binomial_distribution(1) {}
     explicit binomial_distribution(IntType t, double p = 0.5);
     explicit binomial_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const binomial_distribution& x, const binomial_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     double p() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const binomial_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, binomial_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit binomial_distribution(IntType t, double p = 0.5);
 ```
 A `geometric_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
 $$P(i\,|\,p) = p \cdot (1-p)^{i} \text{ .}$$
 ``` cpp
+namespace std {
   template<class IntType = int>
   class geometric_distribution {
   public:
     // types
     using result_type = IntType;
     geometric_distribution() : geometric_distribution(0.5) {}
     explicit geometric_distribution(double p);
     explicit geometric_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const geometric_distribution& x, const geometric_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     double p() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const geometric_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, geometric_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit geometric_distribution(double p);
 ```
 [*Note 1*: This implies that P(i | k,p) is undefined when
 `p == 1`. — *end note*]
 ``` cpp
+namespace std {
   template<class IntType = int>
   class negative_binomial_distribution {
   public:
     // types
     using result_type = IntType;
     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();
+    // equality operators
+    friend bool operator==(const negative_binomial_distribution& x,
+                           const negative_binomial_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     double p() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const negative_binomial_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, negative_binomial_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit negative_binomial_distribution(IntType k, double p = 0.5);
 ```
     poisson_distribution() : poisson_distribution(1.0) {}
     explicit poisson_distribution(double mean);
     explicit poisson_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const poisson_distribution& x, const poisson_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     double mean() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const poisson_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, poisson_distribution& x);
   };
 ```
 ``` cpp
 explicit poisson_distribution(double mean);
 An `exponential_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
 $$p(x\,|\,\lambda) = \lambda e^{-\lambda x} \text{ .}$$
 ``` cpp
+namespace std {
   template<class RealType = double>
   class exponential_distribution {
   public:
     // types
     using result_type = RealType;
     exponential_distribution() : exponential_distribution(1.0) {}
     explicit exponential_distribution(RealType lambda);
     explicit exponential_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const exponential_distribution& x, const exponential_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     RealType lambda() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const exponential_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, exponential_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit exponential_distribution(RealType lambda);
 ```
 $$p(x\,|\,\alpha,\beta) =
      \frac{e^{-x/\beta}}{\beta^{\alpha} \cdot \Gamma(\alpha)} \, \cdot \, x^{\, \alpha-1}
      \text{ .}$$
 ``` cpp
+namespace std {
   template<class RealType = double>
   class gamma_distribution {
   public:
     // types
     using result_type = RealType;
     gamma_distribution() : gamma_distribution(1.0) {}
     explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
     explicit gamma_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const gamma_distribution& x, const gamma_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     RealType beta() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const gamma_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, gamma_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
 ```
      \cdot \left(\frac{x}{b}\right)^{a-1}
      \cdot \, \exp\left( -\left(\frac{x}{b}\right)^a\right)
      \text{ .}$$
 ``` cpp
+namespace std {
   template<class RealType = double>
   class weibull_distribution {
   public:
     // types
     using result_type = RealType;
     weibull_distribution() : weibull_distribution(1.0) {}
     explicit weibull_distribution(RealType a, RealType b = 1.0);
     explicit weibull_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const weibull_distribution& x, const weibull_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     RealType b() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const weibull_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, weibull_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit weibull_distribution(RealType a, RealType b = 1.0);
 ```
 ##### Class template `extreme_value_distribution` <a id="rand.dist.pois.extreme">[[rand.dist.pois.extreme]]</a>
 An `extreme_value_distribution` random number distribution produces
 random numbers x distributed according to the probability density
+function[^7]
+$$p(x\,|\,a,b) = \frac{1}{b}
      \cdot \exp\left(\frac{a-x}{b} - \exp\left(\frac{a-x}{b}\right)\right)
      \text{ .}$$
 ``` cpp
+namespace std {
   template<class RealType = double>
   class extreme_value_distribution {
   public:
     // types
     using result_type = RealType;
     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();
+    // equality operators
+    friend bool operator==(const extreme_value_distribution& x,
+                           const extreme_value_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     RealType b() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const extreme_value_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, extreme_value_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit extreme_value_distribution(RealType a, RealType b = 1.0);
 ```
             }
  \text{ .}$$ The distribution parameters μ and σ are also known as this
 distribution’s *mean* and *standard deviation*.
 ``` cpp
+namespace std {
   template<class RealType = double>
   class normal_distribution {
   public:
     // types
     using result_type = RealType;
     normal_distribution() : normal_distribution(0.0) {}
     explicit normal_distribution(RealType mean, RealType stddev = 1.0);
     explicit normal_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const normal_distribution& x, const normal_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     RealType stddev() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const normal_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, normal_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit normal_distribution(RealType mean, RealType stddev = 1.0);
 ```
 $$p(x\,|\,m,s) = \frac{1}{s x \sqrt{2 \pi}}
      \cdot \exp{\left(-\frac{(\ln{x} - m)^2}{2 s^2}\right)}
      \text{ .}$$
 ``` cpp
+namespace std {
   template<class RealType = double>
   class lognormal_distribution {
   public:
     // types
     using result_type = RealType;
     lognormal_distribution() : lognormal_distribution(0.0) {}
     explicit lognormal_distribution(RealType m, RealType s = 1.0);
     explicit lognormal_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const lognormal_distribution& x, const lognormal_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     RealType s() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const lognormal_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, lognormal_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit lognormal_distribution(RealType m, RealType s = 1.0);
 ```
 A `chi_squared_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
 $$p(x\,|\,n) = \frac{x^{(n/2)-1} \cdot e^{-x/2}}{\Gamma(n/2) \cdot 2^{n/2}} \text{ .}$$
 ``` cpp
+namespace std {
   template<class RealType = double>
   class chi_squared_distribution {
   public:
     // types
     using result_type = RealType;
     chi_squared_distribution() : chi_squared_distribution(1.0) {}
     explicit chi_squared_distribution(RealType n);
     explicit chi_squared_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const chi_squared_distribution& x, const chi_squared_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     RealType n() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const chi_squared_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, chi_squared_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit chi_squared_distribution(RealType n);
 ```
 A `cauchy_distribution` random number distribution produces random
 numbers x distributed according to the probability density function
 $$p(x\,|\,a,b) = \left(\pi b \left(1 + \left(\frac{x-a}{b} \right)^2 \, \right)\right)^{-1} \text{ .}$$
 ``` cpp
+namespace std {
   template<class RealType = double>
   class cauchy_distribution {
   public:
     // types
     using result_type = RealType;
     cauchy_distribution() : cauchy_distribution(0.0) {}
     explicit cauchy_distribution(RealType a, RealType b = 1.0);
     explicit cauchy_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const cauchy_distribution& x, const cauchy_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     RealType b() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const cauchy_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, cauchy_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit cauchy_distribution(RealType a, RealType b = 1.0);
 ```
      \cdot x^{(m/2)-1}
      \cdot \left(1 + \frac{m x}{n}\right)^{-(m + n)/2}
      \text{ .}$$
 ``` cpp
+namespace std {
   template<class RealType = double>
   class fisher_f_distribution {
   public:
     // types
     using result_type = RealType;
     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();
+    // equality operators
+    friend bool operator==(const fisher_f_distribution& x, const fisher_f_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     RealType n() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const fisher_f_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, fisher_f_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit fisher_f_distribution(RealType m, RealType n = 1);
 ```
      \cdot \frac{\Gamma\big((n+1)/2\big)}{\Gamma(n/2)}
      \cdot \left(1 + \frac{x^2}{n} \right)^{-(n+1)/2}
      \text{ .}$$
 ``` cpp
+namespace std {
   template<class RealType = double>
   class student_t_distribution {
   public:
     // types
     using result_type = RealType;
     student_t_distribution() : student_t_distribution(1.0) {}
     explicit student_t_distribution(RealType n);
     explicit student_t_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const student_t_distribution& x, const student_t_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     RealType n() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const student_t_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, student_t_distribution& x);
   };
+}
 ```
 ``` cpp
 explicit student_t_distribution(RealType n);
 ```
 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
+namespace std {
   template<class IntType = int>
   class discrete_distribution {
   public:
     // types
     using result_type = IntType;
     template<class UnaryOperation>
       discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);
     explicit discrete_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const discrete_distribution& x, const discrete_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     vector<double> probabilities() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const discrete_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, discrete_distribution& x);
   };
+}
 ```
 ``` cpp
 discrete_distribution();
 ```
 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
+namespace std {
   template<class RealType = double>
   class piecewise_constant_distribution {
   public:
     // types
     using result_type = RealType;
       piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax,
                                       UnaryOperation fw);
     explicit piecewise_constant_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const piecewise_constant_distribution& x,
+                           const piecewise_constant_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     vector<result_type> densities() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const piecewise_constant_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, piecewise_constant_distribution& x);
   };
+}
 ```
 ``` cpp
 piecewise_constant_distribution();
 ```
 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
+namespace std {
   template<class RealType = double>
   class piecewise_linear_distribution {
   public:
     // types
     using result_type = RealType;
     template<class UnaryOperation>
       piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
     explicit piecewise_linear_distribution(const param_type& parm);
     void reset();
+    // equality operators
+    friend bool operator==(const piecewise_linear_distribution& x,
+                           const piecewise_linear_distribution& y);
     // generating functions
     template<class URBG>
       result_type operator()(URBG& g);
     template<class URBG>
       result_type operator()(URBG& g, const param_type& parm);
     vector<result_type> densities() const;
     param_type param() const;
     void param(const param_type& parm);
     result_type min() const;
     result_type max() const;
+    // inserters and extractors
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const piecewise_linear_distribution& x);
+    template<class charT, class traits>
+      friend basic_istream<charT, traits>&
+        operator>>(basic_istream<charT, traits>& is, piecewise_linear_distribution& x);
   };
+}
 ```
 ``` cpp
 piecewise_linear_distribution();
 ```
 ## Numeric arrays <a id="numarray">[[numarray]]</a>
 ### Header `<valarray>` synopsis <a id="valarray.syn">[[valarray.syn]]</a>
 ``` cpp
+#include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   template<class T> class valarray;         // An array of type T
   class slice;                              // a BLAS-like slice out of an array
   template<class T> class slice_array;
 Any function returning a `valarray<T>` is permitted to return an object
 of another type, provided all the const member functions of
 `valarray<T>` are also applicable to this type. This return type shall
 not add more than two levels of template nesting over the most deeply
+nested argument type.[^8]
 Implementations introducing such replacement types shall provide
 additional functions and operators as follows:
 - for every function taking a `const valarray<T>&` other than `begin`
 mathematical concept of an ordered set of values. For convenience, an
 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.[^9]
 #### Constructors <a id="valarray.cons">[[valarray.cons]]</a>
 ``` cpp
 valarray();
 ```
+*Effects:* Constructs a `valarray` that has zero length.[^10]
 ``` cpp
 explicit valarray(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.[^11]
 ``` cpp
 valarray(const valarray& v);
 ```
 *Effects:* Constructs a `valarray` that has the same length as `v`. The
 elements are initialized with the values of the corresponding elements
+of `v`.[^12]
 ``` cpp
 valarray(valarray&& v) noexcept;
 ```
 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 can be
+used to advantage by optimizing compilers. Compilers can 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
 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
+`*this`; etc. — *end example*]
 ``` cpp
 valarray cshift(int n) const;
 ```
 namespace std {
   class slice {
   public:
     slice();
     slice(size_t, size_t, size_t);
+    slice(const slice&);
     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.[^13]
 #### Constructors <a id="cons.slice">[[cons.slice]]</a>
 ``` cpp
 slice();
 slice(size_t start, size_t length, size_t stride);
 ```
 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,
 ``` 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,
 ```
 This template is a helper template used by the mask subscript operator:
 ``` cpp
+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
 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 the `mask_array` object 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;
 ```
 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_array` object
+refers.
 #### Fill function <a id="mask.array.fill">[[mask.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 This template is a helper template used by the indirect subscript
 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
 #define MATH_ERREXCEPT see below
 #define math_errhandling see below
 namespace std {
+ floating-point-type acos(floating-point-type x);
   float acosf(float x);
   long double acosl(long double x);
+ floating-point-type asin(floating-point-type x);
   float asinf(float x);
   long double asinl(long double x);
+ floating-point-type atan(floating-point-type x);
   float atanf(float x);
   long double atanl(long double x);
+ floating-point-type atan2(floating-point-type y, floating-point-type x);
   float atan2f(float y, float x);
   long double atan2l(long double y, long double x);
+ floating-point-type cos(floating-point-type x);
   float cosf(float x);
   long double cosl(long double x);
+ floating-point-type sin(floating-point-type x);
   float sinf(float x);
   long double sinl(long double x);
+ floating-point-type tan(floating-point-type x);
   float tanf(float x);
   long double tanl(long double x);
+ floating-point-type acosh(floating-point-type x);
   float acoshf(float x);
   long double acoshl(long double x);
+ floating-point-type asinh(floating-point-type x);
   float asinhf(float x);
   long double asinhl(long double x);
+ floating-point-type atanh(floating-point-type x);
   float atanhf(float x);
   long double atanhl(long double x);
+ floating-point-type cosh(floating-point-type x);
   float coshf(float x);
   long double coshl(long double x);
+ floating-point-type sinh(floating-point-type x);
   float sinhf(float x);
   long double sinhl(long double x);
+ floating-point-type tanh(floating-point-type x);
   float tanhf(float x);
   long double tanhl(long double x);
+ floating-point-type exp(floating-point-type x);
   float expf(float x);
   long double expl(long double x);
+ floating-point-type exp2(floating-point-type x);
   float exp2f(float x);
   long double exp2l(long double x);
+ floating-point-type expm1(floating-point-type x);
   float expm1f(float x);
   long double expm1l(long double x);
+ constexpr floating-point-type frexp(floating-point-type value, int* exp);
+ constexpr float frexpf(float value, int* exp);
+ constexpr long double frexpl(long double value, int* exp);
+ constexpr int ilogb(floating-point-type x);
+ constexpr int ilogbf(float x);
+ constexpr int ilogbl(long double x);
+ constexpr floating-point-type ldexp(floating-point-type x, int exp);
+ constexpr float ldexpf(float x, int exp);
+ constexpr long double ldexpl(long double x, int exp);
+ floating-point-type log(floating-point-type x);
   float logf(float x);
   long double logl(long double x);
+ floating-point-type log10(floating-point-type x);
   float log10f(float x);
   long double log10l(long double x);
+ floating-point-type log1p(floating-point-type x);
   float log1pf(float x);
   long double log1pl(long double x);
+ floating-point-type log2(floating-point-type x);
   float log2f(float x);
   long double log2l(long double x);
+ constexpr floating-point-type logb(floating-point-type x);
+ constexpr float logbf(float x);
+ constexpr long double logbl(long double x);
+ constexpr floating-point-type modf(floating-point-type value, floating-point-type* iptr);
+ constexpr float modff(float value, float* iptr);
+ constexpr long double modfl(long double value, long double* iptr);
+ constexpr floating-point-type scalbn(floating-point-type x, int n);
+ constexpr float scalbnf(float x, int n);
+ constexpr long double scalbnl(long double x, int n);
+ constexpr floating-point-type scalbln(floating-point-type x, long int n);
+ constexpr float scalblnf(float x, long int n);
+ constexpr long double scalblnl(long double x, long int n);
+ floating-point-type cbrt(floating-point-type x);
   float cbrtf(float x);
   long double cbrtl(long double x);
   // [c.math.abs], absolute values
+ constexpr int abs(int j);
+ constexpr long int abs(long int j);
+ constexpr long long int abs(long long int j);
+ constexpr floating-point-type abs(floating-point-type j);
+ constexpr floating-point-type fabs(floating-point-type x);
+ constexpr float fabsf(float x);
+ constexpr long double fabsl(long double x);
+ floating-point-type hypot(floating-point-type x, floating-point-type y);
   float hypotf(float x, float y);
   long double hypotl(long double x, long double y);
   // [c.math.hypot3], three-dimensional hypotenuse
+ floating-point-type hypot(floating-point-type x, floating-point-type y,
+                            floating-point-type z);
+ floating-point-type pow(floating-point-type x, floating-point-type y);
   float powf(float x, float y);
   long double powl(long double x, long double y);
+ floating-point-type sqrt(floating-point-type x);
   float sqrtf(float x);
   long double sqrtl(long double x);
+ floating-point-type erf(floating-point-type x);
   float erff(float x);
   long double erfl(long double x);
+ floating-point-type erfc(floating-point-type x);
   float erfcf(float x);
   long double erfcl(long double x);
+ floating-point-type lgamma(floating-point-type x);
   float lgammaf(float x);
   long double lgammal(long double x);
+ floating-point-type tgamma(floating-point-type x);
   float tgammaf(float x);
   long double tgammal(long double x);
+ constexpr floating-point-type ceil(floating-point-type x);
+ constexpr float ceilf(float x);
+ constexpr long double ceill(long double x);
+ constexpr floating-point-type floor(floating-point-type x);
+ constexpr float floorf(float x);
+ constexpr long double floorl(long double x);
+ floating-point-type nearbyint(floating-point-type x);
   float nearbyintf(float x);
   long double nearbyintl(long double x);
+ floating-point-type rint(floating-point-type x);
   float rintf(float x);
   long double rintl(long double x);
+  long int lrint(floating-point-type x);
   long int lrintf(float x);
   long int lrintl(long double x);
+  long long int llrint(floating-point-type x);
   long long int llrintf(float x);
   long long int llrintl(long double x);
+ constexpr floating-point-type round(floating-point-type x);
+ constexpr float roundf(float x);
+ constexpr long double roundl(long double x);
+ constexpr long int lround(floating-point-type x);
+ constexpr long int lroundf(float x);
+ constexpr long int lroundl(long double x);
+ constexpr long long int llround(floating-point-type x);
+ constexpr long long int llroundf(float x);
+ constexpr long long int llroundl(long double x);
+ constexpr floating-point-type trunc(floating-point-type x);
+ constexpr float truncf(float x);
+ constexpr long double truncl(long double x);
+ constexpr floating-point-type fmod(floating-point-type x, floating-point-type y);
+ constexpr float fmodf(float x, float y);
+ constexpr long double fmodl(long double x, long double y);
+ constexpr floating-point-type remainder(floating-point-type x, floating-point-type y);
+ constexpr float remainderf(float x, float y);
+ constexpr long double remainderl(long double x, long double y);
+ constexpr floating-point-type remquo(floating-point-type x, floating-point-type y, int* quo);
+ constexpr float remquof(float x, float y, int* quo);
+ constexpr long double remquol(long double x, long double y, int* quo);
+ constexpr floating-point-type copysign(floating-point-type x, floating-point-type y);
+ constexpr float copysignf(float x, float y);
+ constexpr long double copysignl(long double x, long double y);
   double nan(const char* tagp);
   float nanf(const char* tagp);
   long double nanl(const char* tagp);
+ constexpr floating-point-type nextafter(floating-point-type x, floating-point-type y);
+ constexpr float nextafterf(float x, float y);
+ constexpr long double nextafterl(long double x, long double y);
+ constexpr floating-point-type nexttoward(floating-point-type x, long double y);
+ constexpr float nexttowardf(float x, long double y);
+ constexpr long double nexttowardl(long double x, long double y);
+ constexpr floating-point-type fdim(floating-point-type x, floating-point-type y);
+ constexpr float fdimf(float x, float y);
+ constexpr long double fdiml(long double x, long double y);
+ constexpr floating-point-type fmax(floating-point-type x, floating-point-type y);
+ constexpr float fmaxf(float x, float y);
+ constexpr long double fmaxl(long double x, long double y);
+ constexpr floating-point-type fmin(floating-point-type x, floating-point-type y);
+ constexpr float fminf(float x, float y);
+ constexpr long double fminl(long double x, long double y);
+ constexpr floating-point-type fma(floating-point-type x, floating-point-type y,
+                                  floating-point-type z);
+ constexpr float fmaf(float x, float y, float z);
+ constexpr long double fmal(long double x, long double y, long double z);
   // [c.math.lerp], linear interpolation
+  constexpr floating-point-type lerp(floating-point-type a, floating-point-type b,
+                                    floating-point-type t) noexcept;
   // [c.math.fpclass], classification / comparison functions
+ constexpr int fpclassify(floating-point-type x);
+ constexpr bool isfinite(floating-point-type x);
+ constexpr bool isinf(floating-point-type x);
+  constexpr bool isnan(floating-point-type x);
+ constexpr bool isnormal(floating-point-type x);
+ constexpr bool signbit(floating-point-type x);
+ constexpr bool isgreater(floating-point-type x, floating-point-type y);
+  constexpr bool isgreaterequal(floating-point-type x, floating-point-type y);
+ constexpr bool isless(floating-point-type x, floating-point-type y);
+ constexpr bool islessequal(floating-point-type x, floating-point-type y);
+ constexpr bool islessgreater(floating-point-type x, floating-point-type y);
+  constexpr bool isunordered(floating-point-type x, floating-point-type y);
   // [sf.cmath], mathematical special functions
   // [sf.cmath.assoc.laguerre], associated Laguerre polynomials
+ floating-point-type assoc_laguerre(unsigned n, unsigned m, floating-point-type 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
+ floating-point-type assoc_legendre(unsigned l, unsigned m, floating-point-type 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
+ floating-point-type beta(floating-point-type x, floating-point-type 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
+ floating-point-type comp_ellint_1(floating-point-type 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
+ floating-point-type comp_ellint_2(floating-point-type 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
+ floating-point-type comp_ellint_3(floating-point-type k, floating-point-type 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
+ floating-point-type cyl_bessel_i(floating-point-type nu, floating-point-type 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
+ floating-point-type cyl_bessel_j(floating-point-type nu, floating-point-type 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
+ floating-point-type cyl_bessel_k(floating-point-type nu, floating-point-type 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
+ floating-point-type       cyl_neumann(floating-point-type nu, floating-point-type 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
+ floating-point-type ellint_1(floating-point-type k, floating-point-type 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
+ floating-point-type ellint_2(floating-point-type k, floating-point-type 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
+ floating-point-type ellint_3(floating-point-type k, floating-point-type nu,
+                                 floating-point-type 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
+ floating-point-type expint(floating-point-type x);
   float        expintf(float x);
   long double  expintl(long double x);
   // [sf.cmath.hermite], Hermite polynomials
+ floating-point-type hermite(unsigned n, floating-point-type x);
   float        hermitef(unsigned n, float x);
   long double  hermitel(unsigned n, long double x);
   // [sf.cmath.laguerre], Laguerre polynomials
+ floating-point-type laguerre(unsigned n, floating-point-type x);
   float        laguerref(unsigned n, float x);
   long double  laguerrel(unsigned n, long double x);
   // [sf.cmath.legendre], Legendre polynomials
+ floating-point-type legendre(unsigned l, floating-point-type x);
   float        legendref(unsigned l, float x);
   long double  legendrel(unsigned l, long double x);
   // [sf.cmath.riemann.zeta], Riemann zeta function
+ floating-point-type riemann_zeta(floating-point-type x);
   float        riemann_zetaf(float x);
   long double  riemann_zetal(long double x);
   // [sf.cmath.sph.bessel], spherical Bessel functions of the first kind
+ floating-point-type sph_bessel(unsigned n, floating-point-type 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
+ floating-point-type sph_legendre(unsigned l, unsigned m, floating-point-type 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
+ floating-point-type sph_neumann(unsigned n, floating-point-type x);
   float        sph_neumannf(unsigned n, float x);
   long double  sph_neumannl(unsigned n, long double x);
 }
 ```
 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]], a linear
+interpolation function [[c.math.lerp]], 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 function with at least one parameter of type
+*floating-point-type*, the implementation provides an overload for each
+cv-unqualified floating-point type [[basic.fundamental]] where all uses
+of *floating-point-type* in the function signature are replaced with
+that floating-point type.
+For each function with at least one parameter of type
+*floating-point-type* other than `abs`, the implementation also provides
+additional overloads sufficient to ensure that, if every argument
+corresponding to a *floating-point-type* parameter has arithmetic type,
+then every such argument is effectively cast to the floating-point type
+with the greatest floating-point conversion rank and greatest
+floating-point conversion subrank among the types of all such arguments,
+where arguments of integer type are considered to have the same
+floating-point conversion rank as `double`. If no such floating-point
+type with the greatest rank and subrank exists, then overload resolution
+does not result in a usable candidate [[over.match.general]] from the
+overloads provided by the implementation.
+An invocation of `nexttoward` is ill-formed if the argument
+corresponding to the *floating-point-type* parameter has extended
+floating-point type.
+See also: 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
+constexpr int abs(int j);
+constexpr long int abs(long int j);
+constexpr long long int abs(long long int j);
 ```
+*Effects:* These functions have the semantics specified in the C
+standard library for the functions `abs`, `labs`, and `llabs`,
+respectively.
+*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*]
+``` cpp
+constexpr floating-point-type abs(floating-point-type x);
+```
+*Returns:* The absolute value of `x`.
 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
+floating-point-type hypot(floating-point-type x, floating-point-type y, floating-point-type z);
 ```
 *Returns:* $\sqrt{x^2+y^2+z^2}$.
 ### Linear interpolation <a id="c.math.lerp">[[c.math.lerp]]</a>
 ``` cpp
+constexpr floating-point-type lerp(floating-point-type a, floating-point-type b,
+                                   floating-point-type t) noexcept;
 ```
 *Returns:* a+t(b-a).
 *Remarks:* Let `r` be the value returned. If
 ### 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.
+See also: ISO C 7.12.3, 7.12.4
 ### Mathematical special functions <a id="sf.cmath">[[sf.cmath]]</a>
+#### General <a id="sf.cmath.general">[[sf.cmath.general]]</a>
+If any argument value to any of the functions specified in [[sf.cmath]]
+is a NaN (Not a Number), the function shall return a NaN but it shall
+not report a domain error. Otherwise, the function shall report a domain
+error for just those argument values for which:
+- the function description’s *Returns:* element 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.[^14]
 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
+floating-point-type assoc_laguerre(unsigned n, unsigned m, floating-point-type 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
 *implementation-defined* if `n >= 128` or if `m >= 128`.
 #### Associated Legendre functions <a id="sf.cmath.assoc.legendre">[[sf.cmath.assoc.legendre]]</a>
 ``` cpp
+floating-point-type assoc_legendre(unsigned l, unsigned m, floating-point-type 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
 *implementation-defined* if `l >= 128`.
 #### Beta function <a id="sf.cmath.beta">[[sf.cmath.beta]]</a>
 ``` cpp
+floating-point-type beta(floating-point-type x, floating-point-type y);
 float        betaf(float x, float y);
 long double  betal(long double x, long double y);
 ```
 *Effects:* These functions compute the beta function of their respective
    \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
+floating-point-type comp_ellint_1(floating-point-type 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
 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
+floating-point-type comp_ellint_2(floating-point-type 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
 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
+floating-point-type comp_ellint_3(floating-point-type k, floating-point-type 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
 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
+floating-point-type cyl_bessel_i(floating-point-type nu, floating-point-type 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
 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
+floating-point-type cyl_bessel_j(floating-point-type nu, floating-point-type 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
 *implementation-defined* if `nu >= 128`.
 #### Irregular modified cylindrical Bessel functions <a id="sf.cmath.cyl.bessel.k">[[sf.cmath.cyl.bessel.k]]</a>
 ``` cpp
+floating-point-type cyl_bessel_k(floating-point-type nu, floating-point-type x);
 float        cyl_bessel_kf(float nu, float x);
 long double  cyl_bessel_kl(long double nu, long double x);
 ```
 *Effects:* These functions compute the irregular modified cylindrical
 [[sf.cmath.cyl.neumann]].
 #### Cylindrical Neumann functions <a id="sf.cmath.cyl.neumann">[[sf.cmath.cyl.neumann]]</a>
 ``` cpp
+floating-point-type cyl_neumann(floating-point-type nu, floating-point-type x);
 float        cyl_neumannf(float nu, float x);
 long double  cyl_neumannl(long double nu, long double x);
 ```
 *Effects:* These functions compute the cylindrical Neumann functions,
 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
+floating-point-type ellint_1(floating-point-type k, floating-point-type 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
      \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
+floating-point-type ellint_2(floating-point-type k, floating-point-type 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
    \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
+floating-point-type ellint_3(floating-point-type k, floating-point-type nu,
+                             floating-point-type 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
 where $\nu$ is `nu`, k is `k`, and φ is `phi`.
 #### Exponential integral <a id="sf.cmath.expint">[[sf.cmath.expint]]</a>
 ``` cpp
+floating-point-type expint(floating-point-type x);
 float        expintf(float x);
 long double  expintl(long double x);
 ```
 *Effects:* These functions compute the exponential integral of their
 \;$$ where x is `x`.
 #### Hermite polynomials <a id="sf.cmath.hermite">[[sf.cmath.hermite]]</a>
 ``` cpp
+floating-point-type hermite(unsigned n, floating-point-type x);
 float        hermitef(unsigned n, float x);
 long double  hermitel(unsigned n, long double x);
 ```
 *Effects:* These functions compute the Hermite polynomials of their
 *implementation-defined* if `n >= 128`.
 #### Laguerre polynomials <a id="sf.cmath.laguerre">[[sf.cmath.laguerre]]</a>
 ``` cpp
+floating-point-type laguerre(unsigned n, floating-point-type x);
 float        laguerref(unsigned n, float x);
 long double  laguerrel(unsigned n, long double x);
 ```
 *Effects:* These functions compute the Laguerre polynomials of their
 *implementation-defined* if `n >= 128`.
 #### Legendre polynomials <a id="sf.cmath.legendre">[[sf.cmath.legendre]]</a>
 ``` cpp
+floating-point-type legendre(unsigned l, floating-point-type x);
 float        legendref(unsigned l, float x);
 long double  legendrel(unsigned l, long double x);
 ```
 *Effects:* These functions compute the Legendre polynomials of their
 *implementation-defined* if `l >= 128`.
 #### Riemann zeta function <a id="sf.cmath.riemann.zeta">[[sf.cmath.riemann.zeta]]</a>
 ``` cpp
+floating-point-type riemann_zeta(floating-point-type x);
 float        riemann_zetaf(float x);
 long double  riemann_zetal(long double x);
 ```
 *Effects:* These functions compute the Riemann zeta function of their
 \;$$ where x is `x`.
 #### Spherical Bessel functions of the first kind <a id="sf.cmath.sph.bessel">[[sf.cmath.sph.bessel]]</a>
 ``` cpp
+floating-point-type sph_bessel(unsigned n, floating-point-type 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
 See also [[sf.cmath.cyl.bessel.j]].
 #### Spherical associated Legendre functions <a id="sf.cmath.sph.legendre">[[sf.cmath.sph.legendre]]</a>
 ``` cpp
+floating-point-type sph_legendre(unsigned l, unsigned m, floating-point-type 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
 See also [[sf.cmath.assoc.legendre]].
 #### Spherical Neumann functions <a id="sf.cmath.sph.neumann">[[sf.cmath.sph.neumann]]</a>
 ``` cpp
+floating-point-type sph_neumann(unsigned n, floating-point-type 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
 ### Header `<numbers>` synopsis <a id="numbers.syn">[[numbers.syn]]</a>
 ``` cpp
 namespace std::numbers {
+  template<class T> constexpr T e_v          = unspecified;
+  template<class T> constexpr T log2e_v      = unspecified;
+  template<class T> constexpr T log10e_v     = unspecified;
+  template<class T> constexpr T pi_v         = unspecified;
+  template<class T> constexpr T inv_pi_v     = unspecified;
+  template<class T> constexpr T inv_sqrtpi_v = unspecified;
+  template<class T> constexpr T ln2_v        = unspecified;
+  template<class T> constexpr T ln10_v       = unspecified;
+  template<class T> constexpr T sqrt2_v      = unspecified;
+  template<class T> constexpr T sqrt3_v      = unspecified;
+  template<class T> constexpr T inv_sqrt3_v  = unspecified;
+  template<class T> constexpr T egamma_v     = unspecified;
+  template<class T> constexpr T phi_v        = unspecified;
+  template<floating_point T> constexpr T e_v<T>          = see below;
+  template<floating_point T> constexpr T log2e_v<T>      = see below;
+  template<floating_point T> constexpr T log10e_v<T>     = see below;
+  template<floating_point T> constexpr T pi_v<T>         = see below;
+  template<floating_point T> constexpr T inv_pi_v<T>     = see below;
+  template<floating_point T> constexpr T inv_sqrtpi_v<T> = see below;
+  template<floating_point T> constexpr T ln2_v<T>        = see below;
+  template<floating_point T> constexpr T ln10_v<T>       = see below;
+  template<floating_point T> constexpr T sqrt2_v<T>      = see below;
+  template<floating_point T> constexpr T sqrt3_v<T>      = see below;
+  template<floating_point T> constexpr T inv_sqrt3_v<T>  = see below;
+  template<floating_point T> constexpr T egamma_v<T>     = see below;
+  template<floating_point T> 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>;
 <!-- Link reference definitions -->
 [bad.alloc]: support.md#bad.alloc
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.stc.thread]: basic.md#basic.stc.thread
 [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
+[cfenv.thread]: #cfenv.thread
 [class.gslice]: #class.gslice
 [class.gslice.overview]: #class.gslice.overview
 [class.slice]: #class.slice
 [class.slice.overview]: #class.slice.overview
 [cmath.syn]: #cmath.syn
 [complex]: #complex
 [complex.literals]: #complex.literals
 [complex.member.ops]: #complex.member.ops
 [complex.members]: #complex.members
 [complex.numbers]: #complex.numbers
+[complex.numbers.general]: #complex.numbers.general
 [complex.ops]: #complex.ops
 [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
 [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
 [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
 [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
 [numeric.requirements]: #numeric.requirements
 [numerics]: #numerics
 [numerics.general]: #numerics.general
 [numerics.summary]: #numerics.summary
 [output.iterators]: iterators.md#output.iterators
+[over.match.general]: over.md#over.match.general
 [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.dist.samp.plinear]: #rand.dist.samp.plinear
 [rand.dist.uni]: #rand.dist.uni
 [rand.dist.uni.int]: #rand.dist.uni.int
 [rand.dist.uni.real]: #rand.dist.uni.real
 [rand.eng]: #rand.eng
+[rand.eng.general]: #rand.eng.general
 [rand.eng.lcong]: #rand.eng.lcong
 [rand.eng.mers]: #rand.eng.mers
 [rand.eng.sub]: #rand.eng.sub
+[rand.general]: #rand.general
 [rand.predef]: #rand.predef
 [rand.req]: #rand.req
 [rand.req.adapt]: #rand.req.adapt
 [rand.req.dist]: #rand.req.dist
 [rand.req.eng]: #rand.req.eng
 [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.general]: #sf.cmath.general
 [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
 [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
+[term.literal.type]: basic.md#term.literal.type
 [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
 [^1]: In other words, value types. These include arithmetic types,
     pointers, the library class `complex`, and instantiations of
     `valarray` for value types.
+[^2]: This constructor (as well as the subsequent corresponding `seed()`
+    function) can be particularly useful to applications requiring a
+    large number of independent random sequences.
+[^3]: The name of this engine refers, in part, to a property of its
     period: For properly-selected values of the parameters, the period
     is closely related to a large Mersenne prime number.
+[^4]: The parameter is intended to allow an implementation to
     differentiate between different sources of randomness.
+[^5]: If a device has n states whose respective probabilities are
     P₀, …, Pₙ₋₁, the device entropy S is defined as
     $S = - \sum_{i=0}^{n-1} P_i \cdot \log P_i$.
+[^6]: b is introduced to avoid any attempt to produce more bits of
     randomness than can be held in `RealType`.
+[^7]: 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.
+[^8]:  [[implimits]] recommends a minimum number of recursively nested
     template instantiations. This requirement thus indirectly suggests a
     minimum allowable complexity for valarray expressions.
+[^9]: 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.
+[^10]: This default constructor is essential, since arrays of `valarray`
+ can be useful. After initialization, the length of an empty array
     can be increased with the `resize` member function.
+[^11]: This constructor is the preferred method for converting a C array
     to a `valarray` object.
+[^12]: 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.
+[^13]: BLAS stands for *Basic Linear Algebra Subprograms*. C++ programs
+ can 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.
+[^14]: 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