Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Reducciones y estadística

Una reducción combina un rango en un único resultado. Aprende en qué se diferencian std::accumulate, std::reduce y std::transform_reduce, y a calcular la media y la varianza teniendo en cuenta el tipo del acumulador y el orden de las operaciones.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

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

Una reducción combina los elementos de [first, last) en un único resultado, como una suma. Los algoritmos de <numeric> proporcionan herramientas básicas para los cálculos estadísticos. std::accumulate empieza con init y procesa los elementos en orden, de principio a fin. El tipo de init determina el tipo del acumulador: 0 significa int, mientras que 0.0 significa double. Un tipo inadecuado puede descartar la parte fraccionaria al actualizar el acumulador.

std::reduce puede cambiar el orden y la agrupación de las operaciones incluso sin una política de ejecución. Por tanto, no sustituye a std::accumulate cuando el orden importa. Para que el resultado no dependa del orden, la operación debería ser asociativa y conmutativa; la suma en coma flotante no es asociativa. std::transform_reduce transforma los elementos y reduce los resultados sin necesitar un contenedor intermedio independiente; también permite reordenarlos. Su sobrecarga para un solo rango no transforma init.

Para n observaciones, la media es la suma dividida por n. La varianza poblacional es la suma de los cuadrados de las desviaciones respecto a la media dividida por n; la varianza muestral con la corrección de Bessel usa n - 1. Antes de dividir, exige respectivamente n > 0 o n > 1. El ejemplo realiza dos recorridos: primero calcula la media y luego los cuadrados de las desviaciones. Si la entrada está vacía, termina sin mostrar ningún resultado.

El ejemplo usa std::accumulate para conservar el orden de los cálculos; esto no garantiza una aritmética exacta para datos de coma flotante arbitrarios. Las API mostradas son adecuadas para C++23. El documento enlazado es un borrador de trabajo en evolución, no una publicación inmutable de C++23; la opción del compilador del repositorio no acredita el entorno de producción.

Ejemplos

#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';
}

Resultado

sum=10.00
mean=2.50
population_variance=1.25

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes