Negociamos con opciones sin opciones (Parte 1): Teoría básica y emulación a través de activos subyacentes

Introducción

El instrumento financiero que conocemos por "opción" está atrayendo cada vez más interés entre los tráders bursátiles. Basta decir que en los últimos años, cuando la Bolsa de Moscú MOEX ha celebrado una competición entre inversores privados (LICHI), los tráders de opciones han ganado constantemente premios en la sección de futuros de la competición. Y esto en el contexto de una competencia elevada durante el concurso.

La teoría matemática de las opciones es relativamente compleja y no resulta trivial de entender y calcular manualmente, pero existe un número bastante elevado de las denominadas calculadoras de opciones: programas que permiten calcular cualquier combinación de opciones. Normalmente, se negocia un conjunto de opciones con distintos parámetros: estructuras de opciones. Pero hablaremos más sobre ello en los siguientes artículos.

El artículo de hoy describe la emulación de opciones a través de la compra/venta del activo subyacente. Este método permite crear (emular) una opción sintética con cualquier parámetro deseado (incluido uno que no exista en el mercado real). Por ejemplo, podemos crear un instrumento exótico como una opción sobre una opción, o una opción sobre un spread y otros tipos de activos subyacentes reales o sintéticos.

Fundamentos de la teoría de opciones

• 1. Definiciones

Una opción es un instrumento financiero derivado (de la palabra inglesa "derivative"), que otorga al participante en la negociaciones el derecho (pero no la obligación) de:

• comprar el activo subyacente - opción Call
• vender el activo subyacente - opción Put
  

Para el vendedor de la opción (que es también la contraparte del comprador), el acuerdo no es un derecho, sino una obligación de completar una transacción (si la opción es Call, entonces vender el activo subyacente al comprador; si la opción es Put, entonces comprar el activo subyacente al comprador), por la cual recibe una prima del comprador.

La compra (o venta) del activo subyacente se produce a un precio fijo en o antes de una fecha futura predeterminada: la fecha de vencimiento. Una vez ejecutada (vencida) la opción, el participante recibe en su cuenta el importe correspondiente del activo subyacente comprado (vendido) (acciones, futuros, divisas) para las opciones de entrega, o el equivalente monetario (el resultado de la ejecución de la opción) para las opciones liquidadas en efectivo.

• 2. Términos

El activo subyacente es la acción, el índice, la moneda, la materia prima u otro instrumento sobre el cual se emite la opción.

El precio strike es un precio acordado previamente al cual se puede comprar o vender el activo subyacente, también conocido como precio de ejercicio de la opción.

La prima es el precio de una opción que el comprador paga al vendedor para adquirir el derecho a comprar o vender el activo subyacente a un precio específico en un momento específico.

El vencimiento es la fecha de vencimiento de una opción (de la palabra inglesa “expiration”), fecha antes de la cual el comprador puede ejercer su derecho a comprar/vender el activo subyacente.

• 3. Tipos de opciones

• 3.1. Por tipo de ejecución

Americanas: se pueden ejecutar cualquier día antes del vencimiento (normalmente son más caras que las europeas);

Europeas: solo se puede ejecutar en la fecha de vencimiento;

Bermudas: la ejecución se da en fechas específicas.

• 3.2. Por tipo de cálculo

Con entrega: entrega del activo subyacente;

Liquidadas financieramente: liquidación en dinero.

• 3.3. Por mercado negociado

Cotizada en bolsa: estandarizada, negociada en bolsas (por ejemplo, CBOE, MOEX);

Extrabursátiles u OTC (Over-the-counter): condiciones individuales entre contrapartes.

• 4. Esencia del instrumento de opción

Una opción es un buen medio de cobertura (traducido de hedge, una palabra inglesa que significa valla, cerco), es decir, de protección de inversiones. El precio de la opción (prima de la opción) determina cuánto estamos dispuestos a pagar para eliminar (parcial o totalmente) el riesgo. Por ejemplo, supongamos que decidimos proteger (cubrir) un activo denominado en rublos contra el riesgo de que el tipo de cambio del rublo suba frente al dólar estadounidense durante un periodo de seis meses. Digamos que necesitamos una cierta cantidad de rublos en seis meses para realizar una compra grande.

Una opción de cobertura consiste en este caso en comprar directamente el activo subyacente, dólares por rublos. Pero aquí surgen nuevos riesgos: si durante estos seis meses el rublo empieza a fortalecerse frente al dólar, posiblemente perderemos una cantidad significativa en la conversión inversa a rublos. Por ejemplo, si el tipo de cambio cambiara de 100 rublos/dólar a 80 rublos/dólar, perderíamos el 20% del monto original en rublos.

La segunda opción de cobertura sería comprar una opción Put sobre el activo RUB/USD con una fecha de vencimiento de seis meses y un precio strike aproximadamente igual al tipo de cambio actual del rublo al dólar (digamos 100 rublos/dólar). Al pagar la prima de la opción, podremos ejercer nuestra opción Put dentro de seis meses y obtener el activo subyacente (rublos) a una tasa de 100 rublos/dólar. Incluso si para ese entonces el rublo se fortalece hasta (da miedo imaginarlo) 50 rublos por dólar. Como resultado, solo pagaremos la prima de la opción.

De forma similar, podemos proteger nuestros activos en rublos de la devaluación (depreciación) del rublo. Aquí debemos comprar una opción Call con un precio strike aproximadamente igual al tipo de cambio actual del rublo al dólar.

• 5. Modelo de opciones de Black-Scholes

El modelo Black-Scholes es una fórmula matemática desarrollada en 1973 por Fischer Black, Myron Scholes y (indirectamente) Robert Merton para calcular el precio justo de las opciones europeas. El precio justo, en este caso, es un precio que satisface tanto al comprador como al vendedor de la opción. Por este trabajo, Scholes y Merton recibieron el Premio Nobel de Economía en 1997 (Fisher Black murió antes y no fue galardonado).

Precio (prima) de la opción Call:

Precio (prima) de la opción Put:

donde:

• S - precio actual del activo subyacente
• X - precio strike de la opción
• r - tasa de interés libre de riesgo (devengada continuamente)
• T - tiempo hasta el vencimiento (en años)
• N(d) - función acumulativa de la distribución normal estándar
• σ - volatilidad del activo subyacente

El modelo se basa en varios supuestos:

1. el mercado es absolutamente eficiente: no hay posibilidad de arbitraje;
2. tasa de interés libre de riesgo: constante y conocida;
3. la volatilidad del activo subyacente es constante;
4. ausencia de dividendos: el modelo se perfeccionó posteriormente;
5. distribución lognormal de los precios de los activos: los precios no pueden ser negativos;
6. tiempo continuo: las transacciones comerciales continúan sin interrupción;
7. ausencia de comisiones e impuestos.

Las principales deficiencias del modelo se derivan de los supuestos anteriores:

• el mercado no es eficiente: hasta cierto punto, solo los instrumentos más líquidos pueden considerarse como tales;
• la volatilidad del activo subyacente cambia con demasiada frecuencia y de forma continua como para ser considerada constante;
• la distribución está lejos de ser lognormal: los mercados reales tienen "colas pesadas" (riesgos de caída) y los movimientos repentinos de precios también se ignoran;
• no es apto para opciones americanas.

Existen modelos alternativos de fijación de precios de opciones que consideran algunos de los factores enumerados anteriormente:

• el modelo de Heston (volatilidad estocástica)
• el modelo bayesiano (que tiene en cuenta los macrofactores)
• los métodos de aprendizaje automático (redes neuronales para predecir precios de opciones).

• 6. "Griegas"

Las llamadas "griegas" son indicadores estadísticos de la sensibilidad del precio de una opción respecto al cambio en diversos parámetros: precio strike, volatilidad, precio actual del activo subyacente, fecha de vencimiento, etc. Matemáticamente, las "griegas" son derivadas parciales de la fórmula de Black-Scholes. En esencia, se usan los siguientes indicadores principales:

• Delta: muestra cómo cambia el valor de una opción cuando cambia el precio del activo subyacente. Se calcula como la relación entre el cambio en el valor de la opción y el cambio en el valor del activo. Si el valor delta es negativo, esto significa que conforme el precio del activo aumente, el precio de la opción caerá. Para las opciones Call, el delta es positivo; para las opciones Put, es negativo. Este es el indicador más importante que se usará al emular opciones.
• Gamma: muestra cómo cambia el valor delta cuando cambia el precio del activo subyacente. En esencia, es la segunda derivada del precio de la opción según el precio del activo subyacente. Las opciones con mucho tiempo restante hasta el vencimiento tienen una gamma mínima. Su valor aumenta conforme se acerca el vencimiento.
• Theta: muestra cómo cambia el valor de una opción dependiendo de la proximidad del tiempo de vencimiento. Se calcula como la relación entre el cambio en el precio de la opción y el cambio en el tiempo hasta el vencimiento. El valor de theta siempre se muestra como negativo porque reduce el valor de la opción.
• Vega: muestra cómo cambia el valor de una opción cuando cambia la volatilidad esperada. Se calcula como la relación entre el cambio en el precio de la opción y el cambio en la volatilidad esperada. Los valores de vega más altos corresponden a las opciones con un precio strike más cercano al precio de mercado actual del activo. Estas opciones son las más sensibles a los cambios en la volatilidad esperada. El valor de vega disminuye conforme se acerca la fecha de vencimiento de la opción.
• La volatilidad implícita (IV) es un indicador importante que no está relacionado con las "griegas", pero se utiliza en la fórmula de Black-Scholes. Se calculado usando como base transacciones reales para contratos de opciones específicos. Además, la volatilidad se puede calcular de formas diferentes: ajustándola a la fórmula de Black-Scholes, solo en el strike central, ponderándola por diferentes strikes, teniendo en cuenta y sin tener en cuenta las solicitudes, etc. Durante la emulación, asumiremos que el activo subyacente no tiene opciones ni órdenes reales para ellas, o que no están disponibles para nosotros.

Por ello, en lugar de la volatilidad implícita, utilizaremos la volatilidad histórica (HV), calculada para intervalos: día, semana, mes. El intervalo depende del periodo de tiempo hasta el vencimiento de la opción. Desde un punto de vista matemático, la volatilidad histórica es una medida estadística de la dispersión de los datos respecto de su valor promedio durante un periodo determinado. Se calcula como la desviación estándar multiplicada por la raíz cuadrada del número de periodos de tiempo T. Para nuestros propósitos, es apropiado usar un periodo de tiempo de un día, semana o mes.

Emulación de opciones

• 1. La necesidad de la emulación

La necesidad de emulación viene determinada por varios factores que se enumeran a continuación:

• Ausencia física de una opción sobre el activo subyacente deseado. Por ejemplo, la bolsa de criptomonedas Bybit solo negocia opciones sobre tres activos spot: BTC, ETH y SOL. Además, hasta hace poco, no existían opciones sobre acciones en la Bolsa de Moscú MOEX.
• Tipo de opción inapropiado según el tiempo de vencimiento. Por ejemplo, en MOEX, para las opciones sobre acciones, solo hay opciones europeas, con ejecución solo el último día. Esto reduce el rango de estrategias de trading de opciones, eliminando las especulativas.
• Liquidez insuficiente para apertura/cierre anticipado de opciones. En MOEX, solo las opciones sobre los futuros/acciones más líquidos permiten abrir/cerrar rápidamente una posición de opción. Esto puede dar lugar tanto a pérdidas de beneficios como a pérdidas no sistémicas. Este factor también dificulta el uso de estrategias de scalping, en las que la velocidad de apertura/cierre de las posiciones de opciones resulta crucial.

• 2. Comparación de opciones reales y virtuales

Criterio de comparación	Opción real	Opción virtual
Pago del costo (prima) al comprar una opción	Se paga una prima	Sin costo
Obtención de primas al vender una opción	Hay prima	Sin prima
Presencia de decaimiento temporal en una opción conforme se acerca la fecha de vencimiento	Hay un decaimiento temporal	No hay decaimiento temporal
La influencia de las "réplicas" y el contexto de las noticias	No afecta en general	Afecta a la calidad de la emulación de las opciones.
Flexibilidad en la elección del tiempo de vencimiento	No hay. Es establecido por la bolsa	Definido por el usuario
Posibilidad de utilizar tiempos de vencimiento cortos (día, varias horas, decenas de minutos)	No hay	Cualquier tiempo de vencimiento
Necesidad de un monitoreo constante de las posiciones	No es necesario en general	Se requiere un monitoreo constante

Las cualidades positivas de la opción se destacan en negrita. Como podemos ver en la tabla, ambas opciones tienen sus lados positivos y negativos. Como era de esperar, no hay nada ideal en nuestro mundo.

• 3. Requisitos de las condiciones comerciales para el uso de la emulación de opciones

Como la emulación de opciones implica negociar el activo subyacente, resulta deseable minimizar las comisiones y otros costos generales de negociación, como deslizamientos, spreads elevados y swaps para posiciones abiertas. Todos ellos degradan la calidad de la opción virtual, especialmente con periodos de vencimiento cortos. De lo contrario, no existen requisitos especiales para las condiciones comerciales.

Para argumentar que una posición en el activo subyacente es equivalente a una opción, uno debe entender que en cualquier momento dado, una opción tiene un cierto delta (Delta). Si el monto del activo subyacente coincide con el delta de la opción, entonces estas posiciones serán equivalentes en un momento dado, es decir, generarán las mismas ganancias y pérdidas.
 
Veamos con más detalle cómo construir una emulación.

Digamos que necesitamos comprar o vender una opción o varias opciones sobre un activo subyacente. Primero calculamos (esto se puede hacer, por ejemplo, en el sitio web de la bolsa de Moscú MOEX, si estamos hablando de opciones bursátiles) el delta de esta posición, como si la hubiéramos creado a través de opciones.
Veamos un ejemplo. Digamos que planeamos comprar 100 opciones Call en dinero para participar en el crecimiento con apalancamiento y riesgo limitado. El delta de una opción es 0,5. El delta total de una cartera de 100 opciones será 0,5 * 100 = 50. Para crear una cartera equivalente, solo deberemos comprar 50 unidades del activo subyacente. Entonces el delta de ambas carteras será el mismo e igual a 50.

Sin embargo, una vez que compramos una opción, generalmente podemos olvidarnos de ella hasta su vencimiento. Con la emulación, todo es un poco distinto. Aquí, a lo largo de toda su vida, es necesario asegurar la equivalencia con la cartera de opciones, ya que el precio del mercado cambia continuamente. Por lo tanto, deberemos realizar ajustes (reequilibrios), es decir, la compra/venta del número faltante/excedente de unidades del activo subyacente. ¿Con qué frecuencia y en qué momento debemos realizar el reequilibrio? Esto se puede hacer con un cierto paso temporal (una vez por hora, una vez al día) o con un paso delta (al cambiar el delta en +/- 1, +/- 2, etc.). También hay otras opciones.

Veamos nuestro ejemplo con más detalle. Se ha creado una cartera de 50 unidades compradas del activo subyacente, es decir, 100 opciones Call. Por la tarde, el mercado ha ganado un poco y el delta de una opción Call ha crecido a 0,53 y el delta de la cartera ha aumentado a 0,53 * 100 = 53. Luego, para mantener la equivalencia, debemos comprar 3 unidades más del activo subyacente. Si las cotizaciones vuelven a caer por debajo del nivel de entrada al día siguiente y el delta de la opción disminuye a, digamos, 0,48, deberemos vender 5 unidades del activo subyacente. De esta manera se mantiene la equivalencia de cartera.

¿Por qué el perfil de una posición de opción simulada reflejará el perfil de las opciones compradas? Porque cuando el precio crece, el delta aumenta y el tráder compra más del activo subyacente. Cuanto más "en el dinero" se encuentre la opción, más unidades compradas del activo subyacente tendremos en la cartera, terminando así en ganancias por crecimiento, similar a una opción Call comprada. Si el precio baja, venderemos el activo subyacente y nos desharemos de él hasta la posición cero. Esto garantiza que las pérdidas en caso de caída resulten limitadas, al igual que con una opción Call.

Ahora más detalles sobre el reequilibrio. Este es el punto clave en la emulación. El resultado final depende en realidad de estas transacciones. Los ajustes deben efectuarse sistemáticamente, siguiendo un algoritmo preestablecido, de lo contrario es posible que se produzcan pérdidas inesperadas. Por ejemplo, si el precio ha subido bruscamente de un delta de 0,5 a un delta de 0,6 y no se ha realizado el reequilibrio, es decir, no se han comprado 10 unidades del activo subyacente, entonces el activo subyacente, en el peor de los casos, podría no regresar a esta zona antes del vencimiento. Al día siguiente el delta podría ya estar en 0,65, y nos veremos obligados a comprar 15 unidades en delta 0,65, en lugar de comprar 10 unidades en delta 0,6 y 5 en delta 0,65. Naturalmente, es necesario usar un robot comercial para emular la opción.

La opción ideal es que los futuros se negocien durante todo el día y se puedan realizar ajustes continuamente. No obstante, los ajustes frecuentes pueden dar lugar a pérdidas, a primera vista, innecesarias. Si el mercado se ha movido a lo largo del delta durante tres días: 0,50, 0,55, 0,50, luego, siguiendo el algoritmo de reequilibrio, necesitaremos primero comprar 5 unidades con un delta de 0,55, y al día siguiente vender 5 unidades con un delta de 0,50, lo que naturalmente solucionará nuestras pérdidas. Por lo tanto, si por alguna razón un tráder no ha realizado el ajuste en el segundo día, entonces no ha pasado nada terrible: el precio no ha cambiado. Pero el mercado también puede moverse monótonamente en una dirección, por lo que será necesario reequilibrarlo periódicamente.

La desventaja del "reequilibrio temporal" es la presencia de movimientos bruscos de precios, cuando el mercado sube o baja varios puntos porcentuales en un corto periodo de tiempo. Los métodos de ajuste "por escala delta" combaten esto con éxito, pero a veces también tienen problemas cuando es físicamente imposible ejecutar una transacción al precio previsto debido a un movimiento muy brusco y un deslizamiento significativo. Aquí es donde los robots comerciales vienen al rescate, dado que pueden ajustar las posiciones con mayor rapidez y precisión durante los movimientos del mercado.

Resulta obvio que cuando el activo subyacente fluctúa hacia arriba y hacia abajo, nuestro reequilibrio solo corrige una pequeña pérdida cada vez. De hecho, en el ejemplo de compra de una opción Call, el tráder compra el activo subyacente a un precio alto y lo vende a un precio bajo. Si el activo subyacente no se mueve durante la vida de la posición, la estrategia no será rentable debido al mantenimiento del delta. Pero cuando nosotros compramos una opción, se cobra una prima por ella. Y si no ganamos dinero, entonces la prima también se pierde. El decaimiento temporal corroe la opción; cuando se emula, el reequilibrio puede causar pérdidas.

La compra y venta del activo subyacente para mantener el delta suponen operaciones con pequeñas pérdidas, cuya pérdida total a lo largo del tiempo es aproximadamente igual a la prima de la opción. Está claro que la prima depende de la volatilidad IV en el momento de la compra. Cuanto mayor sea IV, más a menudo se moverá el mercado, como suponen los tráders. Cuanto mayor sea el IV, más cara será la opción. Lo mismo ocurre con la emulación: cuanto más fluctuaba el mercado, más volátil era y más cara se volvía la emulación. Cuanto mayores sean las oscilaciones, mayor será la pérdida, como sucede con el aumento del valor de una opción conforme aumenta la volatilidad.

La emulación está justificada si el activo subyacente ha tenido baja volatilidad durante la vida de la opción y rara vez hemos tenido que reequilibrarlo o si el tamaño de las pérdidas resultantes ha sido pequeño. Entonces es más rentable emular la opción que comprarla en la bolsa con una IV cara. Después de todo, la volatilidad registrada durante la vida de la cartera fue mucho menor que la IV. También en este caso resulta apropiada la analogía con una opción vendida. Por ejemplo, si hemos vendido una opción con una volatilidad del 52% y esta se materializa con un 60%, entonces, debido a que se mantiene la neutralidad delta, el resultado es negativo. Si se alcanza una volatilidad del 45%, entonces la venta resultará rentable, ya que los costes de reequilibrio son menores que la prima.

La emulación es inferior a la compra directa de una opción si la volatilidad realizada excede la IV en el momento de la creación de la cartera. Después de todo, los ajustes frecuentes debido al elevado nerviosismo del mercado superarán el valor de la prima de la opción. Por el contrario, si emulamos una opción corta, entonces con una mayor volatilidad realizada, la emulación resultará más rentable que vender directamente la opción.

¿Qué más necesitamos saber al crear una opción artificialmente?  Recordemos que el precio de las opciones está determinado principalmente por tres factores: el tiempo hasta el vencimiento, el valor del activo subyacente y la volatilidad implícita. En igualdad de condiciones, cada uno de estos factores afecta la opción a su propia manera. Podemos decir que el valor de una opción regular supone una función de tres variables. Una opción emulada consta únicamente en un activo subyacente cuyo precio no depende del nivel de volatilidad implícita ni del tiempo. El precio de una opción "artificial" es función únicamente del valor del activo subyacente.  ¿Esto es bueno o malo?  Obviamente esta circunstancia puede ser tanto positiva como negativa.

Antes de implementar la emulación, vamos a analizar los aspectos prácticos del algoritmo. Para ello, construiremos los gráficos de la dependencia del delta de la opción y del P&L (ganancia/pérdida) respecto del precio del activo subyacente. Estos gráficos se han obtenido del sitio web de MOEX para una opción sobre futuros SBRF con un precio strike de 31000 y una fecha y hora de vencimiento: 18/06/2025. Los gráficos están actualizados al 22 de mayo de 2025. El precio actual (correspondiente a la línea de puntos vertical) en ese momento era 30800.

Fig. 1 Dependencia de la ganancia/pérdida (P&L) de una opción Call adquirida con un precio strike de 31000 respecto del precio del activo subyacente. El P&L se expresa en rublos para una opción. La línea punteada vertical es el momento en el que se han construido los gráficos. En este momento el resultado es negativo e igual a - 23,92 rublos.

La línea roja corresponde al momento actual (22/05/2025), la línea azul corresponde al tiempo de vencimiento (18/06/2025), es decir, cuando T = 1 en la fórmula de Black-Scholes.

Fig. 2 Dependencia del valor delta de una opción Call comprada con un precio strike de 31000 respecto del precio del activo subyacente de una opción. La línea punteada vertical es el momento en el que se han construido los gráficos. En este momento, Delta es 0,48.

La línea roja corresponde al momento actual (22/05/2025), la línea azul corresponde al tiempo de vencimiento (18/06/2025), es decir, cuando T = 1 en la fórmula de Black-Scholes.

Los gráficos que se muestran arriba se derivan directamente de la fórmula de Black-Scholes. Como podemos ver en el gráfico de la fig. 1, al comprar una opción Call, pagamos una prima al vendedor por un monto de aproximadamente 789 rublos por contrato. Es decir, inmediatamente nos encontramos en negativo, a diferencia de una opción emulada (la comisión por comprar el activo subyacente puede, en una primera aproximación, despreciarse). Pero también hay buenas noticias: incluso si el precio del activo subyacente cae por encima de la prima, nuestras pérdidas no pasarán a ser negativas perpetuas. Esta es la diferencia fundamental entre comprar una opción Call y comprar, por ejemplo, una acción: en este último caso, si el precio disminuye, las pérdidas no estarán limitadas de ninguna manera.

Desarrollando una emulación de opciones en MQL5

Por la figura 2 podemos ver que Delta varía (para un contrato de una opción Call comprada) en el rango de 0 a +1. Vamos a pasar para el eje X del gráfico Delta de precios absolutos a incrementos en puntos. Para ello, restamos a los precios el precio strike, en este caso 31000. El gráfico resultante se verá así:

Fig. 3 Dependencia del valor delta de una opción Call comprada con un precio strike de 31000 respecto del cambio en el precio del activo subyacente en relación con el precio strike de una opción. La línea punteada vertical es el momento en el que se han construido los gráficos. En este momento, Delta es 0,48.

La línea roja corresponde al momento actual (22/05/2025), la línea azul corresponde al tiempo de vencimiento (18/06/2025), es decir, cuando T = 1 en la fórmula de Black-Scholes.

Naturalmente, el gráfico resultante no se distingue cualitativamente del original, salvo por la escala en el eje x. Como la fórmula de Black-Scholes utiliza la volatilidad implícita (IV), que generalmente desconocemos, la única opción adecuada es utilizar la volatilidad histórica (HV). Para las opciones mensuales, esta será la HV promedio del mes, para las opciones semanales, la HV promedio de la semana, etc.

Para facilitar la comparación de gráficos con diferentes activos subyacentes y para la posibilidad de crear opciones sobre instrumentos sintéticos (una cartera compuesta por diferentes activos), sería aconsejable utilizar incrementos de precios relativos, normalizando estos incrementos por la volatilidad histórica HV calculada.

Entonces el incremento relativo del precio se expresa mediante la siguiente relación: Relative Price(price) = (price - Strike) / HV.

Supongamos que para el periodo de vencimiento calculamos HV = 5000. En principio esto se puede ver en la figura 3. Obtenemos un gráfico del siguiente tipo:

Fig. 4 Dependencia del valor delta de una opción Call comprada con un precio strike de 31000 sobre el cambio de precio relativo, normalizado a la volatilidad histórica del activo subyacente para una opción. La línea punteada vertical es el momento en el que se han construido los gráficos. En este momento, Delta es 0,48.

La línea roja corresponde al momento actual (22/05/2025), la línea azul corresponde al tiempo de vencimiento (18/06/2025), es decir, cuando T = 1 en la fórmula de Black-Scholes.

Podemos observar que con un precio igual al strike, Delta es 0,5. El gráfico delta mostrado por la línea roja no es más que una función sigmoidea, conocida en matemáticas y aprendizaje automático, de la forma: 1 \ (1 + exp(-K \ (x - S))), donde S = 0, y K es generalmente desconocido y se selecciona experimentalmente. En esencia, el coeficiente K depende del periodo de vencimiento. Conociendo el valor del delta en un punto dado en el tiempo (0,48) al precio actual del activo subyacente (30800), podemos calcular el valor de K: para un punto dado en el tiempo será igual a 2 y cambiará (aumentará) conforme la opción se acerque al vencimiento.

Para la emulación, ignoraremos el decaimiento temporal de la opción y el cambio en K: será constante durante la vida de la opción. Esto tendrá un efecto positivo en las ganancias y pérdidas de la opción Call adquirida y un efecto negativo en las ganancias y pérdidas de la opción Put adquirida. En general, no habrá un impacto significativo en las pérdidas y ganancias de la cartera de opciones.

Si igualamos el parámetro S en la sigmoide 1 \ (1 + exp(-K \ (x - S))) a 0,5, entonces el gráfico de la dependencia del delta con respecto al cambio relativo del precio se desplazará a lo largo del eje X hacia la derecha en la cantidad S, y obtendremos en el cero un valor que estará cerca de cero: la sigmoide tiende asintóticamente a 0 y a 1. Este tipo es más cómodo para la emulación y normalización al rango de volatilidad, que utilizaremos al desarrollar un experto en MQL.

Bien, ya tenemos todos los datos fuente para escribir código en MQL5 para emular una opción en un activo subyacente arbitrario. Es decir: la fórmula de la función de emulación, el precio strike, la volatilidad histórica y una comprensión de los procesos que ocurren en el mercado ideal de Black-Scholes.

• 1. Clase básica

Emularemos los siguientes tipos de opciones:

• compra del derecho a comprar el activo subyacente - opción Call Long
• compra del derecho a vender el activo subyacente - opción Put Long
• venta del derecho a comprar el activo subyacente - opción Call Short
• venta del derecho a vender el activo subyacente - opción Put Short

Vamos a definir todos los tipos de opciones admitidos como una enumeración:

// ---------------------------------------------------------------------
//  Тип опциона:
// ---------------------------------------------------------------------
enum ENUM_OPTION_TYPE
{
   ENUM_OPTION_CALL_LONG,                 // Long Call
   ENUM_OPTION_CALL_SHORT,                // Short Call
   ENUM_OPTION_PUT_LONG,                  // Long Put
   ENUM_OPTION_PUT_SHORT,                 // Short Put
};

La clase básica se deriva de la clase MQL estándar 'CObject'. Esto se hace para facilitar el uso de listas 'CList' MQL estándar para manipular objetos y crear construcciones opcionales de cualquier complejidad. Esto se discutirá en el próximo artículo de la serie.

Los principales miembros de datos de la clase básica son:

• tipo de opción — campo ' type_enum '
• precio strike — campo ' strike '
• el valor actual de la opción delta — campo ' delta '
• precio para normalizar la opción por volatilidad — campo ' norm_price '

También hay una serie de campos auxiliares que serán necesarios en las clases que descienden de la clase básica. La clase básica es abstracta y se requiere que el método 'GetSigmoidValue' esté definido en las clases descendientes. Este método varía para los diferentes tipos de opciones dentro del modelo Black-Scholes. Este enfoque también permitirá la futura incorporación de otros tipos de opciones, por ejemplo, usando métodos de aprendizaje automático y/u otros modelos de precios.

// =====================================================================
// Базовый класс опциона - порожден от 'CObject', чтобы можно было
// помещать в списки.
// =====================================================================
class TOptionBase : public CObject
{
protected:
   ENUM_OPTION_TYPE  type_enum;
   double  strike;
   double  shift;
   double  koeff_K;
   double  koeff_S;
   int     digits;
   double  norm_price;
   double  delta;

   double  norm_koeff;
   bool    range_inited_Flag;

public:
   // ---------------------------------------------------------------------
   //  Конструктор:
   // ---------------------------------------------------------------------
   TOptionBase(const ENUM_OPTION_TYPE _type, const double _k, const double _s, const int _digits)
   :
   CObject(),
   type_enum(_type),
   strike(0.0),
   shift(0.0),
   koeff_K(_k),
   koeff_S(_s),
   digits(_digits),
   range_inited_Flag(false),
   delta(0.0),
   norm_koeff(0.0)
   {
   }

public:
   // ---------------------------------------------------------------------
   //  Установить диапазон нормировки дельты для центрального страйка:
   // ---------------------------------------------------------------------
   void SetRange(const double _strike, const double _norm_price)
   {
     this.strike = _strike;
     this.norm_price = _norm_price;
     this.norm_koeff = 1.0 / (this.norm_price - this.strike);
     this.range_inited_Flag = true;
   }
   // ---------------------------------------------------------------------
   //  Рассчитать значение нормированной дельты для заданной цены:
   // ---------------------------------------------------------------------
   double UpdateDelta(const double _price)
   {
     if(this.range_inited_Flag == false)
     {
       this.delta = 0.0;
     }
     else
     {
       this.delta = NormalizeDouble(this.GetSigmoidValue((_price - this.strike) * this.norm_koeff), 5);
     }

     return(this.delta);
   }
   // ---------------------------------------------------------------------
   //  Получить значение вычисленной ранее нормированной дельты:
   // ---------------------------------------------------------------------
   double Delta()
   {
     return(this.delta);
   }
   // ---------------------------------------------------------------------
   //  Получить флаг инциализации диапазона для дельты:
   // ---------------------------------------------------------------------
   bool    IsRangeInited()
   {
     return(this.range_inited_Flag);
   }
protected:
   // ---------------------------------------------------------------------
   //  Получить значение нормированной дельты:
   // ---------------------------------------------------------------------
   virtual double GetSigmoidValue(const double _x) = 0;
};
// ---------------------------------------------------------------------

• 2. Peculiaridades del trabajo en condiciones reales

Al emular una opción, debemos elegir en qué cambio delta necesitamos reequilibrar las posiciones. Por un lado, esto limitará la precisión de la emulación, pero por otro lado, permitirá controlar los costos de las comisiones al abrir/cerrar posiciones. Nosotros usaremos los parámetros del activo subyacente: Vmin_size (volumen mínimo de una posición abierta) y Vmin_delta_size (cambio mínimo en el volumen de la posición).

También estableceremos el número de reequilibrios de posición cuando el delta cambie en el rango (por módulo) - |0.0...1.0|. Estableceremos este número de reequilibrios N como parámetro externo. Entonces, el volumen total de posiciones variará de 0 a (Vmin_size + Vmin_delta_size * (N - 1)).

Por lo común, Vmin_size es igual a Vmin_deltasize, pero este no es necesariamente el caso. De forma predeterminada, tomaremos un número de reequilibrios igual a diez en el rango delta |0,0...1,0|.

• 3. Opción Call Long

Fig. 5 Dependencia del valor delta del cambio relativo en el precio DPrice (x en la tabla) para la opción Call Long emulada (compra de Call). S = 0,5, K = 10. El rango de delta se divide en diez partes iguales.

El precio strike corresponde al punto cero DPrice = 0. Cuando el valor delta está cerca de uno, se dice que la opción está "profundamente en el dinero"; en este caso, se comporta como una posición larga en el activo subyacente del tamaño máximo. A medida que se acerca el precio strike, el tamaño de la posición en el activo subyacente disminuye y se vuelve cero cuando la opción está "fuera del dinero", lo que significa que delta es cercano a cero. La opción real entra en el menos por el importe de la prima.

// =====================================================================
// Clase de opción de tipo 'Long Call'
// =====================================================================
class OptionLongCall : public TOptionBase
{
public:
    // ---------------------------------------------------------------------
    //    Constructor:
    // ---------------------------------------------------------------------
    OptionLongCall(const double _k, const double _s, const int _digits)
    :
    TOptionBase(ENUM_OPTION_CALL_LONG, _k, _s, _digits)
    {
    }

protected:
    // ---------------------------------------------------------------------
    //    Obtener el valor delta normalizado:
    // ---------------------------------------------------------------------
    double GetSigmoidValue(const double _x) override
    {
        return(1.0 / (1.0 + MathExp(-this.koeff_K * (_x - this.koeff_S))));
    }
};
// ---------------------------------------------------------------------

• 4. Opción Put Long

Fig. 6 Dependencia del valor delta del cambio relativo en el precio DPrice (x en la tabla) para la opción Long Put emulada (comprar Put). S = 0,5, K = 10. El rango de delta se divide en diez partes iguales.

El precio strike corresponde al punto cero DPrice= 0. Cuando el valor delta está cerca de menos uno, se dice que la opción está "profundamente en el dinero"; en este caso, se comporta como una posición vendida en el activo subyacente en su valor máximo. A medida que se acerca el precio strike, el tamaño de la posición en el activo subyacente disminuye y se vuelve cero cuando la opción está "fuera del dinero", lo que significa que delta es cercano a cero. La opción real entra en el menos por el importe de la prima.

// =====================================================================
//    Clase de opción de tipo 'Long Put'
// =====================================================================
class OptionLongPut : public TOptionBase
{
public:
    // ---------------------------------------------------------------------
    //    Constructor:
    // ---------------------------------------------------------------------
    OptionLongPut(const double _k, const double _s, const int _digits)
    :
    TOptionBase(ENUM_OPTION_PUT_LONG, _k, _s, _digits)
    {
    }

protected:
    // ---------------------------------------------------------------------
    //    Obtener el valor delta normalizado:
    // ---------------------------------------------------------------------
    double GetSigmoidValue(const double _x) override
    {
        return(-1.0 / (1.0 + MathExp(-this.koeff_K * (-_x - this.koeff_S))));
    }
};
// ---------------------------------------------------------------------

• 5. Opción Call Short

Fig. 7 Dependencia del valor delta del cambio relativo en el precio DPrice (x en la tabla) para la opción Short Call emulada (venta de Call). S = 0,5, K = 10. El rango de delta se divide en diez partes iguales.

El precio strike corresponde al punto cero DPrice= 0. Cuando el valor delta está cerca de menos uno, se dice que la opción está "profundamente en el dinero"; en este caso, se comporta como una posición vendida en el activo subyacente en su valor máximo. A medida que se acerca el precio strike, el tamaño de la posición del activo subyacente disminuye y se vuelve cero cuando la opción está "fuera del dinero", lo que significa que delta es cercano a cero. La opción real pasa a positivo por el importe de la prima.

//=====================================================================
//    Clase de opción de tipo 'Short Call'
//=====================================================================
class OptionShortCall : public TOptionBase
{
public:
    // ---------------------------------------------------------------------
    //    Constructor:
    // ---------------------------------------------------------------------
    OptionShortCall(const double _k, const double _s, const int _digits)
    :
    TOptionBase(ENUM_OPTION_CALL_SHORT, _k, _s, _digits)
    {
    }

protected:
    // ---------------------------------------------------------------------
    //    Obtener el valor delta normalizado:
    // ---------------------------------------------------------------------
    double GetSigmoidValue(const double _x) override
    {
        return(-1.0 / (1.0 + MathExp(-this.koeff_K * (_x - this.koeff_S))));
    }
};
// ---------------------------------------------------------------------

• 6. Opción Put Short

Fig. 8 Dependencia del valor delta del cambio relativo en el precio DPrice (x en la tabla) para la opción Put Short emulada (venta de Put). S = 0,5, K = 10. El rango de delta se divide en diez partes iguales.

El precio strike corresponde al punto cero DPrice= 0. Cuando el valor delta está cerca de uno, se dice que la opción está "profundamente en el dinero"; en este caso, se comporta como una posición vendida en el activo subyacente en su valor máximo. A medida que se acerca el precio strike, el tamaño de la posición del activo subyacente disminuye y se vuelve cero cuando la opción está "fuera del dinero", lo que significa que delta es cercano a cero. La opción real pasa a positivo por el importe de la prima.

//=====================================================================
//    Clase de opción de tipo 'Short Put'
//=====================================================================
class OptionShortPut : public TOptionBase
{
public:
    // ---------------------------------------------------------------------
    //    Constructor:
    // ---------------------------------------------------------------------
    OptionShortPut(const double _k, const double _s, const int _digits)
    :
    TOptionBase(ENUM_OPTION_PUT_SHORT, _k, _s, _digits)
    {
    }

protected:
    // ---------------------------------------------------------------------
    //    Obtener el valor delta normalizado:
    // ---------------------------------------------------------------------
    double GetSigmoidValue(const double _x) override
    {
        return(1.0 / (1.0 + MathExp(-this.koeff_K * (-_x - this.koeff_S))));
    }
};
// ---------------------------------------------------------------------

• 7. Peculiaridades del cálculo del volumen de posición del activo subyacente

Para calcular el volumen de la posición, necesitamos convertir el valor delta del rango |0.0...1.0| al rango de valores enteros |0...10|. Después multiplicaremos este valor entero por el volumen del cambio de lote mínimo y obtendremos el valor requerido del volumen de la posición. 

Supongamos que el número de "subrangos" delta es diez. Simplemente multiplicar el delta por diez y convertir el resultado a un entero no logrará el objetivo. Dado que cuando el delta fluctúa alrededor de cualquier límite del "sub-rango", el volumen también fluctuará sincrónicamente con el delta. Vamos a explicarlo con un ejemplo: digamos que el delta es 0,090 (el volumen es entonces (int)(0,090 * 10) = 0 (es decir, no hay posición) y luego aumenta a 0,101 (el volumen es entonces (int)(0,101 * 10) = 1), luego, en el siguiente tick después de un corto tiempo disminuye nuevamente a 0,090 - el volumen nuevamente se vuelve igual a 0. Es decir, esencialmente compramos y vendimos casi inmediatamente una posición: un reequilibrio sin sentido de la posición que puede repetirse muchas veces en cuestión de segundos. Esto es el llamado "rebote" de señal.

Por lo tanto, al convertir el delta al volumen requerido, debe haber una cierta "histéresis" de reequilibrio de posición. Esto se logra distinguiendo la dirección del reequilibrio (si es necesario disminuir o aumentar la posición actual en el activo subyacente) y considerando el valor anterior del volumen de la posición.

Vamos a introducir el concepto de nivel de emulación de opciones. Explicación: si la correspondencia se establece en |0.0...1.0| -> |0...10| (ver explicaciones anteriores), asumiremos que el nivel de emulación de la opción cambia de cero a diez. El número de niveles se especifica como un parámetro N externo al método de cálculo. El nivel de emulación, así como el delta, se tomarán en módulo. Y usaremos por separado la opción de signo de nivel de emulación - {0, +1, -1}. Si es 0 la posición estará cerrada.

• 8. Cálculo del volumen de la posición para el activo subyacente en MQL5

El método para implementar la "histéresis" al calcular el nivel actual de emulación de opciones es tabular, con uso de dos arrays:

• IncreaseLevel_Array — define el nivel de emulación de la opción al aumentarla.
• DecreaseLevel_Array — define el nivel de emulación de la opción cuando se disminuye.

Esto se hace en el método UpdateOptionLevel, que toma dos parámetros de entrada:

• _delta — delta actual de la opción.
• _curr_level — nivel de emulación de la opción actual, calculado anteriormente. O bien 0 si esta es la primera llamada al método.

El constructor de la clase OptionContractsVolume toma dos argumentos como parámetros:

• _ZeroDelta — valor delta correspondiente al nivel cero de emulación de opciones. Puede variar de 0,001 a 0,099.
• _LevelsNumber — número de niveles de emulación de las opciones. Cuanto más niveles haya, más fluida y precisa será la emulación, pero mayor será el lote negociado en el activo subyacente (debido a la discreción de su cambio).

En el constructor se rellenan los arrays IncreaseLevel_Array y se inicializan DecreaseLevel_Array y varias variables auxiliares (consulte el código fuente con comentarios).

// =====================================================================
//      Класс расчета объема контракта базового актива для опциона:
// =====================================================================
class OptionContractsVolume
{
  int IncreaseLevel_Array[];          // уровень эмуляции опциона при его увеличении
  int DecreaseLevel_Array[];          // уровень эмуляции опциона при его уменьшении
  // ---------------------------------------------------------------------
protected:
  double  ZeroDelta;                  // значение дельты, соответствующее нулевому уровню уровню эмуляции опциона
  int     LevelsNumber;               // число уровней эмуляции опциона
  // ---------------------------------------------------------------------
  int     zero_delta;                 // целое значение дельты, соответствующее нулевому уровню эмуляции опциона
  int     curr_option_level_sign;     // текуший знак уровня эмуляции опциона
  int     curr_option_level;          // текуший уровень эмуляции опциона
  // ---------------------------------------------------------------------
  int     curr_inc_level;
  int     curr_dec_level;
  // ---------------------------------------------------------------------
  int     curr_contracts_index;
  // ---------------------------------------------------------------------
  bool    is_contracts_updated_Flag;

public:
  // ---------------------------------------------------------------------
  //  Конструктор:
  // ---------------------------------------------------------------------
  OptionContractsVolume(const double _ZeroDelta, const int _levels_number)
  :
  ZeroDelta(_ZeroDelta),
  LevelsNumber(_levels_number),
  curr_option_level_sign(0),
  curr_option_level(0),
  curr_inc_level(0),
  curr_dec_level(0),
  is_contracts_updated_Flag(false)
  {
    this.zero_delta = (int)(NormalizeDouble(this.ZeroDelta, 3) * 1000.0);

    // Выделим память для массивов, хранящих уровни эмуляции:
    ArrayResize(this.IncreaseLevel_Array, (this.LevelsNumber + 1) * 100 + 1);
    ArrayResize(this.DecreaseLevel_Array, (this.LevelsNumber + 1) * 100 + 1);

    // Заполним массив в сторону увеличения:
    for(int i = 0; i < this.LevelsNumber + 1; i++)
    {
      ArrayFill(this.IncreaseLevel_Array, i * this.LevelsNumber * 100, this.LevelsNumber * 100, i);
    }
    ArrayFill(this.IncreaseLevel_Array, (this.LevelsNumber + 1) * 100, 1, this.LevelsNumber);

    // Заполним массив в сторону уменьшения:
    ArrayFill(this.DecreaseLevel_Array, 0,    zero_delta,  0);
    ArrayFill(this.DecreaseLevel_Array, zero_delta,  this.LevelsNumber * 100 - zero_delta + 1,  1);
    for(int i = 2; i < this.LevelsNumber + 1; i++)
    {
      ArrayFill(this.DecreaseLevel_Array, i * this.LevelsNumber * 100,  this.LevelsNumber * 100,  i);
    }
    ArrayFill(this.DecreaseLevel_Array, (this.LevelsNumber + 1) * 100, 1, this.LevelsNumber);
  }
  // ---------------------------------------------------------------------
  //  Рассчитать уровень эмуляции опциона для заданной дельты:
  // ---------------------------------------------------------------------
  //  - если произошло изменении уровня, возвращает 'true'.
  // ---------------------------------------------------------------------
  bool  UpdateOptionLevel(const double _delta, const int _curr_level)
  {
    this.is_contracts_updated_Flag = false;

    //  Определим направление торговли:
    int delta_int = (int)(NormalizeDouble(_delta, 3) * 1000.0);
    this.curr_option_level_sign = 0;
    if(delta_int > zero_delta / 2)
    {
      this.curr_option_level_sign = 1;
    }
    else if(delta_int < -zero_delta / 2)
    {
      this.curr_option_level_sign = -1;
    }

    //  Текущий индекс для массивов, исходя из 'Delta' с точностью 3 знака после запятой:
    this.curr_contracts_index = (int)MathAbs(delta_int);
    if(this.curr_contracts_index > ((this.LevelsNumber + 1) * 100))
    {
      //  Индекс не должен превыщать размер массива (здесь опцион глубоко в деньгах):
      this.curr_contracts_index = (this.LevelsNumber + 1) * 100;
    }

    //  Текущий уровень эмуляции опционов (0...N) в сторону УВЕЛИЧЕНИЯ:
    this.curr_inc_level = this.IncreaseLevel_Array[this.curr_contracts_index];

    //  Текущий уровень эмуляции опционов (0...N) в сторону УМЕНЬШЕНИЯ:
    this.curr_dec_level = this.DecreaseLevel_Array[this.curr_contracts_index];

    //  Если уровень эмуляции опционов (0...N) по сравнению с текущим, УВЕЛИЧИЛСЯ:
    if(this.curr_inc_level > _curr_level)
    {
      this.curr_option_level = this.curr_inc_level;
      this.is_contracts_updated_Flag = true;
      return(true);
    }

    //  Если, уровень эмуляции опционов (0...N) по сравнению с текущим УМЕНЬШИЛСЯ:
    if(this.curr_dec_level < _curr_level)
    {
      this.curr_option_level = this.curr_dec_level;

      this.is_contracts_updated_Flag = true;
      return(true);
    }

    return(false);
  }
};
// ---------------------------------------------------------------------

El texto del código completo se contiene en el archivo OptionEmulatorA1.mqh en el apéndice de este artículo.

Conclusión 

Entonces, hemos analizado la opción de emular opciones a través del activo subyacente; esta es una herramienta relativamente compleja y poderosa que:

• permite crear estrategias de opciones complejas y no estándar;
• proporciona más flexibilidad que las opciones estándar;
• requiere una comprensión profunda de los modelos matemáticos;
• es eficaz con una gestión de riesgos adecuada.

Este método resulta especialmente útil cuando necesitamos:

• cobertura de grandes carteras,
• creación de estrategias de opciones exóticas,
• negociar en mercados con baja liquidez de opciones.

A continuación, analizaremos la parte práctica: mantener/reequilibrar posiciones en el activo subyacente utilizando funciones comerciales MQL5.