Funções `<numeric>`

Artigo
06/16/2023

accumulate

Calcula a soma de todos os elementos em um intervalo especificado, incluindo algum valor inicial, calculando somas parciais sucessivas. Ou calcula o resultado de resultados parciais sucessivos de uma operação binária especificada.

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

Parâmetros

first
Um iterador de entrada que trata do primeiro elemento no intervalo para somar ou combinar usando binary_op.

last
Um iterador de entrada que trata o último elemento no intervalo para ser somado ou combinado usando binary_op, que está uma posição acima do elemento final incluído no acúmulo iterado.

init
Um valor inicial para o qual cada elemento por sua vez é adicionado ou combinado usando binary_op.

binary_op
A operação binária deve ser aplicada a cada elemento no intervalo especificado e o resultado de suas aplicações anteriores.

Valor retornado

A soma de init e todos os elementos no intervalo especificado para a primeira função de modelo ou, para a segunda função de modelo, o resultado da aplicação de operação binária binary_op especificada, em vez da operação de soma, para (*PartialResult, in_iter), em que PartialResult é o resultado de aplicações anteriores da operação e in_iter é um iterador direcionado para um próximo elemento no intervalo.

Comentários

O valor inicial garante que haverá um resultado bem definido quando o intervalo estiver vazio. Nesse caso, init é retornado. A operação binária não precisa ser associativa ou comutativa. O resultado é inicializado com o valor inicial init e, então, o resultado = binary_op(result, in_iter) é calculado iterativamente pelo intervalo, em que in_iter é um iterador direcionado para o elemento sucessivo no intervalo. O intervalo deve ser válido e a complexidade deve estar de acordo com o tamanho do intervalo. O tipo de retorno do operador binário deve ser conversível para Type para garantir o fechamento durante a iteração.

Exemplo

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

Calcula as diferenças sucessivas entre cada elemento e seu antecessor em um intervalo de entrada. Gera os resultados para um intervalo de destino. Ou calcula o resultado de um procedimento generalizado em que a operação de diferença é substituída por outra operação binária especificada.

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

Parâmetros

exec
Uma política de execução.

first
Um iterador de entrada que trata o primeiro elemento no intervalo de entrada cujos elementos deverão ser diferenciados com seus respectivos antecessores ou onde o par de valores deverá ser operado por qualquer outra operação binária especificada.

last
Um iterador de entrada que trata o último elemento no intervalo de entrada cujos elementos deverão ser diferenciados com seus respectivos antecessores ou onde o par de valores deverá ser operado por qualquer outra operação binária especificada.

result
Um iterador de saída que trata o primeiro elemento em um intervalo de destino onde a série de diferenças ou os resultados da operação especificada deverão ser armazenados.

binary_op
A operação binária deverá ser aplicada na operação generalizada, substituindo a operação de subtração no procedimento de diferenciação.

Valor retornado

Um iterador de saída que trata a extremidade do intervalo de destino: result + (last - first).

Comentários

O resultado do iterador de saída pode ser o mesmo iterador como iterador de entrada first, de modo que os valores adjacent_difference podem ser calculados no lugar.

Para uma sequência de valores a1, a2, a3, em um intervalo de entrada, a primeira função de modelo armazena valores sucessivos adjacent_difference a1, a2 - a1, a3 - a2 no intervalo de destino.

Para uma sequência de valores a1, a2, a3, em um intervalo de entrada, a segunda função de modelo armazena valores sucessivos adjacent_difference a1, a2 binary_op a1, a3 binary_op a2, no intervalo de destino.

A operação binária binary_op não precisa obrigatoriamente ser associativa ou comutativa, porque a ordem das operações aplicada é especificada.

Exemplo

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

Calcula uma operação de soma de prefixo exclusivo usando std::plus<>() ou um operador binário especificado em um intervalo, dado um valor inicial. Grava os resultados no intervalo que começa no destino especificado. Uma soma de prefixo exclusivo significa que o enésimo elemento de entrada não está incluído na soma do enésimo. As sobrecargas que incluem um argumento de política de execução são executadas de acordo com a política especificada.

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

Parâmetros

exec
Uma política de execução.

first
Um iterador de entrada que trata do primeiro elemento no intervalo para somar ou combinar usando binary_op.

last
Um iterador de entrada que trata o último elemento no intervalo para ser somado ou combinado usando binary_op, que está uma posição acima do elemento final incluído no acúmulo iterado.

result
Um iterador de saída que trata o primeiro elemento em um intervalo de destino onde a série de somas ou os resultados da operação especificada deverão ser armazenados.

init
Um valor inicial para o qual cada elemento por sua vez é adicionado ou combinado usando binary_op.

binary_op
A operação binária deve ser aplicada a cada elemento no intervalo especificado e o resultado de suas aplicações anteriores.

Valor retornado

Um iterador de saída que trata a extremidade do intervalo de destino: resultado + (last - first).

gcd

Calcula o maior divisor comum dos inteiros m e n.

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

Parâmetros

m, n
Valores de tipo integral.

Valor retornado

Retorna o maior divisor comum dos valores absolutos de m e n ou zero se m e n forem zero. Os resultados são indefinidos se os valores absolutos de m ou n não são representativos como valores do tipo common_type_t<M,N>.

inclusive_scan

Calcula uma operação de soma de prefixo inclusivo usando std::plus<>() ou um operador binário especificado em um intervalo, dado um valor inicial. Grava os resultados no intervalo que começa no destino especificado. Uma soma de prefixo inclusivo significa que o enésimo elemento de entrada está incluído na soma do enésimo. As sobrecargas que incluem um argumento de política de execução são executadas de acordo com a política especificada.

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

Parâmetros

exec
Uma política de execução.

first
Um iterador de entrada que trata do primeiro elemento no intervalo para somar ou combinar usando binary_op.

last
Um iterador de entrada que trata o último elemento no intervalo para ser somado ou combinado usando binary_op, que está uma posição acima do elemento final incluído no acúmulo iterado.

result
Um iterador de saída que trata o primeiro elemento em um intervalo de destino onde a série de somas ou os resultados da operação especificada deverão ser armazenados.

init
Um valor inicial para o qual cada elemento por sua vez é adicionado ou combinado usando binary_op.

binary_op
A operação binária deve ser aplicada a cada elemento no intervalo especificado e o resultado de suas aplicações anteriores.

Valor retornado

Um iterador de saída que trata a extremidade do intervalo de destino: resultado + (last - first).

inner_product

Calcula a soma do produto em relação ao elemento de dois intervalos e a adiciona a um valor inicial especificado ou calcula o resultado de um procedimento generalizado, em que as operações binárias de produto e a soma são substituídas por outras operações binárias especificadas.

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

Parâmetros

first1
Um iterador de entrada que trata o primeiro elemento no primeiro intervalo cujo produto interno ou produto interno generalizado com o segundo intervalo deverá ser calculado.

last1
Um iterador de entrada que trata o último elemento no primeiro intervalo cujo produto interno ou produto interno generalizado com o segundo intervalo deverá ser calculado.

first2
Um iterador de entrada que trata o primeiro elemento no segundo intervalo cujo produto interno ou produto interno generalizado com o primeiro intervalo deverá ser calculado.

init
Um valor inicial para o qual deve ser adicionado o produto interno ou o produto interno generalizado entre os intervalos.

binary_op1
A operação binária que substitui a operação de produto interna da soma aplicada aos produtos em relação ao elemento na generalização do produto interno.

binary_op2
A operação binária que substitui a operação em relação ao elemento do produto interno da multiplicação na generalização do produto interno.

Valor retornado

A primeira função membro retorna a soma dos produtos em relação ao elemento e adiciona a ela o valor inicial especificado. Então, para intervalos de valores ai e bi, ela retornará:

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

substituindo iterativamente o init por init + (ai * bi).

A segunda função membro retorna:

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

substituindo iterativamente init por init binary_op1 (ai binary_op2 bi).

Comentários

O valor inicial garante que haverá um resultado bem definido quando o intervalo estiver vazio. Nesse caso, init é retornado. As operações binárias não precisam ser associativas ou comutativas. O intervalo deve ser válido e a complexidade deve estar de acordo com o tamanho do intervalo. O tipo de retorno do operador binário deve ser conversível para Type para garantir o fechamento durante a iteração.

Exemplo

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

Armazena um valor inicial, começando com o primeiro elemento e preenchendo com incrementos sucessivos do valor (value++) em cada um dos elementos no intervalo [first, last).

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

Parâmetros

first
Um iterador de entrada que trata o primeiro elemento no intervalo a ser preenchido.

last
Um iterador de entrada que trata o último elemento no intervalo a ser preenchido.

value
O valor inicial para armazenar no primeiro elemento e incrementar sucessivamente para elementos posteriores.

Exemplo

O exemplo a seguir demonstra alguns usos para a função iota ao preencher uma lista de inteiros e, em seguida, preencher um vetor com o list para que a função random_shuffle possa ser usada.

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

Calcula uma série de somas em um intervalo de entrada do primeiro elemento até o enésimo elemento e armazena o resultado de cada soma no enésimo elemento de um intervalo de destino. Ou calcula o resultado de um procedimento generalizado em que a operação da soma é substituída por outra operação binária especificada.

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

Parâmetros

first
Um iterador de entrada que trata o primeiro elemento no intervalo para ser parcialmente somado ou combinado de acordo com uma operação binária especificada.

last
Um iterador de entrada que trata o último elemento no intervalo para ser parcialmente somado ou combinado, de acordo com uma operação binária especificada que está uma posição além do elemento final de fato incluído no acúmulo iterado.

result
Um iterador de saída que trata o primeiro elemento de um intervalo de destino para armazenar as séries de somas parciais ou os resultados sucessivos da operação binária especificada.

binary_op
A operação binária aplicada na operação generalizada, substituindo a operação de soma no procedimento de soma parcial.

Valor retornado

Um iterador de saída que trata a extremidade do intervalo de destino: resultado + (last - first).

Comentários

O resultado do iterador de saída pode ser o mesmo iterador que o iterador de entrada first, por isso as somas parciais podem ser calculadas em seu lugar.

Para uma sequência de valores a1, a2, ... ax, em um intervalo de entrada, a primeira função de modelo armazena somas parciais sucessivas no intervalo de destino. O enésimo elemento é fornecido por (a1 + a2 + a3 + ... + an).

Para uma sequência de valores a1, a2, a3,, em um intervalo de entrada, a segunda função de modelo armazena resultados parciais sucessivos no intervalo de destino. O enésimo elemento é dado por ((... ((a1 binary_op a2) binary_op a3) binary_op ... ) binary_op umn).

A operação binária binary_op não precisa obrigatoriamente ser associativa ou comutativa, porque a ordem das operações aplicada é especificada.

Exemplo

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

Reduz todos os elementos em um intervalo especificado, possivelmente incluindo algum valor inicial, calculando somas em uma ordem arbitrária e possivelmente permutada. Ou reduz pelo cálculo os resultados de uma operação binária especificada. As sobrecargas que incluem um argumento de política de execução são executadas de acordo com a política especificada.

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

Parâmetros

exec
Uma política de execução.

first
Um iterador de entrada que trata do primeiro elemento no intervalo para somar ou combinar usando binary_op.

last
Um iterador de entrada que trata o último elemento no intervalo para ser somado ou combinado usando binary_op, que está uma posição acima do elemento final incluído no acúmulo iterado.

result
Um iterador de saída que trata o primeiro elemento em um intervalo de destino onde a série de somas ou os resultados da operação especificada deverão ser armazenados.

init
Um valor inicial para o qual cada elemento por sua vez é adicionado ou combinado usando binary_op.

binary_op
A operação binária deve ser aplicada a cada elemento no intervalo especificado e o resultado de suas aplicações anteriores.

Valor retornado

O resultado da aplicação de binary_op ou std::plus<>() para init e todos os elementos no intervalo especificado para (*PartialResult, in_iter), em que PartialResult é o resultado de aplicativos anteriores da operação e in_iter é um iterador apontando para algum elemento no intervalo. Em sobrecargas que não especificam init, o valor de init usado é equivalente a typename iterator_traits<InputIterator>::value_type{}.

Comentários

O comportamento reduce é não determinístico, a menos que binary_op seja associativo e comutativo. O comportamento será indefinido se binary_op modificar qualquer elemento ou invalidar qualquer iterador no intervalo [first, last], inclusive.

transform_exclusive_scan

Transforma os elementos de um intervalo com um operador unário especificado e, em seguida, calcula uma operação de soma de prefixo exclusivo usando std::plus<>()ou um operador binário especificado sobre o intervalo, considerando um valor inicial. Grava os resultados no intervalo que começa no destino especificado. Uma soma de prefixo exclusivo significa que o enésimo elemento de entrada não está incluído na soma do enésimo. As sobrecargas que incluem um argumento de política de execução são executadas de acordo com a política especificada. A soma pode ser executada em uma ordem arbitrária.

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

Parâmetros

exec
Uma política de execução.

first
Um iterador de entrada que trata do primeiro elemento no intervalo para somar ou combinar usando binary_op.

last
Um iterador de entrada que trata o último elemento no intervalo para ser somado ou combinado usando binary_op, que está uma posição acima do elemento final incluído no acúmulo iterado.

result
Um iterador de saída que trata o primeiro elemento em um intervalo de destino onde a série de somas ou os resultados da operação especificada deverão ser armazenados.

init
Um valor inicial para o qual cada elemento por sua vez é adicionado ou combinado usando binary_op.

binary_op
A operação binária deve ser aplicada a cada elemento no intervalo especificado e o resultado de suas aplicações anteriores.

unary_op
A operação unária a ser aplicada a cada elemento no intervalo especificado.

transform_inclusive_scan

Transforma os elementos de um intervalo com um operador unário especificado e, em seguida, calcula uma operação de soma de prefixo inclusivo usando std::plus<>()ou um operador binário especificado sobre o intervalo, considerando um valor inicial. Grava os resultados no intervalo que começa no destino especificado. Uma soma de prefixo inclusivo significa que o enésimo elemento de entrada está incluído na soma do enésimo. As sobrecargas que incluem um argumento de política de execução são executadas de acordo com a política especificada. A soma pode ser executada em uma ordem arbitrária.

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

Parâmetros

exec
Uma política de execução.

first
Um iterador de entrada que trata do primeiro elemento no intervalo para somar ou combinar usando binary_op.

last
Um iterador de entrada que trata o último elemento no intervalo para ser somado ou combinado usando binary_op, que está uma posição acima do elemento final incluído no acúmulo iterado.

result
Um iterador de saída que trata o primeiro elemento em um intervalo de destino onde a série de somas ou os resultados da operação especificada deverão ser armazenados.

binary_op
A operação binária deve ser aplicada a cada elemento no intervalo especificado e o resultado de suas aplicações anteriores.

unary_op
A operação unária a ser aplicada a cada elemento no intervalo especificado.

init
Um valor inicial para o qual cada elemento por sua vez é adicionado ou combinado usando binary_op.

transform_reduce

Transforma um intervalo de elementos e aplica um functor que reduz os elementos transformados em ordem arbitrária. Efetivamente, um transform seguido por um 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);

Parâmetros

exec
Uma política de execução.

first
Um iterador de entrada que trata do primeiro elemento no intervalo para somar ou combinar usando binary_op.

first1
Um iterador de entrada que trata do primeiro elemento no intervalo para somar ou combinar usando binary_op1.

last
Um iterador de entrada que trata o último elemento no intervalo para ser somado ou combinado usando binary_op, que está uma posição acima do elemento final incluído no acúmulo iterado.

last1
Um iterador de entrada que trata o último elemento no intervalo para ser somado ou combinado usando binary_op1, que está uma posição acima do elemento final incluído no acúmulo iterado.

result
Um iterador de saída que trata o primeiro elemento em um intervalo de destino onde a série de somas ou os resultados da operação especificada deverão ser armazenados.

init
Um valor inicial para o qual cada elemento por sua vez é adicionado ou combinado usando binary_op.

binary_op
A operação binária deve ser aplicada a cada elemento no intervalo especificado e o resultado de suas aplicações anteriores.

unary_op
A operação unária a ser aplicada a cada elemento no intervalo especificado.

Valor retornado

O resultado é transformado e, em seguida, reduzido.

Partilhar via

Funções <numeric>

accumulate

Parâmetros

Valor retornado

Comentários

Exemplo

adjacent_difference

Parâmetros

Valor retornado

Comentários

Exemplo

exclusive_scan

Parâmetros

Valor retornado

gcd

Parâmetros

Valor retornado

inclusive_scan

Parâmetros

Valor retornado

inner_product

Parâmetros

Valor retornado

Comentários

Exemplo

iota

Parâmetros

Exemplo

lcm

partial_sum

Parâmetros

Valor retornado

Comentários

Exemplo

reduce

Parâmetros

Valor retornado

Comentários

transform_exclusive_scan

Parâmetros

transform_inclusive_scan

Parâmetros

transform_reduce

Parâmetros

Valor retornado

Comentários

Recursos adicionais

Funções `<numeric>`