Somma efficiente e stabile dei numeri ordinati

Ho un elenco abbastanza lungo di numeri positivi in ​​virgola mobile ( std::vector<float>, dimensione ~ 1000). I numeri sono ordinati in ordine decrescente. Se li riassumo seguendo l'ordine:

for (auto v : vec) { sum += v; }

Immagino di poter avere qualche problema di stabilità numerica, poiché vicino alla fine del vettore sumsarà molto più grande di v. La soluzione più semplice sarebbe quella di attraversare il vettore in ordine inverso. La mia domanda è: è efficace così come il caso a termine? Mi mancherà più cache?

C'è qualche altra soluzione intelligente?

Immagino di poter avere qualche problema di stabilità numerica

Quindi prova per questo. Attualmente hai un ipotetico problema, vale a dire nessun problema.

Se esegui il test e l'ipotetico si materializza in un problema reale , allora dovresti preoccuparti di risolverlo effettivamente.

Cioè: la precisione in virgola mobile può causare problemi, ma puoi confermare se lo fa davvero per i tuoi dati, prima di dare la priorità a tutto il resto.

... mi mancherà più cache?

Mille float sono 4Kb - si inseriranno nella cache di un moderno sistema di mercato di massa (se hai in mente un'altra piattaforma, dicci di cosa si tratta).

L'unico rischio è che il prefetcher non ti aiuti durante l'iterazione all'indietro, ma ovviamente il tuo vettore potrebbe essere già nella cache. Non è possibile determinarlo fino a quando non si profila nel contesto dell'intero programma, quindi non c'è motivo di preoccuparsi finché non si ha un programma completo.

C'è qualche altra soluzione intelligente?

Non preoccuparti di cose che potrebbero diventare problemi, fino a quando non diventano effettivamente problemi. Al massimo vale la pena notare possibili problemi e strutturare il codice in modo da poter sostituire la soluzione più semplice possibile con una ottimizzata con cura in seguito, senza riscrivere tutto il resto.

Ho contrassegnato il banco con il tuo caso d'uso e i risultati (vedi immagine allegata) indicano la direzione in cui non fa alcuna differenza in termini di prestazioni per andare avanti o indietro.

Potresti voler misurare anche sul tuo hardware + compilatore.

L'utilizzo di STL per eseguire la somma è veloce come il ciclo manuale sui dati ma molto più espressivo.

utilizzare quanto segue per l'accumulo inverso:

std::accumulate(rbegin(data), rend(data), 0.0f);

mentre per l'accumulo in avanti:

std::accumulate(begin(data), end(data), 0.0f);

La soluzione più semplice sarebbe quella di attraversare il vettore in ordine inverso. La mia domanda è: è efficace così come il caso a termine? Mi mancherà più cache?

Sì, è efficiente. La previsione del ramo e la strategia della cache intelligente dal tuo hardware sono ottimizzate per l'accesso sequenziale. Puoi accumulare in sicurezza il tuo vettore:

#include <numeric>

auto const sum = std::accumulate(crbegin(v), crend(v), 0.f);

A tale scopo puoi utilizzare l'iteratore inverso senza alcuna trasposizione nel tuo std::vector<float> vec:

float sum{0.f};
for (auto rIt = vec.rbegin(); rIt!= vec.rend(); ++rIt)
{
    sum += *rit;
}

Oppure fai lo stesso lavoro usando l'algortitmo standard:

float sum = std::accumulate(vec.crbegin(), vec.crend(), 0.f);

Le prestazioni devono essere le stesse, cambiate solo la direzione di bypass del tuo vettore

Se per stabilità numerica intendi precisione, allora sì, potresti finire con problemi di precisione. A seconda del rapporto tra i valori più grandi e quelli più piccoli e i requisiti di accuratezza nel risultato, questo può o meno essere un problema.

Se vuoi avere un'elevata precisione, considera la somma di Kahan - questo utilizza un galleggiante extra per la compensazione degli errori. C'è anche una somma a coppie .

Per un'analisi dettagliata del compromesso tra precisione e tempo, consultare questo articolo .

AGGIORNAMENTO per C ++ 17:

Alcune delle altre risposte menzionano std::accumulate. A partire dal C ++ 17 esistono delle politiche di esecuzione che consentono di parallelizzare gli algoritmi.

Per esempio

#include <vector>
#include <execution>
#include <iostream>
#include <numeric>

int main()
{  
   std::vector<double> input{0.1, 0.9, 0.2, 0.8, 0.3, 0.7, 0.4, 0.6, 0.5};

   double reduceResult = std::reduce(std::execution::par, std::begin(input), std::end(input));

   std:: cout << "reduceResult " << reduceResult << '\n';
}

Ciò dovrebbe rendere più veloce la somma di set di dati di grandi dimensioni a costo di errori di arrotondamento non deterministici (suppongo che l'utente non sarà in grado di determinare il partizionamento dei thread).