Calcular las devoluciones durante el período de tiempo

Question

Estoy tratando de obtener una serie de rendimientos de tiempo para mantener un determinado activo durante un tiempo específico.

Mi trama de datos se parece a esto:

Date   Price 
1998-01-01  20 
1998-01-02  22 
1998-01-03  21 
1998-01-04  25 
... 
1998-01-20  25 
1998-01-21  19 
1998-01-21  20 
.... 
1998-02-01  30 
1998-02-02  28 
1998-02-03  25 
1998-02-04  26 
etc. 

tengo 1 de observación para cada día y mi series de tiempo va desde 1998-1999.

Lo que me gustaría hacer ahora es calcular una ganancia por mantener mi activo por 20 días (es decir, comprándolo el primer día y vendiéndolo el día 20), y hago esto para cada día. Así que me gustaría para calcular esto:

1.day: Retorno (20 días) = ​​log (Precio (t = 20)/Precio (t = 0)),

2.day: Retorno (20 días) = log (Precio (t = 21)/Precio (t = 1)),

3.day: Retorno (20 días) = ​​log (Precio (t = 22)/Precio (t = 2))

etc., es decir, haz esto todos los días en mi muestra.

lo tanto, mi trama de datos resultante sería el siguiente aspecto:

Date   Return 
1998-01-01  0.2 
1998-01-02  0.4 
1998-01-03  0.6 
1998-01-04  0.1 
... 
1998-01-20  0.1 
1998-01-21  0.2 
1998-01-21  0.5 
.... 
1998-02-01  0.1 
1998-02-02  0.2 
1998-02-03  0.5 
1998-02-04  0.01 
etc. 

¿Hay alguna forma en I decir: tomar las primeras 20 observaciones, calcular el retorno. Tome la observación 2-21, calcule el retorno. Tome la observación 3-22, calcule el retorno, etc.

Estoy totalmente estancado y agradecería algo de ayuda. ¡Gracias! Dani

Answer 1

Sugiero cambiar a una clase de series de tiempo, como xts o zoo. Pero si solo desea hacerlo, y obtener más información más adelante, puede hacerlo con bastante facilidad como un marco de datos.Tenga en cuenta que tengo que rellenar los vectores de retorno con NA s de hacer que se alineen correctamente y que un hold de 20 realmente compro el 1 y vende el 1 + 20:

> library(xts) 
> set.seed(2001) 
> n <- 50 
> hold <- 20 
> price <- rep(55, n) 
> walk <- rnorm(n) 
> for (i in 2:n) price[i] <- price[i-1] + walk[i] 
> data <- data.frame(date=as.Date("2001-05-25") + seq(n), price=price) 
> data <- transform(data, return=c(diff(log(price), lag=hold), rep(NA, hold))) 

Si está listo para xts o zoo (esto debería funcionar en cualquiera de los dos), entonces sugiero usar rollapply para obtener el futuro (suponiendo que desea la devolución progresiva, lo que hace que sea mucho más fácil formar carteras hoy y ver cómo funciona en el futuro):

> data.xts <- xts(data[, -1], data[, 1]) 
> f <- function(x) log(tail(x, 1)) - log(head(x, 1)) 
> data.xts$returns.xts <- rollapply(data.xts$price, FUN=f, width=hold+1, align="left", na.pad=T) 

Los dos enfoques son los mismos:

> head(data.xts, hold+2) 
     price  return returns.xts 
[1,] 55.00000 0.026746496 0.026746496 
[2,] 54.22219 0.029114744 0.029114744 
[3,] 53.19811 0.047663206 0.047663206 
[4,] 53.50088 0.046470723 0.046470723 
[5,] 53.85202 0.041843116 0.041843116 
[6,] 54.75061 0.018464467 0.018464467 
[7,] 55.52704 -0.001105607 -0.001105607 
[8,] 56.15930 -0.024183803 -0.024183803 
[9,] 56.61779 -0.010757559 -0.010757559 
[10,] 55.51042 0.005494771 0.005494771 
[11,] 55.17217 0.044864991 0.044864991 
[12,] 56.07005 0.025411005 0.025411005 
[13,] 55.47287 0.052408720 0.052408720 
[14,] 56.10754 0.034089602 0.034089602 
[15,] 56.35584 0.075726190 0.075726190 
[16,] 56.40290 0.072824657 0.072824657 
[17,] 56.05761 0.070589032 0.070589032 
[18,] 55.93916 0.069936575 0.069936575 
[19,] 56.50367 0.081570964 0.081570964 
[20,] 56.12105 0.116041931 0.116041931 
[21,] 56.49091 0.095520517 0.095520517 
[22,] 55.82406 0.137245367 0.137245367 

Answer 2

Puede usar la función ROC en el paquete TTR, o simplemente puede crear su propia función.

> library(quantmod) # loads TTR 
> getSymbols("SPY") 
> tail(ROC(Cl(SPY),20)) 
      SPY.Close 
2010-12-09 0.01350383 
2010-12-10 0.02307920 
2010-12-13 0.03563051 
2010-12-14 0.03792853 
2010-12-15 0.04904805 
2010-12-16 0.05432540 
> tail(log(Cl(SPY)/lag(Cl(SPY),20))) 
      SPY.Close 
2010-12-09 0.01350383 
2010-12-10 0.02307920 
2010-12-13 0.03563051 
2010-12-14 0.03792853 
2010-12-15 0.04904805 
2010-12-16 0.05432540 

Answer 3

Puede utilizar índices de desplazamiento restando de un rango. (.... pero recuerde que R no usa 0 como índice válido.) Digamos que sus precios son la segunda columna en un marco de datos llamado prcs2. Las primeras tres devoluciones con un intervalo de 19 días con sus datos serían:

prcs2[ (20:22)-19, 2] <-c(20,22,21) 
prcs2[ (20:22), 2] <-c(25,19,20) 
log(prcs2[20:22, 2]/prcs2[ (20:22)-19, 2]) 
#[1] 0.22314355 -0.14660347 -0.04879016 

Answer 4

la siguiente función debe hacerlo:

getReturn <- function(data, n=20) { 

    #Assumes 'data' is a two-column data frame with date in the first column, price in the second 

    num.rows <- nrow(data) 

    output.range <- 1:(num.rows-20) 

    buy.price <- data[output.range,2] 
    sell.price <- data[output.range+20,2] 

    returns <- data.frame(log(sell.price) - log(buy.price)) 
    returns <- cbind(data[output.range,],returns) 
    names(returns) <- c("Date","Price","Return") 

    return(returns) 

} 

de entrada de la muestra y de salida:

> head(data) 
     Date Price 
1 2001-01-01 20 
2 2001-01-02 19 
3 2001-01-03 19 
4 2001-01-04 18 
5 2001-01-05 18 
6 2001-01-06 18 
> return<-getReturn(data) 
> head(return) 
     Date Price  Return 
1 2001-01-01 20 0.09531018 
2 2001-01-02 19 0.14660347 
3 2001-01-03 19 0.14660347 
4 2001-01-04 18 0.20067070 
5 2001-01-05 18 0.24512246 
6 2001-01-06 18 0.20067070 

Answer 5

Alternativamente, si está utilizando el XTS paquete, entonces la vida se hace increíblemente s implementar Este es un copiar y pegar directamente de una función que escribí yo hace un tiempo:

ret<-function(x,k=1){ 
    return(diff(log(x),k)) 
} 

Answer 6

datos de la muestra

price <- matrix(c(20,22,21,25,25,19,20,30,28,25,26,27,30,32,31,30),ncol= 1); 

Calcular 1 día Iniciar retorno

OneDayLogReturn <- c(diff(log(price))); 

Calcular 10 días de registro de retorno

TenDaysLogReturn <- c(diff(log(price),10)) 

resultados:

0.2623643 0.2047944 0.3566749 0.2468601 0.2151114 0.4567584 

verifican por:

for (i in 1:6) {print(log(price[10+i]/price[i]))} 

Del mismo modo, 20 días de retorno pueden calcularse utilizando más grande fecha de la muestra y el uso

c(diff(log(price),20)) 

o en su caso

c(diff(log(price$Return),20))