¿Cómo calcular la volatilidad histórica intradía?

Question

Disculpa por lo que debe ser una pregunta de principiante, pero cuando fui a escribir código me di cuenta de que no entendía exactamente cómo se define la volatilidad histórica o volatilidad estadística. Wikipedia me dice que "la volatilidad es la desviación estándar de los rendimientos logarítmicos del instrumento", y el retorno logarítmico se define como $\ln\left(\frac{V_f}{V_i}\right)$, donde $V_f$ es el precio de cierre y $V_i$ es el precio de apertura.

Si quiero calcular la volatilidad de una barra de un minuto, a partir de los ticks en bruto, ¿debo usar solo el primer y último tick en ese minuto? Si uso los primeros y últimos ticks en el minuto (es decir, apertura/cierre de la barra), tendré un único retorno logarítmico, por lo que la desviación estándar de ese valor será 0. En una respuesta a esta pregunta, se describe el gráfico de volatilidad intradía como en forma de U. Exactamente ¿qué sumas debo hacer para generar ese gráfico de volatilidad intradía a partir de los ticks del día?

En términos de R, ¿es el retorno logarítmico:

#x es un objeto xts que contiene ticks
r = na.omit( lag(x)/x )
lnr = log(r)

Antecedentes: Tengo una secuencia de ticks, y mientras los convierto en barras de un minuto (y de periodos más largos) (usando el módulo xts de R) también calculo la media y la desviación estándar. ¿Es la medida financiera estándar de volatilidad diferente de la desviación estándar? Si no lo es, ¿se puede derivar uno de otro?

Si la definición anterior de volatilidad es correcta, mi respuesta (basada en una estimación visual de los gráficos y en la ejecución de cor) parece ser que son realmente bastante diferentes; Todavía estoy reflexionando sobre cómo se relaciona eso con las respuestas aquí.

Answer 1

Utilizo la medida de Yhang Zhang para la volatilidad intradía para series temporales con una ventana de 5 o 10 días. Escribí una implementación en C++ y VBA que estaría encantado de compartir si lo desea. Toma datos olhc y ofrece una 'estimación' de la volatilidad. Para el trading intradía (cobertura gamma), encontré que es un estimador bastante bueno del rango diario. Pero me gustaría advertir sobre si es un predictor de la volatilidad. La correlación de la volatilidad intradía de un día a otro tiende a ser pequeña en mi opinión.

He agregado el código a pedido. Probablemente no sea 100% robusto y probablemente haya algunas condiciones en las que produzca números extraños o simplemente se bloquee. Sin garantías implícitas

/**
    Calcular el yzvol a partir de los datos intradía utilizando un tamaño de ventana dado
    Tenga en cuenta que esta ventana hará que el array final tenga una longitud de (size - ventana)
    por lo que se deben omitir las primeras 'ventana' fechas en el array dt_
    @open - precios de apertura
    @high - precios altos
    @low - precios bajos
    @close - precios de cierre
    @ventana - tamaño de la ventana para hacer una aplicación continua
*/
std::vector calcular_yzvol(
    const std::vector& open,
    const std::vector& high,
    const std::vector& low,
    const std::vector& close,
    const size_t ventana) {
    std::vector yzvol;

    const size_t num_elementos = open.size();
    if (num_elementos - 1 < ventana) {
        BOOST_LOG_TRIVIAL(advertencia) << "El número de precios diarios " << num_elementos << " de la base de datos es menor que el tamaño de la ventana " << ventana;
        return yzvol;
    }

std::vector log_ho(num_elementos);
std::vector log_lo(num_elementos);
std::vector log_co(num_elementos);
std::vector log_oc_sq(num_elementos);
std::vector log_cc_sq(num_elementos - 1);
std::vector rs(num_elementos);

std::transform(open.begin(), open.end(), high.begin(),std::back_inserter>(log_ho),[](auto abrir, auto alto) {
    return ::log(alto / apertura_diaria);
});
for (size_t i = 0; i < num_elementos; i++) {
    const float apertura_diaria = static_cast(1.0 / open[i]);
    log_ho[i] = log(high[i] * apertura_diaria);
    log_lo[i] = log(low[i] * apertura_diaria);
    log_co[i] = log(close[i] * apertura_diaria);
    float oc = log(open[i] / close[i]);
    log_oc_sq[i] = boost::math::pow<2>(oc);
    rs[i] = log_ho[i] * (log_ho[i] - log_co[i]) + log_lo[i] * (log_lo[i] - log_co[i]);
}

for (size_t i = 1; i < num_elementos; i++) {
    const float cc = log(close[i] / close[i - 1]);
    log_cc_sq[i - 1] = boost::math::pow<2>(cc);
}

// Función de suma de volatilidad
auto sumar_vol = [](auto inicio, auto fin, auto ventana) {
    const float factor_ventana = static_cast(1.0 / (ventana - 1.0));
    float suma = 0.0f;
    for (auto i = inicio; i != fin; i++) {
        suma += *i;
    }
    return suma * factor_ventana;
};
typedef std::vector vf;
const vf vol_cierre = rolling_window(log_cc_sq, ventana, sumar_vol);
const vf vol_apertura = rolling_window(log_oc_sq, ventana, sumar_vol);
const vf vol_rs_ventana = rolling_window(rs, ventana, sumar_vol);

// Tenga en cuenta que esta ventana hará que el array final tenga una longitud de (size - ventana)
boost::range::for_each(vol_cierre | boost::adaptors::indexed(0),[&](auto i) {
    const float resultado = ::sqrt(vol_apertura[i.index() + 1] + 0.16433 * vol_cierre[i.index()] + 0.835667 * vol_rs_ventana[i.index() + 1]);
    yzvol.emplace_back(resultado);
});
return yzvol;

}

Answer 2

La equivalencia que estás tratando de encontrar solo puede existir en el marco de la volatilidad estática.

Creo que el problema es que en el mundo real, la volatilidad estadística varía mucho con el tiempo; y lo peor es que la tasa relativa a la que varía aumenta con incrementos de tiempo más pequeños.

Por lo tanto, no solo la respuesta no se aplica en los mercados del mundo real, sino que una estimación de su existencia teórica se vuelve exponencialmente menos precisa con incrementos de tiempo más pequeños.

(Creo que el modelo de Heston apoya esto porque el componente aleatorio de cambio en la varianza del precio de la acción es proporcional a la raíz cuadrada de su propio valor actual, aunque no es inmediatamente obvio que esto siga).