Namespaces
Variants

std::transform_exclusive_scan

С ru.cppreference.net
 
 
Библиотека алгоритмов
Ограниченные алгоритмы и алгоритмы на диапазонах (C++20)
Ограниченные алгоритмы, например ranges::copy, ranges::sort, ...
Операции последовательности без изменения    
Пакетные операции
(C++17)
Операции поиска
Операции последовательности с изменением
Операции копирования
(C++11)
(C++11)
Операции обмена
Операции преобразования
Операции генерации
Операции удаления
Операции изменения порядка
(until C++17)(C++11)
(C++20)(C++20)
Операции выборки
(C++17)

Сортировка и связанные операции
Операции разделения
(C++11)    

Операции сортировки
Операции бинарного поиска
(на разделенных диапазонах)
Операции над множествами (на отсортированных диапазонах)
Операции слияния (на отсортированных диапазонах)
Операции с кучей
Операции минимума/максимума
(C++11)
(C++17)
Операции лексикографического сравнения
Операции перестановки


Политики выполнения (C++17)
(только для пояснения*)(C++26)

Числовые операции
(C++11)
(C++17)
(C++17)    

Специализированные <memory> алгоритмы

Специализированные <random> алгоритмы
Библиотека C









 
 
Определен в заголовке <numeric>
template< class InputIt, class OutputIt, class T, 
          class BinaryOp, class UnaryOp >
OutputIt transform_exclusive_scan
    ( InputIt first, InputIt last, OutputIt d_first, T init,
      BinaryOp binary_op, UnaryOp unary_op );
(1) (since C++17)
(constexpr since C++20)
template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2, class T,
          class BinaryOp, class UnaryOp >
ForwardIt2 transform_exclusive_scan
    ( ExecutionPolicy&& policy,
      ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, T init,
      BinaryOp binary_op, UnaryOp unary_op );
(2) (since C++17)
1) Вычисляет эксклюзивную префиксную сумму, используя op.
Для каждого целого числа i в [0, std::distance(first, last)), выполняет следующие операции по порядку:
  1. Создает последовательность, которая образована init за которой следуют значения, преобразованные из элементов [first, iter) по порядку с помощью unary_op, где iter является следующим i-й итератор .firstВычисляет обобщенную некоммутативную сумму последовательности над
  2. .binary_opПрисваивает результат
  3. , где *dest является следующим dest-й итератор i.2)d_first То же, что и
(1), но выполняется в соответствии с . Эта перегрузка участвует в разрешении перегрузок только если значение следующего выражения равно policy:
(until C++20)true(since C++20)

std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

Обобщенная

std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

обобщенная некоммутативная сумма

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

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


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

, программа является некорректной: TЕсли любое из следующих условий выполнено, поведение неопределено:

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

не является

  • TMoveConstructible. или
  • unary_op изменяет любой элемент binary_op.[first, last) или
  • unary_op делает недействительным любой итератор или поддиапазон binary_op.[first, last]

Параметры

first, last - пара итераторов, определяющих диапазон элементов для суммирования
d_first - начало целевого диапазона, может быть равно first
policy - политика выполнения для использования
init - начальное значение
unary_op - унарный FunctionObject , который будет применен к каждому элементу входного диапазона. Тип возвращаемого значения должен быть допустимым для ввода в binary_op .
binary_op - бинарный FunctionObject , который будет применен к результату unary_op , результатам других binary_op и init .
Требования к типам
-
InputIt должен удовлетворять требованиям LegacyInputIterator .
-
OutputIt должен удовлетворять требованиям LegacyOutputIterator .
-
ForwardIt1, ForwardIt2 должен удовлетворять требованиям LegacyForwardIterator .

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

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

Сложность

Дано N как std:: distance ( first, last ) :

1,2) O(N) применений unary_op и binary_op соответственно.

Исключения

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

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

Примечания

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

Пример

#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

Смотрите также

вычисляет частичную сумму элементов диапазона
(шаблон функции)
аналогично std::partial_sum , исключает i й входной элемент из i й суммы
(шаблон функции)
применяет вызываемый объект, затем вычисляет инклюзивное сканирование
(шаблон функции)