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

Files changed (1) hide show

tmp/tmpf4qs3l8j/{from.md → to.md} +294 -445

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

@@ -1,276 +1,50 @@
 ## Generalized numeric operations <a id="numeric.ops">[[numeric.ops]]</a>
-### Header `<numeric>` synopsis <a id="numeric.ops.overview">[[numeric.ops.overview]]</a>
-``` cpp
-namespace std {
-  // [accumulate], accumulate
-  template <class InputIterator, class T>
-    T accumulate(InputIterator first, InputIterator last, T init);
-  template <class InputIterator, class T, class BinaryOperation>
-    T accumulate(InputIterator first, InputIterator last, T init,
-                 BinaryOperation binary_op);
-  // [reduce], reduce
-  template<class InputIterator>
-    typename iterator_traits<InputIterator>::value_type
-      reduce(InputIterator first, InputIterator last);
-  template<class InputIterator, class T>
-    T reduce(InputIterator first, InputIterator last, T init);
-  template<class InputIterator, class T, class BinaryOperation>
-    T reduce(InputIterator first, InputIterator last, T init,
-             BinaryOperation binary_op);
-  template<class ExecutionPolicy, class ForwardIterator>
-    typename iterator_traits<ForwardIterator>::value_type
-      reduce(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-             ForwardIterator first, ForwardIterator last);
-  template<class ExecutionPolicy, class ForwardIterator, class T>
-    T reduce(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-             ForwardIterator first, ForwardIterator last, T init);
-  template<class ExecutionPolicy, class ForwardIterator, class T, class BinaryOperation>
-    T reduce(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-             ForwardIterator first, ForwardIterator last, T init,
-             BinaryOperation binary_op);
-  // [inner.product], inner product
-  template <class InputIterator1, class InputIterator2, class T>
-    T inner_product(InputIterator1 first1, InputIterator1 last1,
-                    InputIterator2 first2, T init);
-  template <class InputIterator1, class InputIterator2, class T,
-            class BinaryOperation1, class BinaryOperation2>
-    T inner_product(InputIterator1 first1, InputIterator1 last1,
-                    InputIterator2 first2, T init,
-                    BinaryOperation1 binary_op1,
-                    BinaryOperation2 binary_op2);
-  // [transform.reduce], transform reduce
-  template<class InputIterator1, class InputIterator2, class T>
-    T transform_reduce(InputIterator1 first1, InputIterator1 last1,
-                       InputIterator2 first2,
-                       T init);
-  template<class InputIterator1, class InputIterator2, class T,
-           class BinaryOperation1, class BinaryOperation2>
-    T transform_reduce(InputIterator1 first1, InputIterator1 last1,
-                       InputIterator2 first2,
-                       T init,
-                       BinaryOperation1 binary_op1,
-                       BinaryOperation2 binary_op2);
-  template<class InputIterator, class T,
-           class BinaryOperation, class UnaryOperation>
-    T transform_reduce(InputIterator first, InputIterator last,
-                       T init,
-                       BinaryOperation binary_op, UnaryOperation unary_op);
-  template<class ExecutionPolicy,
-           class ForwardIterator1, class ForwardIterator2, class T>
-    T transform_reduce(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                       ForwardIterator1 first1, ForwardIterator1 last1,
-                       ForwardIterator2 first2,
-                       T init);
-  template<class ExecutionPolicy,
-           class ForwardIterator1, class ForwardIterator2, class T,
-           class BinaryOperation1, class BinaryOperation2>
-    T transform_reduce(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                       ForwardIterator1 first1, ForwardIterator1 last1,
-                       ForwardIterator2 first2,
-                       T init,
-                       BinaryOperation1 binary_op1,
-                       BinaryOperation2 binary_op2);
-  template<class ExecutionPolicy,
-           class ForwardIterator, class T,
-           class BinaryOperation, class UnaryOperation>
-    T transform_reduce(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                       ForwardIterator first, ForwardIterator last,
-                       T init,
-                       BinaryOperation binary_op, UnaryOperation unary_op);
-  // [partial.sum], partial sum
-  template <class InputIterator, class OutputIterator>
-    OutputIterator partial_sum(InputIterator first,
-                               InputIterator last,
-                               OutputIterator result);
-  template <class InputIterator, class OutputIterator, class BinaryOperation>
-    OutputIterator partial_sum(InputIterator first,
-                               InputIterator last,
-                               OutputIterator result,
-                               BinaryOperation binary_op);
-  // [exclusive.scan], exclusive scan
-  template<class InputIterator, class OutputIterator, class T>
-    OutputIterator exclusive_scan(InputIterator first, InputIterator last,
-                                  OutputIterator result,
-                                  T init);
-  template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
-    OutputIterator exclusive_scan(InputIterator first, InputIterator last,
-                                  OutputIterator result,
-                                  T init, BinaryOperation binary_op);
-  template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
-    ForwardIterator2 exclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                    ForwardIterator1 first, ForwardIterator1 last,
-                                    ForwardIterator2 result,
-                                    T init);
-  template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T,
-           class BinaryOperation>
-    ForwardIterator2 exclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                    ForwardIterator1 first, ForwardIterator1 last,
-                                    ForwardIterator2 result,
-                                    T init, BinaryOperation binary_op);
-  // [inclusive.scan], inclusive scan
-  template<class InputIterator, class OutputIterator>
-    OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                                  OutputIterator result);
-  template<class InputIterator, class OutputIterator, class BinaryOperation>
-    OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                                  OutputIterator result,
-                                  BinaryOperation binary_op);
-  template<class InputIterator, class OutputIterator, class BinaryOperation, class T>
-    OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                                  OutputIterator result,
-                                  BinaryOperation binary_op, T init);
-  template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-    ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                    ForwardIterator1 first, ForwardIterator1 last,
-                                    ForwardIterator2 result);
-  template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
-           class BinaryOperation>
-    ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                    ForwardIterator1 first, ForwardIterator1 last,
-                                    ForwardIterator2 result,
-                                    BinaryOperation binary_op);
-  template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
-           class BinaryOperation, class T>
-    ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                    ForwardIterator1 first, ForwardIterator1 last,
-                                    ForwardIterator2 result,
-                                    BinaryOperation binary_op, T init);
-  // [transform.exclusive.scan], transform exclusive scan
-  template<class InputIterator, class OutputIterator, class T,
-           class BinaryOperation, class UnaryOperation>
-    OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
-                                            OutputIterator result,
-                                            T init,
-                                            BinaryOperation binary_op,
-                                            UnaryOperation unary_op);
-  template<class ExecutionPolicy,
-           class ForwardIterator1, class ForwardIterator2, class T,
-           class BinaryOperation, class UnaryOperation>
-    ForwardIterator2 transform_exclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                              ForwardIterator1 first, ForwardIterator1 last,
-                                              ForwardIterator2 result,
-                                              T init,
-                                              BinaryOperation binary_op,
-                                              UnaryOperation unary_op);
-  // [transform.inclusive.scan], transform inclusive scan
-  template<class InputIterator, class OutputIterator,
-           class BinaryOperation, class UnaryOperation>
-    OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
-                                            OutputIterator result,
-                                            BinaryOperation binary_op,
-                                            UnaryOperation unary_op);
-  template<class InputIterator, class OutputIterator,
-           class BinaryOperation, class UnaryOperation, class T>
-    OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
-                                            OutputIterator result,
-                                            BinaryOperation binary_op,
-                                            UnaryOperation unary_op,
-                                            T init);
-  template<class ExecutionPolicy,
-           class ForwardIterator1, class ForwardIterator2,
-           class BinaryOperation, class UnaryOperation>
-    ForwardIterator2 transform_inclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                              ForwardIterator1 first, ForwardIterator1 last,
-                                              ForwardIterator2 result,
-                                              BinaryOperation binary_op,
-                                              UnaryOperation unary_op);
-  template<class ExecutionPolicy,
-           class ForwardIterator1, class ForwardIterator2,
-           class BinaryOperation, class UnaryOperation, class T>
-    ForwardIterator2 transform_inclusive_scan(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                              ForwardIterator1 first, ForwardIterator1 last,
-                                              ForwardIterator2 result,
-                                              BinaryOperation binary_op,
-                                              UnaryOperation unary_op,
-                                              T init);
-  // [adjacent.difference], adjacent difference
-  template <class InputIterator, class OutputIterator>
-    OutputIterator adjacent_difference(InputIterator first,
-                                       InputIterator last,
-                                       OutputIterator result);
-  template <class InputIterator, class OutputIterator, class BinaryOperation>
-    OutputIterator adjacent_difference(InputIterator first,
-                                       InputIterator last,
-                                       OutputIterator result,
-                                       BinaryOperation binary_op);
-  template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-    ForwardIterator2 adjacent_difference(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                         ForwardIterator1 first,
-                                         ForwardIterator1 last,
-                                         ForwardIterator2 result);
-  template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
-            class BinaryOperation>
-    ForwardIterator2 adjacent_difference(ExecutionPolicy&& exec, // see [algorithms.parallel.overloads]
-                                         ForwardIterator1 first,
-                                         ForwardIterator1 last,
-                                         ForwardIterator2 result,
-                                         BinaryOperation binary_op);
-  // [numeric.iota], iota
-  template <class ForwardIterator, class T>
-    void iota(ForwardIterator first, ForwardIterator last, T value);
-  // [numeric.ops.gcd], greatest common divisor
-  template <class M, class N>
-    constexpr common_type_t<M,N> gcd(M m, N n);
-  // [numeric.ops.lcm], least common multiple
-  template <class M, class N>
-    constexpr common_type_t<M,N> lcm(M m, N n);
-}
-```
-The requirements on the types of algorithms’ arguments that are
-described in the introduction to Clause  [[algorithms]] also apply to
-the following algorithms.
-Throughout this subclause, the parameters `UnaryOperation`,
-`BinaryOperation`, `BinaryOperation1`, and `BinaryOperation2` are used
-whenever an algorithm expects a function object ([[function.objects]]).
 [*Note 1*: The use of closed ranges as well as semi-open ranges to
 specify requirements throughout this subclause is
 intentional. — *end note*]
 ### Accumulate <a id="accumulate">[[accumulate]]</a>
 ``` cpp
 template<class InputIterator, class T>
-  T accumulate(InputIterator first, InputIterator last, T init);
 template<class InputIterator, class T, class BinaryOperation>
-  T accumulate(InputIterator first, InputIterator last, T init,
                          BinaryOperation binary_op);
 ```
-*Requires:* `T` shall meet the requirements of `CopyConstructible`
-(Table  [[tab:copyconstructible]]) and `CopyAssignable`
-(Table  [[tab:copyassignable]]) types. In the range \[`first`, `last`\],
-`binary_op` shall neither modify elements nor invalidate iterators or
-subranges.[^13]
 *Effects:* Computes its result by initializing the accumulator `acc`
-with the initial value `init` and then modifies it with `acc = acc + *i`
-or `acc = binary_op(acc, *i)` for every iterator `i` in the range
-\[`first`, `last`) in order.[^14]
 ### Reduce <a id="reduce">[[reduce]]</a>
 ``` cpp
 template<class InputIterator>
-  typename iterator_traits<InputIterator>::value_type
     reduce(InputIterator first, InputIterator last);
 ```
 *Effects:* Equivalent to:
@@ -293,11 +67,11 @@ return reduce(std::forward<ExecutionPolicy>(exec), first, last,
               typename iterator_traits<ForwardIterator>::value_type{});
 ```
 ``` cpp
 template<class InputIterator, class T>
-  T reduce(InputIterator first, InputIterator last, T init);
 ```
 *Effects:* Equivalent to:
 ``` cpp
@@ -316,26 +90,33 @@ template<class ExecutionPolicy, class ForwardIterator, class T>
 return reduce(std::forward<ExecutionPolicy>(exec), first, last, init, plus<>());
 ```
 ``` cpp
 template<class InputIterator, class T, class BinaryOperation>
-  T reduce(InputIterator first, InputIterator last, T init,
                      BinaryOperation binary_op);
 template<class ExecutionPolicy, class ForwardIterator, class T, class BinaryOperation>
   T reduce(ExecutionPolicy&& exec,
            ForwardIterator first, ForwardIterator last, T init,
            BinaryOperation binary_op);
 ```
-*Requires:*
-- `T` shall be `MoveConstructible` (Table  [[tab:moveconstructible]]).
-- All of `binary_op(init, *first)`, `binary_op(*first, init)`,
- `binary_op(init, init)`, and `binary_op(*first, *first)` shall be
-  convertible to `T`.
-- `binary_op` shall neither invalidate iterators or subranges, nor
-  modify 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`.
@@ -347,59 +128,69 @@ nondeterministic result for non-associative or non-commutative
 ### Inner product <a id="inner.product">[[inner.product]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2, class T>
-  T inner_product(InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, T init);
 template<class InputIterator1, class InputIterator2, class T,
          class BinaryOperation1, class BinaryOperation2>
-  T inner_product(InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, T init,
                             BinaryOperation1 binary_op1,
                             BinaryOperation2 binary_op2);
 ```
-*Requires:* `T` shall meet the requirements of `CopyConstructible`
-(Table  [[tab:copyconstructible]]) and `CopyAssignable`
-(Table  [[tab:copyassignable]]) types. In the ranges \[`first1`,
 `last1`\] and \[`first2`, `first2 + (last1 - first1)`\] `binary_op1` and
-`binary_op2` shall neither modify elements nor invalidate iterators or
-subranges.[^15]
 *Effects:* Computes its result by initializing the accumulator `acc`
 with the initial value `init` and then modifying it with
-`acc = acc + (*i1) * (*i2)` or
-`acc = binary_op1(acc, binary_op2(*i1, *i2))` for every iterator `i1` in
-the range \[`first1`, `last1`) and iterator `i2` in the range
-\[`first2`, `first2 + (last1 - first1)`) in order.
 ### Transform reduce <a id="transform.reduce">[[transform.reduce]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2, class T>
-  T transform_reduce(InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2,
                                T init);
-template <class ExecutionPolicy,
-          class ForwardIterator1, class ForwardIterator2, class T>
-  T transform_reduce(ExecutionPolicy&& exec,
-                     ForwardIterator1 first1, ForwardIterator1 last1,
-                     ForwardIterator2 first2,
-                     T init);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return transform_reduce(first1, last1, first2, init, plus<>(), multiplies<>());
 ```
 ``` cpp
 template<class InputIterator1, class InputIterator2, class T,
          class BinaryOperation1, class BinaryOperation2>
-  T transform_reduce(InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2,
                                T init,
                                BinaryOperation1 binary_op1,
                                BinaryOperation2 binary_op2);
 template<class ExecutionPolicy,
@@ -411,22 +202,25 @@ template <class ExecutionPolicy,
                      T init,
                      BinaryOperation1 binary_op1,
                      BinaryOperation2 binary_op2);
 ```
-*Requires:*
-- `T` shall be `MoveConstructible` (Table  [[tab:moveconstructible]]).
-- All of
 - `binary_op1(init, init)`,
 - `binary_op1(init, binary_op2(*first1, *first2))`,
 - `binary_op1(binary_op2(*first1, *first2), init)`, and
 - `binary_op1(binary_op2(*first1, *first2), binary_op2(*first1, *first2))`
-  shall be convertible to `T`.
-- Neither `binary_op1` nor `binary_op2` shall invalidate subranges, or
-  modify elements in the ranges \[`first1`, `last1`\] and \[`first2`,
   `first2 + (last1 - first1)`\].
 *Returns:*
 ``` cpp
@@ -439,32 +233,35 @@ for every iterator `i` in \[`first1`, `last1`).
 `binary_op2`.
 ``` cpp
 template<class InputIterator, class T,
          class BinaryOperation, class UnaryOperation>
-  T transform_reduce(InputIterator first, InputIterator last, T init,
                                BinaryOperation binary_op, UnaryOperation unary_op);
 template<class ExecutionPolicy,
          class ForwardIterator, class T,
          class BinaryOperation, class UnaryOperation>
   T transform_reduce(ExecutionPolicy&& exec,
                      ForwardIterator first, ForwardIterator last,
                      T init, BinaryOperation binary_op, UnaryOperation unary_op);
 ```
-*Requires:*
-- `T` shall be `MoveConstructible` (Table  [[tab:moveconstructible]]).
-- All of
 - `binary_op(init, init)`,
 - `binary_op(init, unary_op(*first))`,
 - `binary_op(unary_op(*first), init)`, and
 - `binary_op(unary_op(*first), unary_op(*first))`
-  shall be convertible to `T`.
-- Neither `unary_op` nor `binary_op` shall invalidate subranges, or
-  modify elements in the range \[`first`, `last`\].
 *Returns:*
 ``` cpp
 GENERALIZED_SUM(binary_op, init, unary_op(*i), ...)
@@ -480,34 +277,35 @@ for every iterator `i` in \[`first`, `last`).
 ### Partial sum <a id="partial.sum">[[partial.sum]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator>
- OutputIterator partial_sum(
-    InputIterator first, InputIterator last,
                 OutputIterator result);
 template<class InputIterator, class OutputIterator, class BinaryOperation>
- OutputIterator partial_sum(
-    InputIterator first, InputIterator last,
                 OutputIterator result, BinaryOperation binary_op);
 ```
-*Requires:* `InputIterator`’s value type shall be constructible from the
-type of `*first`. The result of the expression `acc + *i` or
-`binary_op(acc, *i)` shall be implicitly convertible to
-`InputIterator`’s value type. `acc` shall be
-writable ([[iterator.requirements.general]]) to the `result` output
-iterator. In the ranges \[`first`, `last`\] and \[`result`,
-`result + (last - first)`\] `binary_op` shall neither modify elements
-nor invalidate iterators or subranges.[^16]
 *Effects:* For a non-empty range, the function creates an accumulator
 `acc` whose type is `InputIterator`’s value type, initializes it with
 `*first`, and assigns the result to `*result`. For every iterator `i` in
 \[`first + 1`, `last`) in order, `acc` is then modified by
-`acc = acc + *i` or `acc = binary_op(acc, *i)` and the result is
-assigned to `*(result + (i - first))`.
 *Returns:* `result + (last - first)`.
 *Complexity:* Exactly `(last - first) - 1` applications of the binary
 operation.
@@ -516,27 +314,27 @@ operation.
 ### Exclusive scan <a id="exclusive.scan">[[exclusive.scan]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator, class T>
- OutputIterator exclusive_scan(InputIterator first, InputIterator last,
-                                OutputIterator result,
- T init);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return exclusive_scan(first, last, result, init, plus<>());
 ```
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
-  ForwardIterator2 exclusive_scan(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
- ForwardIterator2 result,
-                                  T init);
 ```
 *Effects:* Equivalent to:
 ``` cpp
@@ -544,28 +342,35 @@ return exclusive_scan(std::forward<ExecutionPolicy>(exec),
                       first, last, result, init, plus<>());
 ```
 ``` cpp
 template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
- OutputIterator exclusive_scan(InputIterator first, InputIterator last,
-                                OutputIterator result,
- T init, BinaryOperation binary_op);
 template<class ExecutionPolicy,
          class ForwardIterator1, class ForwardIterator2, class T, class BinaryOperation>
-  ForwardIterator2 exclusive_scan(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
- ForwardIterator2 result,
-                                  T init, BinaryOperation binary_op);
 ```
-*Requires:*
-- `T` shall be `MoveConstructible` (Table  [[tab:moveconstructible]]).
-- All of `binary_op(init, init)`, `binary_op(init, *first)`, and
- `binary_op(*first, *first)` shall be convertible to `T`.
-- `binary_op` shall neither invalidate iterators or subranges, nor
-  modify elements in the ranges \[`first`, `last`\] or \[`result`,
   `result + (last - first)`\].
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of:
@@ -579,19 +384,20 @@ GENERALIZED_NONCOMMUTATIVE_SUM(
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
 *Remarks:* `result` may be equal to `first`.
 [*Note 1*: The difference between `exclusive_scan` and `inclusive_scan`
-is that `exclusive_scan` excludes the `i`th input element from the `i`th
 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>
- OutputIterator inclusive_scan(InputIterator first, InputIterator last,
                    OutputIterator result);
 ```
 *Effects:* Equivalent to:
@@ -599,11 +405,12 @@ template<class InputIterator, class OutputIterator>
 return inclusive_scan(first, last, result, plus<>());
 ```
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
-  ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
                    ForwardIterator2 result);
 ```
 *Effects:* Equivalent to:
@@ -612,43 +419,50 @@ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
 return inclusive_scan(std::forward<ExecutionPolicy>(exec), first, last, result, plus<>());
 ```
 ``` cpp
 template<class InputIterator, class OutputIterator, class BinaryOperation>
- OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                                OutputIterator result,
- BinaryOperation binary_op);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryOperation>
-  ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
- ForwardIterator2 result,
-                                  BinaryOperation binary_op);
 template<class InputIterator, class OutputIterator, class BinaryOperation, class T>
- OutputIterator inclusive_scan(InputIterator first, InputIterator last,
-                                OutputIterator result,
- BinaryOperation binary_op, T init);
 template<class ExecutionPolicy,
          class ForwardIterator1, class ForwardIterator2, class BinaryOperation, class T>
-  ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
- ForwardIterator2 result,
-                                  BinaryOperation binary_op, T init);
 ```
-*Requires:*
-- If `init` is provided, `T` shall be `MoveConstructible`
-  (Table  [[tab:moveconstructible]]); otherwise, `ForwardIterator1`’s
-  value type shall be `MoveConstructible`.
-- If `init` is provided, all of `binary_op(init, init)`,
-  `binary_op(init, *first)`, and `binary_op(*first, *first)` shall be
-  convertible to `T`; otherwise, `binary_op(*first, *first)` shall be
- convertible to `ForwardIterator1`’s value type.
-- `binary_op` shall neither invalidate iterators or subranges, nor
-  modify elements in the ranges \[`first`, `last`\] or \[`result`,
   `result + (last - first)`\].
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of
@@ -665,47 +479,48 @@ through `result + K` the value of
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
 *Remarks:* `result` may be equal to `first`.
 [*Note 1*: The difference between `exclusive_scan` and `inclusive_scan`
-is that `inclusive_scan` includes the `i`th input element in the `i`th
-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,
          class BinaryOperation, class UnaryOperation>
- OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
-                                          OutputIterator result,
- T init,
- BinaryOperation binary_op,
-                                          UnaryOperation unary_op);
 template<class ExecutionPolicy,
          class ForwardIterator1, class ForwardIterator2, class T,
          class BinaryOperation, class UnaryOperation>
-  ForwardIterator2 transform_exclusive_scan(ExecutionPolicy&& exec,
                              ForwardIterator1 first, ForwardIterator1 last,
- ForwardIterator2 result,
-                                            T init,
-                                            BinaryOperation binary_op,
-                                            UnaryOperation unary_op);
 ```
-*Requires:*
-- `T` shall be `MoveConstructible` (Table  [[tab:moveconstructible]]).
-- All of
 - `binary_op(init, init)`,
 - `binary_op(init, unary_op(*first))`, and
 - `binary_op(unary_op(*first), unary_op(*first))`
-  shall be convertible to `T`.
-- Neither `unary_op` nor `binary_op` shall invalidate iterators or
-  subranges, or modify elements in the ranges \[`first`, `last`\] or
-  \[`result`, `result + (last - first)`\].
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of:
 ``` cpp
@@ -731,56 +546,59 @@ may be nondeterministic. `transform_exclusive_scan` does not apply
 ### Transform inclusive scan <a id="transform.inclusive.scan">[[transform.inclusive.scan]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator,
          class BinaryOperation, class UnaryOperation>
- OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
- BinaryOperation binary_op,
-                                          UnaryOperation unary_op);
 template<class ExecutionPolicy,
          class ForwardIterator1, class ForwardIterator2,
          class BinaryOperation, class UnaryOperation>
-  ForwardIterator2 transform_inclusive_scan(ExecutionPolicy&& exec,
                              ForwardIterator1 first, ForwardIterator1 last,
                              ForwardIterator2 result,
- BinaryOperation binary_op,
-                                            UnaryOperation unary_op);
 template<class InputIterator, class OutputIterator,
          class BinaryOperation, class UnaryOperation, class T>
- OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
- BinaryOperation binary_op,
-                                          UnaryOperation unary_op,
                              T init);
 template<class ExecutionPolicy,
          class ForwardIterator1, class ForwardIterator2,
          class BinaryOperation, class UnaryOperation, class T>
-  ForwardIterator2 transform_inclusive_scan(ExecutionPolicy&& exec,
                              ForwardIterator1 first, ForwardIterator1 last,
                              ForwardIterator2 result,
- BinaryOperation binary_op,
-                                            UnaryOperation unary_op,
                              T init);
 ```
-*Requires:*
-- If `init` is provided, `T` shall be `MoveConstructible`
-  (Table  [[tab:moveconstructible]]); otherwise, `ForwardIterator1`’s
-  value type shall be `MoveConstructible`.
-- If `init` is provided, all of
 - `binary_op(init, init)`,
 - `binary_op(init, unary_op(*first))`, and
 - `binary_op(unary_op(*first), unary_op(*first))`
-  shall be convertible to `T`; otherwise,
- `binary_op(unary_op(*first), unary_op(*first))` shall be convertible
-  to `ForwardIterator1`’s value type.
-- Neither `unary_op` nor `binary_op` shall invalidate iterators or
-  subranges, nor modify elements in the ranges \[`first`, `last`\] or
-  \[`result`, `result + (last - first)`\].
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
@@ -810,68 +628,65 @@ may be nondeterministic. `transform_inclusive_scan` does not apply
 ### Adjacent difference <a id="adjacent.difference">[[adjacent.difference]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator>
-  OutputIterator
     adjacent_difference(InputIterator first, InputIterator last,
                         OutputIterator result);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator2
     adjacent_difference(ExecutionPolicy&& exec,
-                        ForwardIterator1 first, ForwardIterator1 last,
-                        ForwardIterator2 result);
 template<class InputIterator, class OutputIterator, class BinaryOperation>
-  OutputIterator
     adjacent_difference(InputIterator first, InputIterator last,
-                        OutputIterator result,
-                        BinaryOperation binary_op);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryOperation>
   ForwardIterator2
     adjacent_difference(ExecutionPolicy&& exec,
                         ForwardIterator1 first, ForwardIterator1 last,
-                        ForwardIterator2 result,
-                        BinaryOperation binary_op);
 ```
-*Requires:*
-- For the overloads with no `ExecutionPolicy`, `InputIterator`’s value
-  type shall be `MoveAssignable` (Table  [[tab:moveassignable]]) and
-  shall be constructible from the type of `*first`. `acc` (defined
-  below) shall be writable ([[iterator.requirements.general]]) to the
-  `result` output iterator. The result of the expression `val - acc` or
-  `binary_op(val, acc)` shall be writable to the `result` output
-  iterator.
-- For the overloads with an `ExecutionPolicy`, the value type of
-  `ForwardIterator1` shall be `CopyConstructible`
-  (Table  [[tab:copyconstructible]]), constructible from the expression
- `*first - *first` or `binary_op(*first, *first)`, and assignable to
- the value type of `ForwardIterator2`.
 - For all overloads, in the ranges \[`first`, `last`\] and \[`result`,
-  `result + (last - first)`\], `binary_op` shall neither modify elements
- nor invalidate iterators or subranges.[^17]
 *Effects:* For the overloads with no `ExecutionPolicy` and a non-empty
-range, the function creates an accumulator `acc` whose type is
-`InputIterator`’s value type, initializes it with `*first`, and assigns
-the result to `*result`. For every iterator `i` in \[`first + 1`,
-`last`) in order, creates an object `val` whose type is
-`InputIterator`’s value type, initializes it with `*i`, computes
-`val - acc` or `binary_op(val, 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, first
-the function creates an object whose type is `ForwardIterator1`’s value
-type, initializes it with `*first`, and assigns the result to `*result`.
-Then for every `d` in \[`1`, `last - first - 1`\], creates an object
-`val` whose type is `ForwardIterator1`’s value type, initializes it with
-`*(first + d) - *(first + d - 1)` or
-`binary_op(*(first + d), *(first + d - 1))`, and assigns the result to
-`*(result + d)`.
 *Returns:* `result + (last - first)`.
 *Complexity:* Exactly `(last - first) - 1` applications of the binary
 operation.
@@ -883,15 +698,15 @@ shall not overlap.
 ### Iota <a id="numeric.iota">[[numeric.iota]]</a>
 ``` cpp
 template<class ForwardIterator, class T>
-  void iota(ForwardIterator first, ForwardIterator last, T value);
 ```
-*Requires:* `T` shall be convertible to `ForwardIterator`’s value type.
-The expression `++val`, where `val` has type `T`, shall be well formed.
 *Effects:* For each element referred to by the iterator `i` in the range
 \[`first`, `last`), assigns `*i = value` and increments `value` as if by
 `++value`.
@@ -902,39 +717,73 @@ The expression `++val`, where `val` has type `T`, shall be well formed.
 ``` cpp
 template<class M, class N>
   constexpr common_type_t<M,N> gcd(M m, N n);
 ```
-*Requires:* `|m|` and `|n|` shall be representable as a value of
 `common_type_t<M, N>`.
 [*Note 1*: These requirements ensure, for example, that
-`gcd(m, m) = |m|` is representable as a value of type
 `M`. — *end note*]
-*Remarks:* If either `M` or `N` is not an integer type, or if either is
-cv `bool`, the program is ill-formed.
 *Returns:* Zero when `m` and `n` are both zero. Otherwise, returns the
-greatest common divisor of `|m|` and `|n|`.
 *Throws:* Nothing.
 ### Least common multiple <a id="numeric.ops.lcm">[[numeric.ops.lcm]]</a>
 ``` cpp
 template<class M, class N>
   constexpr common_type_t<M,N> lcm(M m, N n);
 ```
-*Requires:* `|m|` and `|n|` shall be representable as a value of
-`common_type_t<M, N>`. The least common multiple of `|m|` and `|n|`
-shall be representable as a value of type `common_type_t<M,N>`.
-*Remarks:* If either `M` or `N` is not an integer type, or if either is
-cv `bool` the program is ill-formed.
 *Returns:* Zero when either `m` or `n` is zero. Otherwise, returns the
-least common multiple of `|m|` and `|n|`.
 *Throws:* Nothing.

 ## 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:
+- `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>
+ constexpr T accumulate(InputIterator first, InputIterator last, T init);
 template<class InputIterator, class T, class BinaryOperation>
+ constexpr T accumulate(InputIterator first, InputIterator last, T init,
                          BinaryOperation binary_op);
 ```
+*Preconditions:* `T` meets the *Cpp17CopyConstructible*
+([[cpp17.copyconstructible]]) and *Cpp17CopyAssignable*
+([[cpp17.copyassignable]]) requirements. In the range \[`first`,
+`last`\], `binary_op` neither modifies elements nor invalidates
+iterators or subranges. [^6]
 *Effects:* Computes its result by initializing the accumulator `acc`
+with the initial value `init` and then modifies it with
+`acc = std::move(acc) + *i` or `acc = binary_op(std::move(acc), *i)` for
+every iterator `i` in the range \[`first`, `last`) in order. [^7]
 ### Reduce <a id="reduce">[[reduce]]</a>
 ``` cpp
 template<class InputIterator>
+ constexpr typename iterator_traits<InputIterator>::value_type
     reduce(InputIterator first, InputIterator last);
 ```
 *Effects:* Equivalent to:
               typename iterator_traits<ForwardIterator>::value_type{});
 ```
 ``` cpp
 template<class InputIterator, class T>
+ constexpr T reduce(InputIterator first, InputIterator last, T init);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return reduce(std::forward<ExecutionPolicy>(exec), first, last, init, plus<>());
 ```
 ``` cpp
 template<class InputIterator, class T, class BinaryOperation>
+ constexpr T reduce(InputIterator first, InputIterator last, T init,
                      BinaryOperation binary_op);
 template<class ExecutionPolicy, class ForwardIterator, class T, class BinaryOperation>
   T reduce(ExecutionPolicy&& exec,
            ForwardIterator first, ForwardIterator last, T init,
            BinaryOperation binary_op);
 ```
+*Mandates:* All of
+- `binary_op(init, *first)`,
+- `binary_op(*first, init)`,
+- `binary_op(init, init)`, and
+- `binary_op(*first, *first)`
+are convertible to `T`.
+*Preconditions:*
+- `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`.
 ### Inner product <a id="inner.product">[[inner.product]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2, class T>
+ constexpr T inner_product(InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, T init);
 template<class InputIterator1, class InputIterator2, class T,
          class BinaryOperation1, class BinaryOperation2>
+ constexpr T inner_product(InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, T init,
                             BinaryOperation1 binary_op1,
                             BinaryOperation2 binary_op2);
 ```
+*Preconditions:* `T` meets the *Cpp17CopyConstructible*
+([[cpp17.copyconstructible]]) and *Cpp17CopyAssignable*
+([[cpp17.copyassignable]]) requirements. In the ranges \[`first1`,
 `last1`\] and \[`first2`, `first2 + (last1 - first1)`\] `binary_op1` and
+`binary_op2` neither modifies elements nor invalidates iterators or
+subranges. [^8]
 *Effects:* Computes its result by initializing the accumulator `acc`
 with the initial value `init` and then modifying it with
+`acc = std::move(acc) + (*i1) * (*i2)` or
+`acc = binary_op1(std::move(acc), binary_op2(*i1, *i2))` for every
+iterator `i1` in the range \[`first1`, `last1`) and iterator `i2` in the
+range \[`first2`, `first2 + (last1 - first1)`) in order.
 ### Transform reduce <a id="transform.reduce">[[transform.reduce]]</a>
 ``` cpp
 template<class InputIterator1, class InputIterator2, class T>
+ constexpr T transform_reduce(InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2,
                                T init);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return transform_reduce(first1, last1, first2, init, plus<>(), multiplies<>());
 ```
+``` cpp
+template<class ExecutionPolicy,
+         class ForwardIterator1, class ForwardIterator2, class T>
+  T transform_reduce(ExecutionPolicy&& exec,
+                     ForwardIterator1 first1, ForwardIterator1 last1,
+                     ForwardIterator2 first2,
+                     T init);
+```
+*Effects:* Equivalent to:
+``` cpp
+return transform_reduce(std::forward<ExecutionPolicy>(exec),
+                        first1, last1, first2, init, plus<>(), multiplies<>());
+```
 ``` cpp
 template<class InputIterator1, class InputIterator2, class T,
          class BinaryOperation1, class BinaryOperation2>
+ constexpr T transform_reduce(InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2,
                                T init,
                                BinaryOperation1 binary_op1,
                                BinaryOperation2 binary_op2);
 template<class ExecutionPolicy,
                      T init,
                      BinaryOperation1 binary_op1,
                      BinaryOperation2 binary_op2);
 ```
+*Mandates:* All of
 - `binary_op1(init, init)`,
 - `binary_op1(init, binary_op2(*first1, *first2))`,
 - `binary_op1(binary_op2(*first1, *first2), init)`, and
 - `binary_op1(binary_op2(*first1, *first2), binary_op2(*first1, *first2))`
+are convertible to `T`.
+*Preconditions:*
+- `T` meets the *Cpp17MoveConstructible* ([[cpp17.moveconstructible]])
+  requirements.
+- Neither `binary_op1` nor `binary_op2` invalidates subranges, nor
+  modifies elements in the ranges \[`first1`, `last1`\] and \[`first2`,
   `first2 + (last1 - first1)`\].
 *Returns:*
 ``` cpp
 `binary_op2`.
 ``` cpp
 template<class InputIterator, class T,
          class BinaryOperation, class UnaryOperation>
+ constexpr T transform_reduce(InputIterator first, InputIterator last, T init,
                                BinaryOperation binary_op, UnaryOperation unary_op);
 template<class ExecutionPolicy,
          class ForwardIterator, class T,
          class BinaryOperation, class UnaryOperation>
   T transform_reduce(ExecutionPolicy&& exec,
                      ForwardIterator first, ForwardIterator last,
                      T init, BinaryOperation binary_op, UnaryOperation unary_op);
 ```
+*Mandates:* All of
 - `binary_op(init, init)`,
 - `binary_op(init, unary_op(*first))`,
 - `binary_op(unary_op(*first), init)`, and
 - `binary_op(unary_op(*first), unary_op(*first))`
+are convertible to `T`.
+*Preconditions:*
+- `T` meets the *Cpp17MoveConstructible* ([[cpp17.moveconstructible]])
+  requirements.
+- Neither `unary_op` nor `binary_op` invalidates subranges, nor modifies
+  elements in the range \[`first`, `last`\].
 *Returns:*
 ``` cpp
 GENERALIZED_SUM(binary_op, init, unary_op(*i), ...)
 ### Partial sum <a id="partial.sum">[[partial.sum]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator>
+ constexpr OutputIterator
+ partial_sum(InputIterator first, InputIterator last,
                 OutputIterator result);
 template<class InputIterator, class OutputIterator, class BinaryOperation>
+ constexpr OutputIterator
+ partial_sum(InputIterator first, InputIterator last,
                 OutputIterator result, BinaryOperation binary_op);
 ```
+*Mandates:* `InputIterator`’s value type is constructible from `*first`.
+The result of the expression `std::move(acc) + *i` or
+`binary_op(std::move(acc), *i)` is implicitly convertible to
+`InputIterator`’s value type. `acc` is
+writable [[iterator.requirements.general]] to `result`.
+*Preconditions:* In the ranges \[`first`, `last`\] and \[`result`,
+`result + (last - first)`\] `binary_op` neither modifies elements nor
+invalidates iterators or subranges. [^9]
 *Effects:* For a non-empty range, the function creates an accumulator
 `acc` whose type is `InputIterator`’s value type, initializes it with
 `*first`, and assigns the result to `*result`. For every iterator `i` in
 \[`first + 1`, `last`) in order, `acc` is then modified by
+`acc = std::move(acc) + *i` or `acc = binary_op(std::move(acc), *i)` and
+the result is assigned to `*(result + (i - first))`.
 *Returns:* `result + (last - first)`.
 *Complexity:* Exactly `(last - first) - 1` applications of the binary
 operation.
 ### Exclusive scan <a id="exclusive.scan">[[exclusive.scan]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator, class T>
+ constexpr OutputIterator
+    exclusive_scan(InputIterator first, InputIterator last,
+                   OutputIterator result, T init);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return exclusive_scan(first, last, result, init, plus<>());
 ```
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
+  ForwardIterator2
+    exclusive_scan(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
+ ForwardIterator2 result, T init);
 ```
 *Effects:* Equivalent to:
 ``` cpp
                       first, last, result, init, plus<>());
 ```
 ``` cpp
 template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
+ constexpr OutputIterator
+    exclusive_scan(InputIterator first, InputIterator last,
+                   OutputIterator result, T init, BinaryOperation binary_op);
 template<class ExecutionPolicy,
          class ForwardIterator1, class ForwardIterator2, class T, class BinaryOperation>
+  ForwardIterator2
+    exclusive_scan(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
+ ForwardIterator2 result, T init, BinaryOperation binary_op);
 ```
+*Mandates:* All of
+- `binary_op(init, init)`,
+- `binary_op(init, *first)`, and
+- `binary_op(*first, *first)`
+are convertible to `T`.
+*Preconditions:*
+- `T` meets the *Cpp17MoveConstructible* ([[cpp17.moveconstructible]])
+  requirements.
+- `binary_op` neither invalidates iterators or subranges, nor modifies
+  elements in the ranges \[`first`, `last`\] or \[`result`,
   `result + (last - first)`\].
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of:
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
 *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>
+ constexpr OutputIterator
+    inclusive_scan(InputIterator first, InputIterator last,
                    OutputIterator result);
 ```
 *Effects:* Equivalent to:
 return inclusive_scan(first, last, result, plus<>());
 ```
 ``` cpp
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
+  ForwardIterator2
+    inclusive_scan(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
                    ForwardIterator2 result);
 ```
 *Effects:* Equivalent to:
 return inclusive_scan(std::forward<ExecutionPolicy>(exec), first, last, result, plus<>());
 ```
 ``` cpp
 template<class InputIterator, class OutputIterator, class BinaryOperation>
+ constexpr OutputIterator
+    inclusive_scan(InputIterator first, InputIterator last,
+                   OutputIterator result, BinaryOperation binary_op);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryOperation>
+  ForwardIterator2
+    inclusive_scan(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
+ ForwardIterator2 result, BinaryOperation binary_op);
 template<class InputIterator, class OutputIterator, class BinaryOperation, class T>
+ constexpr OutputIterator
+    inclusive_scan(InputIterator first, InputIterator last,
+                   OutputIterator result, BinaryOperation binary_op, T init);
 template<class ExecutionPolicy,
          class ForwardIterator1, class ForwardIterator2, class BinaryOperation, class T>
+  ForwardIterator2
+    inclusive_scan(ExecutionPolicy&& exec,
                    ForwardIterator1 first, ForwardIterator1 last,
+ ForwardIterator2 result, BinaryOperation binary_op, T init);
 ```
+Let `U` be the value type of `decltype(first)`.
+*Mandates:* If `init` is provided, all of
+- `binary_op(init, init)`,
+- `binary_op(init, *first)`, and
+- `binary_op(*first, *first)`
+are convertible to `T`; otherwise, `binary_op(*first, *first)` is
+convertible to `U`.
+*Preconditions:*
+- If `init` is provided, `T` meets the *Cpp17MoveConstructible*
+  ([[cpp17.moveconstructible]]) requirements; otherwise, `U` meets the
+  *Cpp17MoveConstructible* requirements.
+- `binary_op` neither invalidates iterators or subranges, nor modifies
+  elements in the ranges \[`first`, `last`\] or \[`result`,
   `result + (last - first)`\].
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of
 *Complexity:* 𝑂(`last - first`) applications of `binary_op`.
 *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,
          class BinaryOperation, class UnaryOperation>
+ constexpr OutputIterator
+    transform_exclusive_scan(InputIterator first, InputIterator last,
+                             OutputIterator result, T init,
+ BinaryOperation binary_op, UnaryOperation unary_op);
 template<class ExecutionPolicy,
          class ForwardIterator1, class ForwardIterator2, class T,
          class BinaryOperation, class UnaryOperation>
+  ForwardIterator2
+    transform_exclusive_scan(ExecutionPolicy&& exec,
                              ForwardIterator1 first, ForwardIterator1 last,
+ ForwardIterator2 result, T init,
+                             BinaryOperation binary_op, UnaryOperation unary_op);
 ```
+*Mandates:* All of
 - `binary_op(init, init)`,
 - `binary_op(init, unary_op(*first))`, and
 - `binary_op(unary_op(*first), unary_op(*first))`
+are convertible to `T`.
+*Preconditions:*
+- `T` meets the *Cpp17MoveConstructible* ([[cpp17.moveconstructible]])
+  requirements.
+- Neither `unary_op` nor `binary_op` invalidates iterators or subranges,
+  nor modifies elements in the ranges \[`first`, `last`\] or \[`result`,
+  `result + (last - first)`\].
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of:
 ``` cpp
 ### Transform inclusive scan <a id="transform.inclusive.scan">[[transform.inclusive.scan]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator,
          class BinaryOperation, class UnaryOperation>
+ constexpr OutputIterator
+    transform_inclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
+ BinaryOperation binary_op, UnaryOperation unary_op);
 template<class ExecutionPolicy,
          class ForwardIterator1, class ForwardIterator2,
          class BinaryOperation, class UnaryOperation>
+  ForwardIterator2
+    transform_inclusive_scan(ExecutionPolicy&& exec,
                              ForwardIterator1 first, ForwardIterator1 last,
                              ForwardIterator2 result,
+ BinaryOperation binary_op, UnaryOperation unary_op);
 template<class InputIterator, class OutputIterator,
          class BinaryOperation, class UnaryOperation, class T>
+ constexpr OutputIterator
+    transform_inclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
+ BinaryOperation binary_op, UnaryOperation unary_op,
                              T init);
 template<class ExecutionPolicy,
          class ForwardIterator1, class ForwardIterator2,
          class BinaryOperation, class UnaryOperation, class T>
+  ForwardIterator2
+    transform_inclusive_scan(ExecutionPolicy&& exec,
                              ForwardIterator1 first, ForwardIterator1 last,
                              ForwardIterator2 result,
+ BinaryOperation binary_op, UnaryOperation unary_op,
                              T init);
 ```
+Let `U` be the value type of `decltype(first)`.
+*Mandates:* If `init` is provided, all of
 - `binary_op(init, init)`,
 - `binary_op(init, unary_op(*first))`, and
 - `binary_op(unary_op(*first), unary_op(*first))`
+are convertible to `T`; otherwise,
+`binary_op(unary_op(*first), unary_op(*first))` is convertible to `U`.
+*Preconditions:*
+- If `init` is provided, `T` meets the *Cpp17MoveConstructible*
+  ([[cpp17.moveconstructible]]) requirements; otherwise, `U` meets the
+  *Cpp17MoveConstructible* requirements.
+- Neither `unary_op` nor `binary_op` invalidates iterators or subranges,
+  nor modifies elements in the ranges \[`first`, `last`\] or \[`result`,
+  `result + (last - first)`\].
 *Effects:* For each integer `K` in \[`0`, `last - first`) assigns
 through `result + K` the value of
 - *GENERALIZED_NONCOMMUTATIVE_SUM*(
 ### Adjacent difference <a id="adjacent.difference">[[adjacent.difference]]</a>
 ``` cpp
 template<class InputIterator, class OutputIterator>
+ constexpr OutputIterator
     adjacent_difference(InputIterator first, InputIterator last,
                         OutputIterator result);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
   ForwardIterator2
     adjacent_difference(ExecutionPolicy&& exec,
+                        ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 result);
 template<class InputIterator, class OutputIterator, class BinaryOperation>
+ constexpr OutputIterator
     adjacent_difference(InputIterator first, InputIterator last,
+                        OutputIterator result, BinaryOperation binary_op);
 template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
          class BinaryOperation>
   ForwardIterator2
     adjacent_difference(ExecutionPolicy&& exec,
                         ForwardIterator1 first, ForwardIterator1 last,
+                        ForwardIterator2 result, BinaryOperation binary_op);
 ```
+Let `T` be the value type of `decltype(first)`. For the overloads that
+do not take an argument `binary_op`, let `binary_op` be an lvalue that
+denotes an object of type `minus<>`.
+*Mandates:*
+- For the overloads with no `ExecutionPolicy`, `T` is constructible from
+  `*first`. `acc` (defined below) is
+ writable [[iterator.requirements.general]] to the `result` output
+  iterator. The result of the expression
+  `binary_op(val, std::move(acc))` is writable to `result`.
+- For the overloads with an `ExecutionPolicy`, the result of the
+ expressions `binary_op(*first, *first)` and `*first` are writable to
+  `result`.
+*Preconditions:*
+- 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
+`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
 operation.
 ### Iota <a id="numeric.iota">[[numeric.iota]]</a>
 ``` cpp
 template<class ForwardIterator, class T>
+ constexpr void iota(ForwardIterator first, ForwardIterator last, T value);
 ```
+*Mandates:* `T` is convertible to `ForwardIterator`’s value type. The
+expression `++val`, where `val` has type `T`, is well-formed.
 *Effects:* For each element referred to by the iterator `i` in the range
 \[`first`, `last`), assigns `*i = value` and increments `value` as if by
 `++value`.
 ``` 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
+`gcd(m, m)` = |`m`| is representable as a value of type
 `M`. — *end note*]
 *Returns:* Zero when `m` and `n` are both zero. Otherwise, returns the
+greatest common divisor of |`m`| and |`n`|.
 *Throws:* Nothing.
 ### Least common multiple <a id="numeric.ops.lcm">[[numeric.ops.lcm]]</a>
 ``` 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>`.
 *Returns:* Zero when either `m` or `n` is zero. Otherwise, returns the
+least common multiple of |`m`| and |`n`|.
 *Throws:* Nothing.
+### Midpoint <a id="numeric.ops.midpoint">[[numeric.ops.midpoint]]</a>
+``` cpp
+template<class T>
+  constexpr T midpoint(T a, T b) noexcept;
+```
+*Constraints:* `T` is an arithmetic type other than `bool`.
+*Returns:* Half the sum of `a` and `b`. If `T` is an integer type and
+the sum is odd, the result is rounded towards `a`.
+*Remarks:* No overflow occurs. If `T` is a floating-point type, at most
+one inexact operation occurs.
+``` cpp
+template<class T>
+  constexpr T* midpoint(T* a, T* b);
+```
+*Constraints:* `T` is an object type.
+*Mandates:* `T` is a complete type.
+*Preconditions:* `a` and `b` point to, respectively, elements i and j of
+the same array object `x`.
+[*Note 1*: As specified in [[basic.compound]], an object that is not an
+array element is considered to belong to a single-element array for this
+purpose and a pointer past the last element of an array of n elements is
+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.

Diff to HTML by rtfpessoa