Sensibilidad a las opciones asiáticas

Question

Estoy buscando algunos materiales para perfilar todas las sensibilidades de opciones para opciones asiáticas tanto con promedios geométricos como con promedios aritméticos . El precio subyacente $S_t$ sigue un GBM estándar.

¿Hay algún sitio donde buscar?

Answer 1

Para la Opción Asiática de Media Geométrica en BS, existe una fórmula aritmética para el precio - de hecho, es posible fijar el precio utilizando una calculadora de opciones vainilla de BS, si se ajustan ligeramente los parámetros - tal y como se comenta en esta entrada del blog: http://www.quantopia.net/asian-options-iii-geometric-asian/

Como la fórmula de fijación de precios es la misma, las griegas se pueden derivar de la misma manera que BS, aunque hay que tener un poco de cuidado con los términos de la regla de la cadena (y se puede comprobar la corrección saltando los parámetros directamente y calculando la diferencia a partir de la fórmula de fijación de precios).

Para un asiático aritmético, es necesario utilizar una técnica numérica como Monte Carlo para calcular los precios o las griegas. Sin embargo, ambos estarán próximos al precio geométrico y a las griegas, por lo que pueden utilizarse como aproximación directa o como variante de control en el cálculo MC.

-- EDITAR --

Añadiendo algo de código QuantLib aquí para calcular los deltas. Es necesario incluir el fragmento largo en la parte inferior para configurar el entorno, pero lo he puesto en la parte inferior para no interrumpir el flujo.

En primer lugar, las opciones geométricas pueden valorarse analíticamente, y QL proporciona los precios y las griegas del valorador analítico:

asian_geo_analytic_pricer = ql.AnalyticDiscreteGeometricAveragePriceAsianEngine(process_initial)
asian_option_geometric.setPricingEngine(asian_geo_analytic_pricer)

print(asian_option_geometric.NPV())
print(asian_option_geometric.delta())

También podemos usar MC, pero necesitaremos usar dos procesos, uno con un punto ligeramente bacheado. También es importante garantizar una semilla constante, o utilizar números de discrepancia bajos, para garantizar que la fijación de precios se produzca por los mismos caminos:

rng = "pseudorandom" # could use "lowdiscrepancy"
numPaths = 100000
seed = 43

results = []

for process in [process_initial, process_bumped]:
    asian_geo_mc_pricer = ql.MCDiscreteGeometricAPEngine(process, rng, requiredSamples=numPaths, seed=seed)
    asian_arith_mc_pricer = ql.MCDiscreteArithmeticAPEngine(process, rng, requiredSamples=numPaths, seed=seed)

    asian_option_geometric.setPricingEngine(asian_geo_mc_pricer)
    asian_option_artithmetic.setPricingEngine(asian_arith_mc_pricer)

    results.append({'geometric': asian_option_geometric.NPV(), 'arithmetic': asian_option_artithmetic.NPV()})

df = pd.DataFrame(results).transpose()
df['delta'] = (df[1] - df[0]) / delta
df

Como vemos, el delta geométrico coincide perfectamente con el valor analítico, y el aritmético es ligeramente superior, como cabía esperar.

Establecimiento del cálculo:

import QuantLib as ql
import numpy as np
import pandas as pd

# World State for Vanilla Pricing
vol = 0.1
rate = 0.0
strike = 100

today = ql.Date(1, 7, 2020)

# Set up the vol and risk-free curves
volatility = ql.BlackConstantVol(today, ql.NullCalendar(), vol, ql.Actual365Fixed())
riskFreeCurve = ql.FlatForward(today, rate, ql.Actual365Fixed())

flat_ts = ql.YieldTermStructureHandle(riskFreeCurve)
dividend_ts = ql.YieldTermStructureHandle(riskFreeCurve)
flat_vol = ql.BlackVolTermStructureHandle(volatility)

# And define the options
past_fixings = 0 # Empty because this is a new contract
asian_fixing_dates = [ql.Date(1, 1, 2021), ql.Date(1, 7, 2021), ql.Date(1, 1, 2022), ql.Date(1, 7, 2022)]
asian_expiry_date = ql.Date(1, 7, 2022)

vanilla_payoff = ql.PlainVanillaPayoff(ql.Option.Call, strike)
european_exercise = ql.EuropeanExercise(asian_expiry_date)

average_geo = ql.Average().Geometric
average_arit = ql.Average().Arithmetic

asian_option_geometric = ql.DiscreteAveragingAsianOption(average_geo, 1.0, past_fixings, asian_fixing_dates, vanilla_payoff, european_exercise)
asian_option_artithmetic = ql.DiscreteAveragingAsianOption(average_arit, 0.0, past_fixings, asian_fixing_dates, vanilla_payoff, european_exercise)

# Set up two vol processes, with the spot bumped, for MC delta calculations
delta = 0.001
spot = 100

process_initial = ql.BlackScholesMertonProcess(ql.QuoteHandle(ql.SimpleQuote(spot)), dividend_ts, flat_ts, flat_vol)
process_bumped = ql.BlackScholesMertonProcess(ql.QuoteHandle(ql.SimpleQuote(spot+delta)), dividend_ts, flat_ts, flat_vol)