Was ist die umgekehrte Funktion, um einen R-Vektor/Datenrahmen zu verzögern?

Question

Ich habe ein Problem mit Zeitreihen in R. Umgang

#--------------read data 

wb = loadWorkbook("Countries_Europe_Prices.xlsx") 
df = readWorksheet(wb, sheet="Sheet2") 

x <- df$Year 
y <- df$Index1 

y <- lag(y, 1, na.pad = TRUE) 
cbind(x, y) 

Es gibt mir die folgende Ausgabe:

 x  y 
[1,] 1974 NA 
[2,] 1975 50.8 
[3,] 1976 51.9 
[4,] 1977 54.8 
[5,] 1978 58.8 
[6,] 1979 64.0 
[7,] 1980 68.8 
[8,] 1981 73.6 
[9,] 1982 74.3 
[10,] 1983 74.5 
[11,] 1984 72.9 
[12,] 1985 72.1 
[13,] 1986 72.3 
[14,] 1987 71.7 
[15,] 1988 72.9 
[16,] 1989 75.3 
[17,] 1990 81.2 
[18,] 1991 84.3 
[19,] 1992 87.2 
[20,] 1993 90.1 

Aber ich will der erste Wert in y 50,8 und so weiter zu sein. Mit anderen Worten, ich möchte eine negative Verzögerung bekommen. Ich verstehe es nicht, wie kann ich es tun?

Mein Problem ist diesem Problem sehr ähnlich, aber ich kann es nicht lösen. Ich glaube, ich verstehe immer noch nicht die Lösung (en) ...

Basic lag in R vector/dataframe

Answer 1

Wie sieht es mit der integrierten "Lead" -Funktion aus? (aus dem dplyr-Paket) Erfüllt es nicht genau die Aufgabe von Ahmed?

cbind(x, lead(y, 1)) 

Wenn Sie wollen, entweder berechnen können positive oder negative Lags in der gleichen Funktion, schlage ich eine ‚kürzere‘ Version seiner ‚Shift‘ Funktion:

shift = function(x, lag) { 
    require(dplyr) 
    switch(sign(lag)/2+1.5, lead(x, abs(lag)), lag(x, abs(lag))) 
} 

Was sie tut, ist Erstellen von 2 Fällen, einer mit Verzögerung der anderen mit Blei, und wählt einen Fall abhängig von dem Vorzeichen Ihrer Verzögerung (die +1,5 ist hier, um eine {-1, +1} in eine {1, 2} Alternative zu transformieren).

Answer 2

Es ist ein einfacher Weg, dies zu tun, die ich voll und ganz von this link erfasst haben. Was ich hier tun zu erklären, was Sie tun sollten, in den Schritten:

Erstellen Sie zunächst die folgende Funktion durch den folgenden Code ausführen:

shift<-function(x,shift_by){ 
    stopifnot(is.numeric(shift_by)) 
    stopifnot(is.numeric(x)) 

    if (length(shift_by)>1) 
     return(sapply(shift_by,shift, x=x)) 

    out<-NULL 
    abs_shift_by=abs(shift_by) 
    if (shift_by > 0) 
     out<-c(tail(x,-abs_shift_by),rep(NA,abs_shift_by)) 
    else if (shift_by < 0) 
     out<-c(rep(NA,abs_shift_by), head(x,-abs_shift_by)) 
    else 
     out<-x 
    out 
} 

Dies wird eine Funktion mit zwei Argumenten aufgerufen erstellen shift; Einer ist der Vektor, den Sie benötigen, um seine Verzögerung/Ableitung zu steuern, und der andere ist die Anzahl der Verzögerungen/Ableitungen, die Sie benötigen.

Beispiel:

Angenommen, Sie den folgenden Vektor haben:

x<-seq(1:10) 

x 
[1] 1 2 3 4 5 6 7 8 9 10 

wenn Sie x benötigen s erster Ordnung führen s Verzögerung erster Ordnung

shift(x,-1) 
[1] NA 1 2 3 4 5 6 7 8 9 

wenn Sie x benötigen '(negative Verzögerung)

shift(x,1) 
[1] 2 3 4 5 6 7 8 9 10 NA