<numeric> 函式

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
要套用至指定範圍中的每個專案及其先前應用程式結果的二進位作業。

傳回值

init 與第一個樣板函式指定範圍中的所有元素總和，或第二個範本函式套用二進位運算的結果，binary_op而不是加總運算的結果，其中 PartialRes in_iter ult 是作業先前應用程式的結果，in_iter是指向範圍中下一個專案的反覆運算器。

備註

初始值可確保當範圍是空的時，會有妥善定義的結果，在此情況下 會傳回 init 。 二進位作業不需要關聯或通勤。 結果會初始化為初始值 init，然後逐一計算結果 = binary_op（result，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<>() 或指定二進位運算符，計算獨佔前置詞總和運算。 將結果寫入至從指定目的地開始的範圍。 獨佔前置詞總和表示第 n個輸入元素未包含在第 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
執行原則。

first
輸入反覆運算器，尋址範圍中的第一個專案，以使用 binary_op加總或合併。

last
輸入反覆運算器，尋址範圍中的最後一個元素為加總或結合使用 binary_op，這是實際包含在反覆運算累積中最後一個專案以外的一個位置。

result
輸出反覆運算器，尋址目的地範圍的第一個專案，其中要儲存指定作業的數列總和或結果。

init
使用binary_op來新增或合併每個專案的初始值。

binary_op
要套用至指定範圍中的每個專案及其先前應用程式結果的二進位作業。

傳回值

輸出反覆運算器，尋址目的地範圍的結尾：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<>() 或指定二進位運算符，計算內含前置詞總和運算。 將結果寫入至從指定目的地開始的範圍。 內含前置詞總和表示第 n個輸入元素包含在第 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
執行原則。

first
輸入反覆運算器，尋址範圍中的第一個專案，以使用 binary_op加總或合併。

last
輸入反覆運算器，尋址範圍中的最後一個元素為加總或結合使用 binary_op，這是實際包含在反覆運算累積中最後一個專案以外的一個位置。

result
輸出反覆運算器，尋址目的地範圍的第一個專案，其中要儲存指定作業的數列總和或結果。

init
使用binary_op來新增或合併每個專案的初始值。

binary_op
要套用至指定範圍中的每個專案及其先前應用程式結果的二進位作業。

傳回值

輸出反覆運算器，尋址目的地範圍的結尾：result + （最後 - 一個）。

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 + （a 1 * b1） + （a2 * b2） + ... + （an * bn）

以反覆取代 init + （ai * bi） 的 init 。

第二個成員函式會傳回：

init binary_op1 （a1 binary_op2 b1） binary_op1 （a 2 binary_op2 b2） binary_op1 ... binary_op1 （n binary_op2 bn）

藉由反覆取代 init binary_op1 （ai binary_op2 bi） 取代 init 。

備註

初始值可確保當範圍是空的時，會有妥善定義的結果。 在此情況下， 會傳回 init 。 二進位作業不需要關聯或通勤。 範圍必須有效，而且複雜度與範圍的大小是線性的。 二元運算子的傳回類型必須可轉換成 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

儲存起始值，從第一個元素開始，並在間隔[first, last)中的每個元素中填入該值的後續遞增 。value++。

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

參數

first
輸入迭代器，定址對象是要填入的範圍中的第一個元素。

last
輸入迭代器，定址對象是要填入的範圍中的最後一個元素。

value
要儲存在第一個專案中的起始值，並連續遞增供後續專案使用。

範例

以下範例示範 iota 函式的一些使用方式，方法是填滿一個整數 list，然後以 list 填滿一個 vector，以便使用 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;
}

最小公倍數

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
在一般化作業中套用的二進位作業，取代部分總和程式中的總和運算。

傳回值

輸出反覆運算器，尋址目的地範圍的結尾：result + （最後 - 一個）。

備註

輸出反覆運算器結果可先與輸入反覆運算器相同的反覆運算器，以便就地計算部分總和。

如果是 1、2、... 在輸入範圍中，第一個樣板函式會將連續部分總和儲存在目的範圍中。 第 n個元素是由 （a1 + a2 + a 3 + ... + an） 指定。

針對輸入範圍中 1、2、3 的值序列，第二個範本函式會將連續的部分結果儲存在目的地範圍中。 第 n個元素是由 （...（（1 binary_op二） binary_op 3） binary_op... binary_op n）。

因為指定套用的作業順序，binary_op二進位作業不需要是關聯或通勤作業。

範例

// 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
執行原則。

first
輸入反覆運算器，尋址範圍中的第一個專案，以使用 binary_op加總或合併。

last
輸入反覆運算器，尋址範圍中的最後一個元素為加總或結合使用 binary_op，這是實際包含在反覆運算累積中最後一個專案以外的一個位置。

result
輸出反覆運算器，尋址目的地範圍的第一個專案，其中要儲存指定作業的數列總和或結果。

init
使用binary_op來新增或合併每個專案的初始值。

binary_op
要套用至指定範圍中的每個專案及其先前應用程式結果的二進位作業。

傳回值

將binary_op或套用至 init，並將指定範圍中的所有元素套用至 （*PartialResult， in_iter），其中 PartialResult 是作業先前應用程式的結果，而 in_iter 是指向範圍中某個元素的反覆運算std::plus<>()器。 在未指定 init 的多載中， 使用的 init 值相當於 typename iterator_traits<InputIterator>::value_type{}。

備註

reduce 除非 binary_op 具有關聯性和通勤性，否則行為不具決定性。 如果 binary_op 修改任何元素，或使間隔 [first， last]， 內含的任何反覆運算器失效，則行為是未定義的。

transform_exclusive_scan

使用指定的一元運算符轉換範圍的項目，然後在指定初始值的情況下，使用 std::plus<>() 或指定的二進位運算符，計算獨佔前置詞總和運算。 將結果寫入至從指定目的地開始的範圍。 獨佔前置詞總和表示第 n個輸入元素未包含在第 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
執行原則。

first
輸入反覆運算器，尋址範圍中的第一個專案，以使用 binary_op加總或合併。

last
輸入反覆運算器，尋址範圍中的最後一個元素為加總或結合使用 binary_op，這是實際包含在反覆運算累積中最後一個專案以外的一個位置。

result
輸出反覆運算器，尋址目的地範圍的第一個專案，其中要儲存指定作業的數列總和或結果。

init
使用binary_op來新增或合併每個專案的初始值。

binary_op
要套用至指定範圍中的每個專案及其先前應用程式結果的二進位作業。

unary_op
要套用至指定範圍中每個專案的一元運算。

transform_inclusive_scan

使用指定的一元運算符轉換範圍的項目，然後在指定初始值的情況下，使用 std::plus<>() 或指定的二進位運算符，計算內含前置詞總和運算。 將結果寫入至從指定目的地開始的範圍。 內含前置詞總和表示第 n個輸入元素包含在第 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
執行原則。

first
輸入反覆運算器，尋址範圍中的第一個專案，以使用 binary_op加總或合併。

last
輸入反覆運算器，尋址範圍中的最後一個元素為加總或結合使用 binary_op，這是實際包含在反覆運算累積中最後一個專案以外的一個位置。

result
輸出反覆運算器，尋址目的地範圍的第一個專案，其中要儲存指定作業的數列總和或結果。

binary_op
要套用至指定範圍中的每個專案及其先前應用程式結果的二進位作業。

unary_op
要套用至指定範圍中每個專案的一元運算。

init
使用binary_op來新增或合併每個專案的初始值。

transform_reduce

轉換某個範圍的元素，然後套用運算函式，以任意順序減少已轉換的專案。 實際上，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
執行原則。

first
輸入反覆運算器，尋址範圍中的第一個專案，以使用 binary_op加總或合併。

first1
輸入反覆運算器，尋址範圍中的第一個專案，以使用 binary_op1加總或合併。

last
輸入反覆運算器，尋址範圍中的最後一個元素為加總或結合使用 binary_op，這是實際包含在反覆運算累積中最後一個專案以外的一個位置。

last1
輸入反覆運算器，尋址範圍中的最後一個專案是加總或結合，方法是使用 binary_op1，這是實際包含在反覆運算累積中最後一個專案以外的一個位置。

result
輸出反覆運算器，尋址目的地範圍的第一個專案，其中要儲存指定作業的數列總和或結果。

init
使用binary_op來新增或合併每個專案的初始值。

binary_op
要套用至指定範圍中的每個專案及其先前應用程式結果的二進位作業。

unary_op
要套用至指定範圍中每個專案的一元運算。

傳回值

轉換後的結果會減少。