Fijación del precio de una opción sobre divisas americanas con Quantlib

Question

Necesito orientación para valorar opciones FX estilo americano (spot y forwards) usando quantlib en Python. Dados los siguientes parámetros:

1. Tipos nacionales y extranjeros sin riesgo
2. Puntos al contado y a plazo actuales del mercado para el activo subyacente (vencimiento en la fecha de ejercicio de la opción más tenor) - aparte, ¿se adelanta el vencimiento en caso de ejercicio anticipado de la opción?
3. Volatilidad aproximada del subyacente (utilizando precios históricos)
4. Precio de ejercicio
5. Fecha de expiración
6. Fecha de vencimiento

Esto es lo que he probado hasta ahora:

 # QuantLib date settings
        todayDate = ql.Date().todaysDate()
        ql.Settings.instance().evaluationDate = todayDate
        dayCount = ql.ActualActual()

        volatilityHandle = ql.BlackVolTermStructureHandle(
            ql.BlackConstantVol(todayDate, ql.NullCalendar(), ql.QuoteHandle(ql.SimpleQuote(req.Volatility)), dayCount)
        )

        # define the option
        option = ql.VanillaOption(
            ql.PlainVanillaPayoff(ql.Option.Call, req.StrikePrice), ql.AmericanExercise(req.ExpirationDate)
        )

        # build the process
        localInterestRateHandle = ql.YieldTermStructureHandle(
            ql.FlatForward(todayDate, req.LocalInterestRate / 100, dayCount)
        )
        # this is the one big issue - for FX options, both the domestic and 
        # foreign risk-free rates have to be considered, but the 
        # BlackScholesProcess does not cater for this.
        # foreignInterestRateHandle = ql.YieldTermStructureHandle(
        #     ql.FlatForward(todayDate, req.ForeignInterestRate / 100, dayCount)
        # )
        process = ql.BlackScholesProcess(
            ql.QuoteHandle(ql.SimpleQuote(req.SpotPrice + req.ForwardPoints)),
            localInterestRateHandle,
            volatilityHandle,
        )

        # set the pricing engine
        option.setPricingEngine(ql.MCAmericanEngine(process, "pseudorandom", timeSteps=100, requiredSamples=1000))
        return GetOptionValueResponse(OptionValue=option.NPV())

El mayor problema es que (como se ha comentado), el BlackScholesProcess no tiene en cuenta las RFR nacionales y extranjeras. El sitio GarmanKohlagenProcess funciona para las opciones europeas, pero no he visto un proceso similar para las opciones americanas.

Para mayor claridad, esta es la clase de solicitud que se pasa a la función:

@dataclass
class GetOptionValueRequest:
    """The request parameters of the GetEuropeanOptionValue service."""

    SpotPrice: float
    """The latest spot price of the underlying asset."""
    ForwardPoints: float
    """The latest forward points of the underlying asset."""
    StrikePrice: float
    """The strike price of the option."""
    ExpirationDate: date
    """The expiration date of the option in days."""
    LocalInterestRate: float
    """The risk-free interest rate of the local currency as a percentage"""
    ForeignInterestRate: float
    """The risk-free interest rate of the foreign currency as a percentage"""
    Volatility: float
    """The volatility of the underlying asset"""

Answer 1

En GarmanKohlagenProcess gestiona tanto las curvas exteriores como las interiores y puede pasarse a todos los motores que soliciten una GeneralizedBlackScholesProcess .

No elegiría MCAmericanEngine Sin embargo, utiliza una simulación Longstaff-Schwarz, y probablemente no necesites esa complejidad y el tiempo de cálculo que requiere. Probablemente sea mejor utilizar un árbol binomial (con un motor como BinomialCRRVanillaEngine o uno de los siguientes los demás enumerados aquí ) o un modelo de diferencias finitas (con el FdBlackScholesVanillaEngine ).

Sin embargo, me temo que VanillaOption sólo modelos spot opciones.