Poszukuję prostych (tj. Bez notacji matematycznych, długo odtwarzalnego kodu) przykładów funkcji filter
w R Myślę, że mam głowę wokół metody splotu, ale utknąłem na uogólnieniu opcji rekursywnej. Czytałem i walczyłem z różnymi dokumentami, ale pomoc jest dla mnie trochę nieprzejrzysta.proste przykłady funkcji filtrowania, opcja rekursywna konkretnie
Oto przykłady I zorientowali się tak daleko:
# Set some values for filter components
f1 <- 1; f2 <- 1; f3 <- 1;
I idziemy na:
# 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
teraz to kiedy ja rani moją biedną pnia mózgu. udało mi się zorientować się w najbardziej podstawowy przykład korzystając z informacji w tym poście: 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]
Może ktoś dostarczyć kod podobny do tego, co mam powyżej przykładów splotu dla rekurencyjnej wersji z filter = c(f1,f2)
i filter = c(f1,f2,f3)
?
Odpowiedzi powinny pasujących wyników z funkcji:
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
EDIT
Aby sfinalizować za pomocą odpowiedź schludny @ agstudy za:
> 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
i ...
> 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
an d ...
> 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
Pomyśl o 'filter' jako wzmocnienie za pośrednictwem oryginalnego wektora, stosując wagi i zsumowanie na każdym kroku. Filtr rekursywny jest podobny do filtra splotu, z tym wyjątkiem, że wagi f1, ..., fn automatycznie stają się c (1, f1, ..., fn), a przy każdym kroku 1 jest stosowany do bieżącej wartości, podczas gdy f1, ..., fn są stosowane do ostatnich n wartości z nowo tworzonego wektora korygującego zamiast oryginalnych wartości. W przypadku splotu (z domyślnymi bokami = 2) ciężary przechodzą do bieżącej wartości, z następnymi n/2 oryginalnymi wartościami po jednej stronie i poprzednimi n/2 oryginalnymi wartościami z drugiej strony. –