Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Réductions et statistiques

Une réduction combine une plage en un seul résultat. Découvrez les différences entre std::accumulate, std::reduce et std::transform_reduce, et calculez une moyenne et une variance en tenant compte du type de l’accumulateur et de l’ordre des opérations.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

#include <numeric>
std::accumulate(first, last, init)
std::accumulate(first, last, init, binary_op)
std::reduce(first, last, init)
std::transform_reduce(first, last, init, binary_op, unary_op)

Une réduction combine les éléments de [first, last) en un seul résultat, par exemple une somme. Les algorithmes de <numeric> fournissent des outils de base pour les calculs statistiques. std::accumulate commence par init et traite les éléments dans l’ordre, du début à la fin. Le type de init détermine le type de l’accumulateur : 0 signifie int, tandis que 0.0 signifie double. Un type inadapté peut faire perdre la partie fractionnaire lors de la mise à jour de l’accumulateur.

std::reduce peut modifier l’ordre et le regroupement des opérations, même sans politique d’exécution. Il ne remplace donc pas std::accumulate lorsque l’ordre compte. Pour obtenir un résultat indépendant de l’ordre, l’opération devrait être associative et commutative ; l’addition en virgule flottante n’est pas associative. std::transform_reduce transforme les éléments et réduit les résultats sans nécessiter de conteneur intermédiaire distinct ; il autorise lui aussi un changement d’ordre. Sa surcharge à une seule plage ne transforme pas init.

Pour n observations, la moyenne est la somme divisée par n. La variance de population est la somme des carrés des écarts à la moyenne, divisée par n ; la variance d’échantillon avec la correction de Bessel utilise n - 1. Avant la division, il faut respectivement exiger n > 0 ou n > 1. L’exemple effectue deux passages : il calcule d’abord la moyenne, puis les carrés des écarts. Si l’entrée est vide, il se termine sans afficher de résultat.

L’exemple utilise std::accumulate pour préserver l’ordre des calculs ; cela ne garantit pas une arithmétique exacte pour des données flottantes quelconques. Les API présentées conviennent à C++23. Le document lié est un projet de travail évolutif, et non une publication C++23 figée ; l’option du compilateur dans le dépôt ne certifie pas l’environnement de production.

Exemples

#include <array>
#include <iomanip>
#include <iostream>
#include <numeric>

int main() {
    const std::array<double, 4> values{1.0, 2.0, 3.0, 4.0};
    if (values.empty()) {
        return 0;
    }

    const double n = static_cast<double>(values.size());
    const double sum = std::accumulate(values.begin(), values.end(), 0.0);
    const double mean = sum / n;
    const double squared_deviations = std::accumulate(
        values.begin(), values.end(), 0.0,
        [mean](double acc, double x) {
            const double d = x - mean;
            return acc + d * d;
        });
    const double variance = squared_deviations / n;

    std::cout << std::fixed << std::setprecision(2)
              << "sum=" << sum << '\n'
              << "mean=" << mean << '\n'
              << "population_variance=" << variance << '\n';
}

Résultat

sum=10.00
mean=2.50
population_variance=1.25

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources