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

Files changed (1) hide show

tmp/tmp7t8cthle/{from.md → to.md} +346 -278

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

@@ -4,11 +4,10 @@
 ``` cpp
 #include <initializer_list>
 namespace std {
   template<class T> class valarray;         // An array of type T
   class slice;                              // a BLAS-like slice out of an array
   template<class T> class slice_array;
   class gslice;                             // a generalized slice out of an array
   template<class T> class gslice_array;
@@ -147,11 +146,11 @@ additional functions and operators as follows:
   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
-computed 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.
@@ -162,13 +161,13 @@ to carry out the operation. Note that the exception is not mandated.
 ``` cpp
 namespace std {
   template<class T> class valarray {
   public:
- typedef T value_type;
-    // [valarray.cons] construct/destroy:
     valarray();
     explicit valarray(size_t);
     valarray(const T&, size_t);
     valarray(const T*, size_t);
     valarray(const valarray&);
@@ -178,149 +177,151 @@ namespace std {
     valarray(const mask_array<T>&);
     valarray(const indirect_array<T>&);
     valarray(initializer_list<T>);
     ~valarray();
-    // [valarray.assign] assignment:
-    valarray<T>& operator=(const valarray<T>&);
-    valarray<T>& operator=(valarray<T>&&) noexcept;
     valarray& operator=(initializer_list<T>);
-    valarray<T>& operator=(const T&);
-    valarray<T>& operator=(const slice_array<T>&);
-    valarray<T>& operator=(const gslice_array<T>&);
-    valarray<T>& operator=(const mask_array<T>&);
-    valarray<T>& operator=(const indirect_array<T>&);
-    // [valarray.access] element access:
     const T&          operator[](size_t) const;
     T&                operator[](size_t);
-    // [valarray.sub] subset operations:
-    valarray<T>       operator[](slice) const;
     slice_array<T>    operator[](slice);
-    valarray<T>       operator[](const gslice&) const;
     gslice_array<T>   operator[](const gslice&);
-    valarray<T>       operator[](const valarray<bool>&) const;
     mask_array<T>     operator[](const valarray<bool>&);
-    valarray<T>       operator[](const valarray<size_t>&) const;
     indirect_array<T> operator[](const valarray<size_t>&);
-    // [valarray.unary] unary operators:
-    valarray<T> operator+() const;
-    valarray<T> operator-() const;
-    valarray<T> operator~() const;
     valarray<bool> operator!() const;
-    // [valarray.cassign] computed assignment:
-    valarray<T>& operator*= (const T&);
-    valarray<T>& operator/= (const T&);
-    valarray<T>& operator%= (const T&);
-    valarray<T>& operator+= (const T&);
-    valarray<T>& operator-= (const T&);
-    valarray<T>& operator^= (const T&);
-    valarray<T>& operator&= (const T&);
-    valarray<T>& operator|= (const T&);
-    valarray<T>& operator<<=(const T&);
-    valarray<T>& operator>>=(const T&);
-    valarray<T>& operator*= (const valarray<T>&);
-    valarray<T>& operator/= (const valarray<T>&);
-    valarray<T>& operator%= (const valarray<T>&);
-    valarray<T>& operator+= (const valarray<T>&);
-    valarray<T>& operator-= (const valarray<T>&);
-    valarray<T>& operator^= (const valarray<T>&);
-    valarray<T>& operator|= (const valarray<T>&);
-    valarray<T>& operator&= (const valarray<T>&);
-    valarray<T>& operator<<=(const valarray<T>&);
-    valarray<T>& operator>>=(const valarray<T>&);
-    // [valarray.members] member functions:
     void swap(valarray&) noexcept;
     size_t size() const;
     T sum() const;
     T min() const;
     T max() const;
-    valarray<T> shift (int) const;
-    valarray<T> cshift(int) const;
-    valarray<T> apply(T func(T)) const;
-    valarray<T> apply(T func(const T&)) const;
     void resize(size_t sz, T c = T());
   };
 }
 ```
 The class template `valarray<T>` is a one-dimensional smart array, with
 elements numbered sequentially from zero. It is a representation of the
-mathematical concept of an ordered set of values. 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();
 ```
-*Effects:* Constructs an object of class `valarray<T>`[^9] which has
-zero length.[^10]
 ``` cpp
-explicit valarray(size_t);
 ```
-The array created by this constructor has a length equal to the value of
-the argument. The elements of the array are
-value-initialized ([[dcl.init]]).
 ``` cpp
-valarray(const T&, size_t);
 ```
-The array created by this constructor has a length equal to the second
-argument. The elements of the array are initialized with the value of
-the first argument.
 ``` cpp
-valarray(const T*, size_t);
 ```
-The array created by this constructor has a length equal to the second
-argument `n`. The values of the elements of the array are initialized
-with the first `n` values pointed to by the first argument.[^11] If the
-value of the second argument is greater than the number of values
-pointed to by the first argument, the behavior is undefined.
 ``` cpp
-valarray(const valarray<T>&);
 ```
-The array created by this constructor has the same length as the
-argument array. The elements are initialized with the values of the
-corresponding elements of the argument array.[^12]
 ``` cpp
-valarray(valarray<T>&& v) noexcept;
 ```
-The array created by this constructor has the same length as the
-argument array. The elements are initialized with the values of the
-corresponding elements of the argument array.
 *Complexity:* Constant.
 ``` cpp
 valarray(initializer_list<T> il);
 ```
-*Effects:* Same as `valarray(il.begin(), il.size())`.
 ``` cpp
 valarray(const slice_array<T>&);
 valarray(const gslice_array<T>&);
 valarray(const mask_array<T>&);
@@ -332,101 +333,103 @@ templates to a `valarray`.
 ``` cpp
 ~valarray();
 ```
-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<T>& operator=(const valarray<T>& v);
 ```
-Each element of the `*this` array is assigned the value of the
-corresponding element of the argument array. 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.
-`size() == v.size()`.
 ``` 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);
 ```
-*Effects:* `*this = valarray(il)`.
-*Returns:* `*this`.
 ``` cpp
-valarray<T>& operator=(const T&);
 ```
-The scalar assignment operator causes each element of the `*this` array
-to be assigned the value of the argument.
 ``` cpp
-valarray<T>& operator=(const slice_array<T>&);
-valarray<T>& operator=(const gslice_array<T>&);
-valarray<T>& operator=(const mask_array<T>&);
-valarray<T>& operator=(const indirect_array<T>&);
 ```
 *Requires:* The length of the array to which the argument refers equals
-`size()`.
 These operators allow the results of a generalized subscripting
 operation to be assigned directly to a `valarray`.
-If the value of an element in the left-hand side of a valarray
-assignment operator depends on the value of another element in that
-left-hand side, the resulting behavior is undefined.
 #### `valarray` element access <a id="valarray.access">[[valarray.access]]</a>
 ``` cpp
-const T&  operator[](size_t) const;
-T& operator[](size_t);
 ```
-The subscript operator returns a reference to the corresponding element
-of the array.
-Thus, the expression `(a[i] = q, a[i]) == q` evaluates as 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`.
-The expression `&a[i+j] == &a[i] + j` evaluates as true for all
-`size_t i` and `size_t j` such that `i+j` is less than the length of the
-array `a`.
-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 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
-undefined.
 #### `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
@@ -436,200 +439,231 @@ 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<T> operator[](slice slicearr) const;
 ```
-*Returns:* An object of class `valarray<T>` containing those elements of
-the controlled sequence designated by `slicearr`.
 ``` cpp
 const valarray<char> v0("abcdefghijklmnop", 16);
 // v0[slice(2, 5, 3)] returns valarray<char>("cfilo", 5)
 ```
 ``` cpp
 slice_array<T> operator[](slice slicearr);
 ```
 *Returns:* An object that holds references to elements of the controlled
 sequence selected by `slicearr`.
 ``` cpp
 valarray<char> v0("abcdefghijklmnop", 16);
 valarray<char> v1("ABCDE", 5);
 v0[slice(2, 5, 3)] = v1;
 // v0 == valarray<char>("abAdeBghCjkDmnEp", 16);
 ```
 ``` cpp
-valarray<T> operator[](const gslice& gslicearr) const;
 ```
-*Returns:* An object of class `valarray<T>` containing those elements of
-the controlled sequence designated by `gslicearr`.
 ``` cpp
 const valarray<char> v0("abcdefghijklmnop", 16);
 const size_t lv[] = { 2, 3 };
 const size_t dv[] = { 7, 2 };
 const valarray<size_t> len(lv, 2), str(dv, 2);
 // v0[gslice(3, len, str)] returns
 // valarray<char>("dfhkmo", 6)
 ```
 ``` cpp
 gslice_array<T> operator[](const gslice& gslicearr);
 ```
 *Returns:* An object that holds references to elements of the controlled
 sequence selected by `gslicearr`.
 ``` cpp
 valarray<char> v0("abcdefghijklmnop", 16);
-valarray<char> v1("ABCDE", 5);
 const size_t lv[] = { 2, 3 };
 const size_t dv[] = { 7, 2 };
 const valarray<size_t> len(lv, 2), str(dv, 2);
 v0[gslice(3, len, str)] = v1;
 // v0 == valarray<char>("abcAeBgCijDlEnFp", 16)
 ```
 ``` cpp
-valarray<T> operator[](const valarray<bool>& boolarr) const;
 ```
-*Returns:* An object of class `valarray<T>` containing those elements of
-the controlled sequence designated by `boolarr`.
 ``` cpp
 const valarray<char> v0("abcdefghijklmnop", 16);
 const bool vb[] = { false, false, true, true, false, true };
 // v0[valarray<bool>(vb, 6)] returns
 // valarray<char>("cdf", 3)
 ```
 ``` cpp
 mask_array<T> operator[](const valarray<bool>& boolarr);
 ```
 *Returns:* An object that holds references to elements of the controlled
 sequence selected by `boolarr`.
 ``` cpp
 valarray<char> v0("abcdefghijklmnop", 16);
 valarray<char> v1("ABC", 3);
 const bool vb[] = { false, false, true, true, false, true };
 v0[valarray<bool>(vb, 6)] = v1;
 // v0 == valarray<char>("abABeCghijklmnop", 16)
 ```
 ``` cpp
-valarray<T> operator[](const valarray<size_t>& indarr) const;
 ```
-*Returns:* An object of class `valarray<T>` containing those elements of
-the controlled sequence designated by `indarr`.
 ``` cpp
 const valarray<char> v0("abcdefghijklmnop", 16);
 const size_t vi[] = { 7, 5, 2, 3, 8 };
 // v0[valarray<size_t>(vi, 5)] returns
 // valarray<char>("hfcdi", 5)
 ```
 ``` cpp
 indirect_array<T> operator[](const valarray<size_t>& indarr);
 ```
 *Returns:* An object that holds references to elements of the controlled
 sequence selected by `indarr`.
 ``` cpp
 valarray<char> v0("abcdefghijklmnop", 16);
 valarray<char> v1("ABCDE", 5);
 const size_t vi[] = { 7, 5, 2, 3, 8 };
 v0[valarray<size_t>(vi, 5)] = v1;
 // v0 == valarray<char>("abCDeBgAEjklmnop", 16)
 ```
 #### `valarray` unary operators <a id="valarray.unary">[[valarray.unary]]</a>
 ``` cpp
-valarray<T> operator+() const;
-valarray<T> operator-() const;
-valarray<T> operator~() const;
 valarray<bool> operator!() const;
 ```
-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!`).
-Each of these operators returns an array whose length is equal to the
-length of the array. Each element of the returned array is initialized
-with the result of applying the indicated operator to the corresponding
-element of the array.
-#### `valarray` computed assignment <a id="valarray.cassign">[[valarray.cassign]]</a>
 ``` cpp
-valarray<T>& operator*= (const valarray<T>&);
-valarray<T>& operator/= (const valarray<T>&);
-valarray<T>& operator%= (const valarray<T>&);
-valarray<T>& operator+= (const valarray<T>&);
-valarray<T>& operator-= (const valarray<T>&);
-valarray<T>& operator^= (const valarray<T>&);
-valarray<T>& operator&= (const valarray<T>&);
-valarray<T>& operator|= (const valarray<T>&);
-valarray<T>& operator<<=(const valarray<T>&);
-valarray<T>& operator>>=(const valarray<T>&);
 ```
-Each of these operators may only be instantiated for a type `T` to which
-the indicated operator can be applied. Each of these operators performs
-the indicated operation on each of its elements and the corresponding
-element of the argument array.
-The array is then returned by reference.
-If the array and the argument array do not have the same length, the
-behavior is undefined. The appearance of an array on the left-hand side
-of a computed assignment does `not` invalidate references or pointers.
-If the value of an element in the left-hand side of a valarray computed
-assignment operator depends on the value of another element in that left
-hand side, the resulting behavior is undefined.
 ``` cpp
-valarray<T>& operator*= (const T&);
-valarray<T>& operator/= (const T&);
-valarray<T>& operator%= (const T&);
-valarray<T>& operator+= (const T&);
-valarray<T>& operator-= (const T&);
-valarray<T>& operator^= (const T&);
-valarray<T>& operator&= (const T&);
-valarray<T>& operator|= (const T&);
-valarray<T>& operator<<=(const T&);
-valarray<T>& operator>>=(const T&);
 ```
-Each of these operators may only be instantiated for a type `T` to which
-the indicated operator can be applied.
-Each of these operators applies the indicated operation to each element
-of the array and the non-array argument.
-The array is then returned by reference.
-The appearance of an array on the left-hand side of a computed
-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;
@@ -650,55 +684,81 @@ size_t size() const;
 ``` cpp
 T sum() const;
 ```
-This function may only be instantiated for a type `T` to which
-`operator+=` can be applied. This function returns the sum of all the
-elements of the array.
-If the array has length 0, the behavior is undefined. If the array has
-length 1, `sum()` 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;
 ```
-This function returns the minimum value contained in `*this`. The value
-returned for an array of length 0 is undefined. 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;
 ```
-This function returns the maximum value contained in `*this`. The value
-returned for an array of length 0 is undefined. 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
-valarray<T> shift(int n) const;
 ```
 ``` cpp
-valarray<T> cshift(int n) const;
 ```
 ``` cpp
-valarray<T> apply(T func(T)) const;
-valarray<T> apply(T func(const T&)) const;
 ```
 ``` cpp
 void resize(size_t sz, T c = T());
 ```
 ### `valarray` non-member operations <a id="valarray.nonmembers">[[valarray.nonmembers]]</a>
 #### `valarray` binary operators <a id="valarray.binary">[[valarray.binary]]</a>
 ``` cpp
@@ -722,22 +782,20 @@ template<class T> valarray<T> operator<<
     (const valarray<T>&, const valarray<T>&);
 template<class T> valarray<T> operator>>
     (const valarray<T>&, const valarray<T>&);
 ```
-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`.
-Each of these operators returns an array 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.
-If the argument arrays do not have the same length, the behavior is
-undefined.
 ``` 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&);
@@ -758,19 +816,19 @@ 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>&);
 ```
-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`.
-Each of these operators returns an array 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==
@@ -789,22 +847,20 @@ template<class T> valarray<bool> operator&&
     (const valarray<T>&, const valarray<T>&);
 template<class T> valarray<bool> operator||
     (const valarray<T>&, const valarray<T>&);
 ```
-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`.
-Each of these operators returns a `bool` array 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.
-If the two array arguments do not have the same length, the behavior is
-undefined.
 ``` 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&);
@@ -821,19 +877,19 @@ 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>&);
 ```
-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`.
-Each of these operators returns a `bool` array 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>&);
@@ -858,22 +914,22 @@ 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>&);
 ```
-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:* `x.swap(y)`.
 ### Class `slice` <a id="class.slice">[[class.slice]]</a>
 #### Class `slice` overview <a id="class.slice.overview">[[class.slice.overview]]</a>
@@ -890,11 +946,11 @@ namespace std {
   };
 }
 ```
 The `slice` class represents a BLAS-like slice from an array. Such a
-slice is specified by a starting index, a length, and a stride.[^14]
 #### `slice` constructors <a id="cons.slice">[[cons.slice]]</a>
 ``` cpp
 slice();
@@ -905,12 +961,12 @@ slice(const slice&);
 The default constructor is equivalent to `slice(0, 0, 0)`. A default
 constructor is provided only to permit the declaration of arrays of
 slices. The constructor with arguments for a slice takes a start,
 length, and stride parameter.
-`slice(3, 8, 2)` constructs a slice which selects elements 3, 5, 7, ...
-17 from an array.
 #### `slice` access functions <a id="slice.access">[[slice.access]]</a>
 ``` cpp
 size_t start() const;
@@ -928,11 +984,11 @@ size_t stride() const;
 ``` cpp
 namespace std {
   template <class T> class slice_array {
   public:
- typedef T value_type;
     void operator=  (const valarray<T>&) const;
     void operator*= (const valarray<T>&) const;
     void operator/= (const valarray<T>&) const;
     void operator%= (const valarray<T>&) const;
@@ -962,13 +1018,14 @@ slice_array<T> valarray<T>::operator[](slice);
 ```
 It has reference semantics to a subset of an array specified by a
 `slice` object.
-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.
 #### `slice_array` assignment <a id="slice.arr.assign">[[slice.arr.assign]]</a>
 ``` cpp
 void operator=(const valarray<T>&) const;
@@ -977,11 +1034,11 @@ 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` computed 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;
@@ -992,11 +1049,11 @@ void operator&= (const valarray<T>&) const;
 void operator|= (const valarray<T>&) const;
 void operator<<=(const valarray<T>&) const;
 void operator>>=(const valarray<T>&) const;
 ```
-These computed 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>
@@ -1036,34 +1093,40 @@ number to the number of strides, to a single index k. It is useful for
 building multidimensional array classes using the `valarray` template,
 which is one-dimensional. The set of one-dimensional index values
 specified by a `gslice` are $$k = s + \sum_j i_j d_j$$ where the
 multidimensional indices iⱼ range in value from 0 to lᵢⱼ - 1.
 The `gslice` specification
 ``` cpp
 start  = 3
 length = {2, 4, 3}
 stride = {19, 4, 1}
 ```
 yields the sequence of one-dimensional indices
 $$k = 3 + (0, 1) \times 19 + (0, 1, 2, 3) \times 4 + (0, 1, 2) \times 1$$
 which are ordered as shown in the following table:
 That is, the highest-ordered index turns fastest.
 It is possible to have degenerate generalized slices in which an address
 is repeated.
 If the stride parameters in the previous example are changed to {1, 1,
 1}, the first few elements of the resulting sequence of indices will be
 If a degenerate slice is used as the argument to the non-`const` version
-of `operator[](const gslice&)`, the resulting behavior is undefined.
 #### `gslice` constructors <a id="gslice.cons">[[gslice.cons]]</a>
 ``` cpp
 gslice();
@@ -1097,11 +1160,11 @@ linear in the number of strides.
 ``` cpp
 namespace std {
   template <class T> class gslice_array {
   public:
- typedef T value_type;
     void operator=  (const valarray<T>&) const;
     void operator*= (const valarray<T>&) const;
     void operator/= (const valarray<T>&) const;
     void operator%= (const valarray<T>&) const;
@@ -1146,11 +1209,11 @@ 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` <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;
@@ -1161,11 +1224,11 @@ void operator&= (const valarray<T>&) const;
 void operator|= (const valarray<T>&) const;
 void operator<<=(const valarray<T>&) const;
 void operator>>=(const valarray<T>&) const;
 ```
-These computed 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>
@@ -1184,11 +1247,11 @@ argument to the elements of the `valarray<T>` object to which the
 ``` cpp
 namespace std {
   template <class T> class mask_array {
   public:
- typedef T value_type;
     void operator=  (const valarray<T>&) const;
     void operator*= (const valarray<T>&) const;
     void operator/= (const valarray<T>&) const;
     void operator%= (const valarray<T>&) const;
@@ -1230,11 +1293,11 @@ 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` computed 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;
@@ -1245,11 +1308,11 @@ void operator&= (const valarray<T>&) const;
 void operator|= (const valarray<T>&) const;
 void operator<<=(const valarray<T>&) const;
 void operator>>=(const valarray<T>&) const;
 ```
-These computed 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>
@@ -1267,11 +1330,11 @@ argument to the elements of the `valarray<T>` object to which the
 ``` cpp
 namespace std {
   template <class T> class indirect_array {
   public:
- typedef T value_type;
     void operator=  (const valarray<T>&) const;
     void operator*= (const valarray<T>&) const;
     void operator/= (const valarray<T>&) const;
     void operator%= (const valarray<T>&) const;
@@ -1317,21 +1380,25 @@ values of the argument array elements to selected elements of the
 `valarray<T>` object to which it refers.
 If the `indirect_array` specifies an element in the `valarray<T>` object
 to which it refers more than once, the behavior is undefined.
 ``` cpp
 int addr[] = {2, 3, 1, 4, 4};
 valarray<size_t> indirect(addr, 5);
 valarray<double> a(0., 10), b(1., 5);
 a[indirect] = b;
 ```
 results in undefined behavior since element 4 is specified twice in the
 indirection.
-#### `indirect_array` computed 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;
@@ -1342,11 +1409,11 @@ void operator&= (const valarray<T>&) const;
 void operator|= (const valarray<T>&) const;
 void operator<<=(const valarray<T>&) const;
 void operator>>=(const valarray<T>&) const;
 ```
-These computed 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 `indirect_array`
 object refers.
 If the `indirect_array` specifies an element in the `valarray<T>` object
@@ -1360,19 +1427,21 @@ void operator=(const T&) const;
 This function has reference semantics, assigning the value of its
 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]]) 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&`.
 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.
@@ -1380,15 +1449,14 @@ 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);
 ```
-*Returns:* An iterator referencing the first value in the numeric array.
 ``` cpp
 template <class T> unspecified{1} end(valarray<T>& v);
 template <class T> unspecified{2} end(const valarray<T>& v);
 ```
-*Returns:* An iterator referencing one past the last value in the
-numeric array.

 ``` cpp
 #include <initializer_list>
 namespace std {
   template<class T> class valarray;         // An array of type T
   class slice;                              // a BLAS-like slice out of an array
   template<class T> class slice_array;
   class gslice;                             // a generalized slice out of an array
   template<class T> class gslice_array;
   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.
 ``` cpp
 namespace std {
   template<class T> class valarray {
   public:
+ using value_type = T;
+    // [valarray.cons], construct/destroy
     valarray();
     explicit valarray(size_t);
     valarray(const T&, size_t);
     valarray(const T*, size_t);
     valarray(const valarray&);
     valarray(const mask_array<T>&);
     valarray(const indirect_array<T>&);
     valarray(initializer_list<T>);
     ~valarray();
+    // [valarray.assign], assignment
+    valarray& operator=(const valarray&);
+    valarray& operator=(valarray&&) noexcept;
     valarray& operator=(initializer_list<T>);
+    valarray& operator=(const T&);
+    valarray& operator=(const slice_array<T>&);
+    valarray& operator=(const gslice_array<T>&);
+    valarray& operator=(const mask_array<T>&);
+    valarray& operator=(const indirect_array<T>&);
+    // [valarray.access], element access
     const T&          operator[](size_t) const;
     T&                operator[](size_t);
+    // [valarray.sub], subset operations
+    valarray operator[](slice) const;
     slice_array<T>    operator[](slice);
+    valarray operator[](const gslice&) const;
     gslice_array<T>   operator[](const gslice&);
+    valarray operator[](const valarray<bool>&) const;
     mask_array<T>     operator[](const valarray<bool>&);
+    valarray operator[](const valarray<size_t>&) const;
     indirect_array<T> operator[](const valarray<size_t>&);
+    // [valarray.unary], unary operators
+    valarray operator+() const;
+    valarray operator-() const;
+    valarray operator~() const;
     valarray<bool> operator!() const;
+    // [valarray.cassign], compound assignment
+    valarray& operator*= (const T&);
+    valarray& operator/= (const T&);
+    valarray& operator%= (const T&);
+    valarray& operator+= (const T&);
+    valarray& operator-= (const T&);
+    valarray& operator^= (const T&);
+    valarray& operator&= (const T&);
+    valarray& operator|= (const T&);
+    valarray& operator<<=(const T&);
+    valarray& operator>>=(const T&);
+    valarray& operator*= (const valarray&);
+    valarray& operator/= (const valarray&);
+    valarray& operator%= (const valarray&);
+    valarray& operator+= (const valarray&);
+    valarray& operator-= (const valarray&);
+    valarray& operator^= (const valarray&);
+    valarray& operator|= (const valarray&);
+    valarray& operator&= (const valarray&);
+    valarray& operator<<=(const valarray&);
+    valarray& operator>>=(const valarray&);
+    // [valarray.members], member functions
     void swap(valarray&) noexcept;
     size_t size() const;
     T sum() const;
     T min() const;
     T max() const;
+    valarray shift (int) const;
+    valarray cshift(int) const;
+    valarray apply(T func(T)) const;
+    valarray apply(T func(const T&)) const;
     void resize(size_t sz, T c = T());
   };
+  template<class T, size_t cnt> valarray(const T(&)[cnt], size_t) -> valarray<T>;
 }
 ```
 The class template `valarray<T>` is a one-dimensional smart array, with
 elements numbered sequentially from zero. It is a representation of the
+mathematical concept of an ordered set of values. For convenience, an
+object of type `valarray<T>` is referred to as an “array” throughout the
+remainder of  [[numarray]]. The illusion of higher dimensionality may be
+produced by the familiar idiom of computed indices, together with the
+powerful subsetting capabilities provided by the generalized subscript
+operators.[^8]
 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();
 ```
+*Effects:* Constructs a `valarray` that has zero length.[^9]
 ``` 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);
 ```
+*Effects:* Constructs a `valarray` that has length `n`. Each element of
+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]
 ``` cpp
+valarray(const valarray& v);
 ```
+*Effects:* Constructs a `valarray` that has the same length as `v`. The
+elements are initialized with the values of the corresponding elements
+of `v`.[^11]
 ``` cpp
+valarray(valarray&& v) noexcept;
 ```
+*Effects:* Constructs a `valarray` that has the same length as `v`. The
+elements are initialized with the values of the corresponding elements
+of `v`.
 *Complexity:* Constant.
 ``` cpp
 valarray(initializer_list<T> il);
 ```
+*Effects:* Equivalent to `valarray(il.begin(), il.size())`.
 ``` cpp
 valarray(const slice_array<T>&);
 valarray(const gslice_array<T>&);
 valarray(const mask_array<T>&);
 ``` cpp
 ~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);
 ```
+*Effects:* Each element of the `*this` array is assigned the value of
+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;
 ```
 *Effects:* `*this` obtains the value of `v`. The value of `v` after the
 assignment is not specified.
+*Returns:* `*this`.
 *Complexity:* Linear.
 ``` cpp
 valarray& operator=(initializer_list<T> il);
 ```
+*Effects:* Equivalent to: `return *this = valarray(il);`
 ``` cpp
+valarray& operator=(const T& v);
 ```
+*Effects:* Assigns `v` to each element of `*this`.
+*Returns:* `*this`.
 ``` cpp
+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
 `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;
 ```
+*Returns:* A `valarray` containing those elements of the controlled
+sequence designated by `slicearr`.
+[*Example 1*:
 ``` cpp
 const valarray<char> v0("abcdefghijklmnop", 16);
 // v0[slice(2, 5, 3)] returns valarray<char>("cfilo", 5)
 ```
+— *end example*]
 ``` cpp
 slice_array<T> operator[](slice slicearr);
 ```
 *Returns:* An object that holds references to elements of the controlled
 sequence selected by `slicearr`.
+[*Example 2*:
 ``` cpp
 valarray<char> v0("abcdefghijklmnop", 16);
 valarray<char> v1("ABCDE", 5);
 v0[slice(2, 5, 3)] = v1;
 // v0 == valarray<char>("abAdeBghCjkDmnEp", 16);
 ```
+— *end example*]
 ``` cpp
+valarray operator[](const gslice& gslicearr) const;
 ```
+*Returns:* A `valarray` containing those elements of the controlled
+sequence designated by `gslicearr`.
+[*Example 3*:
 ``` cpp
 const valarray<char> v0("abcdefghijklmnop", 16);
 const size_t lv[] = { 2, 3 };
 const size_t dv[] = { 7, 2 };
 const valarray<size_t> len(lv, 2), str(dv, 2);
 // v0[gslice(3, len, str)] returns
 // valarray<char>("dfhkmo", 6)
 ```
+— *end example*]
 ``` cpp
 gslice_array<T> operator[](const gslice& gslicearr);
 ```
 *Returns:* An object that holds references to elements of the controlled
 sequence selected by `gslicearr`.
+[*Example 4*:
 ``` cpp
 valarray<char> v0("abcdefghijklmnop", 16);
+valarray<char> v1("ABCDEF", 6);
 const size_t lv[] = { 2, 3 };
 const size_t dv[] = { 7, 2 };
 const valarray<size_t> len(lv, 2), str(dv, 2);
 v0[gslice(3, len, str)] = v1;
 // v0 == valarray<char>("abcAeBgCijDlEnFp", 16)
 ```
+— *end example*]
 ``` cpp
+valarray operator[](const valarray<bool>& boolarr) const;
 ```
+*Returns:* A `valarray` containing those elements of the controlled
+sequence designated by `boolarr`.
+[*Example 5*:
 ``` cpp
 const valarray<char> v0("abcdefghijklmnop", 16);
 const bool vb[] = { false, false, true, true, false, true };
 // v0[valarray<bool>(vb, 6)] returns
 // valarray<char>("cdf", 3)
 ```
+— *end example*]
 ``` cpp
 mask_array<T> operator[](const valarray<bool>& boolarr);
 ```
 *Returns:* An object that holds references to elements of the controlled
 sequence selected by `boolarr`.
+[*Example 6*:
 ``` cpp
 valarray<char> v0("abcdefghijklmnop", 16);
 valarray<char> v1("ABC", 3);
 const bool vb[] = { false, false, true, true, false, true };
 v0[valarray<bool>(vb, 6)] = v1;
 // v0 == valarray<char>("abABeCghijklmnop", 16)
 ```
+— *end example*]
 ``` cpp
+valarray operator[](const valarray<size_t>& indarr) const;
 ```
+*Returns:* A `valarray` containing those elements of the controlled
+sequence designated by `indarr`.
+[*Example 7*:
 ``` cpp
 const valarray<char> v0("abcdefghijklmnop", 16);
 const size_t vi[] = { 7, 5, 2, 3, 8 };
 // v0[valarray<size_t>(vi, 5)] returns
 // valarray<char>("hfcdi", 5)
 ```
+— *end example*]
 ``` cpp
 indirect_array<T> operator[](const valarray<size_t>& indarr);
 ```
 *Returns:* An object that holds references to elements of the controlled
 sequence selected by `indarr`.
+[*Example 8*:
 ``` cpp
 valarray<char> v0("abcdefghijklmnop", 16);
 valarray<char> v1("ABCDE", 5);
 const size_t vi[] = { 7, 5, 2, 3, 8 };
 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);
+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);
+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`.
+*Remarks:* The appearance of an array on the left-hand side of a
+compound assignment does not invalidate references or pointers.
 ``` cpp
+valarray& operator*= (const T& v);
+valarray& operator/= (const T& v);
+valarray& operator%= (const T& v);
+valarray& operator+= (const T& v);
+valarray& operator-= (const T& v);
+valarray& operator^= (const T& v);
+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;
 ``` 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<`.
 ``` cpp
+valarray shift(int n) const;
 ```
+*Returns:* A `valarray` of length `size()`, each of whose elements *I*
+is `(*this)[`*`I`*` + n]` if *`I`*` + n` is non-negative and less than
+`size()`, otherwise `T()`.
+[*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;
 ```
+*Returns:* A `valarray` of length `size()` that is a circular shift of
+`*this`. If element zero is taken as the leftmost element, a
+non-negative value of n shifts the elements circularly left n places and
+a negative value of n shifts the elements circularly right -n places.
 ``` cpp
+valarray apply(T func(T)) const;
+valarray apply(T func(const T&)) const;
 ```
+*Returns:* A `valarray` whose length is `size()`. Each element of the
+returned array is assigned the value returned by applying the argument
+function to the corresponding element of `*this`.
 ``` cpp
 void resize(size_t sz, T c = T());
 ```
+*Effects:* Changes the length of the `*this` array to `sz` and then
+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
     (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>&);
 ```
+*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>&);
 ```
+*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>&);
 ```
+*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> 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>
   };
 }
 ```
 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();
 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;
 ``` cpp
 namespace std {
   template <class T> class slice_array {
   public:
+ using value_type = T;
     void operator=  (const valarray<T>&) const;
     void operator*= (const valarray<T>&) const;
     void operator/= (const valarray<T>&) const;
     void operator%= (const valarray<T>&) const;
 ```
 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;
 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;
 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.
 #### `slice_array` fill function <a id="slice.arr.fill">[[slice.arr.fill]]</a>
 building multidimensional array classes using the `valarray` template,
 which is one-dimensional. The set of one-dimensional index values
 specified by a `gslice` are $$k = s + \sum_j i_j d_j$$ where the
 multidimensional indices iⱼ range in value from 0 to lᵢⱼ - 1.
+[*Example 1*:
 The `gslice` specification
 ``` cpp
 start  = 3
 length = {2, 4, 3}
 stride = {19, 4, 1}
 ```
 yields the sequence of one-dimensional indices
 $$k = 3 + (0, 1) \times 19 + (0, 1, 2, 3) \times 4 + (0, 1, 2) \times 1$$
 which are ordered as shown in the following table:
 That is, the highest-ordered index turns fastest.
+— *end example*]
 It is possible to have degenerate generalized slices in which an address
 is repeated.
+[*Example 2*:
 If the stride parameters in the previous example are changed to {1, 1,
 1}, the first few elements of the resulting sequence of indices will be
+— *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();
 ``` cpp
 namespace std {
   template <class T> class gslice_array {
   public:
+ using value_type = T;
     void operator=  (const valarray<T>&) const;
     void operator*= (const valarray<T>&) const;
     void operator/= (const valarray<T>&) const;
     void operator%= (const valarray<T>&) 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;
 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.
 #### `gslice_array` fill function <a id="gslice.array.fill">[[gslice.array.fill]]</a>
 ``` cpp
 namespace std {
   template <class T> class mask_array {
   public:
+ using value_type = T;
     void operator=  (const valarray<T>&) const;
     void operator*= (const valarray<T>&) const;
     void operator/= (const valarray<T>&) const;
     void operator%= (const valarray<T>&) 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;
 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.
 #### `mask_array` fill function <a id="mask.array.fill">[[mask.array.fill]]</a>
 ``` cpp
 namespace std {
   template <class T> class indirect_array {
   public:
+ using value_type = T;
     void operator=  (const valarray<T>&) const;
     void operator*= (const valarray<T>&) const;
     void operator/= (const valarray<T>&) const;
     void operator%= (const valarray<T>&) const;
 `valarray<T>` object to which it refers.
 If the `indirect_array` specifies an element in the `valarray<T>` object
 to which it refers more than once, the behavior is undefined.
+[*Example 1*:
 ``` cpp
 int addr[] = {2, 3, 1, 4, 4};
 valarray<size_t> indirect(addr, 5);
 valarray<double> a(0., 10), b(1., 5);
 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;
 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 `indirect_array`
 object refers.
 If the `indirect_array` specifies an element in the `valarray<T>` object
 This function has reference semantics, assigning the value of its
 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);
 ```
+*Returns:* An iterator referencing the first value in the array.
 ``` cpp
 template <class T> unspecified{1} end(valarray<T>& v);
 template <class T> unspecified{2} end(const valarray<T>& v);
 ```
+*Returns:* An iterator referencing one past the last value in the array.

Diff to HTML by rtfpessoa