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

Files changed (1) hide show

tmp/tmpkqwmksqc/{from.md → to.md} +17 -17

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

@@ -1,11 +1,11 @@
 ## Numeric arrays <a id="numarray">[[numarray]]</a>
 ### Header `<valarray>` synopsis <a id="valarray.syn">[[valarray.syn]]</a>
 ``` cpp
-#include <initializer_list>
 namespace std {
   template<class T> class valarray;         // An array of type T
   class slice;                              // a BLAS-like slice out of an array
   template<class T> class slice_array;
@@ -164,11 +164,11 @@ aliasing, thus allowing operations on these classes to be optimized.
 Any function returning a `valarray<T>` is permitted to return an object
 of another type, provided all the const member functions of
 `valarray<T>` are also applicable to this type. This return type shall
 not add more than two levels of template nesting over the most deeply
-nested argument type.[^7]
 Implementations introducing such replacement types shall provide
 additional functions and operators as follows:
 - for every function taking a `const valarray<T>&` other than `begin`
@@ -289,19 +289,19 @@ elements numbered sequentially from zero. It is a representation of the
 mathematical concept of an ordered set of values. For convenience, an
 object of type `valarray<T>` is referred to as an “array” throughout the
 remainder of  [[numarray]]. The illusion of higher dimensionality may be
 produced by the familiar idiom of computed indices, together with the
 powerful subsetting capabilities provided by the generalized subscript
-operators.[^8]
 #### Constructors <a id="valarray.cons">[[valarray.cons]]</a>
 ``` cpp
 valarray();
 ```
-*Effects:* Constructs a `valarray` that has zero length.[^9]
 ``` cpp
 explicit valarray(size_t n);
 ```
@@ -321,19 +321,19 @@ valarray(const T* p, size_t n);
 *Preconditions:* \[`p`, `p + n`) is a valid range.
 *Effects:* Constructs a `valarray` that has length `n`. The values of
 the elements of the array are initialized with the first `n` values
-pointed to by the first argument.[^10]
 ``` cpp
 valarray(const valarray& v);
 ```
 *Effects:* Constructs a `valarray` that has the same length as `v`. The
 elements are initialized with the values of the corresponding elements
-of `v`.[^11]
 ``` cpp
 valarray(valarray&& v) noexcept;
 ```
@@ -444,12 +444,12 @@ evaluates to `true` for all `size_t i` and `size_t j` such that
 The expression `addressof(a[i]) != addressof(b[j])` evaluates to `true`
 for any two arrays `a` and `b` and for any `size_t i` and `size_t j`
 such that `i < a.size()` and `j < b.size()`.
-[*Note 2*: This property indicates an absence of aliasing and may be
-used to advantage by optimizing compilers. Compilers may take advantage
 of inlining, constant propagation, loop fusion, tracking of pointers
 obtained from `operator new`, and other techniques to generate efficient
 `valarray`s. — *end note*]
 The reference returned by the subscript operator for an array shall be
@@ -757,12 +757,12 @@ is `(*this)[`*`I`*` + n]` if *`I`*` + n` is non-negative and less than
 value of `n` shifts the elements left `n` places, with zero
 fill. — *end note*]
 [*Example 1*: If the argument has the value -2, the first two elements
 of the result will be value-initialized [[dcl.init]]; the third element
-of the result will be assigned the value of the first element of the
-argument; etc. — *end example*]
 ``` cpp
 valarray cshift(int n) const;
 ```
@@ -982,10 +982,11 @@ template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;
 namespace std {
   class slice {
   public:
     slice();
     slice(size_t, size_t, size_t);
     size_t start() const;
     size_t size() const;
     size_t stride() const;
@@ -993,18 +994,17 @@ namespace std {
   };
 }
 ```
 The `slice` class represents a BLAS-like slice from an array. Such a
-slice is specified by a starting index, a length, and a stride.[^12]
 #### Constructors <a id="cons.slice">[[cons.slice]]</a>
 ``` cpp
 slice();
 slice(size_t start, size_t length, size_t stride);
-slice(const slice&);
 ```
 The default constructor is equivalent to `slice(0, 0, 0)`. A default
 constructor is provided only to permit the declaration of arrays of
 slices. The constructor with arguments for a slice takes a start,
@@ -1189,11 +1189,10 @@ of `operator[](const gslice&)`, the behavior is undefined.
 ``` cpp
 gslice();
 gslice(size_t start, const valarray<size_t>& lengths,
        const valarray<size_t>& strides);
-gslice(const gslice&);
 ```
 The default constructor is equivalent to
 `gslice(0, valarray<size_t>(), valarray<size_t>())`. The constructor
 with arguments builds a `gslice` based on a specification of start,
@@ -1331,11 +1330,11 @@ namespace std {
 ```
 This template is a helper template used by the mask subscript operator:
 ``` cpp
-mask_array<T> valarray<T>::operator[](const valarray<bool>&).
 ```
 It has reference semantics to a subset of an array specified by a
 boolean mask. Thus, the expression `a[mask] = b;` has the effect of
 assigning the elements of `b` to the masked elements in `a` (those for
@@ -1348,11 +1347,11 @@ void operator=(const valarray<T>&) const;
 const mask_array& operator=(const mask_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
-`valarray<T>` object to which it refers.
 #### Compound assignment <a id="mask.array.comp.assign">[[mask.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
@@ -1367,11 +1366,12 @@ void operator<<=(const valarray<T>&) const;
 void operator>>=(const valarray<T>&) const;
 ```
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
-elements of the `valarray<T>` object to which the mask object refers.
 #### Fill function <a id="mask.array.fill">[[mask.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
@@ -1415,11 +1415,11 @@ namespace std {
 This template is a helper template used by the indirect subscript
 operator
 ``` cpp
-indirect_array<T> valarray<T>::operator[](const valarray<size_t>&).
 ```
 It has reference semantics to a subset of an array specified by an
 `indirect_array`. Thus, the expression `a[{}indirect] = b;` has the
 effect of assigning the elements of `b` to the elements in `a` whose

 ## Numeric arrays <a id="numarray">[[numarray]]</a>
 ### Header `<valarray>` synopsis <a id="valarray.syn">[[valarray.syn]]</a>
 ``` cpp
+#include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   template<class T> class valarray;         // An array of type T
   class slice;                              // a BLAS-like slice out of an array
   template<class T> class slice_array;
 Any function returning a `valarray<T>` is permitted to return an object
 of another type, provided all the const member functions of
 `valarray<T>` are also applicable to this type. This return type shall
 not add more than two levels of template nesting over the most deeply
+nested argument type.[^8]
 Implementations introducing such replacement types shall provide
 additional functions and operators as follows:
 - for every function taking a `const valarray<T>&` other than `begin`
 mathematical concept of an ordered set of values. For convenience, an
 object of type `valarray<T>` is referred to as an “array” throughout the
 remainder of  [[numarray]]. The illusion of higher dimensionality may be
 produced by the familiar idiom of computed indices, together with the
 powerful subsetting capabilities provided by the generalized subscript
+operators.[^9]
 #### Constructors <a id="valarray.cons">[[valarray.cons]]</a>
 ``` cpp
 valarray();
 ```
+*Effects:* Constructs a `valarray` that has zero length.[^10]
 ``` cpp
 explicit valarray(size_t n);
 ```
 *Preconditions:* \[`p`, `p + n`) is a valid range.
 *Effects:* Constructs a `valarray` that has length `n`. The values of
 the elements of the array are initialized with the first `n` values
+pointed to by the first argument.[^11]
 ``` cpp
 valarray(const valarray& v);
 ```
 *Effects:* Constructs a `valarray` that has the same length as `v`. The
 elements are initialized with the values of the corresponding elements
+of `v`.[^12]
 ``` cpp
 valarray(valarray&& v) noexcept;
 ```
 The expression `addressof(a[i]) != addressof(b[j])` evaluates to `true`
 for any two arrays `a` and `b` and for any `size_t i` and `size_t j`
 such that `i < a.size()` and `j < b.size()`.
+[*Note 2*: This property indicates an absence of aliasing and can be
+used to advantage by optimizing compilers. Compilers can take advantage
 of inlining, constant propagation, loop fusion, tracking of pointers
 obtained from `operator new`, and other techniques to generate efficient
 `valarray`s. — *end note*]
 The reference returned by the subscript operator for an array shall be
 value of `n` shifts the elements left `n` places, with zero
 fill. — *end note*]
 [*Example 1*: If the argument has the value -2, the first two elements
 of the result will be value-initialized [[dcl.init]]; the third element
+of the result will be assigned the value of the first element of
+`*this`; etc. — *end example*]
 ``` cpp
 valarray cshift(int n) const;
 ```
 namespace std {
   class slice {
   public:
     slice();
     slice(size_t, size_t, size_t);
+    slice(const slice&);
     size_t start() const;
     size_t size() const;
     size_t stride() const;
   };
 }
 ```
 The `slice` class represents a BLAS-like slice from an array. Such a
+slice is specified by a starting index, a length, and a stride.[^13]
 #### Constructors <a id="cons.slice">[[cons.slice]]</a>
 ``` cpp
 slice();
 slice(size_t start, size_t length, size_t stride);
 ```
 The default constructor is equivalent to `slice(0, 0, 0)`. A default
 constructor is provided only to permit the declaration of arrays of
 slices. The constructor with arguments for a slice takes a start,
 ``` cpp
 gslice();
 gslice(size_t start, const valarray<size_t>& lengths,
        const valarray<size_t>& strides);
 ```
 The default constructor is equivalent to
 `gslice(0, valarray<size_t>(), valarray<size_t>())`. The constructor
 with arguments builds a `gslice` based on a specification of start,
 ```
 This template is a helper template used by the mask subscript operator:
 ``` cpp
+mask_array<T> valarray<T>::operator[](const valarray<bool>&);
 ```
 It has reference semantics to a subset of an array specified by a
 boolean mask. Thus, the expression `a[mask] = b;` has the effect of
 assigning the elements of `b` to the masked elements in `a` (those for
 const mask_array& operator=(const mask_array&) const;
 ```
 These assignment operators have reference semantics, assigning the
 values of the argument array elements to selected elements of the
+`valarray<T>` object to which the `mask_array` object refers.
 #### Compound assignment <a id="mask.array.comp.assign">[[mask.array.comp.assign]]</a>
 ``` cpp
 void operator*= (const valarray<T>&) const;
 void operator>>=(const valarray<T>&) const;
 ```
 These compound assignments have reference semantics, applying the
 indicated operation to the elements of the argument array and selected
+elements of the `valarray<T>` object to which the `mask_array` object
+refers.
 #### Fill function <a id="mask.array.fill">[[mask.array.fill]]</a>
 ``` cpp
 void operator=(const T&) const;
 This template is a helper template used by the indirect subscript
 operator
 ``` cpp
+indirect_array<T> valarray<T>::operator[](const valarray<size_t>&);
 ```
 It has reference semantics to a subset of an array specified by an
 `indirect_array`. Thus, the expression `a[{}indirect] = b;` has the
 effect of assigning the elements of `b` to the elements in `a` whose

Diff to HTML by rtfpessoa