fonctions`<numeric>`

Article
10/12/2023

accumulate

Calcule la somme de tous les éléments d’une plage spécifiée, y compris une valeur initiale, en calculant des sommes partielles successives. Ou calcule le résultat des résultats partiels successifs d’une opération binaire spécifiée.

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

Paramètres

first
Itérateur d’entrée qui traite le premier élément de la plage pour additionner ou combiner à l’aide de binary_op.

last
Itérateur d’entrée qui traite le dernier élément de la plage pour additionner ou combiner à l’aide de binary_op, il s’agit d’une position au-delà de l’élément final réellement inclus dans l’accumulation itérée.

init
Valeur initiale à laquelle chaque élément est ajouté ou combiné à l’aide de binary_op.

binary_op
Opération binaire à appliquer à chaque élément de la plage spécifiée et au résultat de ses applications précédentes.

Valeur retournée

Somme de l’init et de tous les éléments de la plage spécifiée pour la première fonction de modèle, ou, pour la deuxième fonction de modèle, le résultat de l’application de l’opération binaire binary_op au lieu de l’opération de somme, à (*PartialResult, in_iter), où PartialResult est le résultat des applications précédentes de l’opération et in_iter est un itérateur pointant vers l’élément suivant de la plage.

Notes

La valeur initiale garantit qu’il existe un résultat bien défini lorsque la plage est vide, auquel cas l’init est retourné. L’opération binaire n’a pas besoin d’être associatif ou commutative. Le résultat est initialisé à l’init de la valeur initiale, puis le résultat = binary_op(résultat, in_iter) est calculé de manière itérative à travers la plage, où in_iter est un itérateur pointant vers chaque élément successif de la plage. La plage doit être valide et la complexité est linéaire avec la taille de la plage. Le type de retour de l’opérateur binaire doit être convertible en Type pour assurer la fermeture pendant l’itération.

Exemple

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

Calcule les différences successives entre chaque élément et son prédécesseur dans une plage d’entrée. Génère les résultats dans une plage de destination. Ou calcule le résultat d’une procédure généralisée où l’opération de différence est remplacée par une autre opération binaire spécifiée.

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

Paramètres

exec
Stratégie d’exécution.

first
Itérateur d'entrée qui traite le premier élément d'une plage d'entrée dont les éléments doivent être différenciés de leurs prédécesseurs respectifs, ou bien, dont la paire de valeurs doit être utilisée dans le cadre d'une opération par une opération binaire spécifiée.

last
Itérateur d'entrée qui traite le dernier élément d'une plage d'entrée dont les éléments doivent être différenciés de leurs prédécesseurs respectifs, ou bien, dont la paire de valeurs doit être utilisée dans le cadre d'une opération par une opération binaire spécifiée.

result
Itérateur de sortie qui traite le premier élément d'une plage de destination dans laquelle les différences ou les résultats de l'opération spécifiée doivent être enregistrés.

binary_op
Opération binaire à appliquer dans l’opération généralisée, en remplaçant l’opération de soustraction dans la procédure de différenciation.

Valeur retournée

Itérateur de sortie qui traite la fin de la plage de destination : result + ( - lastfirst).

Notes

Le résultat de l’itérateur de sortie est autorisé à être le même itérateur que l’itérateur d’entrée en premier, afin que les adjacent_difference valeurs puissent être calculées en place.

Pour une séquence de valeurs a1, a2, a3, dans une plage d’entrée, la première fonction de modèle stocke les valeurs successives adjacent_difference a1, a2 - a1, a3 - a2, dans la plage de destination.

Pour une séquence de valeurs a1, a2, a3, dans une plage d’entrée, la deuxième fonction de modèle stocke les valeurs successives adjacent_difference a1, 2 binary_op a1, 3 binary_op a2, dans la plage de destination.

L’opération binaire binary_op n’est pas nécessaire pour être associatif ou commutative, car l’ordre des opérations appliquées est spécifié.

Exemple

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

Calcule une opération de somme de préfixes exclusive à l’aide std::plus<>() d’un opérateur binaire spécifié sur une plage, en fonction d’une valeur initiale. Écrit les résultats dans la plage commençant à la destination spécifiée. Une somme de préfixes exclusive signifie que le nièmeélément d’entrée n’est pas inclus dans la nièmesomme. Surcharges qui incluent un argument de stratégie d’exécution s’exécutent en fonction de la stratégie spécifiée.

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

Paramètres

exec
Stratégie d’exécution.

first
Itérateur d’entrée qui traite le premier élément de la plage pour additionner ou combiner à l’aide de binary_op.

result
Itérateur de sortie qui traite le premier élément d’une plage de destination où la série de sommes ou les résultats de l’opération spécifiée doit être stockée.

init
Valeur initiale à laquelle chaque élément est ajouté ou combiné à l’aide de binary_op.

binary_op
Opération binaire à appliquer à chaque élément de la plage spécifiée et au résultat de ses applications précédentes.

Valeur retournée

Itérateur de sortie ciblant la fin de la plage de destination : résultat + (dernier - premier).

PGCD

Calcule le plus grand diviseur commun des entiers m et n.

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

Paramètres

m, n
Valeurs de type intégral.

Valeur retournée

Retourne le plus grand diviseur commun des valeurs absolues de m et n, ou zéro si les valeurs m et n sont égales à zéro. Les résultats ne sont pas définis si les valeurs absolues de m ou n ne sont pas représentées en tant que valeurs de type common_type_t<M,N>.

inclusive_scan

Calcule une opération de somme de préfixe inclusive à l’aide std::plus<>() d’un opérateur binaire spécifié sur une plage, en fonction d’une valeur initiale. Écrit les résultats dans la plage commençant à la destination spécifiée. Une somme de préfixes inclusive signifie que le nièmeélément d’entrée est inclus dans la nièmesomme. Surcharges qui incluent un argument de stratégie d’exécution s’exécutent en fonction de la stratégie spécifiée.

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

Paramètres

exec
Stratégie d’exécution.

first
Itérateur d’entrée qui traite le premier élément de la plage pour additionner ou combiner à l’aide de binary_op.

result
Itérateur de sortie qui traite le premier élément d’une plage de destination où la série de sommes ou les résultats de l’opération spécifiée doit être stockée.

init
Valeur initiale à laquelle chaque élément est ajouté ou combiné à l’aide de binary_op.

binary_op
Opération binaire à appliquer à chaque élément de la plage spécifiée et au résultat de ses applications précédentes.

Valeur retournée

Itérateur de sortie ciblant la fin de la plage de destination : résultat + (dernier - premier).

inner_product

Calcule la somme du produit d’éléments de deux plages et l’ajoute à une valeur initiale spécifiée, ou calcule le résultat d’une procédure généralisée dans laquelle les opérations binaires de somme et de produit sont remplacées par d’autres opérations binaires spécifiées.

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

Paramètres

first1
Itérateur d’entrée qui traite le premier élément de la première plage dont le produit interne ou le produit interne généralisé avec la deuxième plage est à calculer.

last1
Itérateur d’entrée qui traite le dernier élément de la première plage dont le produit interne ou le produit interne généralisé avec la deuxième plage est à calculer.

first2
Itérateur d’entrée qui traite le premier élément de la deuxième plage dont le produit interne ou le produit interne généralisé avec la première plage est à calculer.

init
Valeur initiale à laquelle ajouter le produit interne ou le produit interne généralisé entre les plages.

binary_op1
Opération binaire qui remplace l’opération de somme du produit interne appliquée aux produits d’éléments dans la généralisation du produit interne.

binary_op2
Opération binaire qui remplace l’opération de multiplication des éléments du produit interne dans la généralisation du produit interne.

Valeur retournée

La première fonction membre retourne la somme des produits d’éléments et y ajoute la valeur initiale spécifiée. Pour les plages de valeurs ai et bi, elle retourne :

init + (a1 * b1) + (a2 * b2) + ... + (a n * bn)

en remplaçant de façon itérative l’init + (ai * bi).

La deuxième fonction membre retourne :

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

en remplaçant itérativement init par binary_op1 init (ai binary_op2 bi).

Notes

La valeur initiale garantit qu’il existe un résultat bien défini lorsque la plage est vide. Dans ce cas, init est retourné. Les opérations binaires n’ont pas besoin d’être associatifs ou commutatives. La plage doit être valide et la complexité est linéaire avec la taille de la plage. Le type de retour de l’opérateur binaire doit être convertible en Type pour assurer la fermeture pendant l’itération.

Exemple

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

Stocke une valeur de départ, en commençant par le premier élément et en remplissant avec des incréments successifs de cette valeur (value++) dans chacun des éléments de l’intervalle [first, last).

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

Paramètres

first
Itérateur d’entrée qui traite le premier élément de la plage à remplir.

last
Itérateur d’entrée qui traite le dernier élément de la plage à remplir.

valeur
Valeur de départ à stocker dans le premier élément et à incrémenter successivement pour les éléments ultérieurs.

Exemple

L’exemple suivant montre certaines utilisations de la fonction iota en remplissant une liste d’entiers (list), puis en remplissant un vecteur (vector) avec les valeurs list pour pouvoir utiliser la fonction 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;
}

PPCM

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

partial_sum

Calcule une série de sommes dans une plage d’entrée entre le premier élément et le nièmeélément et stocke le résultat de chaque somme dans le nièmeélément d’une plage de destination. Ou calcule le résultat d’une procédure généralisée où l’opération de somme est remplacée par une autre opération binaire spécifiée.

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

Paramètres

first
Itérateur d'entrée qui traite le premier élément de la plage qui doit être partiellement additionné ou combiné, selon l'opération binaire spécifiée.

last
Itérateur d'entrée qui traite le dernier élément d'une plage qui doit être partiellement additionné ou combiné selon une opération binaire spécifiée, et dont la position se trouve immédiatement après le dernier élément inclus dans l'accumulation itérée.

result
Itérateur de sortie qui traite le premier élément d’une plage de destination pour stocker la série de sommes partielles, ou les résultats successifs de l’opération binaire spécifiée.

binary_op
Opération binaire à appliquer dans l’opération généralisée, en remplaçant l’opération de somme dans la procédure de somme partielle.

Valeur retournée

Itérateur de sortie ciblant la fin de la plage de destination : résultat + (dernier - premier).

Notes

Le résultat de l’itérateur de sortie est autorisé à être le même itérateur que l’itérateur d’entrée en premier, afin que les sommes partielles puissent être calculées en place.

Pour une séquence de valeurs a1, a2, ... ax, dans une plage d’entrée, la première fonction de modèle stocke des sommes partielles successives dans la plage de destination. Le nièmeélément est donné par (un1 + a2 + a3 + ... + an).

Pour une séquence de valeurs 1, a2, a3, dans une plage d’entrée, la deuxième fonction de modèle stocke les résultats partiels successifs dans la plage de destination. Le nièmeélément est donné par ((... ((a1 binary_op a2) binary_op a3) binary_op ... ) binary_op unn).

L’opération binaire binary_op n’est pas nécessaire pour être associatif ou commutative, car l’ordre des opérations appliquées est spécifié.

Exemple

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

Réduit tous les éléments d’une plage spécifiée, y compris éventuellement une valeur initiale, en calculant les sommes dans un ordre arbitraire et éventuellement permuté. Ou réduit en calculant les résultats d’une opération binaire spécifiée. Surcharges qui incluent un argument de stratégie d’exécution s’exécutent en fonction de la stratégie spécifiée.

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

Paramètres

exec
Stratégie d’exécution.

first
Itérateur d’entrée qui traite le premier élément de la plage pour additionner ou combiner à l’aide de binary_op.

result
Itérateur de sortie qui traite le premier élément d’une plage de destination où la série de sommes ou les résultats de l’opération spécifiée doit être stockée.

init
Valeur initiale à laquelle chaque élément est ajouté ou combiné à l’aide de binary_op.

binary_op
Opération binaire à appliquer à chaque élément de la plage spécifiée et au résultat de ses applications précédentes.

Valeur retournée

Résultat de l’application de binary_op ou std::plus<>() d’init et de tous les éléments de la plage spécifiée à (*PartialResult, in_iter), où PartialResult est le résultat des applications précédentes de l’opération, et in_iter est un itérateur pointant vers un élément de la plage. Dans les surcharges qui ne spécifient pas d’init, la valeur d’init utilisée est équivalente à typename iterator_traits<InputIterator>::value_type{}.

Notes

reduce le comportement n’est pas déterministe, sauf si binary_op est associatif et commutatif. Le comportement n’est pas défini si binary_op modifie un élément ou invalide n’importe quel itérateur dans l’intervalle [premier, dernier], inclus.

transform_exclusive_scan

Transforme les éléments d’une plage avec un opérateur unaire spécifié, puis calcule une opération de somme de préfixes exclusive à l’aide std::plus<>() d’un opérateur binaire ou d’un opérateur binaire spécifié sur la plage, en fonction d’une valeur initiale. Écrit les résultats dans la plage commençant à la destination spécifiée. Une somme de préfixes exclusive signifie que le nièmeélément d’entrée n’est pas inclus dans la nièmesomme. Surcharges qui incluent un argument de stratégie d’exécution s’exécutent en fonction de la stratégie spécifiée. La somme peut être effectuée dans un ordre arbitraire.

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

Paramètres

exec
Stratégie d’exécution.

first
Itérateur d’entrée qui traite le premier élément de la plage pour additionner ou combiner à l’aide de binary_op.

result
Itérateur de sortie qui traite le premier élément d’une plage de destination où la série de sommes ou les résultats de l’opération spécifiée doit être stockée.

init
Valeur initiale à laquelle chaque élément est ajouté ou combiné à l’aide de binary_op.

binary_op
Opération binaire à appliquer à chaque élément de la plage spécifiée et au résultat de ses applications précédentes.

unary_op
Opération unaire à appliquer à chaque élément de la plage spécifiée.

transform_inclusive_scan

Transforme les éléments d’une plage avec un opérateur unaire spécifié, puis calcule une opération de somme de préfixes inclusive à l’aide std::plus<>() d’un opérateur binaire ou d’un opérateur binaire spécifié sur la plage, en fonction d’une valeur initiale. Écrit les résultats dans la plage commençant à la destination spécifiée. Une somme de préfixes inclusive signifie que le nièmeélément d’entrée est inclus dans la nièmesomme. Surcharges qui incluent un argument de stratégie d’exécution s’exécutent en fonction de la stratégie spécifiée. La somme peut être effectuée dans un ordre arbitraire.

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

Paramètres

exec
Stratégie d’exécution.

first
Itérateur d’entrée qui traite le premier élément de la plage pour additionner ou combiner à l’aide de binary_op.

result
Itérateur de sortie qui traite le premier élément d’une plage de destination où la série de sommes ou les résultats de l’opération spécifiée doit être stockée.

binary_op
Opération binaire à appliquer à chaque élément de la plage spécifiée et au résultat de ses applications précédentes.

unary_op
Opération unaire à appliquer à chaque élément de la plage spécifiée.

init
Valeur initiale à laquelle chaque élément est ajouté ou combiné à l’aide de binary_op.

transform_reduce

Transforme une plage d’éléments, puis applique un fonctor qui réduit les éléments transformés dans un ordre arbitraire. Effectivement, suivi transform d’un 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);

Paramètres

exec
Stratégie d’exécution.

first
Itérateur d’entrée qui traite le premier élément de la plage pour additionner ou combiner à l’aide de binary_op.

first1
Itérateur d’entrée qui traite le premier élément de la plage pour additionner ou combiner à l’aide de binary_op1.

last1
Itérateur d’entrée ciblant le dernier élément de la plage pour additionner ou combiner à l’aide de binary_op1, il s’agit d’une position au-delà de l’élément final réellement inclus dans l’accumulation itérée.

result
Itérateur de sortie qui traite le premier élément d’une plage de destination où la série de sommes ou les résultats de l’opération spécifiée doit être stockée.

init
Valeur initiale à laquelle chaque élément est ajouté ou combiné à l’aide de binary_op.

binary_op
Opération binaire à appliquer à chaque élément de la plage spécifiée et au résultat de ses applications précédentes.

unary_op
Opération unaire à appliquer à chaque élément de la plage spécifiée.

Valeur retournée

Résultat transformé puis réduit.

Partager via

fonctions<numeric>

accumulate

Paramètres

Valeur retournée

Notes

Exemple

adjacent_difference

Paramètres

Valeur retournée

Notes

Exemple

exclusive_scan

Paramètres

Valeur retournée

PGCD

Paramètres

Valeur retournée

inclusive_scan

Paramètres

Valeur retournée

inner_product

Paramètres

Valeur retournée

Notes

Exemple

iota

Paramètres

Exemple

PPCM

partial_sum

Paramètres

Valeur retournée

Notes

Exemple

reduce

Paramètres

Valeur retournée

Notes

transform_exclusive_scan

Paramètres

transform_inclusive_scan

Paramètres

transform_reduce

Paramètres

Valeur retournée

Commentaires

Ressources supplémentaires

fonctions`<numeric>`