C++ Academy · Lezione

Algoritmi numerici: accumulate, reduce, transform_reduce

Aggreghi intervalli numerici con accumulate, reduce e transform_reduce, adatto all'elaborazione parallela

Algoritmi numerici: accumulate, reduce, transform_reduce è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

L'header <numeric>

Gli algoritmi numerici operano su range di numeri. Si trovano in <numeric>.

std::accumulate

La classica riduzione. Per impostazione predefinita calcola una somma; passi un'operazione binaria personalizzata per altre riduzioni.

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

Riduzione personalizzata

Fornisca un valore iniziale e un'operazione binaria.

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

Il tipo del valore iniziale è importante

Il tipo dell'accumulatore viene dedotto dal valore iniziale. Fornisca un 0.0 per accumulare valori double in 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)

Come accumulate, ma l'operazione deve essere associativa e commutativa, consentendo la valutazione parallela.

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

reduce e accumulate a confronto

Due differenze:

reduce può essere eseguito in parallelo
reduce non garantisce l'ordine delle operazioni: va bene per + e *, ma non funziona per operazioni non associative come la concatenazione di stringhe

std::transform_reduce (C++17)

Combina una trasformazione e una riduzione in un unico passaggio. È più veloce ed espressivo rispetto a un transform seguito da un 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 = 32

std::inner_product

Il predecessore di transform_reduce. Calcola il prodotto interno (prodotto scalare) di due range. È meno generale, ma offre un'API più semplice.

std::partial_sum

Scrive i totali progressivi in un range di output.

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'opposto di partial_sum: scrive le differenze tra elementi consecutivi.

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}

Attenzione ai numeri in virgola mobile

Per i numeri in virgola mobile, l'ordine di accumulazione è importante a causa degli arrotondamenti. reduce può produrre risultati leggermente diversi da accumulate a causa del suo ordine di valutazione non specificato.

Casi d'uso reali

Gli algoritmi numerici sono alla base di:

calcoli di somme e prodotti
aggregazioni statistiche (media, varianza)
prodotti scalari e norme nell'algebra lineare
somme cumulative per query sui prefissi

Verifica rapida

Quale algoritmo di C++17 riduce in parallelo un range con una singola chiamata di funzione?

Riepilogo

<numeric> fornisce accumulate, reduce, transform_reduce, partial_sum e adjacent_difference per le riduzioni numeriche e le operazioni sui prefissi. Scelga reduce per il parallelismo e accumulate quando serve un ordine deterministico.

Domande Frequenti

La lezione «Algoritmi numerici: accumulate, reduce, transform_reduce» è gratuita?

Sì — il testo completo di «Algoritmi numerici: accumulate, reduce, transform_reduce» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Algoritmi numerici: accumulate, reduce, transform_reduce»?

Aggreghi intervalli numerici con accumulate, reduce e transform_reduce, adatto all'elaborazione parallela Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Algoritmi numerici: accumulate, reduce, transform_reduce»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Algoritmi non modificanti: find, count, all_of
Algoritmi modificanti: transform, copy_if, replace
Ordinamento e partizionamento: sort, stable_partition
Algoritmi numerici: accumulate, reduce, transform_reduce

← Torna a C++ Academy