std::transform_inclusive_scan

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

template< class InputIt, class OutputIt,
          class BinaryOperation, class UnaryOperation >
constexpr OutputIt transform_inclusive_scan( InputIt first, InputIt last,
                                             OutputIt d_first,
                                             BinaryOperation binary_op,
                                             UnaryOperation unary_op );

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

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

template< class InputIt, class OutputIt,
          class BinaryOperation, class UnaryOperation, class T >
constexpr OutputIt transform_inclusive_scan( InputIt first, InputIt last,
                                             OutputIt d_first,
                                             BinaryOperation binary_op,
                                             UnaryOperation unary_op,
                                             T init );

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

Преобразует каждый элемент в диапазоне [first, last) с помощью unary_op, затем вычисляет операцию включительной префиксной суммы с помощью binary_op над полученным диапазоном, необязательно с начальным значением init, и записывает результаты в диапазон, начинающийся с d_first. Включительно означает, что i-й элемент входных данных включён в i-ю сумму.

Формально, присваивает каждому итератору i в [d_first, d_first + (last - first)) значение

• для перегрузок (1,2), обобщённой некоммутативной суммы unary_op(*j)... для каждого j в [first, first + (i - d_first + 1)) над binary_op,
• для перегрузок (3,4), обобщённой некоммутативной суммы init, unary_op(*j)... для каждого j в [first, first + (i - d_first + 1)) над binary_op,

где обобщённая некоммутативная сумма GNSUM(op, a₁, ..., a_N) определяется следующим образом:

• если N = 1, a₁
• если N > 1, op(GNSUM(op, a₁, ..., a_K), GNSUM(op, a_M, ..., a_N)) для любого K, где 1 < K + 1 = M ≤ N.

Другими словами, операции суммирования могут выполняться в произвольном порядке, а поведение не определено, если binary_op не ассоциативно. Перегрузки

unary_op и binary_op не должны делать недействительными итераторы (включая конечные итераторы) или поддиапазоны, а также изменять элементы в диапазонах [first, last) или [d_first, d_first + (last - first)). В противном случае поведение не определено.

Параметры

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

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

Сложность

O(last - first) применений каждого из binary_op и unary_op.

Исключения

Перегрузки с параметром шаблона 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

См. также