Somma ponderata degli ultimi N numeri

Supponiamo di ricevere numeri in uno stream. Dopo aver ricevuto ciascun numero, è necessario calcolare una somma ponderata degli ultimi numeri, in cui i pesi sono sempre gli stessi, ma arbitrari. $N$

Quanto efficacemente può essere fatto se ci è permesso mantenere una struttura di dati per aiutare con il calcolo? Possiamo fare di meglio di , ovvero ricalcolare la somma ogni volta che viene ricevuto un numero? $\Theta(N)$

Ad esempio: supponiamo che i pesi siano . A un certo punto abbiamo l'elenco degli ultimi numeri e la somma ponderata . $W= \langle w_1, w_2, w_3, w_4\rangle$ $N$ $L_1= \langle a, b, c, d \rangle>$ $S_1=w_1*a+w_2*b+w_3*c+w_4*d$

Quando viene ricevuto un altro numero, $e$ , aggiorniamo l'elenco per ottenere $L_2= \langle b,c,d,e\rangle$ e dobbiamo calcolare $S_2=w_1*b+w_2*c+w_3*d+w_4*e$ .

Considerazione sull'uso di FFT Un caso speciale di questo problema sembra essere risolvibile in modo efficiente impiegando la trasformata di Fourier veloce. Qui, calcoliamo le somme pesate $S$ in multipli di $N$ . In altre parole, riceviamo $N$ numeri e solo allora possiamo calcolare le corrispondenti $N$ pesate. Per fare ciò, abbiamo bisogno $N-1$ numeri passati (per i quali sono già state calcolate le somme) e $N$ nuovi numeri, in totale numeri $2N-1$ .

Se questo vettore di numeri di input e il vettore di peso $W$ definiscono i coefficienti dei polinomi $P(x)$ e $Q(x)$ , con coefficienti in $Q$ invertiti, vediamo che il prodotto $P(x)\times Q(x)$ è un polinomio i cui coefficienti davanti a $x^{N-1}$ fino a $x^{2N-2}$ sono esattamente le somme ponderate che cerchiamo. Questi possono essere calcolati usando FFT in $\Theta(N*\log (N))$ tempo, che ci dà una media di $Θ(\log (N))$ tempo per numero di input.

Questa non è tuttavia una soluzione al problema come indicato, poiché è necessario che la somma ponderata sia calcolata in modo efficiente ogni volta che viene ricevuto un nuovo numero - non possiamo ritardare il calcolo.

algorithms data-structures online-algorithms

— Ambroz Bizjak
fonte

Nota che puoi usare LaTeX qui.

— Raffaello

Gli input provengono da una distribuzione nota? Hanno qualche utile proprietà matematica? In caso contrario, è improbabile che ciò sia possibile (a meno che qualcuno non sia in grado di trovare una forma chiusa ordinata che sia calcolabile in modo sublineare - certamente non riesco a trovarne una). Inoltre, le approssimazioni sono OK? Potrebbe essere una strada da percorrere se ti è utile.

— RDN

I filtri FIR lo fanno, quindi il loro design sarà rilevante.

— adrianN,

@RDN Ho posto questa domanda come una curiosità, non ho in mente un'applicazione pratica.

— Ambroz Bizjak,

Ecco un'elaborazione del tuo approccio. Ogni iterazioni, usiamo l'algoritmo FFT per calcolare i valori della convoluzione nel tempo , supponendo che i valori successivi siano zero. In altre parole, stiamo calcolando dove sono i pesi (o i pesi inversi), è la sequenza di input, è l'ora corrente e per . $m$ $m$ $O(n\log n)$ $m$

Σ_{io = 0}^{n - 1} w_{io} {un'}_{t - io + K}, 0 \leq K \leq m - 1,

$\sum_{i=0}^{n-1} w_i a_{t-i+k}, \quad 0 \leq k \leq m-1,$

w_{i}

$w_i$

n

$n$

a_{i}

$a_i$

t

$t$

a_{t^{'}} = 0

$a_{t'} = 0$

t^{'} > t

$t' > t$

Per ciascuna delle seguenti iterazioni, siamo in grado di calcolare la convoluzione richiesto nel tempo (la esima iterazione richiede tempo ). Quindi il tempo ammortizzato è . Questo è ridotto al minimo scegliendo , che fornisce un tempo di esecuzione ammortizzato di . $m$ $O(m)$ $i$ $O(i)$ $O(m) + O(n\log n/m)$ $m = \sqrt{n\log n}$ $O(\sqrt{n\log n})$

Possiamo migliorare il tempo di esecuzione nel caso peggiore di suddividendo il calcolo in parti. Correggi e definisci Ogni dipende solo da input, quindi può essere calcolato nel tempo . Inoltre, dato per , possiamo calcolare la convoluzione nel tempo . Il piano quindi è di mantenere l'elenco Per ogni periodo di $O(\sqrt{n\log n})$ $m$

b_{T, p, o} = \sum_{i = 0}^{m - 1} w_{p m + i} a_{T m - i + o}, C_{T, p} = b_{T, p, 0}, \dots, b_{T, p, m - 1} .

$b_{T,p,o} = \sum_{i=0}^{m-1} w_{pm+i} a_{Tm-i+o}, \quad C_{T,p} = b_{T,p,0}, \ldots, b_{T,p,m-1}.$

C_{T, p}

$C_{T,p}$

2 m

$2m$

O (m \log m)

$O(m\log m)$

C_{⌊ t / m ⌋ - p, p}

$C_{\lfloor t/m \rfloor-p,p}$

0 \leq p \leq n / m - 1

$0 \leq p \leq n/m-1$

O (n / m + m)

$O(n/m + m)$

C_{⌊ t / m ⌋ - p, p}, 0 \leq p \leq n / m - 1.

$C_{\lfloor t/m \rfloor-p,p}, \quad 0 \leq p \leq n/m-1.$

m

$m$ input, dobbiamo aggiornare di questi. Ogni aggiornamento richiede tempo , quindi se distribuiamo questi aggiornamenti in modo uniforme, ogni input occuperà il lavoro . Insieme al calcolo della convoluzione stessa, la complessità temporale per input è . Scegliendo come prima, questo dà .

n / m

$n/m$

O (m \log m)

$O(m\log m)$

O ((n / m^{2}) m \log m) = O ((n / m) \log m)

$O((n/m^2) m\log m) = O((n/m) \log m)$

O ((n / m) \log m + m)

$O((n/m)\log m + m)$

m = \sqrt{n \log n}

$m = \sqrt{n\log n}$

O (\sqrt{n \log n})

$O(\sqrt{n\log n})$

— Yuval Filmus
fonte

Soluzione meravigliosa, grazie, non ero davvero sicuro che potesse essere fatto.

— Ambroz Bizjak,

E funziona! Implementazione C: ideone.com/opuoMj

— Ambroz Bizjak

Meh, mi mancava quell'ultimo bit di codice che in realtà lo fa interrompere il calcolo, risolto qui ideone.com/GRXMAZ .

— Ambroz Bizjak,

Sulla mia macchina questo algoritmo inizia ad essere più veloce del semplice algoritmo a circa 17000 pesi. Per piccoli numeri di pesi è lento. Indice di riferimento: ideone.com/b7erxu

— Ambroz Bizjak

Molto impressionante che tu l'abbia effettivamente implementato! Probabilmente vuoi ottimizzare oltre . La scelta è solo una guida approssimativa e potrebbe non essere ottimale. Hai provato a eseguire l'algoritmo con valori diversi di ?

m

$m$

m = \sqrt{n \log n}

$m = \sqrt{n\log n}$

m

$m$

— Yuval Filmus,