fonctions<numeric>
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_opa1, 3 binary_opa2, 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.
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.
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.
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.
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 :
initbinary_op1 (a1 binary_op2b1) binary_op1 (a2 binary_op2b2) binary_op1 ... binary_op1 (unn binary_op2 bn)
en remplaçant de manière itérative l’init par binary_op1 init(ai binary_op2bi).
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.
value
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;
}
Lcm
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_opa2) binary_opa3) 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.
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.
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’initet 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.
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.
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.
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.
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.
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.
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.
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour