Udostępnij za pośrednictwem

<numeric>, funkcje

  • Artykuł

gromadzić

Oblicza sumę wszystkich elementów w określonym zakresie, w tym pewną wartość początkową, obliczając kolejne sumy częściowe. Lub oblicza wynik kolejnych częściowych wyników określonej operacji binarnej.

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

pierwszy
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie do sumy lub połączenia przy użyciu binary_op.

ostatni
Iterator wejściowy odnoszący się do ostatniego elementu w zakresie do sumy lub połączenia przy użyciu binary_op, jest to jedna pozycja poza ostatnim elementem rzeczywiście uwzględniony w iteracji akumulacji.

init
Początkowa wartość, do której każdy element jest z kolei dodawany lub łączony przy użyciu binary_op.

binary_op
Operacja binarna, która ma być stosowana do każdego elementu w określonym zakresie i wyniku poprzednich aplikacji.

Wartość zwracana

Suma init i wszystkich elementów w określonym zakresie dla pierwszej funkcji szablonu lub, dla drugiej funkcji szablonu, wynik zastosowania operacji binarnej binary_op zamiast operacji sumowania do (*PartialResult, in_iter), gdzie PartialResult jest wynikiem poprzednich aplikacji operacji i in_iter jest iteratorem wskazującym następny element w zakresie.

Uwagi

Wartość początkowa gwarantuje, że istnieje dobrze zdefiniowany wynik, gdy zakres jest pusty, w takim przypadku zwracany jest inicjowanie . Operacja binarna nie musi być asocjacyjna ani dojeżdżająca. Wynik jest inicjowany do początkowej wartości init, a następnie wynik = binary_op (wynik, in_iter) jest obliczany iteracyjnie przez zakres, gdzie in_iter jest iteratorem wskazującym każdy kolejny element w zakresie. Zakres musi być prawidłowy, a złożoność jest liniowa z rozmiarem zakresu. Typ zwracany operatora binarnego musi być konwertowany na typ , aby zapewnić zamknięcie podczas iteracji.

Przykład

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

Oblicza kolejne różnice między poszczególnymi elementami i jego poprzednikami w zakresie danych wejściowych. Zwraca wyniki do zakresu docelowego. Lub oblicza wynik uogólnionej procedury, w której operacja różnicy jest zastępowana przez inną, określoną operację binarną.

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

Exec
Zasady wykonywania.

pierwszy
Iterator danych wejściowych odnoszący się do pierwszego elementu z zakresu wejściowego, którego elementy mają być zróżnicowane z ich odpowiednimi poprzednikami lub gdzie na parze wartości ma działać inna określona operacja binarna.

ostatni
Iterator danych wejściowych odnoszący się do ostatniego elementu z zakresu wejściowego, którego elementy mają być zróżnicowane z ich odpowiednimi poprzednikami lub gdzie na parze wartości ma działać inna określona operacja binarna.

wynik
Iterator danych wyjściowych odnoszący się do pierwszego elementu zakresu docelowego, gdzie ma być przechowywany szereg różnic lub wyniki określonej operacji.

binary_op
Operacja binarna, która ma być stosowana w uogólnionej operacji, zastępując operację odejmowania w procedurze różnicowej.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do końca zakresu docelowego: result + (last - first).

Uwagi

Wynik iteratora wyjściowego może być tym samym iteratorem co iterator wejściowy jako pierwszy, dzięki czemu adjacent_difference wartości mogą być obliczane na miejscu.

W przypadku sekwencji wartości 1, 2, 3, w zakresie wejściowym pierwsza funkcja szablonu przechowuje kolejne adjacent_difference wartości 1, a 2 - a 1, a3 - 2, w zakresie docelowym.

W przypadku sekwencji wartości 1, 2, 3, w zakresie wejściowym druga funkcja szablonu przechowuje kolejne adjacent_difference wartości 1, a 2 binary_op 1, 3 binary_op 2, w zakresie docelowym.

Operacja binarna binary_op nie jest wymagana, aby być skojarzona lub zmutacyjna, ponieważ określono kolejność zastosowanych operacji.

Przykład

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

Oblicza wyłączną operację sumowania prefiksu przy użyciu std::plus<>() operatora binarnego lub określonego operatora binarnego w zakresie, biorąc pod uwagę wartość początkową. Zapisuje wyniki w zakresie rozpoczynającym się od określonego miejsca docelowego. Suma prefiksów wyłącznych oznacza, że nelement wejściowy nie jest uwzględniony w n-tejsumie. Przeciążenia obejmujące argument zasad wykonywania wykonywane zgodnie z określonymi zasadami.

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

Exec
Zasady wykonywania.

pierwszy
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie do sumy lub połączenia przy użyciu binary_op.

ostatni
Iterator wejściowy odnoszący się do ostatniego elementu w zakresie do sumy lub połączenia przy użyciu binary_op, jest to jedna pozycja poza ostatnim elementem rzeczywiście uwzględniony w iteracji akumulacji.

wynik
Iterator danych wyjściowych odnoszący się do pierwszego elementu zakres docelowy, w którym ma być przechowywana seria sum lub wyniki określonej operacji.

init
Początkowa wartość, do której każdy element jest z kolei dodawany lub łączony przy użyciu binary_op.

binary_op
Operacja binarna, która ma być stosowana do każdego elementu w określonym zakresie i wyniku poprzednich aplikacji.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do końca zakresu docelowego: wynik + (ostatni pierwszy - ).

NWD

Oblicza największy wspólny dzielnik liczb całkowitych m i n.

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

Parametry

m, n
Wartości typu całkowitego.

Wartość zwracana

Zwraca największy wspólny dzielnik wartości bezwzględnych m i n, lub zero, jeśli zarówno m, jak i n są zerowe. Wyniki są niezdefiniowane, jeśli wartości bezwzględne m lub n nie są reprezentowane jako wartości typu common_type_t<M,N>.

inclusive_scan

Oblicza operację sumy prefiksu inkluzywnego przy użyciu std::plus<>() operatora binarnego lub określonego operatora binarnego w zakresie, biorąc pod uwagę wartość początkową. Zapisuje wyniki w zakresie rozpoczynającym się od określonego miejsca docelowego. Suma prefiksu inkluzywnego oznacza, że nelement wejściowy jest uwzględniony w ntej sumy. Przeciążenia obejmujące argument zasad wykonywania wykonywane zgodnie z określonymi zasadami.

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

Exec
Zasady wykonywania.

pierwszy
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie do sumy lub połączenia przy użyciu binary_op.

ostatni
Iterator wejściowy odnoszący się do ostatniego elementu w zakresie do sumy lub połączenia przy użyciu binary_op, jest to jedna pozycja poza ostatnim elementem rzeczywiście uwzględniony w iteracji akumulacji.

wynik
Iterator danych wyjściowych odnoszący się do pierwszego elementu zakres docelowy, w którym ma być przechowywana seria sum lub wyniki określonej operacji.

init
Początkowa wartość, do której każdy element jest z kolei dodawany lub łączony przy użyciu binary_op.

binary_op
Operacja binarna, która ma być stosowana do każdego elementu w określonym zakresie i wyniku poprzednich aplikacji.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do końca zakresu docelowego: wynik + (ostatni pierwszy - ).

inner_product

Oblicza sumę produktu mądrego elementu dwóch zakresów i dodaje ją do określonej wartości początkowej lub oblicza wynik uogólnionej procedury, w której operacje sumowania i binarne produktu są zastępowane przez inne określone operacje binarne.

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

first1
Iterator wejściowy odnoszący się do pierwszego elementu w pierwszym zakresie, którego produkt wewnętrzny lub uogólniony produkt wewnętrzny z drugim zakresem ma zostać obliczony.

last1
Iterator wejściowy odnoszący się do ostatniego elementu w pierwszym zakresie, którego produkt wewnętrzny lub uogólniony produkt wewnętrzny z drugim zakresem ma zostać obliczony.

first2
Iterator wejściowy odnoszący się do pierwszego elementu w drugim zakresie, którego produkt wewnętrzny lub uogólniony produkt wewnętrzny z pierwszym zakresem ma zostać obliczony.

init
Początkowa wartość, do której należy dodać produkt wewnętrzny lub uogólniony produkt wewnętrzny między zakresami.

binary_op1
Operacja binarna zastępująca wewnętrzną operację produktu sumą zastosowaną do produktów mądrych elementami w uogólnieniu produktu wewnętrznego.

binary_op2
Operacja binarna zastępująca wewnętrzną operację elementu produktu mnożoną w uogólnieniu produktu wewnętrznego.

Wartość zwracana

Pierwsza funkcja składowa zwraca sumę produktów mądrych elementami i dodaje do niej określoną wartość początkową. Dlatego w przypadku zakresów wartości ai i i zwraca:

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

przez iteracyjne zastępowanie init init + (ai * bi).

Druga funkcja składowa zwraca:

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

przez iteracyjne zastępowanie init init binary_op1 (ai binary_op2 bi).

Uwagi

Początkowa wartość gwarantuje, że istnieje dobrze zdefiniowany wynik, gdy zakres jest pusty. W takim przypadku zwracany jest inicjowanie . Operacje binarne nie muszą być skojarzone ani zmutacyjne. Zakres musi być prawidłowy, a złożoność jest liniowa z rozmiarem zakresu. Typ zwracany operatora binarnego musi być konwertowany na typ , aby zapewnić zamknięcie podczas iteracji.

Przykład

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

Przechowuje wartość początkową, zaczynając od pierwszego elementu i wypełniając kolejne przyrosty tej wartości (value++) w każdym z elementów w interwale [first, last).

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

Parametry

pierwszy
Iterator wejściowy, który adresuje pierwszy element w zakresie, który ma zostać wypełniony.

ostatni
Iterator wejściowy, który adresuje ostatni element w zakresie do wypełnienia.

wartość
Wartość początkowa do przechowywania w pierwszym elemenie i do kolejnych przyrostów dla późniejszych elementów.

Przykład

W poniższym przykładzie pokazano niektóre zastosowania funkcji iota przez wypełnienie listy liczb całkowitych, a następnie wypełnienie wektora list wartością , aby można było użyć funkcji 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;
}

NWW

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

partial_sum

Oblicza serię sum w zakresie wejściowym od pierwszego elementu przez nelementu i przechowuje wynik każdej takiej sumy w nelementu docelowego. Lub oblicza wynik uogólnionej procedury, w której operacja sumowania jest zastępowana przez inną określoną operację binarną.

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

pierwszy
Iterator danych wejściowych odnoszący się do pierwszego elementu w zakresie, który ma być częściowo sumowany lub scalony według określonej operacji binarnej.

ostatni
Iterator danych wejściowych odnoszący się do ostatniego elementu w zakresie, który ma być częściowo sumowany lub scalony według określonej operacji binarnej, znajdujący się o jedną pozycję poza ostatnim elementem faktycznie włączonym w iterowaną akumulację.

wynik
Iterator danych wyjściowych odnoszący się do pierwszego elementu zakresu docelowego do przechowywania serii sum częściowych lub kolejnych wyników określonej operacji binarnej.

binary_op
Operacja binarna, która ma być stosowana w uogólnionej operacji, zastępując operację sumowania w procedurze sumy częściowej.

Wartość zwracana

Iterator danych wyjściowych odnoszący się do końca zakresu docelowego: wynik + (ostatni pierwszy - ).

Uwagi

Wynik iteratora wyjściowego może być taki sam iterator jak iterator wejściowy, dzięki czemu sumy częściowe mogą być obliczane na miejscu.

Dla sekwencji wartości 1, a2, ... ax w zakresie wejściowym pierwsza funkcja szablonu przechowuje kolejne częściowe sumy w zakresie docelowym. N element jest podawany przez (a1 + 2 + 3 + ... + n).

W przypadku sekwencji wartości 1, 2, 3 w zakresie wejściowym druga funkcja szablonu przechowuje kolejne częściowe wyniki w zakresie docelowym. N. element jest podawany przez element ((... (a1 binary_op a 2) binary_op a 3) binary_op ... ) binary_op n).

Operacja binarna binary_op nie jest wymagana, aby być skojarzona lub zmutacyjna, ponieważ określono kolejność zastosowanych operacji.

Przykład

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

zmniejszyć

Zmniejsza wszystkie elementy w określonym zakresie, prawdopodobnie łącznie z pewną wartością początkową, obliczając sumy w dowolnej i prawdopodobnie permutowanej kolejności. Można też zmniejszyć liczbę wyników określonej operacji binarnej. Przeciążenia obejmujące argument zasad wykonywania wykonywane zgodnie z określonymi zasadami.

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

Exec
Zasady wykonywania.

pierwszy
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie do sumy lub połączenia przy użyciu binary_op.

ostatni
Iterator wejściowy odnoszący się do ostatniego elementu w zakresie do sumy lub połączenia przy użyciu binary_op, jest to jedna pozycja poza ostatnim elementem rzeczywiście uwzględniony w iteracji akumulacji.

wynik
Iterator danych wyjściowych odnoszący się do pierwszego elementu zakres docelowy, w którym ma być przechowywana seria sum lub wyniki określonej operacji.

init
Początkowa wartość, do której każdy element jest z kolei dodawany lub łączony przy użyciu binary_op.

binary_op
Operacja binarna, która ma być stosowana do każdego elementu w określonym zakresie i wyniku poprzednich aplikacji.

Wartość zwracana

Wynik zastosowania binary_op lub std::plus<>() do inicjowania i wszystkich elementów w określonym zakresie do (*PartialResult, in_iter), gdzie PartialResult jest wynikiem poprzednich aplikacji operacji, a in_iter jest iteratorem wskazującym jakiś element w zakresie. W przeciążeniach, które nie określają init, użyta wartość inicjowania jest równoważna wartości typename iterator_traits<InputIterator>::value_type{}.

Uwagi

reduce zachowanie nie jest deterministyczne, chyba że binary_op jest asocjacyjny i dojeżdżający. Zachowanie jest niezdefiniowane, jeśli binary_op modyfikuje dowolny element lub unieważnia dowolny iterator w interwale [first, last], inclusive.

transform_exclusive_scan

Przekształca elementy zakresu za pomocą określonego operatora jednoargumentowego, a następnie oblicza wyłączną operację sumowania prefiksu przy użyciu std::plus<>() lub określonego operatora binarnego w zakresie, biorąc pod uwagę wartość początkową. Zapisuje wyniki w zakresie rozpoczynającym się od określonego miejsca docelowego. Suma prefiksów wyłącznych oznacza, że nelement wejściowy nie jest uwzględniony w n-tejsumie. Przeciążenia obejmujące argument zasad wykonywania wykonywane zgodnie z określonymi zasadami. Sumowanie można wykonać w dowolnej kolejności.

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

Exec
Zasady wykonywania.

pierwszy
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie do sumy lub połączenia przy użyciu binary_op.

ostatni
Iterator wejściowy odnoszący się do ostatniego elementu w zakresie do sumy lub połączenia przy użyciu binary_op, jest to jedna pozycja poza ostatnim elementem rzeczywiście uwzględniony w iteracji akumulacji.

wynik
Iterator danych wyjściowych odnoszący się do pierwszego elementu zakres docelowy, w którym ma być przechowywana seria sum lub wyniki określonej operacji.

init
Początkowa wartość, do której każdy element jest z kolei dodawany lub łączony przy użyciu binary_op.

binary_op
Operacja binarna, która ma być stosowana do każdego elementu w określonym zakresie i wyniku poprzednich aplikacji.

unary_op
Operacja jednoargumentowa do zastosowania do każdego elementu w określonym zakresie.

transform_inclusive_scan

Przekształca elementy zakresu za pomocą określonego operatora jednoargumentowego, a następnie oblicza operację sumy prefiksu inkluzywnego przy użyciu std::plus<>() lub określonego operatora binarnego w zakresie, biorąc pod uwagę wartość początkową. Zapisuje wyniki w zakresie rozpoczynającym się od określonego miejsca docelowego. Suma prefiksu inkluzywnego oznacza, że nelement wejściowy jest uwzględniony w ntej sumy. Przeciążenia obejmujące argument zasad wykonywania wykonywane zgodnie z określonymi zasadami. Sumowanie można wykonać w dowolnej kolejności.

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

Exec
Zasady wykonywania.

pierwszy
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie do sumy lub połączenia przy użyciu binary_op.

ostatni
Iterator wejściowy odnoszący się do ostatniego elementu w zakresie do sumy lub połączenia przy użyciu binary_op, jest to jedna pozycja poza ostatnim elementem rzeczywiście uwzględniony w iteracji akumulacji.

wynik
Iterator danych wyjściowych odnoszący się do pierwszego elementu zakres docelowy, w którym ma być przechowywana seria sum lub wyniki określonej operacji.

binary_op
Operacja binarna, która ma być stosowana do każdego elementu w określonym zakresie i wyniku poprzednich aplikacji.

unary_op
Operacja jednoargumentowa do zastosowania do każdego elementu w określonym zakresie.

init
Początkowa wartość, do której każdy element jest z kolei dodawany lub łączony przy użyciu binary_op.

transform_reduce

Przekształca szereg elementów, a następnie stosuje functor, który zmniejsza przekształcone elementy w dowolnej kolejności. Skutecznie, po którym następuje 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);

Parametry

Exec
Zasady wykonywania.

pierwszy
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie do sumy lub połączenia przy użyciu binary_op.

first1
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie do sumowania lub łączenia przy użyciu binary_op1.

ostatni
Iterator wejściowy odnoszący się do ostatniego elementu w zakresie do sumy lub połączenia przy użyciu binary_op, jest to jedna pozycja poza ostatnim elementem rzeczywiście uwzględniony w iteracji akumulacji.

last1
Iterator wejściowy odnoszący się do ostatniego elementu w zakresie do sumy lub połączenia przy użyciu binary_op1, jest to jedna pozycja poza ostatnim elementem faktycznie uwzględniona w iteracji akumulacji.

wynik
Iterator danych wyjściowych odnoszący się do pierwszego elementu zakres docelowy, w którym ma być przechowywana seria sum lub wyniki określonej operacji.

init
Początkowa wartość, do której każdy element jest z kolei dodawany lub łączony przy użyciu binary_op.

binary_op
Operacja binarna, która ma być stosowana do każdego elementu w określonym zakresie i wyniku poprzednich aplikacji.

unary_op
Operacja jednoargumentowa do zastosowania do każdego elementu w określonym zakresie.

Wartość zwracana

Przekształcony następnie zmniejszony wynik.