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

Files changed (1) hide show

tmp/tmpc3novgdb/{from.md → to.md} +315 -258

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

@@ -15,101 +15,133 @@ namespace std {
   template<class T> class indirect_array;   // an indirected array
   template<class T> void swap(valarray<T>&, valarray<T>&) noexcept;
   template<class T> valarray<T> operator* (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator* (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator* (const T&, const valarray<T>&);
   template<class T> valarray<T> operator/ (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator/ (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator/ (const T&, const valarray<T>&);
   template<class T> valarray<T> operator% (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator% (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator% (const T&, const valarray<T>&);
   template<class T> valarray<T> operator+ (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator+ (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator+ (const T&, const valarray<T>&);
   template<class T> valarray<T> operator- (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator- (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator- (const T&, const valarray<T>&);
   template<class T> valarray<T> operator^ (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator^ (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator^ (const T&, const valarray<T>&);
   template<class T> valarray<T> operator& (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator& (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator& (const T&, const valarray<T>&);
   template<class T> valarray<T> operator| (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator| (const valarray<T>&, const T&);
-  template<class T> valarray<T> operator| (const T&, const valarray<T>&);
   template<class T> valarray<T> operator<<(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator<<(const valarray<T>&, const T&);
-  template<class T> valarray<T> operator<<(const T&, const valarray<T>&);
   template<class T> valarray<T> operator>>(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> operator>>(const valarray<T>&, const T&);
-  template<class T> valarray<T> operator>>(const T&, const valarray<T>&);
   template<class T> valarray<bool> operator&&(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator&&(const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator&&(const T&, const valarray<T>&);
   template<class T> valarray<bool> operator||(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator||(const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator||(const T&, const valarray<T>&);
-  template<class T>
- valarray<bool> operator==(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator==(const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator==(const T&, const valarray<T>&);
-  template<class T>
- valarray<bool> operator!=(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator!=(const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator!=(const T&, const valarray<T>&);
-  template<class T>
- valarray<bool> operator< (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator< (const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator< (const T&, const valarray<T>&);
-  template<class T>
- valarray<bool> operator> (const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator> (const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator> (const T&, const valarray<T>&);
-  template<class T>
-    valarray<bool> operator<=(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator<=(const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator<=(const T&, const valarray<T>&);
-  template<class T>
- valarray<bool> operator>=(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<bool> operator>=(const valarray<T>&, const T&);
-  template<class T> valarray<bool> operator>=(const T&, const valarray<T>&);
   template<class T> valarray<T> abs  (const valarray<T>&);
   template<class T> valarray<T> acos (const valarray<T>&);
   template<class T> valarray<T> asin (const valarray<T>&);
   template<class T> valarray<T> atan (const valarray<T>&);
   template<class T> valarray<T> atan2(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> atan2(const valarray<T>&, const T&);
-  template<class T> valarray<T> atan2(const T&, const valarray<T>&);
   template<class T> valarray<T> cos  (const valarray<T>&);
   template<class T> valarray<T> cosh (const valarray<T>&);
   template<class T> valarray<T> exp  (const valarray<T>&);
   template<class T> valarray<T> log  (const valarray<T>&);
   template<class T> valarray<T> log10(const valarray<T>&);
   template<class T> valarray<T> pow(const valarray<T>&, const valarray<T>&);
-  template<class T> valarray<T> pow(const valarray<T>&, const T&);
-  template<class T> valarray<T> pow(const T&, const valarray<T>&);
   template<class T> valarray<T> sin  (const valarray<T>&);
   template<class T> valarray<T> sinh (const valarray<T>&);
   template<class T> valarray<T> sqrt (const valarray<T>&);
   template<class T> valarray<T> tan  (const valarray<T>&);
@@ -138,28 +170,28 @@ nested argument type.[^7]
 Implementations introducing such replacement types shall provide
 additional functions and operators as follows:
 - for every function taking a `const valarray<T>&` other than `begin`
-  and `end` ([[valarray.range]]), identical functions taking the
   replacement types shall be added;
 - for every function taking two `const valarray<T>&` arguments,
   identical functions taking every combination of `const valarray<T>&`
   and replacement types shall be added.
 In particular, an implementation shall allow a `valarray<T>` to be
 constructed from such replacement types and shall allow assignments and
 compound assignments of such types to `valarray<T>`, `slice_array<T>`,
 `gslice_array<T>`, `mask_array<T>` and `indirect_array<T>` objects.
-These library functions are permitted to throw a `bad_alloc` (
-[[bad.alloc]]) exception if there are not sufficient resources available
 to carry out the operation. Note that the exception is not mandated.
 ### Class template `valarray` <a id="template.valarray">[[template.valarray]]</a>
-#### Class template `valarray` overview <a id="template.valarray.overview">[[template.valarray.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class valarray {
   public:
@@ -259,14 +291,11 @@ object of type `valarray<T>` is referred to as an “array” throughout the
 remainder of  [[numarray]]. The illusion of higher dimensionality may be
 produced by the familiar idiom of computed indices, together with the
 powerful subsetting capabilities provided by the generalized subscript
 operators.[^8]
-An implementation is permitted to qualify any of the functions declared
-in `<valarray>` as `inline`.
-#### `valarray` constructors <a id="valarray.cons">[[valarray.cons]]</a>
 ``` cpp
 valarray();
 ```
@@ -275,11 +304,11 @@ valarray();
 ``` cpp
 explicit valarray(size_t n);
 ```
 *Effects:* Constructs a `valarray` that has length `n`. Each element of
-the array is value-initialized ([[dcl.init]]).
 ``` cpp
 valarray(const T& v, size_t n);
 ```
@@ -288,12 +317,11 @@ the array is initialized with `v`.
 ``` cpp
 valarray(const T* p, size_t n);
 ```
-*Requires:* `p` points to an array ([[dcl.array]]) of at least `n`
-elements.
 *Effects:* Constructs a `valarray` that has length `n`. The values of
 the elements of the array are initialized with the first `n` values
 pointed to by the first argument.[^10]
@@ -336,11 +364,11 @@ templates to a `valarray`.
 ```
 *Effects:* The destructor is applied to every element of `*this`; an
 implementation may return all allocated memory.
-#### `valarray` assignment <a id="valarray.assign">[[valarray.assign]]</a>
 ``` cpp
 valarray& operator=(const valarray& v);
 ```
@@ -348,11 +376,11 @@ valarray& operator=(const valarray& v);
 the corresponding element of `v`. If the length of `v` is not equal to
 the length of `*this`, resizes `*this` to make the two arrays the same
 length, as if by calling `resize(v.size())`, before performing the
 assignment.
-*Postconditions:* `size() == v.size()`.
 *Returns:* `*this`.
 ``` cpp
 valarray& operator=(valarray&& v) noexcept;
@@ -384,63 +412,64 @@ valarray& operator=(const slice_array<T>&);
 valarray& operator=(const gslice_array<T>&);
 valarray& operator=(const mask_array<T>&);
 valarray& operator=(const indirect_array<T>&);
 ```
-*Requires:* The length of the array to which the argument refers equals
-`size()`. The value of an element in the left-hand side of a `valarray`
-assignment operator does not depend on the value of another element in
-that left-hand side.
 These operators allow the results of a generalized subscripting
 operation to be assigned directly to a `valarray`.
-#### `valarray` element access <a id="valarray.access">[[valarray.access]]</a>
 ``` cpp
 const T&  operator[](size_t n) const;
 T& operator[](size_t n);
 ```
-*Requires:* `n < size()`.
 *Returns:* A reference to the corresponding element of the array.
 [*Note 1*: The expression `(a[i] = q, a[i]) == q` evaluates to `true`
 for any non-constant `valarray<T> a`, any `T q`, and for any `size_t i`
 such that the value of `i` is less than the length of
 `a`. — *end note*]
-*Remarks:* The expression `&a[i+j] == &a[i] + j` evaluates to `true` for
-all `size_t i` and `size_t j` such that `i+j < a.size()`.
-The expression `&a[i] != &b[j]` evaluates to `true` for any two arrays
-`a` and `b` and for any `size_t i` and `size_t j` such that
-`i < a.size()` and `j < b.size()`.
 [*Note 2*: This property indicates an absence of aliasing and may be
 used to advantage by optimizing compilers. Compilers may take advantage
 of inlining, constant propagation, loop fusion, tracking of pointers
 obtained from `operator new`, and other techniques to generate efficient
 `valarray`s. — *end note*]
 The reference returned by the subscript operator for an array shall be
-valid until the member function
-`resize(size_t, T)` ([[valarray.members]]) is called for that array or
-until the lifetime of that array ends, whichever happens first.
-#### `valarray` subset operations <a id="valarray.sub">[[valarray.sub]]</a>
 The member `operator[]` is overloaded to provide several ways to select
 sequences of elements from among those controlled by `*this`. Each of
 these operations returns a subset of the array. The const-qualified
 versions return this subset as a new `valarray` object. The non-const
 versions return a class template object which has reference semantics to
 the original array, working in conjunction with various overloads of
 `operator=` and other assigning operators to allow selective replacement
 (slicing) of the controlled sequence. In each case the selected
-element(s) must exist.
 ``` cpp
 valarray operator[](slice slicearr) const;
 ```
@@ -587,30 +616,29 @@ v0[valarray<size_t>(vi, 5)] = v1;
 // v0 == valarray<char>("abCDeBgAEjklmnop", 16)
 ```
 — *end example*]
-#### `valarray` unary operators <a id="valarray.unary">[[valarray.unary]]</a>
 ``` cpp
 valarray operator+() const;
 valarray operator-() const;
 valarray operator~() const;
 valarray<bool> operator!() const;
 ```
-*Requires:* Each of these operators may only be instantiated for a type
-`T` to which the indicated operator can be applied and for which the
-indicated operator returns a value which is of type `T` (`bool` for
-`operator!`) or which may be unambiguously implicitly converted to type
-`T` (`bool` for `operator!`).
 *Returns:* A `valarray` whose length is `size()`. Each element of the
 returned array is initialized with the result of applying the indicated
 operator to the corresponding element of the array.
-#### `valarray` compound assignment <a id="valarray.cassign">[[valarray.cassign]]</a>
 ``` cpp
 valarray& operator*= (const valarray& v);
 valarray& operator/= (const valarray& v);
 valarray& operator%= (const valarray& v);
@@ -621,15 +649,18 @@ valarray& operator&= (const valarray& v);
 valarray& operator|= (const valarray& v);
 valarray& operator<<=(const valarray& v);
 valarray& operator>>=(const valarray& v);
 ```
-*Requires:* `size() == v.size()`. Each of these operators may only be
-instantiated for a type `T` if the indicated operator can be applied to
-two operands of type `T`. The value of an element in the left-hand side
-of a valarray compound assignment operator does not depend on the value
-of another element in that left hand side.
 *Effects:* Each of these operators performs the indicated operation on
 each of the elements of `*this` and the corresponding element of `v`.
 *Returns:* `*this`.
@@ -648,24 +679,23 @@ valarray& operator&= (const T& v);
 valarray& operator|= (const T& v);
 valarray& operator<<=(const T& v);
 valarray& operator>>=(const T& v);
 ```
-*Requires:* Each of these operators may only be instantiated for a type
-`T` if the indicated operator can be applied to two operands of type
-`T`.
 *Effects:* Each of these operators applies the indicated operation to
 each element of `*this` and `v`.
 *Returns:* `*this`
 *Remarks:* The appearance of an array on the left-hand side of a
 compound assignment does not invalidate references or pointers to the
 elements of the array.
-#### `valarray` member functions <a id="valarray.members">[[valarray.members]]</a>
 ``` cpp
 void swap(valarray& v) noexcept;
 ```
@@ -684,33 +714,34 @@ size_t size() const;
 ``` cpp
 T sum() const;
 ```
-*Requires:* `size() > 0`. This function may only be instantiated for a
-type `T` to which `operator+=` can be applied.
 *Returns:* The sum of all the elements of the array. If the array has
 length 1, returns the value of element 0. Otherwise, the returned value
 is calculated by applying `operator+=` to a copy of an element of the
 array and all other elements of the array in an unspecified order.
 ``` cpp
 T min() const;
 ```
-*Requires:* `size() > 0`
 *Returns:* The minimum value contained in `*this`. For an array of
 length 1, the value of element 0 is returned. For all other array
 lengths, the determination is made using `operator<`.
 ``` cpp
 T max() const;
 ```
-*Requires:* `size() > 0`.
 *Returns:* The maximum value contained in `*this`. For an array of
 length 1, the value of element 0 is returned. For all other array
 lengths, the determination is made using `operator<`.
@@ -725,13 +756,13 @@ is `(*this)[`*`I`*` + n]` if *`I`*` + n` is non-negative and less than
 [*Note 1*: If element zero is taken as the leftmost element, a positive
 value of `n` shifts the elements left `n` places, with zero
 fill. — *end note*]
 [*Example 1*: If the argument has the value -2, the first two elements
-of the result will be value-initialized ([[dcl.init]]); the third
-element of the result will be assigned the value of the first element of
-the argument; etc. — *end example*]
 ``` cpp
 valarray cshift(int n) const;
 ```
@@ -757,183 +788,197 @@ void resize(size_t sz, T c = T());
 assigns to each element the value of the second argument. Resizing
 invalidates all pointers and references to elements in the array.
 ### `valarray` non-member operations <a id="valarray.nonmembers">[[valarray.nonmembers]]</a>
-#### `valarray` binary operators <a id="valarray.binary">[[valarray.binary]]</a>
 ``` cpp
-template<class T> valarray<T> operator*
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator/
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator%
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator+
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator-
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator^
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator&
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator|
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator<<
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> operator>>
-    (const valarray<T>&, const valarray<T>&);
 ```
-*Requires:* Each of these operators may only be instantiated for a type
-`T` to which the indicated operator can be applied and for which the
-indicated operator returns a value which is of type `T` or which can be
-unambiguously implicitly converted to type `T`. The argument arrays have
-the same length.
 *Returns:* A `valarray` whose length is equal to the lengths of the
 argument arrays. Each element of the returned array is initialized with
 the result of applying the indicated operator to the corresponding
 elements of the argument arrays.
 ``` cpp
-template<class T> valarray<T> operator* (const valarray<T>&, const T&);
-template<class T> valarray<T> operator* (const T&, const valarray<T>&);
-template<class T> valarray<T> operator/ (const valarray<T>&, const T&);
-template<class T> valarray<T> operator/ (const T&, const valarray<T>&);
-template<class T> valarray<T> operator% (const valarray<T>&, const T&);
-template<class T> valarray<T> operator% (const T&, const valarray<T>&);
-template<class T> valarray<T> operator+ (const valarray<T>&, const T&);
-template<class T> valarray<T> operator+ (const T&, const valarray<T>&);
-template<class T> valarray<T> operator- (const valarray<T>&, const T&);
-template<class T> valarray<T> operator- (const T&, const valarray<T>&);
-template<class T> valarray<T> operator^ (const valarray<T>&, const T&);
-template<class T> valarray<T> operator^ (const T&, const valarray<T>&);
-template<class T> valarray<T> operator& (const valarray<T>&, const T&);
-template<class T> valarray<T> operator& (const T&, const valarray<T>&);
-template<class T> valarray<T> operator| (const valarray<T>&, const T&);
-template<class T> valarray<T> operator| (const T&, const valarray<T>&);
-template<class T> valarray<T> operator<<(const valarray<T>&, const T&);
-template<class T> valarray<T> operator<<(const T&, const valarray<T>&);
-template<class T> valarray<T> operator>>(const valarray<T>&, const T&);
-template<class T> valarray<T> operator>>(const T&, const valarray<T>&);
 ```
-*Requires:* Each of these operators may only be instantiated for a type
-`T` to which the indicated operator can be applied and for which the
-indicated operator returns a value which is of type `T` or which can be
-unambiguously implicitly converted to type `T`.
 *Returns:* A `valarray` whose length is equal to the length of the array
 argument. Each element of the returned array is initialized with the
 result of applying the indicated operator to the corresponding element
 of the array argument and the non-array argument.
-#### `valarray` logical operators <a id="valarray.comparison">[[valarray.comparison]]</a>
 ``` cpp
-template<class T> valarray<bool> operator==
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator!=
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator<
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator>
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator<=
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator>=
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator&&
-    (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<bool> operator||
-    (const valarray<T>&, const valarray<T>&);
 ```
-*Requires:* Each of these operators may only be instantiated for a type
-`T` to which the indicated operator can be applied and for which the
-indicated operator returns a value which is of type `bool` or which can
-be unambiguously implicitly converted to type `bool`. The two array
-arguments have the same length.
 *Returns:* A `valarray<bool>` whose length is equal to the length of the
 array arguments. Each element of the returned array is initialized with
 the result of applying the indicated operator to the corresponding
 elements of the argument arrays.
 ``` cpp
-template<class T> valarray<bool> operator==(const valarray<T>&, const T&);
-template<class T> valarray<bool> operator==(const T&, const valarray<T>&);
-template<class T> valarray<bool> operator!=(const valarray<T>&, const T&);
-template<class T> valarray<bool> operator!=(const T&, const valarray<T>&);
-template<class T> valarray<bool> operator< (const valarray<T>&, const T&);
-template<class T> valarray<bool> operator< (const T&, const valarray<T>&);
-template<class T> valarray<bool> operator> (const valarray<T>&, const T&);
-template<class T> valarray<bool> operator> (const T&, const valarray<T>&);
-template<class T> valarray<bool> operator<=(const valarray<T>&, const T&);
-template<class T> valarray<bool> operator<=(const T&, const valarray<T>&);
-template<class T> valarray<bool> operator>=(const valarray<T>&, const T&);
-template<class T> valarray<bool> operator>=(const T&, const valarray<T>&);
-template<class T> valarray<bool> operator&&(const valarray<T>&, const T&);
-template<class T> valarray<bool> operator&&(const T&, const valarray<T>&);
-template<class T> valarray<bool> operator||(const valarray<T>&, const T&);
-template<class T> valarray<bool> operator||(const T&, const valarray<T>&);
 ```
-*Requires:* Each of these operators may only be instantiated for a type
-`T` to which the indicated operator can be applied and for which the
-indicated operator returns a value which is of type `bool` or which can
-be unambiguously implicitly converted to type `bool`.
 *Returns:* A `valarray<bool>` whose length is equal to the length of the
 array argument. Each element of the returned array is initialized with
 the result of applying the indicated operator to the corresponding
 element of the array and the non-array argument.
-#### `valarray` transcendentals <a id="valarray.transcend">[[valarray.transcend]]</a>
 ``` cpp
 template<class T> valarray<T> abs  (const valarray<T>&);
 template<class T> valarray<T> acos (const valarray<T>&);
 template<class T> valarray<T> asin (const valarray<T>&);
 template<class T> valarray<T> atan (const valarray<T>&);
-template<class T> valarray<T> atan2
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> atan2(const valarray<T>&, const T&);
-template<class T> valarray<T> atan2(const T&, const valarray<T>&);
 template<class T> valarray<T> cos  (const valarray<T>&);
 template<class T> valarray<T> cosh (const valarray<T>&);
 template<class T> valarray<T> exp  (const valarray<T>&);
 template<class T> valarray<T> log  (const valarray<T>&);
 template<class T> valarray<T> log10(const valarray<T>&);
-template<class T> valarray<T> pow
- (const valarray<T>&, const valarray<T>&);
-template<class T> valarray<T> pow  (const valarray<T>&, const T&);
-template<class T> valarray<T> pow  (const T&, const valarray<T>&);
 template<class T> valarray<T> sin  (const valarray<T>&);
 template<class T> valarray<T> sinh (const valarray<T>&);
 template<class T> valarray<T> sqrt (const valarray<T>&);
 template<class T> valarray<T> tan  (const valarray<T>&);
 template<class T> valarray<T> tanh (const valarray<T>&);
 ```
-*Requires:* Each of these functions may only be instantiated for a type
-`T` to which a unique function with the indicated name can be applied
-(unqualified). This function shall return a value which is of type `T`
-or which can be unambiguously implicitly converted to type `T`.
-#### `valarray` specialized algorithms <a id="valarray.special">[[valarray.special]]</a>
 ``` cpp
 template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;
 ```
 *Effects:* Equivalent to `x.swap(y)`.
 ### Class `slice` <a id="class.slice">[[class.slice]]</a>
-#### Class `slice` overview <a id="class.slice.overview">[[class.slice.overview]]</a>
 ``` cpp
 namespace std {
   class slice {
   public:
@@ -941,18 +986,20 @@ namespace std {
     slice(size_t, size_t, size_t);
     size_t start() const;
     size_t size() const;
     size_t stride() const;
   };
 }
 ```
 The `slice` class represents a BLAS-like slice from an array. Such a
 slice is specified by a starting index, a length, and a stride.[^12]
-#### `slice` constructors <a id="cons.slice">[[cons.slice]]</a>
 ``` cpp
 slice();
 slice(size_t start, size_t length, size_t stride);
 slice(const slice&);
@@ -962,13 +1009,13 @@ The default constructor is equivalent to `slice(0, 0, 0)`. A default
 constructor is provided only to permit the declaration of arrays of
 slices. The constructor with arguments for a slice takes a start,
 length, and stride parameter.
 [*Example 1*: `slice(3, 8, 2)` constructs a slice which selects
-elements 3, 5, 7, ... 17 from an array. — *end example*]
-#### `slice` access functions <a id="slice.access">[[slice.access]]</a>
 ``` cpp
 size_t start() const;
 size_t size() const;
 size_t stride() const;
@@ -976,13 +1023,25 @@ size_t stride() const;
 *Returns:* The start, length, or stride specified by a `slice` object.
 *Complexity:* Constant time.
 ### Class template `slice_array` <a id="template.slice.array">[[template.slice.array]]</a>
-#### Class template `slice_array` overview <a id="template.slice.array.overview">[[template.slice.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class slice_array {
   public:
@@ -1008,37 +1067,37 @@ namespace std {
     slice_array() = delete;     // as implied by declaring copy constructor above
   };
 }
 ```
-The `slice_array` template is a helper template used by the `slice`
-subscript operator
 ``` cpp
 slice_array<T> valarray<T>::operator[](slice);
 ```
 It has reference semantics to a subset of an array specified by a
 `slice` object.
 [*Example 1*: The expression `a[slice(1, 5, 3)] = b;` has the effect of
 assigning the elements of `b` to a slice of the elements in `a`. For the
-slice shown, the elements selected from `a` are 1, 4, ...,
-13. — *end example*]
-#### `slice_array` assignment <a id="slice.arr.assign">[[slice.arr.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const slice_array& operator=(const slice_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
 `valarray<T>` object to which the `slice_array` object refers.
-#### `slice_array` compound assignment <a id="slice.arr.comp.assign">[[slice.arr.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
@@ -1054,11 +1113,11 @@ void operator>>=(const valarray<T>&) const;
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
 elements of the `valarray<T>` object to which the `slice_array` object
 refers.
-#### `slice_array` fill function <a id="slice.arr.fill">[[slice.arr.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
@@ -1066,11 +1125,11 @@ This function has reference semantics, assigning the value of its
 argument to the elements of the `valarray<T>` object to which the
 `slice_array` object refers.
 ### The `gslice` class <a id="class.gslice">[[class.gslice]]</a>
-#### The `gslice` class overview <a id="class.gslice.overview">[[class.gslice.overview]]</a>
 ``` cpp
 namespace std {
   class gslice {
   public:
@@ -1124,11 +1183,11 @@ If the stride parameters in the previous example are changed to {1, 1,
 — *end example*]
 If a degenerate slice is used as the argument to the non-`const` version
 of `operator[](const gslice&)`, the behavior is undefined.
-#### `gslice` constructors <a id="gslice.cons">[[gslice.cons]]</a>
 ``` cpp
 gslice();
 gslice(size_t start, const valarray<size_t>& lengths,
          const valarray<size_t>& strides);
@@ -1136,13 +1195,13 @@ gslice(const gslice&);
 ```
 The default constructor is equivalent to
 `gslice(0, valarray<size_t>(), valarray<size_t>())`. The constructor
 with arguments builds a `gslice` based on a specification of start,
-lengths, and strides, as explained in the previous section.
-#### `gslice` access functions <a id="gslice.access">[[gslice.access]]</a>
 ``` cpp
 size_t           start()  const;
 valarray<size_t> size() const;
 valarray<size_t> stride() const;
@@ -1154,11 +1213,11 @@ specified for the `gslice`.
 *Complexity:* `start()` is constant time. `size()` and `stride()` are
 linear in the number of strides.
 ### Class template `gslice_array` <a id="template.gslice.array">[[template.gslice.array]]</a>
-#### Class template `gslice_array` overview <a id="template.gslice.array.overview">[[template.gslice.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class gslice_array {
   public:
@@ -1184,36 +1243,34 @@ namespace std {
     gslice_array() = delete;    // as implied by declaring copy constructor above
   };
 }
 ```
-This template is a helper template used by the `slice` subscript
 operator
 ``` cpp
 gslice_array<T> valarray<T>::operator[](const gslice&);
 ```
 It has reference semantics to a subset of an array specified by a
-`gslice` object.
-Thus, the expression `a[gslice(1, length, stride)] = b` has the effect
-of assigning the elements of `b` to a generalized slice of the elements
-in `a`.
-#### `gslice_array` assignment <a id="gslice.array.assign">[[gslice.array.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const gslice_array& operator=(const gslice_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
 `valarray<T>` object to which the `gslice_array` refers.
-#### `gslice_array` compound assignment <a id="gslice.array.comp.assign">[[gslice.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
@@ -1229,11 +1286,11 @@ void operator>>=(const valarray<T>&) const;
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
 elements of the `valarray<T>` object to which the `gslice_array` object
 refers.
-#### `gslice_array` fill function <a id="gslice.array.fill">[[gslice.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
@@ -1241,11 +1298,11 @@ This function has reference semantics, assigning the value of its
 argument to the elements of the `valarray<T>` object to which the
 `gslice_array` object refers.
 ### Class template `mask_array` <a id="template.mask.array">[[template.mask.array]]</a>
-#### Class template `mask_array` overview <a id="template.mask.array.overview">[[template.mask.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class mask_array {
   public:
@@ -1280,24 +1337,24 @@ mask_array<T> valarray<T>::operator[](const valarray<bool>&).
 ```
 It has reference semantics to a subset of an array specified by a
 boolean mask. Thus, the expression `a[mask] = b;` has the effect of
 assigning the elements of `b` to the masked elements in `a` (those for
-which the corresponding element in `mask` is `true`.)
-#### `mask_array` assignment <a id="mask.array.assign">[[mask.array.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const mask_array& operator=(const mask_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
 `valarray<T>` object to which it refers.
-#### `mask_array` compound assignment <a id="mask.array.comp.assign">[[mask.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
@@ -1312,11 +1369,11 @@ void operator>>=(const valarray<T>&) const;
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
 elements of the `valarray<T>` object to which the mask object refers.
-#### `mask_array` fill function <a id="mask.array.fill">[[mask.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
@@ -1324,11 +1381,11 @@ This function has reference semantics, assigning the value of its
 argument to the elements of the `valarray<T>` object to which the
 `mask_array` object refers.
 ### Class template `indirect_array` <a id="template.indirect.array">[[template.indirect.array]]</a>
-#### Class template `indirect_array` overview <a id="template.indirect.array.overview">[[template.indirect.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class indirect_array {
   public:
@@ -1362,15 +1419,15 @@ operator
 ``` cpp
 indirect_array<T> valarray<T>::operator[](const valarray<size_t>&).
 ```
 It has reference semantics to a subset of an array specified by an
-`indirect_array`. Thus the expression `a[indirect] = b;` has the effect
-of assigning the elements of `b` to the elements in `a` whose indices
-appear in `indirect`.
-#### `indirect_array` assignment <a id="indirect.array.assign">[[indirect.array.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const indirect_array& operator=(const indirect_array&) const;
 ```
@@ -1394,11 +1451,11 @@ a[indirect] = b;
 results in undefined behavior since element 4 is specified twice in the
 indirection.
 — *end example*]
-#### `indirect_array` compound assignment <a id="indirect.array.comp.assign">[[indirect.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
@@ -1417,11 +1474,11 @@ elements of the `valarray<T>` object to which the `indirect_array`
 object refers.
 If the `indirect_array` specifies an element in the `valarray<T>` object
 to which it refers more than once, the behavior is undefined.
-#### `indirect_array` fill function <a id="indirect.array.fill">[[indirect.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
@@ -1430,22 +1487,22 @@ argument to the elements of the `valarray<T>` object to which the
 `indirect_array` object refers.
 ### `valarray` range access <a id="valarray.range">[[valarray.range]]</a>
 In the `begin` and `end` function templates that follow, *unspecified*1
-is a type that meets the requirements of a mutable random access
-iterator ([[random.access.iterators]]) and of a contiguous iterator (
-[[iterator.requirements.general]]) whose `value_type` is the template
-parameter `T` and whose `reference` type is `T&`. *unspecified*2 is a
-type that meets the requirements of a constant random access iterator (
-[[random.access.iterators]]) and of a contiguous iterator (
-[[iterator.requirements.general]]) whose `value_type` is the template
-parameter `T` and whose `reference` type is `const T&`.
 The iterators returned by `begin` and `end` for an array are guaranteed
-to be valid until the member function `resize(size_t, T)` (
-[[valarray.members]]) is called for that array or until the lifetime of
 that array ends, whichever happens first.
 ``` cpp
 template<class T> unspecified{1} begin(valarray<T>& v);
 template<class T> unspecified{2} begin(const valarray<T>& v);

   template<class T> class indirect_array;   // an indirected array
   template<class T> void swap(valarray<T>&, valarray<T>&) noexcept;
   template<class T> valarray<T> operator* (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator* (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator* (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator/ (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator/ (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator/ (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator% (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator% (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator% (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator+ (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator+ (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator+ (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator- (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator- (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator- (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator^ (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator^ (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator^ (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator& (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator& (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator& (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator| (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator| (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator| (const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator<<(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator<<(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator<<(const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<T> operator>>(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> operator>>(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> operator>>(const typename valarray<T>::value_type&,
+                                           const valarray<T>&);
   template<class T> valarray<bool> operator&&(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator&&(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator&&(const typename valarray<T>::value_type&,
+                                              const valarray<T>&);
   template<class T> valarray<bool> operator||(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator||(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator||(const typename valarray<T>::value_type&,
+                                              const valarray<T>&);
+  template<class T> valarray<bool> operator==(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator==(const valarray<T>&,
+                                              const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator==(const typename valarray<T>::value_type&,
+                                              const valarray<T>&);
+  template<class T> valarray<bool> operator!=(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator!=(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator!=(const typename valarray<T>::value_type&,
+                                              const valarray<T>&);
+  template<class T> valarray<bool> operator< (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator< (const valarray<T>&,
+                                              const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator< (const typename valarray<T>::value_type&,
+                                              const valarray<T>&);
+  template<class T> valarray<bool> operator> (const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator> (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator> (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+  template<class T> valarray<bool> operator<=(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator<=(const valarray<T>&,
+                                              const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator<=(const typename valarray<T>::value_type&,
+ const valarray<T>&);
+  template<class T> valarray<bool> operator>=(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<bool> operator>=(const valarray<T>&,
+                                              const typename valarray<T>::value_type&);
+  template<class T> valarray<bool> operator>=(const typename valarray<T>::value_type&,
+                                              const valarray<T>&);
   template<class T> valarray<T> abs  (const valarray<T>&);
   template<class T> valarray<T> acos (const valarray<T>&);
   template<class T> valarray<T> asin (const valarray<T>&);
   template<class T> valarray<T> atan (const valarray<T>&);
   template<class T> valarray<T> atan2(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> atan2(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+  template<class T> valarray<T> atan2(const typename valarray<T>::value_type&,
+                                      const valarray<T>&);
   template<class T> valarray<T> cos  (const valarray<T>&);
   template<class T> valarray<T> cosh (const valarray<T>&);
   template<class T> valarray<T> exp  (const valarray<T>&);
   template<class T> valarray<T> log  (const valarray<T>&);
   template<class T> valarray<T> log10(const valarray<T>&);
   template<class T> valarray<T> pow(const valarray<T>&, const valarray<T>&);
+  template<class T> valarray<T> pow(const valarray<T>&, const typename valarray<T>::value_type&);
+  template<class T> valarray<T> pow(const typename valarray<T>::value_type&, const valarray<T>&);
   template<class T> valarray<T> sin  (const valarray<T>&);
   template<class T> valarray<T> sinh (const valarray<T>&);
   template<class T> valarray<T> sqrt (const valarray<T>&);
   template<class T> valarray<T> tan  (const valarray<T>&);
 Implementations introducing such replacement types shall provide
 additional functions and operators as follows:
 - for every function taking a `const valarray<T>&` other than `begin`
+  and `end` [[valarray.range]], identical functions taking the
   replacement types shall be added;
 - for every function taking two `const valarray<T>&` arguments,
   identical functions taking every combination of `const valarray<T>&`
   and replacement types shall be added.
 In particular, an implementation shall allow a `valarray<T>` to be
 constructed from such replacement types and shall allow assignments and
 compound assignments of such types to `valarray<T>`, `slice_array<T>`,
 `gslice_array<T>`, `mask_array<T>` and `indirect_array<T>` objects.
+These library functions are permitted to throw a `bad_alloc`
+[[bad.alloc]] exception if there are not sufficient resources available
 to carry out the operation. Note that the exception is not mandated.
 ### Class template `valarray` <a id="template.valarray">[[template.valarray]]</a>
+#### Overview <a id="template.valarray.overview">[[template.valarray.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class valarray {
   public:
 remainder of  [[numarray]]. The illusion of higher dimensionality may be
 produced by the familiar idiom of computed indices, together with the
 powerful subsetting capabilities provided by the generalized subscript
 operators.[^8]
+#### Constructors <a id="valarray.cons">[[valarray.cons]]</a>
 ``` cpp
 valarray();
 ```
 ``` cpp
 explicit valarray(size_t n);
 ```
 *Effects:* Constructs a `valarray` that has length `n`. Each element of
+the array is value-initialized [[dcl.init]].
 ``` cpp
 valarray(const T& v, size_t n);
 ```
 ``` cpp
 valarray(const T* p, size_t n);
 ```
+*Preconditions:* \[`p`, `p + n`) is a valid range.
 *Effects:* Constructs a `valarray` that has length `n`. The values of
 the elements of the array are initialized with the first `n` values
 pointed to by the first argument.[^10]
 ```
 *Effects:* The destructor is applied to every element of `*this`; an
 implementation may return all allocated memory.
+#### Assignment <a id="valarray.assign">[[valarray.assign]]</a>
 ``` cpp
 valarray& operator=(const valarray& v);
 ```
 the corresponding element of `v`. If the length of `v` is not equal to
 the length of `*this`, resizes `*this` to make the two arrays the same
 length, as if by calling `resize(v.size())`, before performing the
 assignment.
+*Ensures:* `size() == v.size()`.
 *Returns:* `*this`.
 ``` cpp
 valarray& operator=(valarray&& v) noexcept;
 valarray& operator=(const gslice_array<T>&);
 valarray& operator=(const mask_array<T>&);
 valarray& operator=(const indirect_array<T>&);
 ```
+*Preconditions:* The length of the array to which the argument refers
+equals `size()`. The value of an element in the left-hand side of a
+`valarray` assignment operator does not depend on the value of another
+element in that left-hand side.
 These operators allow the results of a generalized subscripting
 operation to be assigned directly to a `valarray`.
+#### Element access <a id="valarray.access">[[valarray.access]]</a>
 ``` cpp
 const T&  operator[](size_t n) const;
 T& operator[](size_t n);
 ```
+*Preconditions:* `n < size()` is `true`.
 *Returns:* A reference to the corresponding element of the array.
 [*Note 1*: The expression `(a[i] = q, a[i]) == q` evaluates to `true`
 for any non-constant `valarray<T> a`, any `T q`, and for any `size_t i`
 such that the value of `i` is less than the length of
 `a`. — *end note*]
+*Remarks:* The expression `addressof(a[i+j]) == addressof(a[i]) + j`
+evaluates to `true` for all `size_t i` and `size_t j` such that
+`i+j < a.size()`.
+The expression `addressof(a[i]) != addressof(b[j])` evaluates to `true`
+for any two arrays `a` and `b` and for any `size_t i` and `size_t j`
+such that `i < a.size()` and `j < b.size()`.
 [*Note 2*: This property indicates an absence of aliasing and may be
 used to advantage by optimizing compilers. Compilers may take advantage
 of inlining, constant propagation, loop fusion, tracking of pointers
 obtained from `operator new`, and other techniques to generate efficient
 `valarray`s. — *end note*]
 The reference returned by the subscript operator for an array shall be
+valid until the member function `resize(size_t, T)` [[valarray.members]]
+is called for that array or until the lifetime of that array ends,
+whichever happens first.
+#### Subset operations <a id="valarray.sub">[[valarray.sub]]</a>
 The member `operator[]` is overloaded to provide several ways to select
 sequences of elements from among those controlled by `*this`. Each of
 these operations returns a subset of the array. The const-qualified
 versions return this subset as a new `valarray` object. The non-const
 versions return a class template object which has reference semantics to
 the original array, working in conjunction with various overloads of
 `operator=` and other assigning operators to allow selective replacement
 (slicing) of the controlled sequence. In each case the selected
+element(s) shall exist.
 ``` cpp
 valarray operator[](slice slicearr) const;
 ```
 // v0 == valarray<char>("abCDeBgAEjklmnop", 16)
 ```
 — *end example*]
+#### Unary operators <a id="valarray.unary">[[valarray.unary]]</a>
 ``` cpp
 valarray operator+() const;
 valarray operator-() const;
 valarray operator~() const;
 valarray<bool> operator!() const;
 ```
+*Mandates:* The indicated operator can be applied to operands of type
+`T` and returns a value of type `T` (`bool` for `operator!`) or which
+may be unambiguously implicitly converted to type `T` (`bool` for
+`operator!`).
 *Returns:* A `valarray` whose length is `size()`. Each element of the
 returned array is initialized with the result of applying the indicated
 operator to the corresponding element of the array.
+#### Compound assignment <a id="valarray.cassign">[[valarray.cassign]]</a>
 ``` cpp
 valarray& operator*= (const valarray& v);
 valarray& operator/= (const valarray& v);
 valarray& operator%= (const valarray& v);
 valarray& operator|= (const valarray& v);
 valarray& operator<<=(const valarray& v);
 valarray& operator>>=(const valarray& v);
 ```
+*Mandates:* The indicated operator can be applied to two operands of
+type `T`.
+*Preconditions:* `size() == v.size()` is `true`.
+The value of an element in the left-hand side of a valarray compound
+assignment operator does not depend on the value of another element in
+that left hand side.
 *Effects:* Each of these operators performs the indicated operation on
 each of the elements of `*this` and the corresponding element of `v`.
 *Returns:* `*this`.
 valarray& operator|= (const T& v);
 valarray& operator<<=(const T& v);
 valarray& operator>>=(const T& v);
 ```
+*Mandates:* The indicated operator can be applied to two operands of
+type `T`.
 *Effects:* Each of these operators applies the indicated operation to
 each element of `*this` and `v`.
 *Returns:* `*this`
 *Remarks:* The appearance of an array on the left-hand side of a
 compound assignment does not invalidate references or pointers to the
 elements of the array.
+#### Member functions <a id="valarray.members">[[valarray.members]]</a>
 ``` cpp
 void swap(valarray& v) noexcept;
 ```
 ``` cpp
 T sum() const;
 ```
+*Mandates:* `operator+=` can be applied to operands of type `T`.
+*Preconditions:* `size() > 0` is `true`.
 *Returns:* The sum of all the elements of the array. If the array has
 length 1, returns the value of element 0. Otherwise, the returned value
 is calculated by applying `operator+=` to a copy of an element of the
 array and all other elements of the array in an unspecified order.
 ``` cpp
 T min() const;
 ```
+*Preconditions:* `size() > 0` is `true`.
 *Returns:* The minimum value contained in `*this`. For an array of
 length 1, the value of element 0 is returned. For all other array
 lengths, the determination is made using `operator<`.
 ``` cpp
 T max() const;
 ```
+*Preconditions:* `size() > 0` is `true`.
 *Returns:* The maximum value contained in `*this`. For an array of
 length 1, the value of element 0 is returned. For all other array
 lengths, the determination is made using `operator<`.
 [*Note 1*: If element zero is taken as the leftmost element, a positive
 value of `n` shifts the elements left `n` places, with zero
 fill. — *end note*]
 [*Example 1*: If the argument has the value -2, the first two elements
+of the result will be value-initialized [[dcl.init]]; the third element
+of the result will be assigned the value of the first element of the
+argument; etc. — *end example*]
 ``` cpp
 valarray cshift(int n) const;
 ```
 assigns to each element the value of the second argument. Resizing
 invalidates all pointers and references to elements in the array.
 ### `valarray` non-member operations <a id="valarray.nonmembers">[[valarray.nonmembers]]</a>
+#### Binary operators <a id="valarray.binary">[[valarray.binary]]</a>
 ``` cpp
+template<class T> valarray<T> operator* (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator/ (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator% (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator+ (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator- (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator^ (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator& (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator| (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator<<(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> operator>>(const valarray<T>&, const valarray<T>&);
 ```
+*Mandates:* The indicated operator can be applied to operands of type
+`T` and returns a value of type `T` or which can be unambiguously
+implicitly converted to `T`.
+*Preconditions:* The argument arrays have the same length.
 *Returns:* A `valarray` whose length is equal to the lengths of the
 argument arrays. Each element of the returned array is initialized with
 the result of applying the indicated operator to the corresponding
 elements of the argument arrays.
 ``` cpp
+template<class T> valarray<T> operator* (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator* (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<T> operator/ (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator/ (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<T> operator% (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator% (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<T> operator+ (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator+ (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<T> operator- (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator- (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<T> operator^ (const valarray<T>&,
+                                         const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator^ (const typename valarray<T>::value_type&,
+                                         const valarray<T>&);
+template<class T> valarray<T> operator& (const valarray<T>&,
+                                         const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator& (const typename valarray<T>::value_type&,
+                                         const valarray<T>&);
+template<class T> valarray<T> operator| (const valarray<T>&,
+                                         const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator| (const typename valarray<T>::value_type&,
+                                         const valarray<T>&);
+template<class T> valarray<T> operator<<(const valarray<T>&,
+                                         const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator<<(const typename valarray<T>::value_type&,
+                                         const valarray<T>&);
+template<class T> valarray<T> operator>>(const valarray<T>&,
+                                         const typename valarray<T>::value_type&);
+template<class T> valarray<T> operator>>(const typename valarray<T>::value_type&,
+                                         const valarray<T>&);
 ```
+*Mandates:* The indicated operator can be applied to operands of type
+`T` and returns a value of type `T` or which can be unambiguously
+implicitly converted to `T`.
 *Returns:* A `valarray` whose length is equal to the length of the array
 argument. Each element of the returned array is initialized with the
 result of applying the indicated operator to the corresponding element
 of the array argument and the non-array argument.
+#### Logical operators <a id="valarray.comparison">[[valarray.comparison]]</a>
 ``` cpp
+template<class T> valarray<bool> operator==(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator!=(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator< (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator> (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator<=(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator>=(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator&&(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<bool> operator||(const valarray<T>&, const valarray<T>&);
 ```
+*Mandates:* The indicated operator can be applied to operands of type
+`T` and returns a value of type `bool` or which can be unambiguously
+implicitly converted to `bool`.
+*Preconditions:* The two array arguments have the same length.
 *Returns:* A `valarray<bool>` whose length is equal to the length of the
 array arguments. Each element of the returned array is initialized with
 the result of applying the indicated operator to the corresponding
 elements of the argument arrays.
 ``` cpp
+template<class T> valarray<bool> operator==(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator==(const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<bool> operator!=(const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator!=(const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<bool> operator< (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator< (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<bool> operator> (const valarray<T>&,
+ const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator> (const typename valarray<T>::value_type&,
+ const valarray<T>&);
+template<class T> valarray<bool> operator<=(const valarray<T>&,
+                                            const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator<=(const typename valarray<T>::value_type&,
+                                            const valarray<T>&);
+template<class T> valarray<bool> operator>=(const valarray<T>&,
+                                            const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator>=(const typename valarray<T>::value_type&,
+                                            const valarray<T>&);
+template<class T> valarray<bool> operator&&(const valarray<T>&,
+                                            const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator&&(const typename valarray<T>::value_type&,
+                                            const valarray<T>&);
+template<class T> valarray<bool> operator||(const valarray<T>&,
+                                            const typename valarray<T>::value_type&);
+template<class T> valarray<bool> operator||(const typename valarray<T>::value_type&,
+                                            const valarray<T>&);
 ```
+*Mandates:* The indicated operator can be applied to operands of type
+`T` and returns a value of type `bool` or which can be unambiguously
+implicitly converted to `bool`.
 *Returns:* A `valarray<bool>` whose length is equal to the length of the
 array argument. Each element of the returned array is initialized with
 the result of applying the indicated operator to the corresponding
 element of the array and the non-array argument.
+#### Transcendentals <a id="valarray.transcend">[[valarray.transcend]]</a>
 ``` cpp
 template<class T> valarray<T> abs  (const valarray<T>&);
 template<class T> valarray<T> acos (const valarray<T>&);
 template<class T> valarray<T> asin (const valarray<T>&);
 template<class T> valarray<T> atan (const valarray<T>&);
+template<class T> valarray<T> atan2(const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> atan2(const valarray<T>&, const typename valarray<T>::value_type&);
+template<class T> valarray<T> atan2(const typename valarray<T>::value_type&, const valarray<T>&);
 template<class T> valarray<T> cos  (const valarray<T>&);
 template<class T> valarray<T> cosh (const valarray<T>&);
 template<class T> valarray<T> exp  (const valarray<T>&);
 template<class T> valarray<T> log  (const valarray<T>&);
 template<class T> valarray<T> log10(const valarray<T>&);
+template<class T> valarray<T> pow  (const valarray<T>&, const valarray<T>&);
+template<class T> valarray<T> pow  (const valarray<T>&, const typename valarray<T>::value_type&);
+template<class T> valarray<T> pow  (const typename valarray<T>::value_type&, const valarray<T>&);
 template<class T> valarray<T> sin  (const valarray<T>&);
 template<class T> valarray<T> sinh (const valarray<T>&);
 template<class T> valarray<T> sqrt (const valarray<T>&);
 template<class T> valarray<T> tan  (const valarray<T>&);
 template<class T> valarray<T> tanh (const valarray<T>&);
 ```
+*Mandates:* A unique function with the indicated name can be applied
+(unqualified) to an operand of type `T`. This function returns a value
+of type `T` or which can be unambiguously implicitly converted to type
+`T`.
+#### Specialized algorithms <a id="valarray.special">[[valarray.special]]</a>
 ``` cpp
 template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;
 ```
 *Effects:* Equivalent to `x.swap(y)`.
 ### Class `slice` <a id="class.slice">[[class.slice]]</a>
+#### Overview <a id="class.slice.overview">[[class.slice.overview]]</a>
 ``` cpp
 namespace std {
   class slice {
   public:
     slice(size_t, size_t, size_t);
     size_t start() const;
     size_t size() const;
     size_t stride() const;
+    friend bool operator==(const slice& x, const slice& y);
   };
 }
 ```
 The `slice` class represents a BLAS-like slice from an array. Such a
 slice is specified by a starting index, a length, and a stride.[^12]
+#### Constructors <a id="cons.slice">[[cons.slice]]</a>
 ``` cpp
 slice();
 slice(size_t start, size_t length, size_t stride);
 slice(const slice&);
 constructor is provided only to permit the declaration of arrays of
 slices. The constructor with arguments for a slice takes a start,
 length, and stride parameter.
 [*Example 1*: `slice(3, 8, 2)` constructs a slice which selects
+elements 3, 5, 7, …, 17 from an array. — *end example*]
+#### Access functions <a id="slice.access">[[slice.access]]</a>
 ``` cpp
 size_t start() const;
 size_t size() const;
 size_t stride() const;
 *Returns:* The start, length, or stride specified by a `slice` object.
 *Complexity:* Constant time.
+#### Operators <a id="slice.ops">[[slice.ops]]</a>
+``` cpp
+friend bool operator==(const slice& x, const slice& y);
+```
+*Effects:* Equivalent to:
+``` cpp
+return x.start() == y.start() && x.size() == y.size() && x.stride() == y.stride();
+```
 ### Class template `slice_array` <a id="template.slice.array">[[template.slice.array]]</a>
+#### Overview <a id="template.slice.array.overview">[[template.slice.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class slice_array {
   public:
     slice_array() = delete;     // as implied by declaring copy constructor above
   };
 }
 ```
+This template is a helper template used by the `slice` subscript
+operator
 ``` cpp
 slice_array<T> valarray<T>::operator[](slice);
 ```
 It has reference semantics to a subset of an array specified by a
 `slice` object.
 [*Example 1*: The expression `a[slice(1, 5, 3)] = b;` has the effect of
 assigning the elements of `b` to a slice of the elements in `a`. For the
+slice shown, the elements selected from `a` are
+1, 4, …, 13. — *end example*]
+#### Assignment <a id="slice.arr.assign">[[slice.arr.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const slice_array& operator=(const slice_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
 `valarray<T>` object to which the `slice_array` object refers.
+#### Compound assignment <a id="slice.arr.comp.assign">[[slice.arr.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
 elements of the `valarray<T>` object to which the `slice_array` object
 refers.
+#### Fill function <a id="slice.arr.fill">[[slice.arr.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
 argument to the elements of the `valarray<T>` object to which the
 `slice_array` object refers.
 ### The `gslice` class <a id="class.gslice">[[class.gslice]]</a>
+#### Overview <a id="class.gslice.overview">[[class.gslice.overview]]</a>
 ``` cpp
 namespace std {
   class gslice {
   public:
 — *end example*]
 If a degenerate slice is used as the argument to the non-`const` version
 of `operator[](const gslice&)`, the behavior is undefined.
+#### Constructors <a id="gslice.cons">[[gslice.cons]]</a>
 ``` cpp
 gslice();
 gslice(size_t start, const valarray<size_t>& lengths,
          const valarray<size_t>& strides);
 ```
 The default constructor is equivalent to
 `gslice(0, valarray<size_t>(), valarray<size_t>())`. The constructor
 with arguments builds a `gslice` based on a specification of start,
+lengths, and strides, as explained in the previous subclause.
+#### Access functions <a id="gslice.access">[[gslice.access]]</a>
 ``` cpp
 size_t           start()  const;
 valarray<size_t> size() const;
 valarray<size_t> stride() const;
 *Complexity:* `start()` is constant time. `size()` and `stride()` are
 linear in the number of strides.
 ### Class template `gslice_array` <a id="template.gslice.array">[[template.gslice.array]]</a>
+#### Overview <a id="template.gslice.array.overview">[[template.gslice.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class gslice_array {
   public:
     gslice_array() = delete;    // as implied by declaring copy constructor above
   };
 }
 ```
+This template is a helper template used by the `gslice` subscript
 operator
 ``` cpp
 gslice_array<T> valarray<T>::operator[](const gslice&);
 ```
 It has reference semantics to a subset of an array specified by a
+`gslice` object. Thus, the expression `a[gslice(1, length, stride)] = b`
+has the effect of assigning the elements of `b` to a generalized slice
+of the elements in `a`.
+#### Assignment <a id="gslice.array.assign">[[gslice.array.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const gslice_array& operator=(const gslice_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
 `valarray<T>` object to which the `gslice_array` refers.
+#### Compound assignment <a id="gslice.array.comp.assign">[[gslice.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
 elements of the `valarray<T>` object to which the `gslice_array` object
 refers.
+#### Fill function <a id="gslice.array.fill">[[gslice.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
 argument to the elements of the `valarray<T>` object to which the
 `gslice_array` object refers.
 ### Class template `mask_array` <a id="template.mask.array">[[template.mask.array]]</a>
+#### Overview <a id="template.mask.array.overview">[[template.mask.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class mask_array {
   public:
 ```
 It has reference semantics to a subset of an array specified by a
 boolean mask. Thus, the expression `a[mask] = b;` has the effect of
 assigning the elements of `b` to the masked elements in `a` (those for
+which the corresponding element in `mask` is `true`).
+#### Assignment <a id="mask.array.assign">[[mask.array.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const mask_array& operator=(const mask_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
 `valarray<T>` object to which it refers.
+#### Compound assignment <a id="mask.array.comp.assign">[[mask.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
 elements of the `valarray<T>` object to which the mask object refers.
+#### Fill function <a id="mask.array.fill">[[mask.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
 argument to the elements of the `valarray<T>` object to which the
 `mask_array` object refers.
 ### Class template `indirect_array` <a id="template.indirect.array">[[template.indirect.array]]</a>
+#### Overview <a id="template.indirect.array.overview">[[template.indirect.array.overview]]</a>
 ``` cpp
 namespace std {
   template<class T> class indirect_array {
   public:
 ``` cpp
 indirect_array<T> valarray<T>::operator[](const valarray<size_t>&).
 ```
 It has reference semantics to a subset of an array specified by an
+`indirect_array`. Thus, the expression `a[{}indirect] = b;` has the
+effect of assigning the elements of `b` to the elements in `a` whose
+indices appear in `indirect`.
+#### Assignment <a id="indirect.array.assign">[[indirect.array.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
 const indirect_array& operator=(const indirect_array&) const;
 ```
 results in undefined behavior since element 4 is specified twice in the
 indirection.
 — *end example*]
+#### Compound assignment <a id="indirect.array.comp.assign">[[indirect.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator/= (const valarray<T>&) const;
 void operator%= (const valarray<T>&) const;
 object refers.
 If the `indirect_array` specifies an element in the `valarray<T>` object
 to which it refers more than once, the behavior is undefined.
+#### Fill function <a id="indirect.array.fill">[[indirect.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 ```
 `indirect_array` object refers.
 ### `valarray` range access <a id="valarray.range">[[valarray.range]]</a>
 In the `begin` and `end` function templates that follow, *unspecified*1
+is a type that meets the requirements of a mutable
+*Cpp17RandomAccessIterator* [[random.access.iterators]] and models
+`contiguous_iterator` [[iterator.concept.contiguous]], whose
+`value_type` is the template parameter `T` and whose `reference` type is
+`T&`. *unspecified*2 is a type that meets the requirements of a constant
+*Cpp17RandomAccessIterator* and models `contiguous_iterator`, whose
+`value_type` is the template parameter `T` and whose `reference` type is
+`const T&`.
 The iterators returned by `begin` and `end` for an array are guaranteed
+to be valid until the member function `resize(size_t, T)`
+[[valarray.members]] is called for that array or until the lifetime of
 that array ends, whichever happens first.
 ``` cpp
 template<class T> unspecified{1} begin(valarray<T>& v);
 template<class T> unspecified{2} begin(const valarray<T>& v);

Diff to HTML by rtfpessoa