[numerics] - C++11 → C++14

Files changed (1) hide show

tmp/tmpn4bg2l_b/{from.md → to.md} +133 -80

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

@@ -195,30 +195,30 @@ namespace std {
   template<class T> complex<T> operator/(const T&, const complex<T>&);
   template<class T> complex<T> operator+(const complex<T>&);
   template<class T> complex<T> operator-(const complex<T>&);
-  template<class T> bool operator==(
     const complex<T>&, const complex<T>&);
-  template<class T> bool operator==(const complex<T>&, const T&);
-  template<class T> bool operator==(const T&, const complex<T>&);
-  template<class T> bool operator!=(const complex<T>&, const complex<T>&);
-  template<class T> bool operator!=(const complex<T>&, const T&);
-  template<class T> bool operator!=(const T&, const complex<T>&);
   template<class T, class charT, class traits>
   basic_istream<charT, traits>&
   operator>>(basic_istream<charT, traits>&, complex<T>&);
   template<class T, class charT, class traits>
   basic_ostream<charT, traits>&
   operator<<(basic_ostream<charT, traits>&, const complex<T>&);
   // [complex.value.ops], values:
-  template<class T> T real(const complex<T>&);
-  template<class T> T imag(const complex<T>&);
   template<class T> T abs(const complex<T>&);
   template<class T> T arg(const complex<T>&);
   template<class T> T norm(const complex<T>&);
@@ -248,10 +248,22 @@ namespace std {
   template<class T> complex<T> sin  (const complex<T>&);
   template<class T> complex<T> sinh (const complex<T>&);
   template<class T> complex<T> sqrt (const complex<T>&);
   template<class T> complex<T> tan  (const complex<T>&);
   template<class T> complex<T> tanh (const complex<T>&);
 }
 ```
 ### Class template `complex` <a id="complex">[[complex]]</a>
@@ -260,17 +272,17 @@ namespace std {
   template<class T>
   class complex {
   public:
     typedef T value_type;
-    complex(const T& re = T(), const T& im = T());
-    complex(const complex&);
-    template<class X> complex(const complex<X>&);
-    T real() const;
     void real(T);
-    T imag() const;
     void imag(T);
     complex<T>& operator= (const T&);
     complex<T>& operator+=(const T&);
     complex<T>& operator-=(const T&);
@@ -297,16 +309,16 @@ namespace std {
   template<> class complex<float> {
   public:
     typedef float value_type;
     constexpr complex(float re = 0.0f, float im = 0.0f);
- explicit constexpr complex(const complex<double>&);
- explicit constexpr complex(const complex<long double>&);
-    constexpr float real();
     void real(float);
-    constexpr float imag();
     void imag(float);
     complex<float>& operator= (float);
     complex<float>& operator+=(float);
     complex<float>& operator-=(float);
@@ -325,15 +337,15 @@ namespace std {
   public:
     typedef double value_type;
     constexpr complex(double re = 0.0, double im = 0.0);
     constexpr complex(const complex<float>&);
- explicit constexpr complex(const complex<long double>&);
-    constexpr double real();
     void real(double);
-    constexpr double imag();
     void imag(double);
     complex<double>& operator= (double);
     complex<double>& operator+=(double);
     complex<double>& operator-=(double);
@@ -354,13 +366,13 @@ namespace std {
     constexpr complex(long double re = 0.0L, long double im = 0.0L);
     constexpr complex(const complex<float>&);
     constexpr complex(const complex<double>&);
-    constexpr long double real();
     void real(long double);
-    constexpr long double imag();
     void imag(long double);
     complex<long double>& operator=(const complex<long double>&);
     complex<long double>& operator= (long double);
     complex<long double>& operator+=(long double);
@@ -378,19 +390,19 @@ namespace std {
 ```
 ### `complex` member functions <a id="complex.members">[[complex.members]]</a>
 ``` cpp
-template<class T> complex(const T& re = T(), const T& im = T());
 ```
 *Effects:* Constructs an object of class `complex`.
 `real() == re && imag() == im`.
 ``` cpp
-T real() const;
 ```
 *Returns:* The value of the real component.
 ``` cpp
@@ -398,11 +410,11 @@ void real(T val);
 ```
 *Effects:* Assigns `val` to the real component.
 ``` cpp
-T imag() const;
 ```
 *Returns:* The value of the imaginary component.
 ``` cpp
@@ -450,38 +462,38 @@ complex<T>& operator/=(const T& rhs);
 and stores the result in `*this`.
 *Returns:* `*this`.
 ``` cpp
-complex<T>& operator+=(const complex<T>& rhs);
 ```
 *Effects:* Adds the complex value `rhs` to the complex value `*this` and
 stores the sum in `*this`.
 *Returns:* `*this`.
 ``` cpp
-complex<T>& operator-=(const complex<T>& rhs);
 ```
 *Effects:* Subtracts the complex value `rhs` from the complex value
 `*this` and stores the difference in `*this`.
 *Returns:* `*this`.
 ``` cpp
-complex<T>& operator*=(const complex<T>& rhs);
 ```
 *Effects:* Multiplies the complex value `rhs` by the complex value
 `*this` and stores the product in `*this`.
 *Returns:* `*this`.
 ``` cpp
-complex<T>& operator/=(const complex<T>& rhs);
 ```
 *Effects:* Divides the complex value `rhs` into the complex value
 `*this` and stores the quotient in `*this`.
@@ -541,25 +553,25 @@ template<class T> complex<T> operator/(const T& lhs, const complex<T>& rhs);
 *Returns:* `complex<T>(lhs) /= rhs`.
 ``` cpp
 template<class T>
-  bool operator==(const complex<T>& lhs, const complex<T>& rhs);
-template<class T> bool operator==(const complex<T>& lhs, const T& rhs);
-template<class T> bool operator==(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `lhs.real() == rhs.real() && lhs.imag() == rhs.imag()`.
 *Remarks:* The imaginary part is assumed to be `T()`, or 0.0, for the
 `T` arguments.
 ``` cpp
 template<class T>
-  bool operator!=(const complex<T>& lhs, const complex<T>& rhs);
-template<class T> bool operator!=(const complex<T>& lhs, const T& rhs);
-template<class T> bool operator!=(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `rhs.real() != lhs.real() || rhs.imag() != lhs.imag()`.
 ``` cpp
@@ -612,17 +624,17 @@ explicit decimal point character; as a result, all inserted sequences of
 complex numbers can be extracted unambiguously.
 ### `complex` value operations <a id="complex.value.ops">[[complex.value.ops]]</a>
 ``` cpp
-template<class T> T real(const complex<T>& x);
 ```
 *Returns:* `x.real()`.
 ``` cpp
-template<class T> T imag(const complex<T>& x);
 ```
 *Returns:* `x.imag()`.
 ``` cpp
@@ -829,10 +841,39 @@ ensure, for a call with at least one argument of type `complex<T>`:
     or an integer type, then both arguments are effectively cast to
     `complex<double>`.
 3.  Otherwise, if either argument has type `complex<float>` or `float`,
     then both arguments are effectively cast to `complex<float>`.
 ### Header `<ccomplex>` <a id="ccmplx">[[ccmplx]]</a>
 The header behaves as if it simply includes the header `<complex>`.
 ## Random number generation <a id="rand">[[rand]]</a>
@@ -1045,11 +1086,11 @@ It is unspecified whether `D::param_type` is declared as a (nested)
 `D::param_type` are in the form of `typedef`s for convenience of
 exposition only.
 `P` shall satisfy the requirements of `CopyConstructible` (Table
 [[copyconstructible]]), `CopyAssignable` (Table  [[copyassignable]]),
-and EqualityComparable (Table  [[equalitycomparable]]) types.
 For each of the constructors of `D` taking arguments corresponding to
 parameters of the distribution, `P` shall have a corresponding
 constructor subject to the same requirements and taking arguments
 identical in number, type, and default values. Moreover, for each of the
@@ -1074,13 +1115,13 @@ namespace std {
  template<class UIntType, UIntType a, UIntType c, UIntType m>
    class linear_congruential_engine;
  // [rand.eng.mers], class template mersenne_twister_engine
  template<class UIntType, size_t w, size_t n, size_t m, size_t r,
-          UIntType a, size_t u, UintType d, size_t s,
           UIntType b, size_t t,
-          UIntType c, size_t l, UintType f>
    class mersenne_twister_engine;
  // [rand.eng.sub], class template subtract_with_carry_engine
  template<class UIntType, size_t w, size_t s, size_t r>
    class subtract_with_carry_engine;
@@ -1268,12 +1309,12 @@ public:
  // engine characteristics
  static constexpr result_type multiplier = a;
  static constexpr result_type increment = c;
  static constexpr result_type modulus = m;
- static constexpr result_type min() { return c == 0u ? 1u: 0u };
- static constexpr result_type max() { return m - 1u };
  static constexpr result_type default_seed = 1u;
  // constructors and seeding functions
  explicit linear_congruential_engine(result_type s = default_seed);
  template<class Sseq> explicit linear_congruential_engine(Sseq& q);
@@ -1799,11 +1840,11 @@ typedef discard_block_engine<ranlux24_base, 223, 23>
 default-constructed object of type `ranlux24` shall produce the value
 9901578.
 ``` cpp
 typedef discard_block_engine<ranlux48_base, 389, 11>
-       ranlux48@
 ```
 *Required behavior:* The $10000^{\,th}$ consecutive invocation of a
 default-constructed object of type `ranlux48` shall produce the value
 249142670248501.
@@ -1897,13 +1938,10 @@ these values are generated.
 ### Utilities <a id="rand.util">[[rand.util]]</a>
 #### Class `seed_seq` <a id="rand.util.seedseq">[[rand.util.seedseq]]</a>
-No function described in this section  [[rand.util.seedseq]] throws an
-exception.
 ``` cpp
 class seed_seq
 {
 public:
  // types
@@ -1939,10 +1977,12 @@ seed_seq();
 ```
 *Effects:* Constructs a `seed_seq` object as if by default-constructing
 its member `v`.
 ``` cpp
 template<class T>
  seed_seq(initializer_list<T> il);
 ```
@@ -1983,18 +2023,23 @@ s = `v.size()` and n = `end` - `begin`, fills the supplied range
 [`begin`,`end`) according to the following algorithm in which each
 operation is to be carried out modulo 2³², each indexing operator
 applied to `begin` is to be taken modulo n, and T(x) is defined as
 $x \, \xor \, (x \, \rightshift \, 27)$:
 ``` cpp
 size_t size() const;
 ```
 *Returns:* The number of 32-bit units that would be returned by a call
 to `param()`.
-*Complexity:* constant time.
 ``` cpp
 template<class OutputIterator>
   void param(OutputIterator dest) const;
 ```
@@ -2009,10 +2054,12 @@ destination, as if by executing the following statement:
 ``` cpp
 copy(v.begin(), v.end(), dest);
 ```
 #### Function template `generate_canonical` <a id="rand.util.canonical">[[rand.util.canonical]]</a>
 Each function instantiated from the template described in this section
 [[rand.util.canonical]] maps the result of one or more invocations of a
 supplied uniform random number generator `g` to one member of the
@@ -2249,11 +2296,11 @@ constructed.
 A `binomial_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
 $$%
  P(i\,|\,t,p)
-      = {t \choose i} \cdot p^i \cdot (1-p)^{t-i}
 \; \mbox{.}$$
 ``` cpp
 template<class IntType = int>
  class binomial_distribution
@@ -2365,11 +2412,11 @@ constructed.
 A `negative_binomial_distribution` random number distribution produces
 random integers i ≥ 0 distributed according to the discrete probability
 function $$%
  P(i\,|\,k,p)
-      = {k+i-1 \choose i} \cdot p^k \cdot (1-p)^i
 \; \mbox{.}$$
 ``` cpp
 template<class IntType = int>
  class negative_binomial_distribution
@@ -2539,13 +2586,11 @@ constructed.
 A `gamma_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
 $$%
  p(x\,|\,\alpha,\beta)
-      = { e^{-x/\beta}
-        \over {\beta^{\alpha} \cdot \Gamma(\alpha)}
-        }
         \, \cdot \, x^{\, \alpha-1}
 \; \mbox{.}$$
 ``` cpp
 template<class RealType = double>
@@ -2619,11 +2664,11 @@ public:
  // types
  typedef RealType result_type;
  typedef unspecified param_type;
  // constructor and reset functions
- explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0)
  explicit weibull_distribution(const param_type& parm);
  void reset();
  // generating functions
  template<class URNG>
@@ -2734,11 +2779,11 @@ constructed.
 ##### Class template `normal_distribution` <a id="rand.dist.norm.normal">[[rand.dist.norm.normal]]</a>
 A `normal_distribution` random number distribution produces random
 numbers x distributed according to the probability density function $$%
  p(x\,|\,\mu,\sigma)
-      = {1 \over \sigma \sqrt{2\pi}}
         \cdot
         % e^{-(x-\mu)^2 / (2\sigma^2)}
         \exp{\left(- \, \frac{(x - \mu)^2}
                              {2 \sigma^2}
              \right)
@@ -3228,11 +3273,11 @@ $$%
 The n+1 distribution parameters bᵢ, also known as this distribution’s
 *interval boundaries* , shall satisfy the relation bᵢ < bᵢ₊₁ for
 i = 0, …, n-1. Unless specified otherwise, the remaining n distribution
 parameters are calculated as: $$%
  \rho_k = \;
-   {w_k \over {S \cdot (b_{k+1}-b_k)}}
    \; \mbox{ for } k = 0, \ldots, n\!-\!1,$$ in which the values wₖ,
 commonly known as the *weights* , shall be non-negative, non-NaN, and
 non-infinity. Moreover, the following relation shall hold:
 0 < S = w₀ + ⋯ + wₙ₋₁.
@@ -3356,12 +3401,12 @@ k = 0, …, n-1.
 A `piecewise_linear_distribution` random number distribution produces
 random numbers x, b₀ ≤ x < bₙ, distributed over each subinterval
 [ bᵢ, bᵢ₊₁ ) according to the probability density function $$%
  p(x\,|\,b_0,\ldots,b_n,\;\rho_0,\ldots,\rho_n)
-      = \rho_i     \cdot {{b_{i+1} - x} \over {b_{i+1} - b_i}}
-      + \rho_{i+1} \cdot {{x - b_i} \over {b_{i+1} - b_i}}
 \; \mbox{,}
 \mbox{ for } b_i \le x < b_{i+1}
 \; \mbox{.}$$
 The n+1 distribution parameters bᵢ, also known as this distribution’s
@@ -3631,12 +3676,13 @@ 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>&`, identical functions
- taking the replacement types shall be added;
 - for every function taking two `const valarray<T>&` arguments,
   identical functions taking every combination of `const valarray<T>&`
   and replacement types shall be added.
 In particular, an implementation shall allow a `valarray<T>` to be
@@ -3845,16 +3891,14 @@ the assignment.
 ``` cpp
 valarray<T>& operator=(valarray<T>&& v) noexcept;
 ```
-*Effects:* `*this` obtains the value of `v`. If the length of `v` is not
-equal to the length of `*this`, resizes `*this` to make the two arrays
-the same length, as if by calling `resize(v.size())`, before performing
-the assignment.
-*Complexity:* Constant.
 ``` cpp
 valarray& operator=(initializer_list<T> il);
 ```
@@ -3908,12 +3952,12 @@ Likewise, the expression `&a[i] != &b[j]` evaluates as `true` for any
 two arrays `a` and `b` and for any `size_t i` and `size_t j` such that
 `i` is less than the length of `a` and `j` is less than the length of
 `b`. This property indicates an absence of aliasing and may be used to
 advantage by optimizing compilers.[^13]
-The reference returned by the subscript operator for an array is
-guaranteed to be valid until the member function
 `resize(size_t, T)` ([[valarray.members]]) is called for that array or
 until the lifetime of that array ends, whichever happens first.
 If the subscript operator is invoked with a `size_t` argument whose
 value is not less than the length of the array, the behavior is
@@ -4138,11 +4182,11 @@ void swap(valarray& v) noexcept;
 size_t size() const;
 ```
 *Returns:* The number of elements in the array.
-*Complexity:* constant time.
 ``` cpp
 T sum() const;
 ```
@@ -4412,11 +4456,11 @@ size_t size() const;
 size_t stride() const;
 ```
 *Returns:* The start, length, or stride specified by a `slice` object.
-*Complexity:* constant time.
 ### Class template `slice_array` <a id="template.slice.array">[[template.slice.array]]</a>
 #### Class template `slice_array` overview <a id="template.slice.array.overview">[[template.slice.array.overview]]</a>
@@ -4864,10 +4908,15 @@ iterator ([[random.access.iterators]]) whose `value_type` is the
 template parameter `T` and whose `reference` type is `T&`.
 *unspecified*2 is a type that meets the requirements of a constant
 random access iterator ([[random.access.iterators]]) whose `value_type`
 is the template parameter `T` and whose `reference` type is `const T&`.
 ``` cpp
 template <class T> unspecified{1} begin(valarray<T>& v);
 template <class T> unspecified{2} begin(const valarray<T>& v);
 ```
@@ -5036,11 +5085,11 @@ template <class InputIterator, class OutputIterator, class BinaryOperation>
 *Effects:* For a non-empty range, the function creates an accumulator
 `acc` whose type is `InputIterator`’s value type, initializes it with
 `*first`, and assigns the result to `*result`. For every iterator `i` in
 \[`first + 1`, `last`) in order, creates an object `val` whose type is
-`InputIterator`’s value type, initializes it with \*i, computes
 `val - acc` or `binary_op(val, acc)`, assigns the result to
 `*(result + (i - first))`, and move assigns from `val` to `acc`.
 *Requires:* `InputIterator`’s value type shall be `MoveAssignable`
 (Table  [[moveassignable]]) and shall be constructible from the type of
@@ -5076,12 +5125,12 @@ The expression `++val`, where `val` has type `T`, shall be well formed.
 ## C library <a id="c.math">[[c.math]]</a>
 The header `<ctgmath>` simply includes the headers `<ccomplex>` and
 `<cmath>`.
-The overloads provided in C by magic macros are already provided in
-`<ccomplex>` and `<cmath>` by “sufficient” additional overloads.
 Tables  [[tab:numerics.hdr.cmath]] and  [[tab:numerics.hdr.cstdlib]]
 describe headers `<cmath>` and `<cstdlib>`, respectively.
 The contents of these headers are the same as the Standard C library
@@ -5091,11 +5140,13 @@ changes:
 The `rand` function has the semantics specified in the C standard,
 except that the implementation may specify that particular library
 functions may call `rand`. It is implementation-defined whether the
 `rand` function may introduce data races ([[res.on.data.races]]). The
 random number generation ([[rand]]) facilities in this standard are
-often preferable to `rand`.
 In addition to the `int` versions of certain math functions in
 `<cstdlib>`, C++adds `long` and `long long` overloaded versions of these
 functions, with the same semantics.
@@ -5283,18 +5334,19 @@ bool islessgreater(long double x, long double y);
 bool isunordered(long double x, long double y);
 ```
 Moreover, there shall be additional overloads sufficient to ensure:
-1.  If any argument corresponding to a `double` parameter has type
-    `long double`, then all arguments corresponding to `double`
-    parameters are effectively cast to `long double`.
-2.  Otherwise, if any argument corresponding to a `double` parameter has
-    type `double` or an integer type, then all arguments corresponding
-    to `double` parameters are effectively cast to `double`.
-3.  Otherwise, all arguments corresponding to `double` parameters are
-    effectively cast to `float`.
 ISO C 7.5, 7.10.2, 7.10.6.
 <!-- Link reference definitions -->
 [accumulate]: #accumulate
@@ -5312,10 +5364,11 @@ ISO C 7.5, 7.10.2, 7.10.6.
 [class.gslice.overview]: #class.gslice.overview
 [class.slice]: #class.slice
 [class.slice.overview]: #class.slice.overview
 [cmplx.over]: #cmplx.over
 [complex]: #complex
 [complex.member.ops]: #complex.member.ops
 [complex.members]: #complex.members
 [complex.numbers]: #complex.numbers
 [complex.ops]: #complex.ops
 [complex.special]: #complex.special

   template<class T> complex<T> operator/(const T&, const complex<T>&);
   template<class T> complex<T> operator+(const complex<T>&);
   template<class T> complex<T> operator-(const complex<T>&);
+  template<class T> constexpr bool operator==(
     const complex<T>&, const complex<T>&);
+  template<class T> constexpr bool operator==(const complex<T>&, const T&);
+  template<class T> constexpr bool operator==(const T&, const complex<T>&);
+  template<class T> constexpr bool operator!=(const complex<T>&, const complex<T>&);
+  template<class T> constexpr bool operator!=(const complex<T>&, const T&);
+  template<class T> constexpr bool operator!=(const T&, const complex<T>&);
   template<class T, class charT, class traits>
   basic_istream<charT, traits>&
   operator>>(basic_istream<charT, traits>&, complex<T>&);
   template<class T, class charT, class traits>
   basic_ostream<charT, traits>&
   operator<<(basic_ostream<charT, traits>&, const complex<T>&);
   // [complex.value.ops], values:
+  template<class T> constexpr T real(const complex<T>&);
+  template<class T> constexpr T imag(const complex<T>&);
   template<class T> T abs(const complex<T>&);
   template<class T> T arg(const complex<T>&);
   template<class T> T norm(const complex<T>&);
   template<class T> complex<T> sin  (const complex<T>&);
   template<class T> complex<T> sinh (const complex<T>&);
   template<class T> complex<T> sqrt (const complex<T>&);
   template<class T> complex<T> tan  (const complex<T>&);
   template<class T> complex<T> tanh (const complex<T>&);
+  // [complex.literals], complex literals:
+  inline namespace literals {
+    inline namespace complex_literals {
+      constexpr complex<long double> operator""il(long double);
+      constexpr complex<long double> operator""il(unsigned long long);
+      constexpr complex<double> operator""i(long double);
+      constexpr complex<double> operator""i(unsigned long long);
+      constexpr complex<float> operator""if(long double);
+      constexpr complex<float> operator""if(unsigned long long);
+    }
+  }
 }
 ```
 ### Class template `complex` <a id="complex">[[complex]]</a>
   template<class T>
   class complex {
   public:
     typedef T value_type;
+ constexpr complex(const T& re = T(), const T& im = T());
+ constexpr complex(const complex&);
+    template<class X> constexpr complex(const complex<X>&);
+ constexpr T real() const;
     void real(T);
+ constexpr T imag() const;
     void imag(T);
     complex<T>& operator= (const T&);
     complex<T>& operator+=(const T&);
     complex<T>& operator-=(const T&);
   template<> class complex<float> {
   public:
     typedef float value_type;
     constexpr complex(float re = 0.0f, float im = 0.0f);
+    constexpr explicit complex(const complex<double>&);
+    constexpr explicit complex(const complex<long double>&);
+    constexpr float real() const;
     void real(float);
+    constexpr float imag() const;
     void imag(float);
     complex<float>& operator= (float);
     complex<float>& operator+=(float);
     complex<float>& operator-=(float);
   public:
     typedef double value_type;
     constexpr complex(double re = 0.0, double im = 0.0);
     constexpr complex(const complex<float>&);
+    constexpr explicit complex(const complex<long double>&);
+    constexpr double real() const;
     void real(double);
+    constexpr double imag() const;
     void imag(double);
     complex<double>& operator= (double);
     complex<double>& operator+=(double);
     complex<double>& operator-=(double);
     constexpr complex(long double re = 0.0L, long double im = 0.0L);
     constexpr complex(const complex<float>&);
     constexpr complex(const complex<double>&);
+    constexpr long double real() const;
     void real(long double);
+    constexpr long double imag() const;
     void imag(long double);
     complex<long double>& operator=(const complex<long double>&);
     complex<long double>& operator= (long double);
     complex<long double>& operator+=(long double);
 ```
 ### `complex` member functions <a id="complex.members">[[complex.members]]</a>
 ``` cpp
+template<class T> constexpr complex(const T& re = T(), const T& im = T());
 ```
 *Effects:* Constructs an object of class `complex`.
 `real() == re && imag() == im`.
 ``` cpp
+constexpr T real() const;
 ```
 *Returns:* The value of the real component.
 ``` cpp
 ```
 *Effects:* Assigns `val` to the real component.
 ``` cpp
+constexpr T imag() const;
 ```
 *Returns:* The value of the imaginary component.
 ``` cpp
 and stores the result in `*this`.
 *Returns:* `*this`.
 ``` cpp
+template<class X> complex<T>& operator+=(const complex<X>& rhs);
 ```
 *Effects:* Adds the complex value `rhs` to the complex value `*this` and
 stores the sum in `*this`.
 *Returns:* `*this`.
 ``` cpp
+template<class X> complex<T>& operator-=(const complex<X>& rhs);
 ```
 *Effects:* Subtracts the complex value `rhs` from the complex value
 `*this` and stores the difference in `*this`.
 *Returns:* `*this`.
 ``` cpp
+template<class X> complex<T>& operator*=(const complex<X>& rhs);
 ```
 *Effects:* Multiplies the complex value `rhs` by the complex value
 `*this` and stores the product in `*this`.
 *Returns:* `*this`.
 ``` cpp
+template<class X> complex<T>& operator/=(const complex<X>& rhs);
 ```
 *Effects:* Divides the complex value `rhs` into the complex value
 `*this` and stores the quotient in `*this`.
 *Returns:* `complex<T>(lhs) /= rhs`.
 ``` cpp
 template<class T>
+ constexpr bool operator==(const complex<T>& lhs, const complex<T>& rhs);
+template<class T> constexpr bool operator==(const complex<T>& lhs, const T& rhs);
+template<class T> constexpr bool operator==(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `lhs.real() == rhs.real() && lhs.imag() == rhs.imag()`.
 *Remarks:* The imaginary part is assumed to be `T()`, or 0.0, for the
 `T` arguments.
 ``` cpp
 template<class T>
+ constexpr bool operator!=(const complex<T>& lhs, const complex<T>& rhs);
+template<class T> constexpr bool operator!=(const complex<T>& lhs, const T& rhs);
+template<class T> constexpr bool operator!=(const T& lhs, const complex<T>& rhs);
 ```
 *Returns:* `rhs.real() != lhs.real() || rhs.imag() != lhs.imag()`.
 ``` cpp
 complex numbers can be extracted unambiguously.
 ### `complex` value operations <a id="complex.value.ops">[[complex.value.ops]]</a>
 ``` cpp
+template<class T> constexpr T real(const complex<T>& x);
 ```
 *Returns:* `x.real()`.
 ``` cpp
+template<class T> constexpr T imag(const complex<T>& x);
 ```
 *Returns:* `x.imag()`.
 ``` cpp
     or an integer type, then both arguments are effectively cast to
     `complex<double>`.
 3.  Otherwise, if either argument has type `complex<float>` or `float`,
     then both arguments are effectively cast to `complex<float>`.
+### Suffixes for complex number literals <a id="complex.literals">[[complex.literals]]</a>
+This section describes literal suffixes for constructing complex number
+literals. The suffixes `i`, `il`, and `if` create complex numbers of the
+types `complex<double>`, `complex<long double>`, and `complex<float>`
+respectively, with their imaginary part denoted by the given literal
+number and the real part being zero.
+``` cpp
+constexpr complex<long double> operator""il(long double d);
+constexpr complex<long double> operator""il(unsigned long long d);
+```
+*Returns:* `complex<long double>{0.0L, static_cast<long double>(d)}`.
+``` cpp
+constexpr complex<double> operator""i(long double d);
+constexpr complex<double> operator""i(unsigned long long d);
+```
+*Returns:* `complex<double>{0.0, static_cast<double>(d)}`.
+``` cpp
+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)}`.
 ### Header `<ccomplex>` <a id="ccmplx">[[ccmplx]]</a>
 The header behaves as if it simply includes the header `<complex>`.
 ## Random number generation <a id="rand">[[rand]]</a>
 `D::param_type` are in the form of `typedef`s for convenience of
 exposition only.
 `P` shall satisfy the requirements of `CopyConstructible` (Table
 [[copyconstructible]]), `CopyAssignable` (Table  [[copyassignable]]),
+and `EqualityComparable` (Table  [[equalitycomparable]]) types.
 For each of the constructors of `D` taking arguments corresponding to
 parameters of the distribution, `P` shall have a corresponding
 constructor subject to the same requirements and taking arguments
 identical in number, type, and default values. Moreover, for each of the
  template<class UIntType, UIntType a, UIntType c, UIntType m>
    class linear_congruential_engine;
  // [rand.eng.mers], class template mersenne_twister_engine
  template<class UIntType, size_t w, size_t n, size_t m, size_t r,
+          UIntType a, size_t u, UIntType d, size_t s,
           UIntType b, size_t t,
+          UIntType c, size_t l, UIntType f>
    class mersenne_twister_engine;
  // [rand.eng.sub], class template subtract_with_carry_engine
  template<class UIntType, size_t w, size_t s, size_t r>
    class subtract_with_carry_engine;
  // engine characteristics
  static constexpr result_type multiplier = a;
  static constexpr result_type increment = c;
  static constexpr result_type modulus = m;
+ static constexpr result_type min() { return c == 0u ? 1u: 0u; }
+ static constexpr result_type max() { return m - 1u; }
  static constexpr result_type default_seed = 1u;
  // constructors and seeding functions
  explicit linear_congruential_engine(result_type s = default_seed);
  template<class Sseq> explicit linear_congruential_engine(Sseq& q);
 default-constructed object of type `ranlux24` shall produce the value
 9901578.
 ``` cpp
 typedef discard_block_engine<ranlux48_base, 389, 11>
+       ranlux48;
 ```
 *Required behavior:* The $10000^{\,th}$ consecutive invocation of a
 default-constructed object of type `ranlux48` shall produce the value
 249142670248501.
 ### 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
 ```
 *Effects:* Constructs a `seed_seq` object as if by default-constructing
 its member `v`.
+*Throws:* Nothing.
 ``` cpp
 template<class T>
  seed_seq(initializer_list<T> il);
 ```
 [`begin`,`end`) according to the following algorithm in which each
 operation is to be carried out modulo 2³², each indexing operator
 applied to `begin` is to be taken modulo n, and T(x) is defined as
 $x \, \xor \, (x \, \rightshift \, 27)$:
+*Throws:* What and when `RandomAccessIterator` operations of `begin` and
+`end` throw.
 ``` cpp
 size_t size() const;
 ```
 *Returns:* The number of 32-bit units that would be returned by a call
 to `param()`.
+*Throws:* Nothing.
+*Complexity:* Constant time.
 ``` cpp
 template<class OutputIterator>
   void param(OutputIterator dest) const;
 ```
 ``` cpp
 copy(v.begin(), v.end(), dest);
 ```
+*Throws:* What and when `OutputIterator` operations of `dest` throw.
 #### Function template `generate_canonical` <a id="rand.util.canonical">[[rand.util.canonical]]</a>
 Each function instantiated from the template described in this section
 [[rand.util.canonical]] maps the result of one or more invocations of a
 supplied uniform random number generator `g` to one member of the
 A `binomial_distribution` random number distribution produces integer
 values i ≥ 0 distributed according to the discrete probability function
 $$%
  P(i\,|\,t,p)
+      = \binom{t}{i} \cdot p^i \cdot (1-p)^{t-i}
 \; \mbox{.}$$
 ``` cpp
 template<class IntType = int>
  class binomial_distribution
 A `negative_binomial_distribution` random number distribution produces
 random integers i ≥ 0 distributed according to the discrete probability
 function $$%
  P(i\,|\,k,p)
+      = \binom{k+i-1}{i} \cdot p^k \cdot (1-p)^i
 \; \mbox{.}$$
 ``` cpp
 template<class IntType = int>
  class negative_binomial_distribution
 A `gamma_distribution` random number distribution produces random
 numbers x > 0 distributed according to the probability density function
 $$%
  p(x\,|\,\alpha,\beta)
+      = \frac{e^{-x/\beta}}{\beta^{\alpha} \cdot \Gamma(\alpha)}
         \, \cdot \, x^{\, \alpha-1}
 \; \mbox{.}$$
 ``` cpp
 template<class RealType = double>
  // types
  typedef RealType result_type;
  typedef unspecified param_type;
  // constructor and reset functions
+ explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0);
  explicit weibull_distribution(const param_type& parm);
  void reset();
  // generating functions
  template<class URNG>
 ##### Class template `normal_distribution` <a id="rand.dist.norm.normal">[[rand.dist.norm.normal]]</a>
 A `normal_distribution` random number distribution produces random
 numbers x distributed according to the probability density function $$%
  p(x\,|\,\mu,\sigma)
+      = \frac{1}{\sigma \sqrt{2\pi}}
         \cdot
         % e^{-(x-\mu)^2 / (2\sigma^2)}
         \exp{\left(- \, \frac{(x - \mu)^2}
                              {2 \sigma^2}
              \right)
 The n+1 distribution parameters bᵢ, also known as this distribution’s
 *interval boundaries* , shall satisfy the relation bᵢ < bᵢ₊₁ for
 i = 0, …, n-1. Unless specified otherwise, the remaining n distribution
 parameters are calculated as: $$%
  \rho_k = \;
+ \frac{w_k}{S \cdot (b_{k+1}-b_k)}
    \; \mbox{ for } k = 0, \ldots, n\!-\!1,$$ in which the values wₖ,
 commonly known as the *weights* , shall be non-negative, non-NaN, and
 non-infinity. Moreover, the following relation shall hold:
 0 < S = w₀ + ⋯ + wₙ₋₁.
 A `piecewise_linear_distribution` random number distribution produces
 random numbers x, b₀ ≤ x < bₙ, distributed over each subinterval
 [ bᵢ, bᵢ₊₁ ) according to the probability density function $$%
  p(x\,|\,b_0,\ldots,b_n,\;\rho_0,\ldots,\rho_n)
+      = \rho_i     \cdot {\frac{b_{i+1} - x}{b_{i+1} - b_i}}
+      + \rho_{i+1} \cdot {\frac{x - b_i}{b_{i+1} - b_i}}
 \; \mbox{,}
 \mbox{ for } b_i \le x < b_{i+1}
 \; \mbox{.}$$
 The n+1 distribution parameters bᵢ, also known as this distribution’s
 nested argument type.[^7]
 Implementations introducing such replacement types shall provide
 additional functions and operators as follows:
+- for every function taking a `const valarray<T>&` other than `begin`
+ and `end` ([[valarray.range]]), identical functions taking the
+  replacement types shall be added;
 - for every function taking two `const valarray<T>&` arguments,
   identical functions taking every combination of `const valarray<T>&`
   and replacement types shall be added.
 In particular, an implementation shall allow a `valarray<T>` to be
 ``` cpp
 valarray<T>& operator=(valarray<T>&& v) noexcept;
 ```
+*Effects:* `*this` obtains the value of `v`. The value of `v` after the
+assignment is not specified.
+*Complexity:* Linear.
 ``` cpp
 valarray& operator=(initializer_list<T> il);
 ```
 two arrays `a` and `b` and for any `size_t i` and `size_t j` such that
 `i` is less than the length of `a` and `j` is less than the length of
 `b`. This property indicates an absence of aliasing and may be used to
 advantage by optimizing compilers.[^13]
+The reference returned by the subscript operator for an array shall be
+valid until the member function
 `resize(size_t, T)` ([[valarray.members]]) is called for that array or
 until the lifetime of that array ends, whichever happens first.
 If the subscript operator is invoked with a `size_t` argument whose
 value is not less than the length of the array, the behavior is
 size_t size() const;
 ```
 *Returns:* The number of elements in the array.
+*Complexity:* Constant time.
 ``` cpp
 T sum() const;
 ```
 size_t stride() const;
 ```
 *Returns:* The start, length, or stride specified by a `slice` object.
+*Complexity:* Constant time.
 ### Class template `slice_array` <a id="template.slice.array">[[template.slice.array]]</a>
 #### Class template `slice_array` overview <a id="template.slice.array.overview">[[template.slice.array.overview]]</a>
 template parameter `T` and whose `reference` type is `T&`.
 *unspecified*2 is a type that meets the requirements of a constant
 random access iterator ([[random.access.iterators]]) whose `value_type`
 is the template parameter `T` and whose `reference` type is `const T&`.
+The iterators returned by `begin` and `end` for an array are guaranteed
+to be valid until the member function `resize(size_t, T)` (
+[[valarray.members]]) is called for that array or until the lifetime of
+that array ends, whichever happens first.
 ``` cpp
 template <class T> unspecified{1} begin(valarray<T>& v);
 template <class T> unspecified{2} begin(const valarray<T>& v);
 ```
 *Effects:* For a non-empty range, the function creates an accumulator
 `acc` whose type is `InputIterator`’s value type, initializes it with
 `*first`, and assigns the result to `*result`. For every iterator `i` in
 \[`first + 1`, `last`) in order, creates an object `val` whose type is
+`InputIterator`’s value type, initializes it with `*i`, computes
 `val - acc` or `binary_op(val, acc)`, assigns the result to
 `*(result + (i - first))`, and move assigns from `val` to `acc`.
 *Requires:* `InputIterator`’s value type shall be `MoveAssignable`
 (Table  [[moveassignable]]) and shall be constructible from the type of
 ## C library <a id="c.math">[[c.math]]</a>
 The header `<ctgmath>` simply includes the headers `<ccomplex>` and
 `<cmath>`.
+The overloads provided in C by type-generic macros are already provided
+in `<ccomplex>` and `<cmath>` by “sufficient” additional overloads.
 Tables  [[tab:numerics.hdr.cmath]] and  [[tab:numerics.hdr.cstdlib]]
 describe headers `<cmath>` and `<cstdlib>`, respectively.
 The contents of these headers are the same as the Standard C library
 The `rand` function has the semantics specified in the C standard,
 except that the implementation may specify that particular library
 functions may call `rand`. It is implementation-defined whether the
 `rand` function may introduce data races ([[res.on.data.races]]). The
 random number generation ([[rand]]) facilities in this standard are
+often preferable to `rand`, because `rand`’s underlying algorithm is
+unspecified. Use of `rand` therefore continues to be nonportable, with
+unpredictable and oft-questionable quality and performance.
 In addition to the `int` versions of certain math functions in
 `<cstdlib>`, C++adds `long` and `long long` overloaded versions of these
 functions, with the same semantics.
 bool isunordered(long double x, long double y);
 ```
 Moreover, there shall be additional overloads sufficient to ensure:
+1.  If any arithmetic argument corresponding to a `double` parameter has
+ type `long double`, then all arithmetic arguments corresponding to
+ `double` parameters are effectively cast to `long double`.
+2.  Otherwise, if any arithmetic argument corresponding to a `double`
+ parameter has type `double` or an integer type, then all arithmetic
+ arguments corresponding to `double` parameters are effectively cast
+ to `double`.
+3.  Otherwise, all arithmetic arguments corresponding to `double`
+    parameters have type `float`.
 ISO C 7.5, 7.10.2, 7.10.6.
 <!-- Link reference definitions -->
 [accumulate]: #accumulate
 [class.gslice.overview]: #class.gslice.overview
 [class.slice]: #class.slice
 [class.slice.overview]: #class.slice.overview
 [cmplx.over]: #cmplx.over
 [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

Diff to HTML by rtfpessoa