<numeric> – funkce

hromadit

Vypočítá součet všech prvků v zadaném rozsahu, včetně určité počáteční hodnoty, tím, že vypočítá následné částečné součty. Nebo vypočítá výsledek následných částečných výsledků zadané binární operace.

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);

Parametry

první
Vstupní iterátor adresuje první prvek v oblasti tak, aby se součet nebo kombinování pomocí binary_op.

poslední
Vstupní iterátor adresovaný posledním prvkem v oblasti, který sečte nebo zkombinuje pomocí binary_op, je to jedna pozice za posledním prvkem, který je skutečně zahrnut do iterated akumulace.

init
Počáteční hodnota, ke které se jednotlivé prvky přidají nebo zkombinují pomocí binary_op.

binary_op
Binární operace, která se použije pro každý prvek v zadaném rozsahu a výsledek předchozích aplikací.

Vrácená hodnota

Součet inicializačních a všech prvků v zadaném rozsahu pro první funkci šablony, nebo výsledek použití binární operace binary_op místo operace součtu (*PartialResult, in_iter), kde PartialResult je výsledkem předchozích aplikací operace a in_iter je iterátor odkazující na další prvek v oblasti.

Poznámky

Počáteční hodnota zajišťuje, že je v případě, že je rozsah prázdný, v takovém případě se vrátí inicializace . Binární operace nemusí být asociativní ani commutativní. Výsledek se inicializuje na inicializaci počáteční hodnoty a výsledek = binary_op(výsledek, in_iter) se vypočítá iterativním způsobem v oblasti, kde in_iter je iterátor odkazující na každý následný prvek v oblasti. Rozsah musí být platný a složitost je lineární s velikostí rozsahu. Návratový typ binárního operátoru musí být konvertibilní na typ , aby se zajistilo uzavření během iterace.

Příklad

// 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

Vypočítá následující rozdíly mezi jednotlivými prvky a jeho předchůdcem ve vstupním rozsahu. Vypíše výsledky do cílového rozsahu. Nebo vypočítá výsledek generalizované procedury, kde je operace rozdílu nahrazena jinou zadanou binární operací.

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);

Parametry

vykonavatel
Zásady spuštění.

první
Vstupní iterátor adresující první prvek ve vstupním rozsahu, jehož prvky mají být diferencovány s příslušnými předchůdci nebo ve kterém použije dvojice hodnot jiná zadaná binární operace.

poslední
Vstupní iterátor adresující poslední prvek ve vstupním rozsahu, jehož prvky mají být diferencovány s příslušnými předchůdci nebo ve kterém použije dvojice hodnot jiná zadaná binární operace.

výsledek
Vstupní iterátor adresující první prvek v cílovém rozsahu, ve kterém se uloží série rozdílů nebo výsledky zadané operace.

binary_op
Binární operace, která se má použít v zobecněné operaci, nahrazuje operaci odčítání v rozdílové procedurě.

Vrácená hodnota

Výstupní iterátor adresuje konec cílového rozsahu: result + ( - lastfirst).

Poznámky

Výsledek výstupního iterátoru může být nejprve stejný iterátor jako vstupní iterátor, aby adjacent_difference se hodnoty mohly vypočítat na místě.

Pro sekvenci hodnot 1, 2, 3 ve vstupním rozsahu ukládá první funkce šablony následující adjacent_difference hodnoty 1, 2 – 1, a3 – 2 v cílovém rozsahu.

Pro sekvenci hodnot 1, 2, 3 ve vstupním rozsahu ukládá druhá funkce šablony v cílovém rozsahu následující adjacent_difference hodnoty 1, 2 binary_op 1, 3 binary_op a 2.

Binární operace binary_op nemusí být asociativní nebo komutativní, protože je zadáno pořadí použitých operací.

Příklad

// 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

Vypočítá operaci výhradního součtu předpon pomocí std::plus<>() buď nebo zadaného binárního operátoru v rozsahu vzhledem k počáteční hodnotě. Zapíše výsledky do rozsahu začínajícího v zadaném cíli. Exkluzivní součet předpon znamená, že n. vstupní prvek není zahrnut do n. součtu. Přetížení, která obsahují argument zásady spouštění, se spouští podle zadané zásady.

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);

Parametry

vykonavatel
Zásady spuštění.

první
Vstupní iterátor adresuje první prvek v oblasti tak, aby se součet nebo kombinování pomocí binary_op.

poslední
Vstupní iterátor adresovaný posledním prvkem v oblasti, který sečte nebo zkombinuje pomocí binary_op, je to jedna pozice za posledním prvkem, který je skutečně zahrnut do iterated akumulace.

výsledek
Výstupní iterátor adresovaný prvnímu prvku cílového rozsahu, kde má být uložena řada součtů nebo výsledků zadané operace.

init
Počáteční hodnota, ke které se jednotlivé prvky přidají nebo zkombinují pomocí binary_op.

binary_op
Binární operace, která se použije pro každý prvek v zadaném rozsahu a výsledek předchozích aplikací.

Vrácená hodnota

Výstupní iterátor adresuje konec cílového rozsahu: výsledek + (poslední - první).

největší společný dělitel

Vypočítá největší společný dělitel celých čísel m a n.

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

Parametry

m, n
Hodnoty celočíselného typu

Vrácená hodnota

Vrátí největší společný dělitel absolutních hodnot m a n nebo nulu, pokud m i n jsou nula. Výsledky nejsou definovány, pokud absolutní hodnoty m nebo n nejsou reprezentovatelné jako hodnoty typu common_type_t<M,N>.

inclusive_scan

Vypočítá operaci součtu inkluzivních předpon pomocí std::plus<>() buď nebo zadaného binárního operátoru v rozsahu vzhledem k počáteční hodnotě. Zapíše výsledky do rozsahu začínajícího v zadaném cíli. Inkluzivní součet předpon znamená, že n. vstupní prvek je zahrnut do n. součtu. Přetížení, která obsahují argument zásady spouštění, se spouští podle zadané zásady.

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);

Parametry

vykonavatel
Zásady spuštění.

první
Vstupní iterátor adresuje první prvek v oblasti tak, aby se součet nebo kombinování pomocí binary_op.

poslední
Vstupní iterátor adresovaný posledním prvkem v oblasti, který sečte nebo zkombinuje pomocí binary_op, je to jedna pozice za posledním prvkem, který je skutečně zahrnut do iterated akumulace.

výsledek
Výstupní iterátor adresovaný prvnímu prvku cílového rozsahu, kde má být uložena řada součtů nebo výsledků zadané operace.

init
Počáteční hodnota, ke které se jednotlivé prvky přidají nebo zkombinují pomocí binary_op.

binary_op
Binární operace, která se použije pro každý prvek v zadaném rozsahu a výsledek předchozích aplikací.

Vrácená hodnota

Výstupní iterátor adresuje konec cílového rozsahu: výsledek + (poslední - první).

inner_product

Vypočítá součet součinu prvku se dvěma rozsahy a přičte ho k zadané počáteční hodnotě nebo vypočítá výsledek zobecněné procedury, kde jsou součtové a binární operace produktu nahrazeny jinými zadanými binárními operacemi.

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);

Parametry

první 1
Vstupní iterátor adresovaný prvním prvkem v prvním rozsahu, jehož vnitřní produkt nebo generalizovaný vnitřní produkt s druhým rozsahem je vypočítán.

poslední 1
Vstupní iterátor adresovaný posledním prvkem v prvním rozsahu, jehož vnitřní produkt nebo generalizovaný vnitřní produkt s druhým rozsahem je vypočítán.

první2
Vstupní iterátor adresovaný prvnímu prvku v druhém rozsahu, jehož vnitřní produkt nebo generalizovaný vnitřní produkt s prvním rozsahem je vypočítán.

init
Počáteční hodnota, do které má být přidán vnitřní produkt nebo generalizovaný vnitřní produkt mezi rozsahy.

binary_op1
Binární operace, která nahrazuje vnitřní součin operace součtu použitého na produkty moudré prvky ve generalizaci vnitřního produktu.

binary_op2
Binární operace, která nahrazuje vnitřní prvek produktu operace násobení v generalizaci vnitřního produktu.

Vrácená hodnota

První členová funkce vrátí součet produktů moudrých prvků a přičte k ní zadanou počáteční hodnotu. Takže pro rozsahy hodnot a i a bi vrátí:

init + (a1 * b1) + (a2 * b2) + ... + (an * bn)

iterativním nahrazením init + (a i * bi).

Druhá členová funkce vrátí:

init binary_op1 (a1 binary_op2 b1) binary_op1 (a2 binary_op2 b2) binary_op1 ... binary_op1 (n binary_op2 bn)

iterativním nahrazením inicializačního binary_op1 (i binary_op2 bi).

Poznámky

Počáteční hodnota zajistí, že je v rozsahu prázdný dobře definovaný výsledek. V takovém případě se vrátí init . Binární operace nemusí být asociativní ani commutativní. Rozsah musí být platný a složitost je lineární s velikostí rozsahu. Návratový typ binárního operátoru musí být konvertibilní na typ , aby se zajistilo uzavření během iterace.

Příklad

// 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;
}

jota

Uloží počáteční hodnotu, počínaje prvním prvkem a vyplněním po sobě jdoucích přírůstků této hodnoty (value++) v každém prvku v intervalu [first, last).

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

Parametry

první
Vstupní iterátor, který řeší první prvek v rozsahu, který se má vyplnit.

poslední
Vstupní iterátor, který řeší poslední prvek v rozsahu, který se má vyplnit.

value
Počáteční hodnota pro uložení v prvním prvku a následné zvýšení pro pozdější prvky.

Příklad

Následující příklad ukazuje použití funkce vyplněním seznamu celých čísel a vyplněním vektoru list tak, aby bylo možné použít random_shuffle funkci.iota

// 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

Vypočítá řadu součtů ve vstupním rozsahu od prvního prvku až po n. prvek a uloží výsledek každého takového součtu do n. prvku cílového rozsahu. Nebo vypočítá výsledek generalizované procedury, kde je operace součtu nahrazena jinou zadanou binární operací.

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);

Parametry

první
Vstupní iterátor adresující první prvek v rozsahu, u kterého bude proveden částečný součet nebo který bude zkombinován podle zadané binární operace.

poslední
Vstupní iterátor adresující poslední prvek v rozsahu, u kterého bude proveden částečný součet nebo který bude zkombinován podle zadané binární operace, který se nachází o jednu pozici za posledním prvkem, který je skutečně zahrnut do iterovaného souhrnu.

výsledek
Výstupní iterátor adresovaný prvním prvkem cílového rozsahu pro uložení řady částečných součtů nebo následných výsledků zadané binární operace.

binary_op
Binární operace, která se použije v zobecněné operaci a nahradí operaci součtu v rámci částečného součtu.

Vrácená hodnota

Výstupní iterátor adresuje konec cílového rozsahu: výsledek + (poslední - první).

Poznámky

Výsledek výstupního iterátoru může být nejprve stejný iterátor jako vstupní iterátor, aby bylo možné vypočítat částečné součty.

Pro sekvenci hodnot 1, 2, ... ax, ve vstupním rozsahu, první funkce šablony ukládá následné částečné součty v cílovém rozsahu. N. prvek je dán (1 + a 2 + 3 + ... + n).

U posloupnosti hodnot 1, 2, 3 ve vstupním rozsahu ukládá druhá funkce šablony následné částečné výsledky v cílovém rozsahu. N. prvek je dán ((... ((1 binary_op a2) binary_op a3) binary_op ... ) binary_op n).

Binární operace binary_op nemusí být asociativní nebo komutativní, protože je zadáno pořadí použitých operací.

Příklad

// 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;
}

zmenšit

Zmenší všechny prvky v zadaném rozsahu, pravděpodobně i určitou počáteční hodnotu, tím, že vypočítá součty v libovolném a případně permutovaném pořadí. Nebo se sníží výpočtem výsledků zadané binární operace. Přetížení, která obsahují argument zásady spouštění, se spouští podle zadané zásady.

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);

Parametry

vykonavatel
Zásady spuštění.

první
Vstupní iterátor adresuje první prvek v oblasti tak, aby se součet nebo kombinování pomocí binary_op.

poslední
Vstupní iterátor adresovaný posledním prvkem v oblasti, který sečte nebo zkombinuje pomocí binary_op, je to jedna pozice za posledním prvkem, který je skutečně zahrnut do iterated akumulace.

výsledek
Výstupní iterátor adresovaný prvnímu prvku cílového rozsahu, kde má být uložena řada součtů nebo výsledků zadané operace.

init
Počáteční hodnota, ke které se jednotlivé prvky přidají nebo zkombinují pomocí binary_op.

binary_op
Binární operace, která se použije pro každý prvek v zadaném rozsahu a výsledek předchozích aplikací.

Vrácená hodnota

Výsledek použití binary_op nebo std::plus<>() inicializaci a všech prvků v zadaném rozsahu (*PartialResult, in_iter), kde PartialResult je výsledkem předchozích aplikací operace a in_iter je iterátor odkazující na určitý prvek v oblasti. V přetíženích, které nezadávají inicializaci, je použitá hodnota inicializační hodnota ekvivalentní typename iterator_traits<InputIterator>::value_type{}.

Poznámky

reduce chování není deterministické, pokud binary_op není asociativní a commutativní. Chování není definováno, pokud binary_op upraví jakýkoli prvek nebo zneplatní jakýkoli iterátor v intervalu [první, poslední], včetně.

transform_exclusive_scan

Transformuje prvky oblasti pomocí zadaného unárního operátoru a potom vypočítá operaci s výhradním součtem předpon pomocí std::plus<>() buď nebo zadaného binárního operátoru v rozsahu vzhledem k počáteční hodnotě. Zapíše výsledky do rozsahu začínajícího v zadaném cíli. Exkluzivní součet předpon znamená, že n. vstupní prvek není zahrnut do n. součtu. Přetížení, která obsahují argument zásady spouštění, se spouští podle zadané zásady. Suma může být provedena v libovolném pořadí.

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);

Parametry

vykonavatel
Zásady spuštění.

první
Vstupní iterátor adresuje první prvek v oblasti tak, aby se součet nebo kombinování pomocí binary_op.

poslední
Vstupní iterátor adresovaný posledním prvkem v oblasti, který sečte nebo zkombinuje pomocí binary_op, je to jedna pozice za posledním prvkem, který je skutečně zahrnut do iterated akumulace.

výsledek
Výstupní iterátor adresovaný prvnímu prvku cílového rozsahu, kde má být uložena řada součtů nebo výsledků zadané operace.

init
Počáteční hodnota, ke které se jednotlivé prvky přidají nebo zkombinují pomocí binary_op.

binary_op
Binární operace, která se použije pro každý prvek v zadaném rozsahu a výsledek předchozích aplikací.

unary_op
Unární operace, která se použije pro každý prvek v zadaném rozsahu.

transform_inclusive_scan

Transformuje prvky rozsahu pomocí zadaného unárního operátoru a potom vypočítá operaci inkluzivního součtu předpon pomocí std::plus<>() buď nebo zadaného binárního operátoru v rozsahu vzhledem k počáteční hodnotě. Zapíše výsledky do rozsahu začínajícího v zadaném cíli. Inkluzivní součet předpon znamená, že n. vstupní prvek je zahrnut do n. součtu. Přetížení, která obsahují argument zásady spouštění, se spouští podle zadané zásady. Suma může být provedena v libovolném pořadí.

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);

Parametry

vykonavatel
Zásady spuštění.

první
Vstupní iterátor adresuje první prvek v oblasti tak, aby se součet nebo kombinování pomocí binary_op.

poslední
Vstupní iterátor adresovaný posledním prvkem v oblasti, který sečte nebo zkombinuje pomocí binary_op, je to jedna pozice za posledním prvkem, který je skutečně zahrnut do iterated akumulace.

výsledek
Výstupní iterátor adresovaný prvnímu prvku cílového rozsahu, kde má být uložena řada součtů nebo výsledků zadané operace.

binary_op
Binární operace, která se použije pro každý prvek v zadaném rozsahu a výsledek předchozích aplikací.

unary_op
Unární operace, která se použije pro každý prvek v zadaném rozsahu.

init
Počáteční hodnota, ke které se jednotlivé prvky přidají nebo zkombinují pomocí binary_op.

transform_reduce

Transformuje rozsah prvků a pak použije functor, který redukuje transformované prvky v libovolném pořadí. Účinně, transform následuje .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);

Parametry

vykonavatel
Zásady spuštění.

první
Vstupní iterátor adresuje první prvek v oblasti tak, aby se součet nebo kombinování pomocí binary_op.

první 1
Vstupní iterátor adresuje první prvek v oblasti tak, aby se součet nebo kombinování pomocí binary_op1.

poslední
Vstupní iterátor adresovaný posledním prvkem v oblasti, který sečte nebo zkombinuje pomocí binary_op, je to jedna pozice za posledním prvkem, který je skutečně zahrnut do iterated akumulace.

poslední 1
Vstupní iterátor adresovaný posledním prvkem v oblasti, který sečte nebo zkombinuje pomocí binary_op1, je to jedna pozice za posledním prvkem, který je skutečně zahrnut do iterated akumulace.

výsledek
Výstupní iterátor adresovaný prvnímu prvku cílového rozsahu, kde má být uložena řada součtů nebo výsledků zadané operace.

init
Počáteční hodnota, ke které se jednotlivé prvky přidají nebo zkombinují pomocí binary_op.

binary_op
Binární operace, která se použije pro každý prvek v zadaném rozsahu a výsledek předchozích aplikací.

unary_op
Unární operace, která se použije pro každý prvek v zadaném rozsahu.

Vrácená hodnota

Transformovaný a následně snížený výsledek.