[template.valarray] - C++14 → C++17

Files changed (1) hide show

tmp/tmp6m104vf0/{from.md → to.md} +265 -204

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

@@ -4,13 +4,13 @@
 ``` 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&);
@@ -20,149 +20,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>&);
@@ -174,101 +176,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
@@ -278,200 +282,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;
@@ -492,50 +527,76 @@ 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());
 ```

 ``` 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.

Diff to HTML by rtfpessoa