C++ Academy · Leçon

Algorithmes numériques : accumulate, reduce, transform_reduce

Agréger des plages numériques avec accumulate, reduce et transform_reduce, adapté à l’exécution parallèle

Algorithmes numériques : accumulate, reduce, transform_reduce est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

L’en-tête <numeric>

Les algorithmes numériques opèrent sur des plages de nombres. Ils se trouvent dans <numeric>.

std::accumulate

La réduction classique. Effectue une somme par défaut — transmettez une opération binaire personnalisée pour d’autres réductions.

#include <numeric>
std::vector<int> v = {1, 2, 3, 4, 5};
int sum = std::accumulate(v.begin(), v.end(), 0);
// sum = 15

Réduction personnalisée

Fournissez une valeur initiale et une opération binaire.

int product = std::accumulate(v.begin(), v.end(), 1,
    std::multiplies<int>{});
// product = 120

Le type de la valeur initiale compte

Le type de l’accumulateur est déduit de la valeur initiale. Fournissez un 0.0 pour accumuler des valeurs de type double dans un double.

std::vector<double> v = {1.5, 2.5, 3.5};
double sum_d = std::accumulate(v.begin(), v.end(), 0.0);    // 7.5
int    sum_i = std::accumulate(v.begin(), v.end(), 0);      // truncates to 6

std::reduce (C++17)

Comme accumulate, mais l’opération doit être associative et commutative — ce qui permet une évaluation parallèle.

#include <numeric>
#include <execution>
std::vector<int> v(1000);
int sum = std::reduce(std::execution::par,
    v.begin(), v.end(), 0);

reduce ou accumulate

Deux différences :

reduce peut s’exécuter en parallèle
reduce ne garantit pas l’ordre d’exécution — convient pour + et *, mais ne convient pas aux opérations non associatives telles que la concaténation de chaînes

std::transform_reduce (C++17)

Combine une transformation et une réduction en un seul parcours. Plus rapide et plus expressif qu’une transformation suivie d’une réduction.

// Dot product
std::vector<int> a = {1, 2, 3}, b = {4, 5, 6};
int dot = std::transform_reduce(
    a.begin(), a.end(), b.begin(),
    0,
    std::plus<int>{},          // reduce
    std::multiplies<int>{}     // transform
);
// dot = 1*4 + 2*5 + 3*6 = 32

std::inner_product

Le prédécesseur de transform_reduce. Calcule le produit scalaire de deux plages. Moins général, mais doté d’une interface plus simple.

std::partial_sum

Écrit les totaux cumulés dans une plage de sortie.

std::vector<int> v = {1, 2, 3, 4};
std::vector<int> sums(4);
std::partial_sum(v.begin(), v.end(), sums.begin());
// sums = {1, 3, 6, 10}

std::adjacent_difference

L’opposé de partial_sum — écrit les différences entre éléments consécutifs.

std::vector<int> v = {1, 3, 6, 10};
std::vector<int> diffs(4);
std::adjacent_difference(v.begin(), v.end(), diffs.begin());
// diffs = {1, 2, 3, 4}

Précaution concernant les nombres à virgule flottante

Pour les flottants, l’ordre d’accumulation compte en raison des arrondis. reduce peut produire des résultats légèrement différents de accumulate à cause de son ordre d’évaluation non spécifié.

Cas d’usage réels

Les algorithmes numériques sont à la base de :

Calculs de sommes et de produits
Agrégats statistiques (moyenne, variance)
Produits scalaires et normes en algèbre linéaire
Sommes cumulées pour les requêtes sur les préfixes

Vérification rapide

Quel algorithme de C++17 effectue une réduction parallèle d’une plage avec un seul appel de fonction ?

Récapitulatif

<numeric> fournit accumulate, reduce, transform_reduce, partial_sum et adjacent_difference pour les réductions numériques et les opérations sur les préfixes. Choisissez reduce pour le parallélisme et accumulate pour un ordre déterministe.

Questions Fréquemment Posées

La leçon « Algorithmes numériques : accumulate, reduce, transform_reduce » est-elle gratuite ?

Oui — le texte complet de « Algorithmes numériques : accumulate, reduce, transform_reduce » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Algorithmes numériques : accumulate, reduce, transform_reduce » ?

Agréger des plages numériques avec accumulate, reduce et transform_reduce, adapté à l’exécution parallèle Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Algorithmes numériques : accumulate, reduce, transform_reduce » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Algorithmes non modificateurs : find, count, all_of
Algorithmes modificateurs : transform, copy_if, replace
Tri et partitionnement : sort, stable_partition
Algorithmes numériques : accumulate, reduce, transform_reduce

← Retour à C++ Academy