promediador - filtros fir e iir

Ejemplos simples de función de filtro, opción recursiva específicamente.

Question

Estoy buscando algunos ejemplos simples (es decir, sin notación matemática, código reproducible de formato largo) para la función de filter en R Creo que tengo mi cabeza en torno al método de convolución, pero estoy atascado en generalizar la opción recursiva. He leído y luchado con varios documentos, pero la ayuda es un poco opaca para mí.

Aquí están los ejemplos que he descubierto hasta ahora:

# Set some values for filter components
f1 <- 1; f2 <- 1; f3 <- 1;

Y seguimos adelante:

# basic convolution filter
filter(1:5,f1,method="convolution")
[1] 1 2 3 4 5
#equivalent to:
x[1] * f1
x[2] * f1
x[3] * f1
x[4] * f1
x[5] * f1
# convolution with 2 coefficients in filter
filter(1:5,c(f1,f2),method="convolution")
[1] 3 5 7 9 NA
#equivalent to:
x[1] * f2 + x[2] * f1
x[2] * f2 + x[3] * f1
x[3] * f2 + x[4] * f1
x[4] * f2 + x[5] * f1
x[5] * f2 + x[6] * f1
# convolution with 3 coefficients in filter
filter(1:5,c(f1,f2,f3),method="convolution")
[1] NA 6 9 12 NA
#equivalent to:
NA * f3 + x[1] * f2 + x[2] * f1 #x[0] = doesn''t exist/NA
x[1] * f3 + x[2] * f2 + x[3] * f1
x[2] * f3 + x[3] * f2 + x[4] * f1
x[3] * f3 + x[4] * f2 + x[5] * f1
x[4] * f3 + x[5] * f2 + x[6] * f1

Ahora es cuando estoy lastimando mi pobre tallo cerebral. Me las arreglé para descubrir el ejemplo más básico usando la información en esta publicación: https://stackoverflow.com/a/11552765/496803

filter(1:5, f1, method="recursive")
[1] 1 3 6 10 15
#equivalent to:
x[1]
x[2] + f1*x[1]
x[3] + f1*x[2] + f1^2*x[1]
x[4] + f1*x[3] + f1^2*x[2] + f1^3*x[1]
x[5] + f1*x[4] + f1^2*x[3] + f1^3*x[2] + f1^4*x[1]

¿Puede alguien proporcionar un código similar al que tengo arriba para los ejemplos de convolución para la versión recursiva con filter = c(f1,f2) y filter = c(f1,f2,f3) ?

Las respuestas deben coincidir con los resultados de la función:

filter(1:5, c(f1,f2), method="recursive")
[1] 1 3 7 14 26
filter(1:5, c(f1,f2,f3), method="recursive")
[1] 1 3 7 15 30

EDITAR

Para finalizar usando la respuesta ordenada de @agstudy:

> filter(1:5, f1, method="recursive")
Time Series:
Start = 1
End = 5
Frequency = 1
[1] 1 3 6 10 15
> y1 <- x[1]
> y2 <- x[2] + f1*y1
> y3 <- x[3] + f1*y2
> y4 <- x[4] + f1*y3
> y5 <- x[5] + f1*y4
> c(y1,y2,y3,y4,y5)
[1] 1 3 6 10 15

y...

> filter(1:5, c(f1,f2), method="recursive")
Time Series:
Start = 1
End = 5
Frequency = 1
[1] 1 3 7 14 26
> y1 <- x[1]
> y2 <- x[2] + f1*y1
> y3 <- x[3] + f1*y2 + f2*y1
> y4 <- x[4] + f1*y3 + f2*y2
> y5 <- x[5] + f1*y4 + f2*y3
> c(y1,y2,y3,y4,y5)
[1] 1 3 7 14 26

y...

> filter(1:5, c(f1,f2,f3), method="recursive")
Time Series:
Start = 1
End = 5
Frequency = 1
[1] 1 3 7 15 30
> y1 <- x[1]
> y2 <- x[2] + f1*y1
> y3 <- x[3] + f1*y2 + f2*y1
> y4 <- x[4] + f1*y3 + f2*y2 + f3*y1
> y5 <- x[5] + f1*y4 + f2*y3 + f3*y2
> c(y1,y2,y3,y4,y5)
[1] 1 3 7 15 30

Answer 1

Con recursivo, la secuencia de sus "filtros" es el coeficiente aditivo para las sumas anteriores o los valores de salida de la secuencia. Con filter=c(1,1) estás diciendo "toma el componente i-th en mi secuencia x y añádelo 1 vez el resultado del paso anterior y 1 veces el resultado del paso anterior a ese". Aquí hay un par de ejemplos para ilustrar

Creo que la notación de efecto rezagado se ve así:

## only one filter, so autoregressive cumsum only looks "one sequence behind"
> filter(1:5, c(2), method=''recursive'')
Time Series:
Start = 1
End = 5
Frequency = 1
[1] 1 4 11 26 57
1 = 1
2*1 + 2 = 4
2*(2*1 + 2) + 3 = 11
...
## filter with lag in it, looks two sequences back
> filter(1:5, c(0, 2), method=''recursive'')
Time Series:
Start = 1
End = 5
Frequency = 1
[1] 1 2 5 8 15
1= 1
0*1 + 2 = 2
2*1 + 0*(0*1 + 2) + 3 = 5
2*(0*1 + 2) + 0 * (2*1 + 0*(0*1 + 2) + 3) + 4 = 8
2*(2*1 + 0*(0*1 + 2) + 3) + 0*(2*(0*1 + 2) + 0 * (2*1 + 0*(0*1 + 2) + 3) + 4) + 5 = 15

¿Ves el patrón acumulativo allí? Dicho de otra manera.

1 = 1
0*1 + 2 = 2
2*1 + 0*2 + 3 = 5
2*2 + 0*5 + 4 = 8
2*5 + 0*8 + 5 = 15

Answer 2

En el caso recursivo, creo que no es necesario expandir la expresión en términos de xi. La clave con "recursivo" es expresar la expresión de la mano derecha en términos de y anteriores.

Prefiero pensar en términos de tamaño de filtro.

tamaño del filtro = 1

y1 <- x1
y2 <- x2 + f1*y1
y3 <- x3 + f1*y2
y4 <- x4 + f1*y3
y5 <- x5 + f1*y4 

tamaño del filtro = 2

y1 <- x1
y2 <- x2 + f1*y1
y3 <- x3 + f1*y2 + f2*y1 # apply the filter for the past value and add current input
y4 <- x4 + f1*y3 + f2*y2
y5 <- x5 + f1*y4 + f2*y3

Answer 3

Este es el ejemplo que me ha resultado más útil para visualizar lo que realmente está haciendo el filtro recursivo:

(x <- rep(1, 10))
# [1] 1 1 1 1 1 1 1 1 1 1
as.vector(filter(x, c(1), method="recursive")) ## Equivalent to cumsum()
# [1] 1 2 3 4 5 6 7 8 9 10
as.vector(filter(x, c(0,1), method="recursive"))
# [1] 1 1 2 2 3 3 4 4 5 5
as.vector(filter(x, c(0,0,1), method="recursive"))
# [1] 1 1 1 2 2 2 3 3 3 4
as.vector(filter(x, c(0,0,0,1), method="recursive"))
# [1] 1 1 1 1 2 2 2 2 3 3
as.vector(filter(x, c(0,0,0,0,1), method="recursive"))
# [1] 1 1 1 1 1 2 2 2 2 2

Answer 4

Pasé una hora leyendo esto, a continuación se encuentra mi resumen, en comparación con Matlab.

NOTACIÓN : comando en Matlab = comando en R

filter([1,1,1], 1, data) = filter(data, [1,1,1], method = "convolution") ; but the difference is that the first 2 elements are NA
filter(1, [1,-1,-1,-1], data) = filter(data, [1,1,1], method = "recursive")

Si conoce algo de DSP, entonces recursivo es para IIR, convolución es para FIR