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

См. также