Algoritmos numéricos: accumulate, reduce y transform_reduce
Agregue rangos numéricos con accumulate, reduce y transform_reduce, compatible con el procesamiento paralelo.
Algoritmos numéricos: accumulate, reduce y transform_reduce es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.
La cabecera <numeric>
Los algoritmos numéricos operan sobre rangos de números. Se encuentran en <numeric>.
std::accumulate
La reducción clásica. De forma predeterminada, suma; pase una operación binaria personalizada para realizar otras reducciones.
#include <numeric>
std::vector<int> v = {1, 2, 3, 4, 5};
int sum = std::accumulate(v.begin(), v.end(), 0);
// sum = 15Reducción personalizada
Proporcione un valor inicial y una operación binaria.
int product = std::accumulate(v.begin(), v.end(), 1,
std::multiplies<int>{});
// product = 120El tipo del valor inicial es importante
El tipo del acumulador se deduce a partir del valor inicial. Proporcione un 0.0 para acumular valores de tipo double en 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 6std::reduce (C++17)
Como accumulate, pero la operación debe ser asociativa y conmutativa, lo que permite evaluarla en paralelo.
#include <numeric>
#include <execution>
std::vector<int> v(1000);
int sum = std::reduce(std::execution::par,
v.begin(), v.end(), 0);reduce frente a accumulate
Hay dos diferencias:
reducepuede ejecutarse en paraleloreduceno garantiza el orden de evaluación; esto funciona bien con + y *, pero falla con operaciones no asociativas, como la concatenación de cadenas
std::transform_reduce (C++17)
Combina una transformación y una reducción en una sola pasada. Es más rápido y expresivo que separar transform y reduce.
// 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 = 32std::inner_product
El hermano mayor de transform_reduce. Calcula el producto interno (producto escalar) de dos rangos. Es menos general, pero su API es más sencilla.
std::partial_sum
Escribe los totales acumulados en un rango de salida.
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
Es lo contrario de partial_sum: escribe las diferencias entre elementos consecutivos.
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}Precaución con la coma flotante
Con valores de coma flotante, el orden de acumulación importa debido al redondeo. reduce puede producir resultados ligeramente distintos de accumulate debido a su orden de evaluación no especificado.
Casos de uso reales
Los algoritmos numéricos son fundamentales para:
- Cálculos de sumas y productos
- Agregados estadísticos (media, varianza)
- Productos escalares y normas en álgebra lineal
- Sumas acumuladas para consultas de prefijos
Comprobación rápida
¿Qué algoritmo de C++17 reduce un rango en paralelo con una sola llamada a una función?
Resumen
<numeric> proporciona accumulate, reduce, transform_reduce, partial_sum y adjacent_difference para reducciones numéricas y operaciones de prefijos. Elija reduce para el paralelismo y accumulate para un orden determinista.
Aprende C++ con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 51
- Lecciones
- 203
Preguntas frecuentes
¿La lección «Algoritmos numéricos: accumulate, reduce y transform_reduce» es gratis?
Sí — el texto completo de «Algoritmos numéricos: accumulate, reduce y transform_reduce» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Algoritmos numéricos: accumulate, reduce y transform_reduce»?
Agregue rangos numéricos con accumulate, reduce y transform_reduce, compatible con el procesamiento paralelo. Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C++ Academy?
No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Algoritmos numéricos: accumulate, reduce y transform_reduce»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C++ Academy?
Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Algoritmos no modificadores: find, count y all_of
- Algoritmos modificadores: transform, copy_if y replace
- Ordenación y particionado: sort y stable_partition
- Algoritmos numéricos: accumulate, reduce y transform_reduce