¿Cuáles son los paquetes para backtesting efectivo en R?

Question

Necesito un paquete rápido para backtesting en R. Voy a optimizar mucho, así que estaré ejecutando mis estrategias muchas millones de veces. Conozco paquetes como quantstrat o SIT pero son terriblemente lentos para mis propósitos, tengo una estrategia, no voy a modelar 20 carteras al mismo tiempo y cosas así. ¿Qué paquete puedes recomendar?

ACTUALIZACIÓN=========

Sí, implementé algo muy simple como

signals <- sample(c(-1,0,1),30,replace = T)

-1 abrir venta

1 abrir compra

0 no hacer nada y cerrar cualquier posición

prices <- cumsum(rnorm(30))+100

count_balance <- function(prices,signals){
  p <- c(0,diff(prices))
  s <- c(0,signals[-length(signals)])
  return(   cumsum(p*s)   )
}

count_balance(p = prices,sig = signals)

o equivalente en Rcpp aún más rápido 30 veces

#include 
using namespace Rcpp;

// [[Rcpp::export]]
NumericVector count_balance_cpp(NumericVector prices, NumericVector signals) {
  int n = prices.size();
  NumericVector result(n);
  result[0] = 0;
  for (int i = 1; i < n; ++i) {
    result[i] = result[i-1] + signals[i-1] * (prices[i] - prices[i-1]);
  }
  return result;
}

Pero me gustaría un poco más

1. tomar en cuenta la comisión
2. tener un registro de operaciones para saber la proporción de operaciones rentables y perdedoras

En principio, también puedo implementar esto, pero no estaré completamente seguro de haberlo hecho correctamente, ya que soy un programador muy malo. Ni siquiera estoy seguro de las funciones que publiqué arriba)

Por eso estaba buscando una biblioteca simple, rápida, lista y, lo más importante, comprobada

Answer 1

Para tomar la sugerencia de Mark de escribir su propio código: la computación P/L en bruto a partir de un vector de señales en R puede ser bastante rápida.

P <- c(100, 99, 104, 103, 105, 104)  ## serie de precios
S <- c(  0,  1,   1,   0,   1,   0)  ## posición a mantener
dS <- c(0, diff(S)) ## cambio en la posición ==> operaciones
## [1]  0  1  0 -1  1 -1

valor.portafolio <- S*P - cumsum(dS*P)
## [1] 0 0 5 4 4 3

Pero el backtesting puede significar cosas diferentes para diferentes personas: desde el simple cálculo de P/L, pasando por la computación/informe de estadísticas, hasta la conectividad real con el trading en vivo. Y las estrategias también vienen en muchos sabores. Puede obtener mejores respuestas si proporciona más detalles sobre su estrategia y cómo/intenta optimizarla.

---

Respuesta a la actualización:

Si solo necesita una correspondencia entre las señales y el P/L, será difícil superar una implementación en bruto, en particular escrita en C. No conozco un paquete que ofrezca esto, pero tal vez exista. (También puede plantear esta pregunta en R-SIG-Finance, donde al menos en el pasado los mantenedores de los paquetes que mencionó han respondido preguntas.)

Dicho esto, tendrá que decidir cuánta velocidad necesita. Los costos de transacción son fáciles de agregar al fragmento anterior:

## con tarifas proporcionales de 10 puntos básicos
dSP <- dS*P
valor.portafolio <- S*P - cumsum(dSP) - cumsum(abs(dSP)*0.001)
## [1]  0.000 -0.099  4.901  3.798  3.693  2.589

En cuanto a un registro de operaciones: lo tiene en el vector dS. Aquí hay un bosquejo de cómo podría manejar las operaciones, utilizando el paquete PMwR (que mantengo).

## operaciones
library("PMwR")
J <- journal(amount = dS, price = P, timestamp = seq_along(P))
J
##    timestamp  amount  price
## 1          1       0    100
## 2          2       1     99
## 3          3       0    104
## 4          4      -1    103
## 5          5       1    105
## 6          6      -1    104
## 
## 6 transacciones

pl(J)
## P/L total         3
## compra promedio     102
## venta promedio  103.5
## volumen acumulado       4
## 
## ‘P/L total’ está en unidades del instrumento;
## ‘volumen’ es la suma de cantidades /absolutas/.

pl dará el P/L total. Pero puedes dividir fácilmente las operaciones.

operación <- dS != 0
operaciones <- split_trades(amount = dS[operación],
                       price = P[operación],
                       timestamp = seq_along(P)[operación])
## [[1]]
## [[1]]$cantidad
## [1]  1 -1
## 
## [[1]]$precio
## [1]  99 103
## 
## [[1]]$timestamp
## [1] 2 4
## 
## 
## [[2]]
## [[2]]$cantidad
## [1]  1 -1
## 
## [[2]]$precio
## [1] 105 104
## 
## [[2]]$timestamp
## [1] 5 6

Llame a pl para cada operación.

sapply(operaciones,
       function(x) pl(as.journal(x), solo pl = VERDADERO))
## [1]  4 -1