Soma ponderada dos últimos N números

Suponha que estamos recebendo números em um fluxo. Depois que cada número é recebido, uma soma ponderada dos últimos $N$ números precisa ser calculada, onde os pesos são sempre os mesmos, mas arbitrários.

Com que eficiência isso pode ser feito se tivermos permissão para manter uma estrutura de dados para ajudar no cálculo? Podemos fazer algo melhor que $\Theta(N)$ , ou seja, recalcular a soma cada vez que um número é recebido?

Por exemplo: Suponhamos que os pesos são $W= \langle w_1, w_2, w_3, w_4\rangle$ . Em um ponto que tem a lista dos últimos $N$ números $L_1= \langle a, b, c, d \rangle>$ , e a soma ponderada $S_1=w_1*a+w_2*b+w_3*c+w_4*d$ .

Quando um outro número, $e$ , é recebida, que actualizar a lista para obter $L_2= \langle b,c,d,e\rangle$ e é preciso calcular $S_2=w_1*b+w_2*c+w_3*d+w_4*e$ .

Consideração sobre o uso da FFT Um caso especial desse problema parece ser solucionável com eficiência, empregando a Transformada rápida de Fourier. Aqui, nós calcular as somas ponderadas em múltiplos de N . Em outras palavras, nós recebemos N números e só então podemos calcular as N somas ponderadas correspondentes . Para fazer isso, precisamos de números anteriores N - 1 (para os quais as somas já foram computadas) e N novos números, no total de 2 números N - 1 .$S$$N$$N$$N$$N-1$$N$$2N-1$

Se esse vetor de números de entrada e o vetor de peso definem os coeficientes dos polinômios P ( x ) e Q ( x ) , com os coeficientes em Q invertidos, vemos que o produto P ( x ) × Q ( x ) é um polinômio cujos coeficientes na frente de x N - 1 até x 2 N - 2 são exatamente as somas ponderadas que buscamos. Estes podem ser calculados usando FFT em Θ ( N ∗ $W$$P(x)$$Q(x)$$Q$$P(x)\times Q(x)$$x^{N-1}$$x^{2N-2}$ , que nos dá uma média de Θ ( log ( N ) ) por número de entrada.$\Theta(N*\log (N))$$Θ(\log (N))$

No entanto, essa não é uma solução para o problema, conforme declarado, porque é necessário que a soma ponderada seja computada com eficiência cada vez que um novo número for recebido - não podemos atrasar o cálculo.

Aqui está uma elaboração da sua abordagem. A cada iteração, usamos o algoritmo FFT para calcular m valores da convolução no tempo O ( n log n ) , assumindo que os valores m subsequentes sejam zero. Em outras palavras, estamos computando n - 1 ∑ i = 0 w i a t - i + k$m$$m$$O(n\log n)$$m$ onde w i são os n pesos (ou os pesos reversos), a i é a sequência de entrada, t é o tempo atual e a t '

$$\sum_{i=0}^{n-1} w_i a_{t-i+k}, \quad 0 \leq k \leq m-1,$$ $w_i$$n$$a_i$$t$ para t " > t .$a_{t'} = 0$$t' > t$

Para cada um dos seguintes iterações, que são capazes de calcular a convolução necessário em tempo O ( m ) (o i th iteração precisa de tempo S ( i ) ). Portanto, o tempo amortizado é O ( m ) + O ( n log n / m ) . Isso é minimizado escolhendo m = $m$$O(m)$$i$$O(i)$$O(m) + O(n\log n/m)$ , que fornece um tempo de execução amortizado deO($m = \sqrt{n\log n}$.$O(\sqrt{n\log n})$

Podemos melhorar isso para o pior caso de tempo de execução de dividindo o cálculo em partes. Fixm, e definir b T , P , o = m - 1 Σ i = 0 W p m + i uma T m - i + o$O(\sqrt{n\log n})$$m$ Cada C T , p depende apenas de 2 m de entradas, portanto pode ser calculada no tempo O ( m log m ) . Além disso, dado C ⌊ t / m ⌋ - p , p para 0 ≤ p ≤

$$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}$$2m$$O(m\log m)$$C_{\lfloor t/m \rfloor-p,p}$ , podemos calcular a convolução no tempo O ( n / m + m ) . Portanto, o plano é manter a lista C ⌊ t / m ⌋ - p , p$0 \leq p \leq n/m-1$$O(n/m + m)$ Para cada período de m entradas, precisamos atualizar n / m delas. Cada atualização leva tempo O ( m log m ) ; portanto, se espalharmos essas atualizações uniformemente, cada entrada ocupará o trabalho O ( ( n / m 2 ) m log m ) = O ( ( n / m ) log m $$C_{\lfloor t/m \rfloor-p,p}, \quad 0 \leq p \leq n/m-1.$$ $m$$n/m$$O(m\log m)$$O((n/m^2) m\log m) = O((n/m) \log m)$ . Juntamente com o cálculo da própria convolução, a complexidade do tempo por entrada é $O((n/m)\log m + m)$$m = \sqrt{n\log n}$$O(\sqrt{n\log n})$