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

Files changed (1) hide show

tmp/tmpckzbunwf/{from.md → to.md} +94 -19

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

@@ -6,20 +6,20 @@
 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:
 - `a1` when `N` is `1`, otherwise
-- `op(GENERALIZED_NONCOMMUTATIVE_SUM(op, a1, ..., aK),`
-  `\phantom{op(}GENERALIZED_NONCOMMUTATIVE_SUM(op, aM, ..., aN))` for
- any `K` where 1 < K+1 = M ≤ N.
-Define `GENERALIZED_SUM(op, a1, ..., aN)` as
-`GENERALIZED_NONCOMMUTATIVE_SUM(op, b1, ..., bN)`, where `b1, ..., bN`
-may be any permutation of `a1, ..., aN`.
 ### Accumulate <a id="accumulate">[[accumulate]]</a>
 ``` cpp
 template<class InputIterator, class T>
@@ -116,11 +116,11 @@ are convertible to `T`.
 - `T` meets the *Cpp17MoveConstructible* ([[cpp17.moveconstructible]])
   requirements.
 - `binary_op` neither invalidates iterators or subranges, nor modifies
   elements in the range \[`first`, `last`\].
-*Returns:* *GENERALIZED_SUM*(binary_op, init, \*i, ...) for every `i` in
 \[`first`, `last`).
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
 [*Note 1*: The difference between `reduce` and `accumulate` is that
@@ -224,11 +224,11 @@ are convertible to `T`.
   `first2 + (last1 - first1)`\].
 *Returns:*
 ``` cpp
-GENERALIZED_SUM(binary_op1, init, binary_op2(*i, *(first2 + (i - first1))), ...)
 ```
 for every iterator `i` in \[`first1`, `last1`).
 *Complexity:* 𝑂(`last1 - first1`) applications each of `binary_op1` and
@@ -264,11 +264,11 @@ are convertible to `T`.
   elements in the range \[`first`, `last`\].
 *Returns:*
 ``` cpp
-GENERALIZED_SUM(binary_op, init, unary_op(*i), ...)
 ```
 for every iterator `i` in \[`first`, `last`).
 *Complexity:* 𝑂(`last - first`) applications each of `unary_op` and
@@ -376,11 +376,11 @@ are convertible to `T`.
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of:
 ``` cpp
 GENERALIZED_NONCOMMUTATIVE_SUM(
-    binary_op, init, *(first + 0), *(first + 1), ..., *(first + K - 1))
 ```
 *Returns:* The end of the resulting range beginning at `result`.
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
@@ -467,15 +467,14 @@ convertible to `U`.
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
-      binary_op, init, \*(first + 0), \*(first + 1), ..., \*(first +
-  K))
   if `init` is provided, or
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
-      binary_op, \*(first + 0), \*(first + 1), ..., \*(first + K))
   otherwise.
 *Returns:* The end of the resulting range beginning at `result`.
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
@@ -526,11 +525,11 @@ are convertible to `T`.
 through `result + K` the value of:
 ``` cpp
 GENERALIZED_NONCOMMUTATIVE_SUM(
     binary_op, init,
-    unary_op(*(first + 0)), unary_op(*(first + 1)), ..., unary_op(*(first + K - 1)))
 ```
 *Returns:* The end of the resulting range beginning at `result`.
 *Complexity:* 𝑂(`last - first`) applications each of `unary_op` and
@@ -603,16 +602,16 @@ are convertible to `T`; otherwise,
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
       binary_op, init,
-      unary_op(\*(first + 0)), unary_op(\*(first + 1)), ...,
   unary_op(\*(first + K)))
   if `init` is provided, or
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
       binary_op,
-      unary_op(\*(first + 0)), unary_op(\*(first + 1)), ...,
   unary_op(\*(first + K)))
   otherwise.
 *Returns:* The end of the resulting range beginning at `result`.
@@ -682,12 +681,12 @@ every iterator `i` in \[`first + 1`, `last`) in order, creates an object
 `val` whose type is `T`, initializes it with `*i`, computes
 `binary_op(val, std::move(acc))`, assigns the result to
 `*(result + (i - first))`, and move assigns from `val` to `acc`.
 For the overloads with an `ExecutionPolicy` and a non-empty range,
-performs `*result = *first`. Then, for every `d` in
-`[1, last - first - 1]`, performs
 `*(result + d) = binary_op(*(first + d), *(first + (d - 1)))`.
 *Returns:* `result + (last - first)`.
 *Complexity:* Exactly `(last - first) - 1` applications of the binary
@@ -806,5 +805,81 @@ considered to be equivalent to a pointer to a hypothetical array element
 n for this purpose. — *end note*]
 *Returns:* A pointer to array element $i+\frac{j-i}{2}$ of `x`, where
 the result of the division is truncated towards zero.

 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:
 - `a1` when `N` is `1`, otherwise
+- `op(GENERALIZED_NONCOMMUTATIVE_SUM(op, a1, …, aK),`
+  `\phantom{op(}GENERALIZED_NONCOMMUTATIVE_SUM(op, aM, …, aN))` for any
+  `K` where 1 < K+1 = M ≤ N.
+Define `GENERALIZED_SUM(op, a1, …, aN)` as
+`GENERALIZED_NONCOMMUTATIVE_SUM(op, b1, …, bN)`, where `b1, …, bN` may
+be any permutation of `a1, …, aN`.
 ### Accumulate <a id="accumulate">[[accumulate]]</a>
 ``` cpp
 template<class InputIterator, class T>
 - `T` meets the *Cpp17MoveConstructible* ([[cpp17.moveconstructible]])
   requirements.
 - `binary_op` neither invalidates iterators or subranges, nor modifies
   elements in the range \[`first`, `last`\].
+*Returns:* *GENERALIZED_SUM*(binary_op, init, \*i, …) for every `i` in
 \[`first`, `last`).
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
 [*Note 1*: The difference between `reduce` and `accumulate` is that
   `first2 + (last1 - first1)`\].
 *Returns:*
 ``` cpp
+GENERALIZED_SUM(binary_op1, init, binary_op2(*i, *(first2 + (i - first1))), …)
 ```
 for every iterator `i` in \[`first1`, `last1`).
 *Complexity:* 𝑂(`last1 - first1`) applications each of `binary_op1` and
   elements in the range \[`first`, `last`\].
 *Returns:*
 ``` cpp
+GENERALIZED_SUM(binary_op, init, unary_op(*i), …)
 ```
 for every iterator `i` in \[`first`, `last`).
 *Complexity:* 𝑂(`last - first`) applications each of `unary_op` and
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of:
 ``` cpp
 GENERALIZED_NONCOMMUTATIVE_SUM(
+    binary_op, init, *(first + 0), *(first + 1), …, *(first + K - 1))
 ```
 *Returns:* The end of the resulting range beginning at `result`.
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
+      binary_op, init, \*(first + 0), \*(first + 1), …, \*(first + K))
   if `init` is provided, or
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
+      binary_op, \*(first + 0), \*(first + 1), …, \*(first + K))
   otherwise.
 *Returns:* The end of the resulting range beginning at `result`.
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
 through `result + K` the value of:
 ``` cpp
 GENERALIZED_NONCOMMUTATIVE_SUM(
     binary_op, init,
+    unary_op(*(first + 0)), unary_op(*(first + 1)), …, unary_op(*(first + K - 1)))
 ```
 *Returns:* The end of the resulting range beginning at `result`.
 *Complexity:* 𝑂(`last - first`) applications each of `unary_op` and
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
       binary_op, init,
+      unary_op(\*(first + 0)), unary_op(\*(first + 1)), …,
   unary_op(\*(first + K)))
   if `init` is provided, or
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
       binary_op,
+      unary_op(\*(first + 0)), unary_op(\*(first + 1)), …,
   unary_op(\*(first + K)))
   otherwise.
 *Returns:* The end of the resulting range beginning at `result`.
 `val` whose type is `T`, initializes it with `*i`, computes
 `binary_op(val, std::move(acc))`, assigns the result to
 `*(result + (i - first))`, and move assigns from `val` to `acc`.
 For the overloads with an `ExecutionPolicy` and a non-empty range,
+performs `*result = *first`. Then, for every `d` in \[`1`,
+`last - first - 1`\], performs
 `*(result + d) = binary_op(*(first + d), *(first + (d - 1)))`.
 *Returns:* `result + (last - first)`.
 *Complexity:* Exactly `(last - first) - 1` applications of the binary
 n for this purpose. — *end note*]
 *Returns:* A pointer to array element $i+\frac{j-i}{2}$ of `x`, where
 the result of the division is truncated towards zero.
+### Saturation arithmetic <a id="numeric.sat">[[numeric.sat]]</a>
+#### Arithmetic functions <a id="numeric.sat.func">[[numeric.sat.func]]</a>
+In the following descriptions, an arithmetic operation is performed as a
+mathematical operation with infinite range and then it is determined
+whether the mathematical result fits into the result type.
+``` cpp
+template<class T>
+  constexpr T add_sat(T x, T y) noexcept;
+```
+*Constraints:* `T` is a signed or unsigned integer
+type [[basic.fundamental]].
+*Returns:* If `x` + `y` is representable as a value of type `T`,
+`x` + `y`; otherwise, either the largest or smallest representable value
+of type `T`, whichever is closer to the value of `x` + `y`.
+``` cpp
+template<class T>
+  constexpr T sub_sat(T x, T y) noexcept;
+```
+*Constraints:* `T` is a signed or unsigned integer
+type [[basic.fundamental]].
+*Returns:* If `x` - `y` is representable as a value of type `T`,
+`x` - `y`; otherwise, either the largest or smallest representable value
+of type `T`, whichever is closer to the value of `x` - `y`.
+``` cpp
+template<class T>
+  constexpr T mul_sat(T x, T y) noexcept;
+```
+*Constraints:* `T` is a signed or unsigned integer
+type [[basic.fundamental]].
+*Returns:* If `x` × `y` is representable as a value of type `T`,
+`x` × `y`; otherwise, either the largest or smallest representable value
+of type `T`, whichever is closer to the value of `x` × `y`.
+``` cpp
+template<class T>
+  constexpr T div_sat(T x, T y) noexcept;
+```
+*Constraints:* `T` is a signed or unsigned integer
+type [[basic.fundamental]].
+*Preconditions:* `y != 0` is `true`.
+*Returns:* If `T` is a signed integer type and
+`x == numeric_limits<T>::min() && y == -1` is `true`,
+`numeric_limits<T>::max()`, otherwise, `x / y`.
+*Remarks:* A function call expression that violates the precondition in
+the *Preconditions* element is not a core constant
+expression [[expr.const]].
+#### Casting <a id="numeric.sat.cast">[[numeric.sat.cast]]</a>
+``` cpp
+template<class R, class T>
+  constexpr R saturate_cast(T x) noexcept;
+```
+*Constraints:* `R` and `T` are signed or unsigned integer
+types [[basic.fundamental]].
+*Returns:* If `x` is representable as a value of type `R`, `x`;
+otherwise, either the largest or smallest representable value of type
+`R`, whichever is closer to the value of `x`.

Diff to HTML by rtfpessoa