std::transform_inclusive_scan

template< class InputIt, class OutputIt,
          class BinaryOp, class UnaryOp >
OutputIt transform_inclusive_scan
    ( InputIt first, InputIt last, OutputIt d_first,
      BinaryOp binary_op, UnaryOp unary_op );

template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2,
          class BinaryOp, class UnaryOp >
ForwardIt2 transform_inclusive_scan
    ( ExecutionPolicy&& policy,
      ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
      BinaryOp binary_op, UnaryOp unary_op );

template< class InputIt, class OutputIt,
          class BinaryOp, class UnaryOp, class T >
OutputIt transform_inclusive_scan
    ( InputIt first, InputIt last, OutputIt d_first,
      BinaryOp binary_op, UnaryOp unary_op, T init );

template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2,
          class BinaryOp, class UnaryOp, class T >
ForwardIt2 transform_inclusive_scan
    ( ExecutionPolicy&& policy,
      ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,
      BinaryOp binary_op, UnaryOp unary_op, T init );

Обобщённая некоммутативная сумма последовательности элементов относительно бинарной операции binary_op определяется следующим образом:

• Если последовательность содержит только один элемент, сумма равна значению этого элемента.
• В противном случае выполняются следующие операции в указанном порядке:

1. Из последовательности выбираются любые два соседних элемента elem1 и elem2.
2. Вычисляется binary_op(elem1, elem2), и эти два элемента в последовательности заменяются полученным результатом.
3. Шаги 1 и 2 повторяются, пока в последовательности не останется один элемент.

Результат является недетерминированным, если binary_op не ассоциативна (например, сложение чисел с плавающей точкой).

Для перегрузок (1,2), если binary_op(unary_op(*first), unary_op(*first)) нельзя преобразовать к типу значения decltype(first), программа некорректна.

Для перегрузок (3,4), если любое из следующих значений нельзя преобразовать к T, программа некорректна:

• binary_op(init, init)
• binary_op(init, unary_op(*first))
• binary_op(unary_op(*first), unary_op(*first))

Поведение не определено, если выполняется любое из следующих условий:

• Для перегрузок (1,2) тип значения decltype(first) не удовлетворяет требованиям MoveConstructible.
• Для перегрузок (3,4) T не удовлетворяет требованиям MoveConstructible.
• unary_op или binary_op изменяет какой-либо элемент [first, last).
• unary_op или binary_op делает недействительным какой-либо итератор или поддиапазон [first, last].

Параметры

Возвращаемое значение

Итератор на элемент, следующий за последним записанным элементом.

Сложность

Пусть \(\scriptsize N\)N — std::distance(first, last):

Исключения

Перегрузки с параметром шаблона с именем ExecutionPolicy сообщают об ошибках следующим образом:

• Если при выполнении функции, вызванной в рамках алгоритма, возникает исключение и ExecutionPolicy — одна из стандартных политик, вызывается std::terminate. Для любого другого ExecutionPolicy поведение определяется реализацией.
• Если алгоритму не удаётся выделить память, выбрасывается std::bad_alloc.

Примечания

unary_op никогда не применяется к init.

Параметр init указан последним, в отличие от std::transform_exclusive_scan, поскольку для этой функции он необязателен.

Пример

#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>

int main()
{
    std::vector data{3, 1, 4, 1, 5, 9, 2, 6};

    auto times_10 = [](int x) { return x * 10; };

    std::cout << "10 times exclusive sum: ";
    std::transform_exclusive_scan(data.begin(), data.end(),
                                  std::ostream_iterator<int>(std::cout, " "),
                                  0, std::plus<int>{}, times_10);
    std::cout << "\n10 times inclusive sum: ";
    std::transform_inclusive_scan(data.begin(), data.end(),
                                  std::ostream_iterator<int>(std::cout, " "),
                                  std::plus<int>{}, times_10);
    std::cout << '\n';
}

10 times exclusive sum: 0 30 40 80 90 140 230 250 
10 times inclusive sum: 30 40 80 90 140 230 250 310

См. также