29 Numerics library [numerics]

29.8 Generalized numeric operations [numeric.ops]

29.8.1 Header <numeric> synopsis [numeric.ops.overview]

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);
}
1
#

Требования к типам аргументов алгоритмов, которые описаны во введении к пункту, [algorithms] также применимы к следующим алгоритмам.

2
#

На протяжении всего этого подпункта, параметры UnaryOperation, BinaryOperation, BinaryOperation1, и BinaryOperation2 используются всякий раз , когда алгоритм ожидает функциональный объект ([function.objects]).

3
#

[  Note: Использование закрытых диапазонов, а также полуоткрытых диапазонов для определения требований в этом подпункте является преднамеренным. ] — end note 

29.8.2 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);

1
#

Requires: T должны соответствовать требованиям CopyConstructible и CopyAssignable типам. В пределах [first, last], binary_­op не должны ни изменять элементы , ни к аннулированию итератора или поддиапазоны.281

2
#

Effects: Вычисляет свой результат, инициализируя аккумулятор acc начальным значением, init а затем изменяет его с помощью acc = acc + *i или acc = binary_­op(acc, *i) для каждого итератора i в диапазоне [first, last) по порядку.282

281)

Использование полностью замкнутых диапазонов является преднамеренным.

282)

accumulate аналогичен оператору сокращения APL и функции сокращения Common Lisp, но позволяет избежать трудности определения результата сокращения для пустой последовательности, всегда требуя начального значения.

29.8.3 Reduce [reduce]

template<class InputIterator> typename iterator_traits<InputIterator>::value_type reduce(InputIterator first, InputIterator last);

1
#

Effects: Эквивалентен: 

return reduce(first, last,
              typename iterator_traits<InputIterator>::value_type{});

template<class ExecutionPolicy, class ForwardIterator> typename iterator_traits<ForwardIterator>::value_type reduce(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last);

2
#

Effects: Эквивалентен: 

return reduce(std::forward<ExecutionPolicy>(exec), first, last,
              typename iterator_traits<ForwardIterator>::value_type{});

template<class InputIterator, class T> T reduce(InputIterator first, InputIterator last, T init);

3
#

Effects: Эквивалентен: 

return reduce(first, last, init, plus<>());

template<class ExecutionPolicy, class ForwardIterator, class T> T reduce(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, T init);

4
#

Effects: Эквивалентен: 

return reduce(std::forward<ExecutionPolicy>(exec), first, last, init, plus<>());

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);

5
#

Requires:

  • (5.1)

    T будет MoveConstructible (таблица 23).

  • (5.2)

    Все binary_­op(init, *first), binary_­op(*first, init), binary_­op(init, init)и binary_­op(*first, *first) должны быть конвертированы в T.

  • (5.3)

    binary_­op не должен ни аннулировать итераторы или поддиапазоны, ни изменять элементы в диапазоне [first, last].

6
#

Returns: GENERALIZED_­SUM(binary_­op, init, *i, ...) за каждый i ин [first, last).

7
#

Complexity: O(last - first) приложения binary_­op.

8
#

[  Note: Разница между reduce и accumulate заключается в том, что reduce применяется binary_­op в неопределенном порядке, что дает недетерминированный результат для неассоциативных или некоммутативных, binary_­op таких как сложение с плавающей запятой. ]  — end note 

29.8.4 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);

1
#

Requires: T должны соответствовать требованиям CopyConstructible и CopyAssignable типам. В диапазонах [first1, last1] и [first2, first2 + (last1 - first1)] binary_­op1 и binary_­op2 не должны изменять элементы или делать недействительными итераторы или поддиапазоны.283

2
#

Effects: Вычисляет свой результат, инициализируя аккумулятор acc начальным значением, init а затем изменяя его с помощью acc = acc + (*i1) * (*i2) или acc = binary_­op1(acc, binary_­op2(*i1, *i2)) для каждого итератора i1 в диапазоне [first1, last1) и итератора i2 в диапазоне [first2, first2 + (last1 - first1)) по порядку.

283)

Использование полностью замкнутых диапазонов является преднамеренным.

29.8.5 Transform reduce [transform.reduce]

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);

1
#

Effects: Эквивалентен: 

return transform_reduce(first1, last1, first2, init, plus<>(), multiplies<>());

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, class ForwardIterator1, class ForwardIterator2, class T, class BinaryOperation1, class BinaryOperation2> T transform_reduce(ExecutionPolicy&& exec, ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);

2
#

Requires:

  • (2.1)

    T будет MoveConstructible (таблица 23).

  • (2.2)

    Все

    • (2.2.1)

      binary_­op1(init, init),

    • (2.2.2)

      binary_­op1(init, binary_­op2(*first1, *first2)),

    • (2.2.3)

      binary_­op1(binary_­op2(*first1, *first2), init), а также

    • (2.2.4)

      binary_­op1(binary_­op2(*first1, *first2), binary_­op2(*first1, *first2))

    конвертируется в T.

  • (2.3)

    Ни и binary_­op1 не binary_­op2 должны аннулировать поддиапазоны или изменять элементы в диапазонах [first1, last1] и [first2, first2 + (last1 - first1)].

3
#

Returns: 

GENERALIZED_SUM(binary_op1, init, binary_op2(*i, *(first2 + (i - first1))), ...)

для каждого итератора i в [first1, last1).

4
#

Complexity: O(last1 - first1) приложения каждый из binary_­op1 и 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 ForwardIterator, class T, class BinaryOperation, class UnaryOperation> T transform_reduce(ExecutionPolicy&& exec, ForwardIterator first, ForwardIterator last, T init, BinaryOperation binary_op, UnaryOperation unary_op);

5
#

Requires:

  • (5.1)

    T будет MoveConstructible (таблица 23).

  • (5.2)

    Все

    • (5.2.1)

      binary_­op(init, init),

    • (5.2.2)

      binary_­op(init, unary_­op(*first)),

    • (5.2.3)

      binary_­op(unary_­op(*first), init), а также

    • (5.2.4)

      binary_­op(unary_­op(*first), unary_­op(*first))

    конвертируется в T.

  • (5.3)

    Ни и unary_­op не binary_­op должно аннулировать поддиапазоны или изменять элементы в диапазоне [first, last].

6
#

Returns: 

GENERALIZED_SUM(binary_op, init, unary_op(*i), ...)

для каждого итератора i в [first, last).

7
#

Complexity: O(last - first) приложения каждый из unary_­op и binary_­op.

8
#

[  Note: transform_­reduce не относится unary_­op к init. ]  — end note 

29.8.6 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);

1
#

Requires: InputIteratorТип значения должен быть сконструирован из типа *first. Результат выражения acc + *i или binary_­op(acc, *i) должен быть неявно преобразован в InputIteratorтип значения. acc должен быть writable к result итератору вывода. В диапазонах [first, last] и [result, result + (last - first)] binary_­op не должен изменять элементы или делать недействительными итераторы или поддиапазоны.284

2
#

Effects: Для непустого диапазона функция создает аккумулятор acc , тип которого является InputIteratorтипом значения, инициализирует его *firstи присваивает результат *result. Для каждого итератора i по [first + 1, last) порядку acc затем модифицируется с помощью acc = acc + *i или, acc = binary_­op(acc, *i) а результат присваивается *(result + (i - first)).

3
#

Returns: result + (last - first).

4
#

Complexity: Собственно (last - first) - 1 применения бинарной операции.

5
#

Remarks: result может быть равно first.

284)

Использование полностью замкнутых диапазонов является преднамеренным.

29.8.7 Exclusive scan [exclusive.scan]

template<class InputIterator, class OutputIterator, class T> OutputIterator exclusive_scan(InputIterator first, InputIterator last, OutputIterator result, T init);

1
#

Effects: Эквивалентен: 

return exclusive_scan(first, last, result, init, plus<>());

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T> ForwardIterator2 exclusive_scan(ExecutionPolicy&& exec, ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 result, T init);

2
#

Effects: Эквивалентен: 

return exclusive_scan(std::forward<ExecutionPolicy>(exec),
                      first, last, result, init, plus<>());

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);

3
#

Requires:

  • (3.1)

    T будет MoveConstructible (таблица 23).

  • (3.2)

    Все binary_­op(init, init), binary_­op(init, *first)и binary_­op(*first, *first) должны быть конвертированы в T.

  • (3.3)

    binary_­op не должен ни аннулировать итераторы или поддиапазоны, ни изменять элементы в диапазонах [first, last] или [result, result + (last - first)].

4
#

Effects: Каждому целому числу K в [0, last - first) присваивается result + K значение: 

GENERALIZED_NONCOMMUTATIVE_SUM(
    binary_op, init, *(first + 0), *(first + 1), ..., *(first + K - 1))
5
#

Returns: Конец результирующего диапазона, начинающийся с result.

6
#

Complexity: O(last - first) приложения binary_­op.

7
#

Remarks: result может быть равно first.

8
#

[  Note: Разница между exclusive_­scan и в inclusive_­scan том, что exclusive_­scan исключает ith входной элемент из ith суммы. Если binary_­op не является математически ассоциативным, поведение exclusive_­scan может быть недетерминированным. ]  — end note 

29.8.8 Inclusive scan [inclusive.scan]

template<class InputIterator, class OutputIterator> OutputIterator inclusive_scan(InputIterator first, InputIterator last, OutputIterator result);

1
#

Effects: Эквивалентен: 

return inclusive_scan(first, last, result, plus<>());

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2> ForwardIterator2 inclusive_scan(ExecutionPolicy&& exec, ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 result);

2
#

Effects: Эквивалентен: 

return inclusive_scan(std::forward<ExecutionPolicy>(exec), first, last, result, plus<>());

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);

3
#

Requires:

  • (3.1)

    Если init предусмотрено, T должно быть MoveConstructible (Таблица 23); в противном случае ForwardIterator1тип значения должен быть MoveConstructible.

  • (3.2)

    Если init предусмотрено, все binary_­op(init, init), binary_­op(init, *first)и binary_­op(*first, *first) должны быть конвертированы в T; в противном случае binary_­op(*first, *first) должен быть преобразован в ForwardIterator1тип значения.

  • (3.3)

    binary_­op не должен ни аннулировать итераторы или поддиапазоны, ни изменять элементы в диапазонах [first, last] или [result, result + (last - first)].

4
#

Effects: Каждому целому числу K в [0, last - first) присваивается result + K значение

  • (4.1)

    GENERALIZED_­NONCOMMUTATIVE_­SUM(
        binary_­op, init, *(first + 0), *(first + 1), ..., *(first + K))
    если init предоставляется, или

  • (4.2)

    GENERALIZED_­NONCOMMUTATIVE_­SUM(
        binary_­op, *(first + 0), *(first + 1), ..., *(first + K))
    иначе.

5
#

Returns: Конец результирующего диапазона, начинающийся с result.

6
#

Complexity: O(last - first) приложения binary_­op.

7
#

Remarks: result может быть равно first.

8
#

[  Note: Разница между exclusive_­scan и inclusive_­scan состоит в том, что inclusive_­scan включает i-й входной элемент в i-ую сумму. Если binary_­op не является математически ассоциативным, поведение inclusive_­scan может быть недетерминированным. ]  — end note 

29.8.9 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, ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 result, T init, BinaryOperation binary_op, UnaryOperation unary_op);

1
#

Requires:

  • (1.1)

    T будет MoveConstructible (таблица 23).

  • (1.2)

    Все

    • (1.2.1)

      binary_­op(init, init),

    • (1.2.2)

      binary_­op(init, unary_­op(*first)), а также

    • (1.2.3)

      binary_­op(unary_­op(*first), unary_­op(*first))

    конвертируется в T.

  • (1.3)

    Ни и unary_­op не binary_­op должны аннулировать итераторы или поддиапазоны, или изменять элементы в диапазонах [first, last] или [result, result + (last - first)].

2
#

Effects: Каждому целому числу K в [0, last - first) присваивается result + K значение: 

GENERALIZED_NONCOMMUTATIVE_SUM(
    binary_op, init,
    unary_op(*(first + 0)), unary_op(*(first + 1)), ..., unary_op(*(first + K - 1)))
3
#

Returns: Конец результирующего диапазона, начинающийся с result.

4
#

Complexity: O(last - first) приложения каждый из unary_­op и binary_­op.

5
#

Remarks: result может быть равно first.

6
#

[  Note: Разница между transform_­exclusive_­scan и transform_­inclusive_­scan заключается в том, transform_­exclusive_­scan что ith элемент ввода исключается из ith суммы. Если binary_­op не является математически ассоциативным, поведение transform_­exclusive_­scan может быть недетерминированным. transform_­exclusive_­scan не относится unary_­op к init. ]  — end note 

29.8.10 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 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);

1
#

Requires:

  • (1.1)

    Если init предусмотрено, T должно быть MoveConstructible (Таблица 23); в противном случае ForwardIterator1тип значения должен быть MoveConstructible.

  • (1.2)

    Если init предоставляется, все

    • (1.2.1)

      binary_­op(init, init),

    • (1.2.2)

      binary_­op(init, unary_­op(*first)), а также

    • (1.2.3)

      binary_­op(unary_­op(*first), unary_­op(*first))

    может быть конвертирован в T; в противном случае binary_­op(unary_­op(*first), unary_­op(*first)) должен быть преобразован в ForwardIterator1тип значения.

  • (1.3)

    Ни и unary_­op не binary_­op должны аннулировать итераторы или поддиапазоны, а также изменять элементы в диапазонах [first, last] или [result, result + (last - first)].

2
#

Effects: Каждому целому числу K в [0, last - first) присваивается result + K значение

  • (2.1)

    GENERALIZED_­NONCOMMUTATIVE_­SUM(
        binary_­op, init,
        unary_­op(*(first + 0)), unary_­op(*(first + 1)), ..., unary_­op(*(first + K)))
    если init предоставляется, или

  • (2.2)

    GENERALIZED_­NONCOMMUTATIVE_­SUM(
        binary_­op,
        unary_­op(*(first + 0)), unary_­op(*(first + 1)), ..., unary_­op(*(first + K)))
    иначе.

3
#

Returns: Конец результирующего диапазона, начинающийся с result.

4
#

Complexity: O(last - first) приложения каждый из unary_­op и binary_­op.

5
#

Remarks: result может быть равно first.

6
#

[  Note: Разница между transform_­exclusive_­scan и transform_­inclusive_­scan заключается в том, transform_­inclusive_­scan что ith в ith сумму входит входной элемент . Если binary_­op не является математически ассоциативным, поведение transform_­inclusive_­scan может быть недетерминированным. transform_­inclusive_­scan не относится unary_­op к init. ]  — end note 

29.8.11 Adjacent difference [adjacent.difference]

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);

1
#

Requires:

  • (1.1)

    Для перегрузки без каких - либо ExecutionPolicy, InputIterator«с типом значение должно быть MoveAssignable (таблица 25) и должны быть конструктивны от типа *first. acc (определенный ниже) должен быть доступен для записи ([iterator.requirements.general]) result итератору вывода. Результат выражения val - acc или binary_­op(val, acc) должен быть доступен для записи в result итератор вывода.

  • (1.2)

    Для перегрузок с a ExecutionPolicyтип значения ForwardIterator1 должен быть CopyConstructible (Таблица 24), конструируемым из выражения *first - *first или binary_­op(*first, *first)и присваиваемым типу значения ForwardIterator2.

  • (1.3)

    Для всех перегрузок, в диапазонах [first, last] и [result, result + (last - first)], binary_­op не должен ни изменять элементы , ни к аннулированию итератора или поддиапазонов.285

2
#

Effects: Для перегрузок без ExecutionPolicy и с непустым диапазоном функция создает аккумулятор acc , тип которого является InputIteratorтипом значения, инициализирует его *firstи присваивает результат *result. Для каждого итератора i по [first + 1, last) порядку создает объект val , тип которого является типом InputIteratorзначения, инициализирует его *i, вычисляет val - acc или binary_­op(val, acc), присваивает результат *(result + (i - first))и перемещает присваивает из val в acc.

3
#

Для перегрузок с ExecutionPolicy диапазоном и непустым диапазоном сначала функция создает объект, тип которого является ForwardIterator1типом значения, инициализирует его *firstи присваивает результат *result. Затем для каждого d in [1, last - first - 1]создает объект val , тип которого является типом ForwardIterator1значения, инициализирует его с помощью *(first + d) - *(first + d - 1) или binary_­op(*(first + d), *(first + d - 1))и присваивает результат *(result + d).

4
#

Returns: result + (last - first).

5
#

Complexity: Собственно (last - first) - 1 применения бинарной операции.

6
#

Remarks: Для перегрузок без ExecutionPolicy, result может быть равно first. Для перегрузок с ExecutionPolicyдиапазоны [first, last) и [result, result + (last - first)) не должны перекрываться.

285)

Использование полностью замкнутых диапазонов является преднамеренным.

29.8.12 Iota [numeric.iota]

template <class ForwardIterator, class T> void iota(ForwardIterator first, ForwardIterator last, T value);

1
#

Requires: T должен быть преобразован в ForwardIteratorтип значения. Выражение ++val, где val имеет тип T, должно быть правильно сформировано.

2
#

Effects: Для каждого элемента, на который ссылается итератор i в диапазоне [first, last), присваивает *i = value и увеличивает, value как если бы ++value.

3
#

Complexity: Ровно last - first прибавки и присваивания.

29.8.13 Greatest common divisor [numeric.ops.gcd]

template <class M, class N> constexpr common_type_t<M,N> gcd(M m, N n);

1
#

Requires: |m| и |n| должен быть представлен как значение common_­type_­t<M, N>. [  Note: Эти требования гарантируют, например, что gcd(m, m) = |m| это может быть представлено как значение типа M. ]  — end note 

2
#

Remarks: Если один из типов M или N не является целочисленным типом, либо один из них cv bool, программа имеет неправильный формат .

3
#

Returns: Ноль, когда m и n оба равны нулю. В противном случае возвращает наибольший общий делитель |m| и |n|.

4
#

Throws: Ничего такого.

29.8.14 Least common multiple [numeric.ops.lcm]

template <class M, class N> constexpr common_type_t<M,N> lcm(M m, N n);

1
#

Requires: |m| и |n| должен быть представлен как значение common_­type_­t<M, N>. Наименьшее общее кратное для |m| и |n| должно быть представлено как значение типа common_­type_­t<M,N>.

2
#

Remarks: Если один из типов M или N не является целочисленным, или если один cv bool из них, программа имеет неверный формат .

3
#

Returns: Ноль, когда либо m либо n равно нулю. В противном случае возвращает наименьшее общее кратное для |m| и |n|.

4
#

Throws: Ничего такого.