Bibliothèque standard C++`<numeric>`

Dans le développement C++ quotidien, nous rencontrons souvent les besoins suivants :

Calculer la somme / le produit d'un tableau
Calculer les sommes préfixes pour les requêtes d'intervalle
Accumuler par lots pour générer une nouvelle séquence
Calculer le produit interne (produit scalaire) entre vecteurs

Si vous l'écrivez encore à la mainforBoucle, puis<numeric>Ce sont exactement les outils de la bibliothèque standard que vous devez maîtriser.

Dans la bibliothèque standard C++<numeric>Le fichier d'en-tête fournit un ensemble de modèles de fonctions pour le calcul numérique. Ces fonctions peuvent effectuer diverses opérations numériques sur les éléments d'un conteneur, telles que la somme, le produit, le minimum, le maximum, etc. Ces modèles de fonctions sont extrêmement puissants et peuvent être appliqués à tout type de conteneur, y compris les tableaux, les vecteurs, les listes, etc.

Lors de l'utilisation<numeric>Avant d'utiliser les fonctions du fichier d'en-tête, vous devez inclure ce fichier d'en-tête dans votre programme C++ :

#include <numeric>

Fonctions courantes

<numeric>est la façon dont C++ gèrele calcul de séquences numériquesC'est le fichier d'en-tête principal, axé sur des opérations telles que la réduction, l'accumulation et la différence, et il est compatible avec tous les conteneurs STL ;
Fonctions de base (accumulate/partial_sum/iotaC'est le cœur de C++98/11, répondant à la plupart des besoins conventionnels de calcul numérique ;
nouvellement ajouté dans C++17reduce/inclusive_scanDes fonctions parallèles comme celles-ci peuvent considérablement améliorer l'efficacité de calcul avec de grands volumes de données et doivent être utilisées avec des politiques d'exécution parallèles.

Nom de la fonction	Version C++	Fonctionnalités principales	Prototype de fonction simplifié (en prenant`vector<int>`comme exemple)	cas d'utilisation typiques
`accumulate`	C++98	Calcule la somme cumulée d'une séquence (une opération binaire personnalisée peut être spécifiée)	`int accumulate(iterator beg, iterator end, int init);`	Calculer la somme d'un tableau, accumuler des statistiques
`inner_product`	C++98	Calcule le produit scalaire de deux séquences (multiplier les éléments correspondants puis accumuler ; des opérations personnalisées peuvent être spécifiées)	`int inner_product(iter1 b1, iter1 e1, iter2 b2, int init);`	Produit scalaire de vecteurs, somme pondérée
`partial_sum`	C++98	Calculer les sommes préfixes d'une séquence (le n-ième résultat = somme des n premiers éléments, opération personnalisable)	`void partial_sum(iter b, iter e, iter res);`	Générer un tableau de sommes préfixes, statistiques cumulées
`adjacent_difference`	C++98	Calculer les différences entre éléments adjacents dans une séquence (le n-ième résultat = elem[n] - elem[n-1], opération personnalisable)	`void adjacent_difference(iter b, iter e, iter res);`	Calculer les différences, détecter les changements de séquence
`iota`	C++11	Remplit une séquence avec des valeurs croissantes en continu (en partant de init, en incrémentant de 1 à chaque fois)	`void iota(iter b, iter e, T init);`	Génère une séquence d'entiers consécutifs, initialise des conteneurs ordonnés
`reduce`	C++17	Version parallèle de accumulate (similaire à accumulate, prend en charge l'exécution parallèle, réduction non ordonnée)	`T reduce(iter b, iter e, T init = T{});`	Sommation parallèle pour de grands volumes de données, améliorant l'efficacité de calcul
`transform_reduce`	C++17	Transformation + réduction (d'abord transformer les éléments, puis accumuler, prend en charge l'exécution parallèle)	`T transform_reduce(iter1 b1, iter1 e1, iter2 b2, T init);`	Produit scalaire parallèle, somme après transformation
`inclusive_scan`	C++17	Somme préfixe parallèle (incluant l'élément courant, similaire à partial_sum, prend en charge l'exécution parallèle)	`void inclusive_scan(iter b, iter e, iter res);`	Génération parallèle de tableaux de sommes préfixes
`exclusive_scan`	C++17	Version parallèle de la somme préfixe (excluant l'élément courant ; le n-ième résultat = somme des n-1 premiers éléments)	`void exclusive_scan(iter b, iter e, iter res, T init);`	Génération parallèle de sommes préfixes n'incluant pas l'élément courant

1. `accumulate`

accumulateLa fonction est utilisée pour calculer la somme de tous les éléments d'un conteneur. Elle prend trois paramètres : l'itérateur de début du conteneur, l'itérateur de fin et la valeur initiale.

Syntaxe:

template <InputIterator Iter, class T>
T accumulate(Iter first, Iter last, T init);

Exemple:

Exemple

#include <iostream>
#include <numeric>
#include <vector>

int main() {
std::vector<int> v = {1, 2, 3, 4, 5};
int sum = std::accumulate(v.begin(), v.end(), 0);
std::cout << "Somme : " << sum << std::endl; // Sortie : Sum: 15
return 0;
}

2. `inner_product`

inner_productLa fonction est utilisée pour calculer la somme des produits des éléments correspondants dans deux conteneurs.

Syntaxe:

template <InputIterator1 Iter1, InputIterator2 Iter2, class T>
T inner_product(Iter1 first1, Iter1 last1, Iter2 first2, T init);

Exemple:

Exemple

#include <iostream>
#include <numeric>
#include <vector>

int main() {
std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = {4, 5, 6};
int product_sum = std::inner_product(v1.begin(), v1.end(), v2.begin(), 0);
std::cout << "Product Sum: " << product_sum << std::endl; // Sortie : Product Sum: 32
return 0;
}

3. `partial_sum`

partial_sumLa fonction calcule les sommes partielles des éléments d'un conteneur et stocke les résultats dans un autre conteneur.

Syntaxe:

template <InputIterator InIter, OutputIterator OutIter>
OutIter partial_sum(InIter first, InIter last, OutIter result);

Exemple:

Exemple

#include <iostream>
#include <numeric>
#include <vector>

int main() {
std::vector<int> v = {1, 2, 3, 4};
std::vector<int> result(v.size());
std::partial_sum(v.begin(), v.end(), result.begin());
for (int i : result) {
std::cout << i << " "; // Sortie : 1 3 6 10
}
return 0;
}

4. `adjacent_difference`

adjacent_differenceLa fonction calcule les différences entre les éléments adjacents d'un conteneur et stocke les résultats dans un autre conteneur.

Syntaxe:

template <InputIterator InIter, OutputIterator OutIter>
OutIter adjacent_difference(InIter first, InIter last, OutIter result);

Exemple:

Exemple

#include <iostream>
#include <numeric>
#include <vector>

int main() {
std::vector<int> v = {1, 2, 3, 4};
std::vector<int> result(v.size() - 1);
std::adjacent_difference(v.begin(), v.end(), result.begin());
for (int i : result) {
std::cout << i << " "; // Sortie : 1 1 1
}
return 0;
}

5. std::gcd

Utilisez std::gcd pour calculer le plus grand commun diviseur de deux entiers :

Exemple

#include <iostream>
#include <numeric>

int main() {
int a = 48;
int b = 18;
int result = std::gcd(a, b); // Calculer le plus grand commun diviseur de 48 et 18
std::cout << "PGCD : " << result << std::endl; // Sortie 6
return 0;
}

6. std::lcm

Utilisez std::lcm pour calculer le plus petit commun multiple de deux entiers :

Exemple

#include <iostream>
#include <numeric>

int main() {
int a = 48;
int b = 18;
int result = std::lcm(a, b); // Calculer le plus petit commun multiple de 48 et 18
std::cout << "PPCM : " << result << std::endl; // Sortie 144
return 0;
}

7. std::iota

Exemple

#include <iostream>
#include <numeric> // Inclure le fichier d'en-tête numeric
#include <vector>

int main() {
std::vector<int> v(5); // Créer un vecteur contenant 5 éléments

// Remplir le vecteur avec std::iota, en commençant à 1
std::iota(std::begin(v), std::end(v), 1);

// Afficher le vecteur rempli
for (int i : v) {
std::cout << i << " ";
}
std::cout << std::endl; // Sortie : 1 2 3 4 5

return 0;
}

Utilisez std::iota pour remplir une plage avec des valeurs séquentielles.

template<class ForwardIt, class T>
void iota(ForwardIt first, ForwardIt last, T value);

8. Trouver les valeurs maximale et minimale

min_elementetmax_elementLa fonction est utilisée pour trouver les valeurs maximale et minimale dans un conteneur.

Exemple

#include <iostream>
#include <numeric>
#include <vector>
#include <algorithm> // Pour utiliser std::min_element et std::max_element

int main() {
// Définir un vecteur d'entiers
std::vector<int> v = {3, 1, 4, 1, 5, 9};

// Calculer les valeurs minimale et maximale
int min_val = *std::min_element(v.begin(), v.end());
int max_val = *std::max_element(v.begin(), v.end());

// Calculer la somme
int sum_val = std::accumulate(v.begin(), v.end(), 0);

// Calculer la moyenne
double avg_val = static_cast<double>(sum_val) / v.size();

// Afficher les résultats
std::cout << "Min : " << min_val << std::endl;
std::cout << "Max : " << max_val << std::endl;
std::cout << "Somme : " << sum_val << std::endl;
std::cout << "Moyenne : " << avg_val << std::endl;

return 0;
}

Le résultat de sortie est:

Min: 1
Max: 9
Sum: 23
Average: 3.83333

autres extensions

C++ orienté objet

C++ Tutoriels avancés

C++ Ressources

Bibliothèque standard C++`<numeric>`

Fonctions courantes

1. `accumulate`

Exemple

2. `inner_product`

Exemple

3. `partial_sum`

Exemple

4. `adjacent_difference`

Exemple

5. std::gcd

Exemple

6. std::lcm

Exemple

7. std::iota

Exemple

8. Trouver les valeurs maximale et minimale

Exemple

C++ orienté objet

C++ Tutoriels avancés

C++ Ressources

Bibliothèque standard C++<numeric>

Fonctions courantes

1. accumulate

Exemple

2. inner_product

Exemple

3. partial_sum

Exemple

4. adjacent_difference

Exemple

5. std::gcd

Exemple

6. std::lcm

Exemple

7. std::iota

Exemple

8. Trouver les valeurs maximale et minimale

Exemple

Bibliothèque standard C++`<numeric>`

1. `accumulate`

2. `inner_product`

3. `partial_sum`

4. `adjacent_difference`