Rogers Satchell Volatilidad

Question

Estoy tratando de implementar la volatilidad de Roger Satchell en Go, pero mis resultados no coinciden con la realidad... He estado en esto todo el día, pero no puedo encontrar mi error. La volatilidad Rogers Satchell de 30 días está en 8,75%, pero mi salida es 0,004858435700980119... La fórmula se puede encontrar aquí: https://portfolioslab.com/tools/rogers-satchell

func getRogersSatchell(class OHLC, period_length int) Volatilities {

    var vol Volatilities

    for i := period_length; i < len(class.close); i++ {

        var sum float64

        for j := i; j > (i - period_length); j-- {

            x1 := math.Log(class.high[j] / class.close[j])
            x2 := math.Log(class.high[j] / class.open[j])
            x3 := math.Log(class.low[j] / class.close[j])
            x4 := math.Log(class.low[j] / class.open[j])

            sum += (x1 * x2) + (x3 * x4)

        }

        volatility := math.Sqrt(sum / float64(period_length))

        vol.rogers_satchell = append(vol.rogers_satchell, volatility)

    }

    return vol
}
```

Answer 1

Una respuesta con R y pseudocódigo:

Como señala @markleeds, no hay necesidad de dos bucles for, ya que puedes vectorizar el bucle exterior. Sólo necesitas el último bucle for si quieres hacer estimaciones de volatilidad rolling Roger-Satchell. No puedo codificar en Go pero puedo proporcionarle un pseudocódigo .

Deje que sus datos de OHLC se definan como $X \in \mathbb{R}^{T\times 4}$ donde cada columna es, respectivamente, la apertura, el máximo, el mínimo y el cierre diarios. Es decir, $X$ es una matriz con la dimensión del tiempo, $t=1,\ldots,T$ como las filas y OHLC como las columnas. Construyendo algo de pseudocódigo, su función Golang debería tener una estructura similar a la del fragmento de abajo:

function RSVol(OHLC, n){

  ""Initialise RSVol to store numeric values:""
  RSVol = Vector()

  ""These are now vectors of dimension T x 1:""
  open = OHLC[,1] 
  high = OHLC[,2] 
  low = OHLC[,3] 
  close = OHLC[,4] 

  ""the inner part of the mean:""
  inner = log(high/close) * log(high/open) + log(low/close) * log(low/open)

  ""Doing a rolling mean depending on n:""
  for(i=n:length(open); i++){

    RSVol[i] =  sqrt(mean(inner[i+1-n:i])

  }

  return(RSVol)
}

La implementación del pseudocódigo anterior en R y comparando mi función con el estimador Rogers Satchell en el TTR producen los mismos resultados:

library(TTR)

#first 6 rolling estimates with n=10.

myfunc <- RSVol(OHLC,10)[11:16] 
TTR_RSVol <- volatility(OHLC, n = 10, calc = "rogers.satchell", N = 1, mean0 = FALSE)[11:16]

data.frame(myfunc = myfunc, TTR_func = TTR_RSVol)

Los resultados casi idénticos vistos arriba, dan cierta validez a mi pseudocódigo y R código . He proporcionado mi R función en un apéndice más abajo. Espero que esto ayude a la correcta implementación de su estimador Rogers Satchell en Go . Si no es así, edite su pregunta y proporcione algunos datos de ejemplo o dónde conseguirlos. Entonces podremos hacer una comparación de resultados entre las funciones construidas.

---

Apéndice: Código R

He proporcionado mi código R a continuación para una mejor comprensión.

RSVol <- function(OHLC, n){

  open <- OHLC[,1]
  high <- OHLC[,2]
  low <- OHLC[,3]
  close <- OHLC[,4]

  RSVol <- numeric()

  firstpart <- log(high/close) * log(high/open)
  lastpart <- log(low/close) * log(low/open)

  inner <- firstpart + lastpart

  #calculating rolling mean:

  for(i in n:nrow(OHLC)){

    RSVol[i] <- sqrt(mean(inner[(i+1-n):i]))
  }

 return(RSVol)
}