`<numeric>`Функции

Статья
10/12/2023

accumulate

Вычисляет сумму всех элементов в указанном диапазоне, включая некоторое начальное значение, вычисляя последовательные частичные суммы. Или вычисляет результат последовательных частичных результатов указанной двоичной операции.

template <class InputIterator, class Type>
Type accumulate(
    InputIterator first,
    InputIterator last,
    Type init);

template <class InputIterator, class Type, class BinaryOperation>
Type accumulate(
    InputIterator first,
    InputIterator last,
    Type init,
    BinaryOperation binary_op);

Параметры

first
Входной итератор, обращающийся к первому элементу в диапазоне, к сумме или комбинировать с помощью binary_op.

last
Входной итератор, обращающийся к последнему элементу в диапазоне для суммы или объединения с помощью binary_op, это одна позиция за последним элементом, фактически включенным в итерированное накопление.

init
Начальное значение, к которому каждый элемент, в свою очередь, добавляется или объединяется с помощью binary_op.

binary_op
Двоичная операция, применяемая к каждому элементу в указанном диапазоне, и результатом предыдущих приложений.

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

Сумма инициализации и всех элементов в указанном диапазоне для первой функции шаблона или, для второй функции шаблона, результат применения двоичной операции binary_op вместо операции суммы (*PartialResult, in_iter), где PartialResult является результатом предыдущих приложений операции и in_iter является итератором, указывающим на следующий элемент в диапазоне.

Замечания

Начальное значение гарантирует наличие четко определенного результата, если диапазон пуст, в этом случае возвращается инициализация . Двоичная операция не должна быть ассоциативной или коммутативной. Результат инициализируется в начальном инициализированном значении, а затем = вычисляется binary_op(результат, in_iter) через диапазон, где in_iter является итератором, указывающим на каждый последовательный элемент в диапазоне. Диапазон должен быть допустимым, и сложность является линейной с размером диапазона. Возвращаемый тип бинарного оператора должен поддерживать преобразование в Type, чтобы гарантировать закрытие в ходе перебора.

Пример

// numeric_accum.cpp
// compile with: /EHsc
#include <vector>
#include <numeric>
#include <functional>
#include <iostream>

int main( )
{
   using namespace std;

   vector <int> v1, v2(20);
   vector <int>::iterator iter1, iter2;

   int i;
   for (i = 1; i < 21; i++)
   {
      v1.push_back(i);
   }

   cout << "The original vector v1 is:\n ( " ;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
      cout << *iter1 << " ";
   cout << ")." << endl;

   // The first member function for the accumulated sum
   int total;
   total = accumulate(v1.begin(), v1.end(), 0);

   cout << "The sum of the integers from 1 to 20 is: "
        << total << "." << endl;

   // Constructing a vector of partial sums
   int j = 0, partotal;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
   {
      partotal = accumulate(v1.begin(), iter1 + 1, 0);
      v2[j] = partotal;
      j++;
   }

   cout << "The vector of partial sums is:\n ( " ;
   for (iter2 = v2.begin(); iter2 != v2.end(); iter2++)
      cout << *iter2 << " ";
   cout << ")." << endl << endl;

   // The second member function for the accumulated product
   vector <int> v3, v4(10);
   vector <int>::iterator iter3, iter4;

   int s;
   for (s = 1; s < 11; s++)
   {
      v3.push_back(s);
   }

   cout << "The original vector v3 is:\n ( " ;
   for (iter3 = v3.begin(); iter3 != v3.end(); iter3++)
      cout << *iter3 << " ";
   cout << ")." << endl;

   int ptotal;
   ptotal = accumulate(v3.begin(), v3.end(), 1, multiplies<int>());

   cout << "The product of the integers from 1 to 10 is: "
        << ptotal << "." << endl;

   // Constructing a vector of partial products
   int k = 0, ppartotal;
   for (iter3 = v3.begin(); iter3 != v3.end(); iter3++) {
      ppartotal = accumulate(v3.begin(), iter3 + 1, 1, multiplies<int>());
      v4[k] = ppartotal;
      k++;
   }

   cout << "The vector of partial products is:\n ( " ;
   for (iter4 = v4.begin(); iter4 != v4.end(); iter4++)
      cout << *iter4 << " ";
   cout << ")." << endl;
}

The original vector v1 is:
( 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ).
The sum of the integers from 1 to 20 is: 210.
The vector of partial sums is:
( 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210 ).

The original vector v3 is:
( 1 2 3 4 5 6 7 8 9 10 ).
The product of the integers from 1 to 10 is: 3628800.
The vector of partial products is:
( 1 2 6 24 120 720 5040 40320 362880 3628800 ).

adjacent_difference

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

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

template <class InputIterator, class OutIterator, 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,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result);

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

Параметры

exec
Политика выполнения.

first
Итератор ввода, обращающийся к первому элементу в диапазоне ввода, элементы которого необходимо отличить от соответствующих им предшественников или где с парой значений должна быть выполнена другая заданная бинарная операция.

last
Итератор ввода, обращающийся к последнему элементу в диапазоне ввода, элементы которого необходимо отличить от соответствующих им предшественников или где с парой значений должна быть выполнена другая заданная бинарная операция.

result
Итератор вывода, обращающийся к первому элементу в диапазоне назначения, где необходимо сохранить ряд различий или результаты определенной операции.

binary_op
Двоичная операция, применяемая в обобщенной операции, заменяя операцию вычитания в процедуре разностной.

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

Итератор вывода, указывающий конец диапазона назначения: result + ( - lastfirst).

Замечания

Результат итератора выходных данных может быть тем же итератором, что adjacent_difference итератор входных данных, поэтому значения могут быть вычисляться на месте.

Для последовательности значений 1, 2, 3 в входном диапазоне первая функция шаблона сохраняет последовательные adjacent_difference значения 1, а 2 — 1, a3 — 2 в диапазоне назначения.

Для последовательности значений 1, 2, 3 в входном диапазоне вторая функция шаблона сохраняет последовательные adjacent_difference значения 1, 2 binary_op 1, 3 binary_op 2 в диапазоне назначения.

Двоичная операция binary_op не обязательно должна быть ассоциативной или коммутативной, так как указан порядок примененных операций.

Пример

// numeric_adj_diff.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <numeric>
#include <functional>
#include <iostream>

int main( )
{
   using namespace std;

   vector<int> V1( 10 ), V2( 10 );
   vector<int>::iterator VIter1, VIter2, VIterend, VIterend2;

   list <int> L1;
   list <int>::iterator LIter1, LIterend, LIterend2;

   int t;
   for ( t = 1 ; t <= 10 ; t++ )
   {
      L1.push_back( t * t );
   }

   cout << "The input list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != L1.end( ) ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;

   // The first member function for the adjacent_differences of
   // elements in a list output to a vector
   VIterend = adjacent_difference ( L1.begin ( ) , L1.end ( ) ,
      V1.begin ( ) );

   cout << "Output vector containing adjacent_differences is:\n ( " ;
   for ( VIter1 = V1.begin( ) ; VIter1 != VIterend ; VIter1++ )
      cout << *VIter1 << " ";
   cout << ")." << endl;

   // The second member function used to compute
   // the adjacent products of the elements in a list
   VIterend2 = adjacent_difference ( L1.begin ( ) , L1.end ( ) , V2.begin ( ) ,
      multiplies<int>( ) );

   cout << "The output vector with the adjacent products is:\n ( " ;
   for ( VIter2 = V2.begin( ) ; VIter2 != VIterend2 ; VIter2++ )
      cout << *VIter2 << " ";
   cout << ")." << endl;

   // Computation of adjacent_differences in place
   LIterend2 = adjacent_difference ( L1.begin ( ) , L1.end ( ) , L1.begin ( ) );
   cout << "In place output adjacent_differences in list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != LIterend2 ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;
}

exclusive_scan

Вычисляет операцию с суммой монопольного префикса с помощью std::plus<>() заданного двоичного оператора в диапазоне, учитывая начальное значение. Записывает результаты в диапазон, начиная с указанного назначения. Монопольная сумма префикса означает , что входной элемент nth не включен в сумму n. Перегрузки, включающие аргумент политики выполнения, выполняются в соответствии с указанной политикой.

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

template<class InputIterator, class OutputIterator, class Type, class BinaryOperation>
OutputIterator exclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    Type init,
    BinaryOperation binary_op);

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

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

Параметры

exec
Политика выполнения.

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

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

Итератор вывода, указывающий конец диапазона назначения: результат + (последний - первый).

наибольший общий делитель

Вычисляет наибольший общий делитель целых чисел m и n.

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

Параметры

m, n
Значения целочисленного типа.

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

Возвращает наибольший общий делитель абсолютных значений m и n, или ноль, если оба значения m и n равны нулю. Результаты не определены, если абсолютные значения m или n не представляются в качестве значений типа common_type_t<M,N>.

inclusive_scan

Вычисляет инклюзивную операцию суммы префикса с помощью std::plus<>() указанного двоичного оператора в диапазоне, учитывая начальное значение. Записывает результаты в диапазон, начиная с указанного назначения. Инклюзивная сумма префикса означает, что входной элемент nth включается в сумму n. Перегрузки, включающие аргумент политики выполнения, выполняются в соответствии с указанной политикой.

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 Type>
OutputIterator inclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op,
    Type init);

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

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 ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
class BinaryOperation, class Type>
ForwardIterator2 inclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryOperation binary_op,
    Type init);

Параметры

exec
Политика выполнения.

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

Итератор вывода, указывающий конец диапазона назначения: результат + (последний - первый).

inner_product

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

template <class InputIterator1, class InputIterator2, class Type>
Type inner_product(
    InputIterator1   first1,
    InputIterator1   last1,
    InputIterator2   first2,
    Type             init);

template <class InputIterator1, class InputIterator2, class Type, class BinaryOperation1, class BinaryOperation2>
Type inner_product(
    InputIterator1   first1,
    InputIterator1   last1,
    InputIterator2   first2,
    Type             init,
    BinaryOperation1 binary_op1,
    BinaryOperation2 binary_op2);

Параметры

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

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

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

init
Начальное значение, к которому прибавляется внутреннее произведение или обобщенное внутреннее произведение диапазонов.

binary_op1
Бинарная операция, которая заменяет операцию внутреннего произведения суммирования, применяемую к поэлементным произведениям в обобщении внутреннего произведения.

binary_op2
Бинарная операция, которая заменяет операцию внутреннего поэлементного произведения умножения в обобщении внутреннего произведения.

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

Первая функция-член возвращает сумму поэлементного произведения и добавляет к ней указанное начальное значение. Таким образом, для диапазонов значений ai и bi она возвращает:

init + (a1 * b 1) + (a2 * b2) + ... + (n * bn)

путем итеративной замены инициализации на init + (ai * bi).

Вторая функция-член возвращает:

init binary_op1 (1 binary_op2 b1) binary_op1 (2 binary_op2 b2) binary_op1 ... binary_op1 (n binary_op2 bn)

путем итеративной замены инициализации binary_op1 (i binary_op2 bi).

Замечания

Начальное значение гарантирует наличие четко определенного результата при пустом диапазоне. В этом случае возвращается инициализация . Двоичные операции не должны быть ассоциативными или коммутативными. Диапазон должен быть допустимым, и сложность является линейной с размером диапазона. Возвращаемый тип бинарного оператора должен поддерживать преобразование в Type, чтобы гарантировать закрытие в ходе перебора.

Пример

// numeric_inner_prod.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <numeric>
#include <functional>
#include <iostream>

int main()
{
   using namespace std;

   vector <int> v1, v2(7), v3(7);
   vector <int>::iterator iter1, iter2, iter3;

   int i;
   for (i = 1; i <= 7; i++)
   {
      v1.push_back(i);
   }

   cout << "The original vector v1 is:\n ( " ;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
      cout << *iter1 << " ";
   cout << ")." << endl;

   list <int> l1, l2(7);
   list <int>::iterator lIter1, lIter2;

   int t;
   for (t = 1; t <= 7; t++)
   {
      l1.push_back(t);
   }

   cout << "The original list l1 is:\n ( " ;
   for (lIter1 = l1.begin(); lIter1 != l1.end(); lIter1++)
      cout << *lIter1 << " ";
   cout << ")." << endl;

   // The first member function for the inner product
   int inprod;
   inprod = inner_product(v1.begin(), v1.end(), l1.begin(), 0);

   cout << "The inner_product of the vector v1 and the list l1 is: "
        << inprod << "." << endl;

   // Constructing a vector of partial inner_products between v1 & l1
   int j = 0, parinprod;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++) {
      parinprod = inner_product(v1.begin(), iter1 + 1, l1.begin(), 0);
      v2[j] = parinprod;
      j++;
   }

   cout << "Vector of partial inner_products between v1 & l1 is:\n ( " ;
   for (iter2 = v2.begin(); iter2 != v2.end(); iter2++)
      cout << *iter2 << " ";
   cout << ")." << endl << endl;

   // The second member function used to compute
   // the product of the element-wise sums
   int inprod2;
   inprod2 = inner_product (v1.begin(), v1.end(),
      l1.begin(), 1, multiplies<int>(), plus<int>());

   cout << "The sum of the element-wise products of v1 and l1 is: "
        << inprod2 << "." << endl;

   // Constructing a vector of partial sums of element-wise products
   int k = 0, parinprod2;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
   {
      parinprod2 =
         inner_product(v1.begin(), iter1 + 1, l1.begin(), 1,
         multiplies<int>(), plus<int>());
      v3[k] = parinprod2;
      k++;
   }

   cout << "Vector of partial sums of element-wise products is:\n ( " ;
   for (iter3 = v3.begin(); iter3 != v3.end(); iter3++)
      cout << *iter3 << " ";
   cout << ")." << endl << endl;
}

iota

Сохраняет начальное значение, начиная с первого элемента и заполняя последовательными добавками этого значения (value++) в каждом из элементов интервала [first, last).

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

Параметры

first
Входной итератор, адресующий первый элемент в диапазоне для заполнения.

last
Входной итератор, адресующий последний элемент в диапазоне для заполнения.

значение
Начальное значение для хранения в первом элементе и последовательное увеличение для последующих элементов.

Пример

Следующий пример показывает некоторые способы использования функции iota заполнением списка целых чисел, а затем заполнением вектораlist, так что можно будет использовать функцию random_shuffle.

// compile by using: cl /EHsc /nologo /W4 /MTd
#include <algorithm>
#include <numeric>
#include <list>
#include <vector>
#include <iostream>

using namespace std;

int main(void)
{
    list <int> intList(10);
    vector <list<int>::iterator> intVec(intList.size());

    // Fill the list
    iota(intList.begin(), intList.end(), 0);

    // Fill the vector with the list so we can shuffle it
    iota(intVec.begin(), intVec.end(), intList.begin());

    random_shuffle(intVec.begin(), intVec.end());

    // Output results
    cout << "Contents of the integer list: " << endl;
    for (auto i: intList) {
        cout << i << ' ';
    }
    cout << endl << endl;

    cout << "Contents of the integer list, shuffled by using a vector: " << endl;
    for (auto i: intVec) {
        cout << *i << ' ';
    }
    cout << endl;
}

lcm

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

partial_sum

Вычисляет ряд сумм в входном диапазоне от первого элемента через n-й элемент и сохраняет результат каждой такой суммы в N-мэлементе диапазона назначения. Или вычисляет результат обобщенной процедуры, в которой операция суммы заменяется другой указанной двоичной операцией.

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

template <class InputIterator, class OutIt, class Fn2>
OutputIterator partial_sum(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op);

Параметры

first
Итератор ввода, обращающийся к первому элементу в диапазоне, который необходимо частично суммировать или объединить в соответствии с заданной бинарной операцией.

last
Итератор ввода, обращающийся к последнему элементу в диапазоне, который необходимо частично суммировать или объединить в соответствии с указанной бинарной операцией, который расположен на одну позицию далее за последним элементом, фактически включенным в совокупности, в которой проводятся итерации.

result
Итератор вывода, обращаюющийся к первому элементу диапазона назначения для хранения ряда частичных сумм или последовательных результатов указанной двоичной операции.

binary_op
Двоичная операция, применяемая в обобщенной операции, заменяя операцию суммы в процедуре частичной суммы.

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

Итератор вывода, указывающий конец диапазона назначения: результат + (последний - первый).

Замечания

Результат итератора выходных данных может быть тем же итератором, что итератор входных данных, поэтому частичные суммы могут быть вычисляться на месте.

Для последовательности значений 1, 2, ... xв входном диапазоне первая функция шаблона сохраняет последовательные частичные суммы в целевом диапазоне. N-й элемент присваивается (1 + 2 + 3 + ... + n).

Для последовательности значений 1, 2, 3 в входном диапазоне вторая функция шаблона сохраняет последовательные частичные результаты в целевом диапазоне. N-й элемент присваивается ((... ((1 binary_op 2) binary_op 3) binary_op ... ) binary_op n).

Пример

// numeric_partial_sum.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <numeric>
#include <functional>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int> V1( 10 ), V2( 10 );
   vector<int>::iterator VIter1, VIter2, VIterend, VIterend2;

   list <int> L1;
   list <int>::iterator LIter1, LIterend;

   int t;
   for ( t = 1 ; t <= 10 ; t++ )
   {
      L1.push_back( t );
   }

   cout << "The input list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != L1.end( ) ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;

   // The first member function for the partial sums of
   // elements in a list output to a vector
   VIterend = partial_sum ( L1.begin ( ) , L1.end ( ) ,
      V1.begin ( ) );

   cout << "The output vector containing the partial sums is:\n ( " ;
   for ( VIter1 = V1.begin( ) ; VIter1 != VIterend ; VIter1++ )
      cout << *VIter1 << " ";
   cout << ")." << endl;

   // The second member function used to compute
   // the partial product of the elements in a list
   VIterend2 = partial_sum ( L1.begin ( ) , L1.end ( ) , V2.begin ( ) ,
      multiplies<int>( ) );

   cout << "The output vector with the partial products is:\n ( " ;
   for ( VIter2 = V2.begin( ) ; VIter2 != VIterend2 ; VIter2++ )
      cout << *VIter2 << " ";
   cout << ")." << endl;

   // Computation of partial sums in place
   LIterend = partial_sum ( L1.begin ( ) , L1.end ( ) , L1.begin ( ) );
   cout << "The in place output partial_sum list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != LIterend ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;
}

reduce

Уменьшает все элементы в указанном диапазоне, в том числе некоторые начальные значения, вычисляя суммы в произвольном порядке и, возможно, пермутированным порядком. Кроме того, вычислив результаты указанной двоичной операции. Перегрузки, включающие аргумент политики выполнения, выполняются в соответствии с указанной политикой.

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

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

template<class InputIterator, class Type, class BinaryOperation>
Type reduce(
    InputIterator first,
    InputIterator last,
    Type init,
    BinaryOperation binary_op);

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

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

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

Параметры

exec
Политика выполнения.

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

Результат применения binary_op или std::plus<>() инициализации всех элементов в указанном диапазоне (*PartialResult, in_iter), где PartialResult является результатом предыдущих приложений операции, и in_iter является итератором, указывающим на некоторый элемент в диапазоне. В перегрузках, которые не указывают инициализацию, используемое значение инициализации эквивалентно typename iterator_traits<InputIterator>::value_type{}.

Замечания

reduce поведение является недетерминированным, если binary_op не является ассоциативным и коммутативным. Поведение не определено, если binary_op изменяет любой элемент или недействителен любой итератор в интервале [первый, последний], включительно.

transform_exclusive_scan

Преобразует элементы диапазона с указанным унарным оператором, а затем вычисляет операцию монопольной суммы префикса с помощью либо std::plus<>() указанного двоичного оператора по диапазону, учитывая начальное значение. Записывает результаты в диапазон, начиная с указанного назначения. Монопольная сумма префикса означает , что входной элемент nth не включен в сумму n. Перегрузки, включающие аргумент политики выполнения, выполняются в соответствии с указанной политикой. Суммирование может выполняться в произвольном порядке.

template<class InputIterator, class OutputIterator, class Type, class BinaryOperation, class UnaryOperation>
OutputIterator transform_exclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    Type init,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type, class BinaryOperation, class UnaryOperation>
ForwardIterator2 transform_exclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    Type init,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

Параметры

exec
Политика выполнения.

unary_op
Унарная операция, применяемая к каждому элементу в указанном диапазоне.

transform_inclusive_scan

Преобразует элементы диапазона с указанным унарным оператором, а затем вычисляет инклюзивную операцию суммы префикса, используя std::plus<>() либо указанный двоичный оператор по диапазону, учитывая начальное значение. Записывает результаты в диапазон, начиная с указанного назначения. Инклюзивная сумма префикса означает, что входной элемент nth включается в сумму n. Перегрузки, включающие аргумент политики выполнения, выполняются в соответствии с указанной политикой. Суммирование может выполняться в произвольном порядке.

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 Type>
OutputIterator transform_inclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op,
    UnaryOperation unary_op,
    Type init);

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 ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class BinaryOperation, class UnaryOperation, class Type>
ForwardIterator2 transform_inclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryOperation binary_op,
    UnaryOperation unary_op,
    Type init);

Параметры

exec
Политика выполнения.

unary_op
Унарная операция, применяемая к каждому элементу в указанном диапазоне.

transform_reduce

Преобразует диапазон элементов, а затем применяет functor, который уменьшает преобразованные элементы в произвольном порядке. Фактически, transform за которым следует reduce.

template<class InputIterator1, class InputIterator2, class Type>
Type transform_reduce(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    Type init);

template<class InputIterator1, class InputIterator2, class Type, class BinaryOperation1, class BinaryOperation2>
Type transform_reduce(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    Type init,
    BinaryOperation1 binary_op1,
    BinaryOperation2 binary_op2);

template<class InputIterator, class Type, class BinaryOperation, class UnaryOperation>
Type transform_reduce(
    InputIterator first,
    InputIterator last,
    Type init,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type>
Type transform_reduce(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    Type init);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type, class BinaryOperation1, class BinaryOperation2>
Type transform_reduce(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    Type init,
    BinaryOperation1 binary_op1,
    BinaryOperation2 binary_op2);

template<class ExecutionPolicy, class ForwardIterator, class Type, class BinaryOperation, class UnaryOperation>
Type transform_reduce(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Type init,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

Параметры

exec
Политика выполнения.

first1
Входной итератор, обращающийся к первому элементу в диапазоне, к сумме или комбинировать с помощью binary_op1.

last1
Входной итератор, обращающийся к последнему элементу в диапазоне для суммы или объединения с помощью binary_op1, это одна позиция за конечным элементом, фактически включенным в итерированное накопление.

unary_op
Унарная операция, применяемая к каждому элементу в указанном диапазоне.

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

Преобразованный результат уменьшается.

Поделиться через

<numeric>Функции

accumulate

Параметры

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

Замечания

Пример

adjacent_difference

Параметры

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

Замечания

Пример

exclusive_scan

Параметры

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

наибольший общий делитель

Параметры

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

inclusive_scan

Параметры

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

inner_product

Параметры

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

Замечания

Пример

iota

Параметры

Пример

lcm

partial_sum

Параметры

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

Замечания

Пример

reduce

Параметры

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

Замечания

transform_exclusive_scan

Параметры

transform_inclusive_scan

Параметры

transform_reduce

Параметры

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

Обратная связь

Дополнительные ресурсы

`<numeric>`Функции