einfache Beispiele für Filterfunktion, rekursive Option speziell

Question

Ich suche einige einfache (dh - keine mathematische Notation, lang reproduzierbaren Code) Beispiele für die filter Funktion in R Ich denke, ich habe meinen Kopf rund um die Faltungs-Methode, aber Ich bleibe bei der Verallgemeinerung der rekursiven Option. Ich habe verschiedene Dokumente gelesen und gekämpft, aber die Hilfe ist nur ein bisschen undurchsichtig für mich.

Hier sind die Beispiele, die ich bisher herausgefunden:

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

Und wir gehen:

# 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 

Jetzt ist, wenn ich meine armen kleinen Hirnstamm bin zu verletzen. ich es geschafft, das grundlegendste Beispiel, um herauszufinden, in diesem Beitrag mit Informationen: 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] 

Kann jemand einen ähnlichen Code zur Verfügung stellen, was ich mit filter = c(f1,f2) und filter = c(f1,f2,f3) oben für die Faltung Beispiele für die rekursive Version?

> 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 

und ...

> 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 

:

Antworten sollten die Ergebnisse der Funktion entsprechen: mit @ agstudy die saubere Antwort

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

Zum Abschluss

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 

Answer 1

Im rekursiven Fall, ich denke, keine Notwendigkeit, den Ausdruck in Bezug auf Xi zu erweitern. Der Schlüssel mit "rekursiv" ist, den Ausdruck der rechten Hand in Form von vorherigen y auszudrücken.

Ich denke lieber in Bezug auf die Filtergröße.

Filtergröße = 1

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

Filter size = 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 2

Hier ist das Beispiel, das ich gefunden habe, sehr hilfreich bei der Visualisierung, was rekursive Filterung ist wirklich tun:

(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 3

Mit rekursiv, die Reihenfolge Ihrer „Filter“ ist das Additiv Koeffizient für die vorherigen Summen oder Ausgabewerte der Sequenz. Mit filter=c(1,1) sagst du "nimm die i-te Komponente in meiner Sequenz x und addiere dazu das 1-fache des Ergebnisses aus dem vorherigen Schritt und das 1-fache der Ergebnisse aus dem vorherigen Schritt". Hier ein paar Beispiele zu illustrieren

denke ich, die verzögerte Wirkung Notation wie folgt aussieht:

## 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 

Sehen Sie das kumulative Muster da? Anders ausgedrückt.

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 4

verbrachte ich 1 Stunde dies zu lesen, ist unten meine Zusammenfassung, im Vergleich mit Matlab

NOTATION : Befehl in Matlab = Befehl in 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") 

Wenn Sie einige von DSP kennen, dann für IIR rekursiv ist, Faltung ist für FIR