[numeric.ops] - C++20 → C++23

Files changed (1) hide show

tmp/tmpd49hfqgf/{from.md → to.md} +29 -8

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

@@ -1,9 +1,11 @@
 ## Generalized numeric operations <a id="numeric.ops">[[numeric.ops]]</a>
 [*Note 1*: The use of closed ranges as well as semi-open ranges to
-specify requirements throughout this subclause is
 intentional. — *end note*]
 ### Definitions <a id="numerics.defns">[[numerics.defns]]</a>
 Define `GENERALIZED_NONCOMMUTATIVE_SUM(op, a1, ..., aN)` as follows:
@@ -386,11 +388,11 @@ GENERALIZED_NONCOMMUTATIVE_SUM(
 *Remarks:* `result` may be equal to `first`.
 [*Note 1*: The difference between `exclusive_scan` and `inclusive_scan`
 is that `exclusive_scan` excludes the iᵗʰ input element from the iᵗʰ
 sum. If `binary_op` is not mathematically associative, the behavior of
-`exclusive_scan` may be nondeterministic. — *end note*]
 ### Inclusive scan <a id="inclusive.scan">[[inclusive.scan]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator>
@@ -481,11 +483,11 @@ through `result + K` the value of
 *Remarks:* `result` may be equal to `first`.
 [*Note 1*: The difference between `exclusive_scan` and `inclusive_scan`
 is that `inclusive_scan` includes the iᵗʰ input element in the iᵗʰ sum.
 If `binary_op` is not mathematically associative, the behavior of
-`inclusive_scan` may be nondeterministic. — *end note*]
 ### Transform exclusive scan <a id="transform.exclusive.scan">[[transform.exclusive.scan]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator, class T,
@@ -538,11 +540,11 @@ GENERALIZED_NONCOMMUTATIVE_SUM(
 [*Note 1*: The difference between `transform_exclusive_scan` and
 `transform_inclusive_scan` is that `transform_exclusive_scan` excludes
 the iᵗʰ input element from the iᵗʰ sum. If `binary_op` is not
 mathematically associative, the behavior of `transform_exclusive_scan`
-may be nondeterministic. `transform_exclusive_scan` does not apply
 `unary_op` to `init`. — *end note*]
 ### Transform inclusive scan <a id="transform.inclusive.scan">[[transform.inclusive.scan]]</a>
 ``` cpp
@@ -621,11 +623,11 @@ through `result + K` the value of
 [*Note 1*: The difference between `transform_exclusive_scan` and
 `transform_inclusive_scan` is that `transform_inclusive_scan` includes
 the iᵗʰ input element in the iᵗʰ sum. If `binary_op` is not
 mathematically associative, the behavior of `transform_inclusive_scan`
-may be nondeterministic. `transform_inclusive_scan` does not apply
 `unary_op` to `init`. — *end note*]
 ### Adjacent difference <a id="adjacent.difference">[[adjacent.difference]]</a>
 ``` cpp
@@ -669,11 +671,11 @@ denotes an object of type `minus<>`.
 - For the overloads with no `ExecutionPolicy`, `T` meets the
   *Cpp17MoveAssignable* ([[cpp17.moveassignable]]) requirements.
 - For all overloads, in the ranges \[`first`, `last`\] and \[`result`,
   `result + (last - first)`\], `binary_op` neither modifies elements nor
- invalidate iterators or subranges. [^10]
 *Effects:* For the overloads with no `ExecutionPolicy` and a non-empty
 range, the function creates an accumulator `acc` of type `T`,
 initializes it with `*first`, and assigns the result to `*result`. For
 every iterator `i` in \[`first + 1`, `last`) in order, creates an object
@@ -710,18 +712,37 @@ expression `++val`, where `val` has type `T`, is well-formed.
 \[`first`, `last`), assigns `*i = value` and increments `value` as if by
 `++value`.
 *Complexity:* Exactly `last - first` increments and assignments.
 ### Greatest common divisor <a id="numeric.ops.gcd">[[numeric.ops.gcd]]</a>
 ``` cpp
 template<class M, class N>
   constexpr common_type_t<M, N> gcd(M m, N n);
 ```
-*Mandates:* `M` and `N` both are integer types and not cv `bool`.
 *Preconditions:* |`m`| and |`n`| are representable as a value of
 `common_type_t<M, N>`.
 [*Note 1*: These requirements ensure, for example, that
@@ -738,11 +759,11 @@ greatest common divisor of |`m`| and |`n`|.
 ``` cpp
 template<class M, class N>
   constexpr common_type_t<M, N> lcm(M m, N n);
 ```
-*Mandates:* `M` and `N` both are integer types and not cv `bool`.
 *Preconditions:* |`m`| and |`n`| are representable as a value of
 `common_type_t<M, N>`. The least common multiple of |`m`| and |`n`| is
 representable as a value of type `common_type_t<M, N>`.

 ## Generalized numeric operations <a id="numeric.ops">[[numeric.ops]]</a>
+### General <a id="numeric.ops.general">[[numeric.ops.general]]</a>
 [*Note 1*: The use of closed ranges as well as semi-open ranges to
+specify requirements throughout [[numeric.ops]] is
 intentional. — *end note*]
 ### Definitions <a id="numerics.defns">[[numerics.defns]]</a>
 Define `GENERALIZED_NONCOMMUTATIVE_SUM(op, a1, ..., aN)` as follows:
 *Remarks:* `result` may be equal to `first`.
 [*Note 1*: The difference between `exclusive_scan` and `inclusive_scan`
 is that `exclusive_scan` excludes the iᵗʰ input element from the iᵗʰ
 sum. If `binary_op` is not mathematically associative, the behavior of
+`exclusive_scan` can be nondeterministic. — *end note*]
 ### Inclusive scan <a id="inclusive.scan">[[inclusive.scan]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator>
 *Remarks:* `result` may be equal to `first`.
 [*Note 1*: The difference between `exclusive_scan` and `inclusive_scan`
 is that `inclusive_scan` includes the iᵗʰ input element in the iᵗʰ sum.
 If `binary_op` is not mathematically associative, the behavior of
+`inclusive_scan` can be nondeterministic. — *end note*]
 ### Transform exclusive scan <a id="transform.exclusive.scan">[[transform.exclusive.scan]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator, class T,
 [*Note 1*: The difference between `transform_exclusive_scan` and
 `transform_inclusive_scan` is that `transform_exclusive_scan` excludes
 the iᵗʰ input element from the iᵗʰ sum. If `binary_op` is not
 mathematically associative, the behavior of `transform_exclusive_scan`
+can be nondeterministic. `transform_exclusive_scan` does not apply
 `unary_op` to `init`. — *end note*]
 ### Transform inclusive scan <a id="transform.inclusive.scan">[[transform.inclusive.scan]]</a>
 ``` cpp
 [*Note 1*: The difference between `transform_exclusive_scan` and
 `transform_inclusive_scan` is that `transform_inclusive_scan` includes
 the iᵗʰ input element in the iᵗʰ sum. If `binary_op` is not
 mathematically associative, the behavior of `transform_inclusive_scan`
+can be nondeterministic. `transform_inclusive_scan` does not apply
 `unary_op` to `init`. — *end note*]
 ### Adjacent difference <a id="adjacent.difference">[[adjacent.difference]]</a>
 ``` cpp
 - For the overloads with no `ExecutionPolicy`, `T` meets the
   *Cpp17MoveAssignable* ([[cpp17.moveassignable]]) requirements.
 - For all overloads, in the ranges \[`first`, `last`\] and \[`result`,
   `result + (last - first)`\], `binary_op` neither modifies elements nor
+ invalidates iterators or subranges.[^10]
 *Effects:* For the overloads with no `ExecutionPolicy` and a non-empty
 range, the function creates an accumulator `acc` of type `T`,
 initializes it with `*first`, and assigns the result to `*result`. For
 every iterator `i` in \[`first + 1`, `last`) in order, creates an object
 \[`first`, `last`), assigns `*i = value` and increments `value` as if by
 `++value`.
 *Complexity:* Exactly `last - first` increments and assignments.
+``` cpp
+template<input_or_output_iterator O, sentinel_for<O> S, weakly_incrementable T>
+  requires indirectly_writable<O, const T&>
+  constexpr ranges::iota_result<O, T> ranges::iota(O first, S last, T value);
+template<weakly_incrementable T, output_range<const T&> R>
+  constexpr ranges::iota_result<borrowed_iterator_t<R>, T> ranges::iota(R&& r, T value);
+```
+*Effects:* Equivalent to:
+``` cpp
+while (first != last) {
+  *first = as_const(value);
+  ++first;
+  ++value;
+}
+return {std::move(first), std::move(value)};
+```
 ### Greatest common divisor <a id="numeric.ops.gcd">[[numeric.ops.gcd]]</a>
 ``` cpp
 template<class M, class N>
   constexpr common_type_t<M, N> gcd(M m, N n);
 ```
+*Mandates:* `M` and `N` both are integer types other than cv `bool`.
 *Preconditions:* |`m`| and |`n`| are representable as a value of
 `common_type_t<M, N>`.
 [*Note 1*: These requirements ensure, for example, that
 ``` cpp
 template<class M, class N>
   constexpr common_type_t<M, N> lcm(M m, N n);
 ```
+*Mandates:* `M` and `N` both are integer types other than cv `bool`.
 *Preconditions:* |`m`| and |`n`| are representable as a value of
 `common_type_t<M, N>`. The least common multiple of |`m`| and |`n`| is
 representable as a value of type `common_type_t<M, N>`.

Diff to HTML by rtfpessoa