`<numeric>` funzioni

Articolo
10/12/2023

accumulate

Calcola la somma di tutti gli elementi in un intervallo specificato, incluso un valore iniziale, calcolando somme parziali successive. In alternativa, calcola il risultato di risultati parziali successivi di un'operazione binaria specificata.

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

Parametri

first
Iteratore di input che punta al primo elemento dell'intervallo per sommare o combinare utilizzando binary_op.

last
Iteratore di input che punta all'ultimo elemento dell'intervallo per sommare o combinare usando binary_op, ovvero una posizione oltre l'elemento finale effettivamente incluso nell'accumulo iterato.

init
Valore iniziale a cui ogni elemento viene aggiunto o combinato usando binary_op.

binary_op
Operazione binaria da applicare a ogni elemento nell'intervallo specificato e al risultato delle applicazioni precedenti.

Valore restituito

La somma di init e di tutti gli elementi nell'intervallo specificato per la prima funzione modello o, per la seconda funzione modello, il risultato dell'applicazione dell'operazione binaria binary_op invece dell'operazione somma, a (*PartialResult, in_iter), dove PartialResult è il risultato delle applicazioni precedenti dell'operazione e in_iter è un iteratore che punta all'elemento successivo nell'intervallo.

Osservazioni:

Il valore iniziale garantisce che esista un risultato ben definito quando l'intervallo è vuoto, nel qual caso viene restituito init . L'operazione binaria non deve essere associativa o commutativa. Il risultato viene inizializzato nel valore iniziale init e quindi il risultato = binary_op(risultato, in_iter) viene calcolato in modo iterativo attraverso l'intervallo, dove in_iter è un iteratore che punta a ogni elemento successivo nell'intervallo. L'intervallo deve essere valido e la complessità è lineare con le dimensioni dell'intervallo. Il tipo restituito dell'operatore binario deve essere convertibile in Type per garantire la chiusura durante l'iterazione.

Esempio

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

Calcola le differenze successive tra ogni elemento e il relativo predecessore in un intervallo di input. Restituisce i risultati in un intervallo di destinazione. In alternativa, calcola il risultato di una procedura generalizzata in cui l'operazione di differenza viene sostituita da un'altra operazione binaria specificata.

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

Parametri

exec
Criteri di esecuzione.

first
Iteratore di input che punta al primo elemento dell'intervallo di input i cui elementi devono essere differenziati dai rispettivi predecessori o sulla cui coppia di valori deve operare un'altra operazione binaria specificata.

last
Iteratore di input che punta all'ultimo elemento dell'intervallo di input in cui gli elementi devono essere differenziati con i rispettivi predecessori o in cui sulla coppia di valori deve operare un'altra operazione binaria specificata.

result
Iteratore di output che punta al primo elemento di un intervallo di destinazione in cui devono essere archiviati la serie di differenze o i risultati dell'operazione specificata.

binary_op
Operazione binaria da applicare nell'operazione generalizzata, sostituendo l'operazione di sottrazione nella procedura di differenze.

Valore restituito

Iteratore di output che punta alla fine dell'intervallo di destinazione: result + ( - lastfirst).

Osservazioni:

Il risultato dell'iteratore di output può essere lo stesso iteratore dell'iteratore di input, in modo che adjacent_difference i valori possano essere calcolati sul posto.

Per una sequenza di valori 1, 2, 3, in un intervallo di input, la prima funzione modello archivia i valori successivi adjacent_difference 1, 2 - a 1, a3 - 2, nell'intervallo di destinazione.

Per una sequenza di valori 1, 2, 3, in un intervallo di input, la seconda funzione modello archivia i valori successivi adjacent_difference 1, 2 binary_op 1, 3 binary_op 2, nell'intervallo di destinazione.

L'operazione binaria binary_op non deve essere associativa o commutativa, perché viene specificato l'ordine delle operazioni applicate.

Esempio

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

Calcola un'operazione di somma dei prefissi esclusiva usando std::plus<>() o un operatore binario specificato su un intervallo, dato un valore iniziale. Scrive i risultati nell'intervallo a partire dalla destinazione specificata. Una somma del prefisso esclusivo indica che l'n elemento di input non è incluso nella nsomma. Gli overload che includono un argomento dei criteri di esecuzione vengono eseguiti in base ai criteri specificati.

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

Parametri

exec
Criteri di esecuzione.

first
Iteratore di input che punta al primo elemento dell'intervallo per sommare o combinare utilizzando binary_op.

result
Iteratore di output che punta al primo elemento di un intervallo di destinazione in cui deve essere archiviata la serie di somme o i risultati dell'operazione specificata.

init
Valore iniziale a cui ogni elemento viene aggiunto o combinato usando binary_op.

binary_op
Operazione binaria da applicare a ogni elemento nell'intervallo specificato e al risultato delle applicazioni precedenti.

Valore restituito

Iteratore di output che punta alla fine dell'intervallo di destinazione: risultato + (ultimo - primo).

Gcd

Calcola il più grande divisore comune dei numeri interi m e n.

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

Parametri

m, n
Valori di tipo integrale.

Valore restituito

Restituisce il divisore comune più grande dei valori assoluti di m e n oppure zero se sia m che n sono zero. I risultati non sono definiti se i valori assoluti di m o n non sono rappresentabili come valori di tipo common_type_t<M,N>.

inclusive_scan

Calcola un'operazione di somma del prefisso inclusivo usando std::plus<>() o un operatore binario specificato su un intervallo, dato un valore iniziale. Scrive i risultati nell'intervallo a partire dalla destinazione specificata. Una somma di prefisso inclusivo indica che l'n elemento di input è incluso nella n somma. Gli overload che includono un argomento dei criteri di esecuzione vengono eseguiti in base ai criteri specificati.

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

Parametri

exec
Criteri di esecuzione.

first
Iteratore di input che punta al primo elemento dell'intervallo per sommare o combinare utilizzando binary_op.

result
Iteratore di output che punta al primo elemento di un intervallo di destinazione in cui deve essere archiviata la serie di somme o i risultati dell'operazione specificata.

init
Valore iniziale a cui ogni elemento viene aggiunto o combinato usando binary_op.

binary_op
Operazione binaria da applicare a ogni elemento nell'intervallo specificato e al risultato delle applicazioni precedenti.

Valore restituito

Iteratore di output che punta alla fine dell'intervallo di destinazione: risultato + (ultimo - primo).

inner_product

Calcola la somma del prodotto tra gli elementi di due intervalli e aggiunge tale somma a un valore iniziale specificato oppure calcola il risultato di una procedura generalizzata in cui le operazioni binarie di somma e prodotto vengono sostituite da altre operazioni binarie specificate.

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

Parametri

first1
Iteratore di input che punta al primo elemento del primo intervallo di cui è necessario calcolare il prodotto interno o il prodotto interno generalizzato con il secondo intervallo.

last1
Iteratore di input che punta all'ultimo elemento del primo intervallo di cui è necessario calcolare il prodotto interno o il prodotto interno generalizzato con il secondo intervallo.

first2
Iteratore di input che punta al primo elemento del secondo intervallo di cui è necessario calcolare il prodotto interno o il prodotto interno generalizzato con il primo intervallo.

init
Valore iniziale a cui è necessario aggiungere il prodotto interno o il prodotto interno generalizzato tra gli intervalli.

binary_op1
Operazione binaria che sostituisce l'operazione del prodotto interno di somma applicata ai prodotti tra gli elementi nella generalizzazione del prodotto interno.

binary_op2
Operazione binaria che sostituisce l'operazione tra gli elementi del prodotto interno di moltiplicazione nella generalizzazione del prodotto interno.

Valore restituito

La prima funzione membro restituisce la somma dei prodotti tra gli elementi e la aggiunge al valore iniziale specificato. Per gli intervalli di valori ai e bi, viene quindi restituito:

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

sostituendo init in modo iterativo con init + (ai * bi).

La seconda funzione membro restituisce:

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

sostituendo in modo iterativo init con init binary_op1 (ai binary_op2 bi).

Osservazioni:

Il valore iniziale garantisce che sia presente un risultato ben definito quando l'intervallo è vuoto. In tal caso, viene restituito init . Le operazioni binarie non devono essere associative o commutative. L'intervallo deve essere valido e la complessità è lineare con le dimensioni dell'intervallo. Il tipo restituito dell'operatore binario deve essere convertibile in Type per garantire la chiusura durante l'iterazione.

Esempio

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

Archivia un valore iniziale, a partire dal primo elemento e riempiendo con incrementi successivi di tale valore (value++) in ognuno degli elementi nell'intervallo [first, last).

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

Parametri

first
Iteratore di input che punta al primo elemento nel intervallo da compilare.

last
Iteratore di input che punta all'ultimo elemento nel intervallo da compilare.

value
Valore iniziale da archiviare nel primo elemento e incrementare successivamente per gli elementi successivi.

Esempio

L'esempio seguente illustra alcuni usi della funzione iota tramite la compilazione di una classe list di valori integer e quindi di una classe vector con l'oggetto list in modo che possa essere usata la funzione 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;
}

minimo comune multiplo

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

partial_sum

Calcola una serie di somme in un intervallo di input dal primo elemento all'ultimo elemento e archivia il risultato di ogni somma nell'n elemento dell'intervallo di destinazione. In alternativa, calcola il risultato di una procedura generalizzata in cui l'operazione di somma viene sostituita da un'altra operazione binaria specificata.

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

Parametri

first
Iteratore di input che punta al primo elemento dell'intervallo perché venga parzialmente sommato o combinato secondo un'operazione binaria specificata.

last
Iteratore di input che punta all'ultimo elemento dell'intervallo perché venga parzialmente sommato o combinato secondo un'operazione binaria specificata immediatamente successiva all'ultimo elemento incluso nella somma iterata.

result
Iteratore di output che punta al primo elemento di un intervallo di destinazione per archiviare la serie di somme parziali o i risultati successivi dell'operazione binaria specificata.

binary_op
Operazione binaria da applicare nell'operazione generalizzata, sostituendo l'operazione di somma nella procedura di somma parziale.

Valore restituito

Iteratore di output che punta alla fine dell'intervallo di destinazione: risultato + (ultimo - primo).

Osservazioni:

Il risultato dell'iteratore di output può essere lo stesso iteratore dell'iteratore di input, in modo che le somme parziali possano essere calcolate sul posto.

Per una sequenza di valori 1, 2, ... unax, in un intervallo di input, la prima funzione modello archivia somme parziali successive nell'intervallo di destinazione. L'n° elemento è dato da (un1 + a2 + a3 + ... + an).

Per una sequenza di valori 1, 2, 3, in un intervallo di input, la seconda funzione modello archivia i risultati parziali successivi nell'intervallo di destinazione. L'n elemento è dato da ((... ((a1 binary_op a2) binary_op a3) binary_op ... ) binary_op an).

L'operazione binaria binary_op non deve essere associativa o commutativa, perché viene specificato l'ordine delle operazioni applicate.

Esempio

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

Riduce tutti gli elementi in un intervallo specificato, possibilmente includendo un valore iniziale, calcolando somme in un ordine arbitrario ed eventualmente permutato. In alternativa, riduce calcolando i risultati di un'operazione binaria specificata. Gli overload che includono un argomento dei criteri di esecuzione vengono eseguiti in base ai criteri specificati.

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

Parametri

exec
Criteri di esecuzione.

first
Iteratore di input che punta al primo elemento dell'intervallo per sommare o combinare utilizzando binary_op.

result
Iteratore di output che punta al primo elemento di un intervallo di destinazione in cui deve essere archiviata la serie di somme o i risultati dell'operazione specificata.

init
Valore iniziale a cui ogni elemento viene aggiunto o combinato usando binary_op.

binary_op
Operazione binaria da applicare a ogni elemento nell'intervallo specificato e al risultato delle applicazioni precedenti.

Valore restituito

Risultato dell'applicazione di binary_op o std::plus<>() a init e a tutti gli elementi nell'intervallo specificato a (*PartialResult, in_iter), dove PartialResult è il risultato delle applicazioni precedenti dell'operazione e in_iter è un iteratore che punta a un elemento nell'intervallo. Negli overload che non specificano init, il valore init usato equivale a typename iterator_traits<InputIterator>::value_type{}.

Osservazioni:

reduce il comportamento non deterministico, a meno che binary_op sia associativo e commutativo. Il comportamento non è definito se binary_op modifica qualsiasi elemento o invalida qualsiasi iteratore nell'intervallo [primo, ultimo], inclusivo.

transform_exclusive_scan

Trasforma gli elementi di un intervallo con un operatore unario specificato, quindi calcola un'operazione di somma del prefisso esclusivo usando std::plus<>() o un operatore binario specificato nell'intervallo, dato un valore iniziale. Scrive i risultati nell'intervallo a partire dalla destinazione specificata. Una somma del prefisso esclusivo indica che l'n elemento di input non è incluso nella nsomma. Gli overload che includono un argomento dei criteri di esecuzione vengono eseguiti in base ai criteri specificati. La somma può essere eseguita in un ordine arbitrario.

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

Parametri

exec
Criteri di esecuzione.

first
Iteratore di input che punta al primo elemento dell'intervallo per sommare o combinare utilizzando binary_op.

result
Iteratore di output che punta al primo elemento di un intervallo di destinazione in cui deve essere archiviata la serie di somme o i risultati dell'operazione specificata.

init
Valore iniziale a cui ogni elemento viene aggiunto o combinato usando binary_op.

binary_op
Operazione binaria da applicare a ogni elemento nell'intervallo specificato e al risultato delle applicazioni precedenti.

unary_op
Operazione unaria da applicare a ogni elemento nell'intervallo specificato.

transform_inclusive_scan

Trasforma gli elementi di un intervallo con un operatore unario specificato, quindi calcola un'operazione di somma del prefisso inclusivo usando std::plus<>() o un operatore binario specificato nell'intervallo, dato un valore iniziale. Scrive i risultati nell'intervallo a partire dalla destinazione specificata. Una somma di prefisso inclusivo indica che l'n elemento di input è incluso nella n somma. Gli overload che includono un argomento dei criteri di esecuzione vengono eseguiti in base ai criteri specificati. La somma può essere eseguita in un ordine arbitrario.

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

Parametri

exec
Criteri di esecuzione.

first
Iteratore di input che punta al primo elemento dell'intervallo per sommare o combinare utilizzando binary_op.

result
Iteratore di output che punta al primo elemento di un intervallo di destinazione in cui deve essere archiviata la serie di somme o i risultati dell'operazione specificata.

binary_op
Operazione binaria da applicare a ogni elemento nell'intervallo specificato e al risultato delle applicazioni precedenti.

unary_op
Operazione unaria da applicare a ogni elemento nell'intervallo specificato.

init
Valore iniziale a cui ogni elemento viene aggiunto o combinato usando binary_op.

transform_reduce

Trasforma un intervallo di elementi, quindi applica un funtore che riduce gli elementi trasformati in ordine arbitrario. In effetti, un transform oggetto seguito da un oggetto 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);

Parametri

exec
Criteri di esecuzione.

first
Iteratore di input che punta al primo elemento dell'intervallo per sommare o combinare utilizzando binary_op.

first1
Iteratore di input che punta al primo elemento dell'intervallo per sommare o combinare utilizzando binary_op1.

last1
Iteratore di input che punta all'ultimo elemento dell'intervallo per sommare o combinare usando binary_op1, ovvero una posizione oltre l'elemento finale effettivamente incluso nell'accumulo iterato.

result
Iteratore di output che punta al primo elemento di un intervallo di destinazione in cui deve essere archiviata la serie di somme o i risultati dell'operazione specificata.

init
Valore iniziale a cui ogni elemento viene aggiunto o combinato usando binary_op.

binary_op
Operazione binaria da applicare a ogni elemento nell'intervallo specificato e al risultato delle applicazioni precedenti.

unary_op
Operazione unaria da applicare a ogni elemento nell'intervallo specificato.

Valore restituito

Risultato quindi ridotto.

Condividi tramite

<numeric> funzioni

accumulate

Parametri

Valore restituito

Osservazioni:

Esempio

adjacent_difference

Parametri

Valore restituito

Osservazioni:

Esempio

exclusive_scan

Parametri

Valore restituito

Gcd

Parametri

Valore restituito

inclusive_scan

Parametri

Valore restituito

inner_product

Parametri

Valore restituito

Osservazioni:

Esempio

iota

Parametri

Esempio

minimo comune multiplo

partial_sum

Parametri

Valore restituito

Osservazioni:

Esempio

reduce

Parametri

Valore restituito

Osservazioni:

transform_exclusive_scan

Parametri

transform_inclusive_scan

Parametri

transform_reduce

Parametri

Valore restituito

Commenti e suggerimenti

Risorse aggiuntive

`<numeric>` funzioni