recursivo promediador los lineal iir ideales fir filtros filtro fase digitales definicion causales aplicaciones r filter time-series

promediador - filtros fir e iir



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

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

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


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


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


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