¿Por qué tarda tanto muchas líneas de código a un precio incluso la más simple de las opciones con QuantLib

Question

He estado buscando en QuantLib estoy tratando de averiguar por qué tengo que escribir mucho código repetitivo, incluso cuando los precios de las "más simples" del Europeo de Opciones de uso de la analítica fórmula Black-Scholes (nota: soy nuevo en la opción de fijación de precios y podría faltar lo que el código siguiente proporciona más allá del libro de texto de la opción de ejemplos de fijación de precios. En otras palabras, si este código se toma en cuenta el "mundo real" opción de cuestiones que sería genial para apuntar esto):

#include <ql/quantlib.hpp>

using namespace QuantLib;

int main(int, char* []) {

// date set up
Calendar calendar = TARGET(); 
Date todaysDate(27, Jan, 2011);
Date settlementDate(27, Jan, 2011);
Settings::instance().evaluationDate() = todaysDate;

// option parameters
Option::Type type(Option::Call);
Real stock = 47;
Real strike = 40;
Spread dividendYield = 0.00;
Rate riskFreeRate = 0.05;
Volatility volatility = 0.20;
Date maturity(27, May, 2011);
DayCounter dayCounter = Actual365Fixed();

boost::shared_ptr<Exercise> 
europeanExercise(new EuropeanExercise(maturity));

Handle<Quote> 
underlyingH(boost::shared_ptr<Quote>(new SimpleQuote(stock)));

// bootstrap the yield/dividend/vol curves
Handle<YieldTermStructure> flatTermStructure(boost::shared_ptr<YieldTermStructure>(
    new FlatForward(
        settlementDate,
        riskFreeRate,
        dayCounter)));

Handle<YieldTermStructure> flatDividendTS(boost::shared_ptr<YieldTermStructure>(
    new FlatForward(settlementDate,
        dividendYield,
        dayCounter)));

Handle<BlackVolTermStructure> flatVolTS(boost::shared_ptr<BlackVolTermStructure>(
    new BlackConstantVol(
        settlementDate,
        calendar,
        volatility,
        dayCounter)));

boost::shared_ptr<StrikedTypePayoff> payoff(
    new PlainVanillaPayoff(
        type,
        strike));

boost::shared_ptr<BlackScholesMertonProcess> bsmProcess(
    new BlackScholesMertonProcess(
        underlyingH,
        flatDividendTS,
        flatTermStructure,
        flatVolTS));

// our option is European-style
VanillaOption europeanOption(
    payoff,
    europeanExercise);

// computing the option price with the analytic Black-Scholes formulae
europeanOption.setPricingEngine(boost::shared_ptr<PricingEngine>(
    new AnalyticEuropeanEngine(
        bsmProcess)));

// outputting
std::cout << "Option type = " << type << std::endl;
std::cout << "Maturity = " << maturity << std::endl;
std::cout << "Stock price = " << stock << std::endl;
std::cout << "Strike = " << strike << std::endl;
std::cout << "Risk-free interest rate = " << io::rate(riskFreeRate) << std::endl;
std::cout << "Dividend yield = " << io::rate(dividendYield) << std::endl;
std::cout << "Volatility = " << io::volatility(volatility) <<  std::endl << std::endl;
std::cout<<"European Option value = " << europeanOption.NPV() << std::endl;
return 0;
}

Answer 1

He estado usando QuantLib por un buen rato. Permítanme compartir con ustedes algunas experiencias:

QuantLib es un sofisticado marco cuantitativo. Se puede hacer mucho y mucho más que un simple precio de la opción Europea. Por ejemplo, en tu ejemplo, usted podría haber cambiado la rentabilidad de los binarios de la rentabilidad o dar un monte-carlo de precios de motor (en lugar de AnalyticEuropeanEngine).

Es complicado porque la biblioteca está diseñado para la flexibilidad y poderes, no la sencillez. El QuantLib equipo hace que los inteligentes Orientados a Objetos y C++ plantillas. Lo que se ve en el código ya está bastante avanzada.

Para apreciar el diseño, ¿qué haría usted si desea incorporar volatilidad estocástica en el modelo? Te gustaría modificar:

1. boost::shared_ptr < BlackScholesMertonProcess > para apuntar a algún otro proceso estocástico

2. Pasar un diferente precio motor de setPricingEngine()

Se puede ver el patrón? Fijación de precios con un modelo estocástico es altamente matemático exige, pero la codificación actual sería bastante simple. Nos gustaría simplemente necesita dar precios diferentes y un motor de diferentes procesos estocásticos.

Entiendo que estaban un poco preocupados porque estaban a la espera de una forma mucho más simple de precios código. Sin embargo, el mundo real de precios código no suele ser tan simple como se puede ver en el libro de texto. Un mundo real de precios de la biblioteca necesita para manejar el calendario, el día de conteo, fechas y muchos más. QuantLib debe ser capaz de hacer todo de forma coherente. Si usted piensa que QuantLib es difícil de aprender, intentar OpenGamma...

Por supuesto, esto es un poco excesivo para una simple libro de texto Europeo de precios de opciones. Si yo era el doctor Ballabio, me gustaría escribir un simple envoltorio.

Esencialmente, los poderes de Quantlib viene cuando te sumerjas más en finanzas cuantitativas.

EDITADO por el comentario:

Usted puede el precio de una opción como una calculadora en QuantLib. Yo no lo hago porque considero que es demasiado bajo nivel (también hay días-a contar), pero es posible.

Por ejemplo, el precio de una opción Europea como un libro de texto, tendría que mirar en BlackScholesCalculator (https://github.com/lballabio/quantlib/blob/2a5c086844775b6c1b986df2a5631d2ba3b1e6a4/QuantLib/ql/pricingengines/blackscholescalculator.hpp)

Esto es tan simple como usted puede conseguir en QuantLib. Si usted está buscando para la fijación de precios código, yo te recomiendo OptionMatrix. Es como un libro de cocina para las finanzas cuantitativas.

Answer 2

Y no te olvides de que no son contenedores como eq RQuantLib que yo uso en la línea de comandos aquí:

edd@max:~$ r -l RQuantLib -e 'print(EuropeanOption("call", 47, 40, 0.05, 0.0, 4/12, 0.2))'
    Concise summary of valuation for EuropeanOption 
       value    delta    gamma     vega    theta      rho   divRho 
      6.4728   0.8899   0.0307   4.5139   0.7372  11.7849 -13.9425 
    edd@max:~$ 

donde 4/12 es rápida y sucia para la madurez. Que debe recoger su ejemplo.

En una R de símbolo de sistema, se ve un poco más natural:

R> library(RQuantLib)
R> ans <- EuropeanOption("call", 47, 40, 0.05, 0.0, 4/12, 0.2)
R> ans
Concise summary of valuation for EuropeanOption 
   value    delta    gamma     vega    theta      rho   divRho 
  6.4728   0.8899   0.0307   4.5139   0.7372  11.7849 -13.9425 
R> str(ans)
List of 7
 $ value : num 6.47
     $ delta : num 0.89
 $ gamma : num 0.0307
     $ vega  : num 4.51
 $ theta : num 0.737
     $ rho   : num 11.8
 $ divRho: num -13.9
 - attr(*, "class")= chr [1:2] "EuropeanOption" "Option"
R> 

Esto demuestra tanto el resultado de la moratoria print método así como los componentes del objeto devuelto.

Answer 3

Para añadir a la T de Student de la respuesta, que yo segundo: el complejo de instalación empieza a hacer sentido (y su costo se presenta amortizado) una vez que empiece a mantener los instrumentos en lugar de tirarlas a la basura después de la fijación de precios.

Por ejemplo, una vez que la opción anterior está construido, puede cambiar el precio de mercado del subyacente (o su volatilidad, o la tasa libre de riesgo) con sólo la creación de un nuevo valor a la correspondiente comilla, y la opción de actualización de su precio en consecuencia. Puede ver un ejemplo de esto en https://www.youtube.com/watch?v=__PBUqjCy6E, que también muestra el cambio del motor de T de Student sugerido; el código en Python, pero puede ser fácilmente traducido a C++.

Como la sugerencia de un contenedor simple: en lugar de escribir eso y tiene que llamar al marco, me gustaría ir a otro lado y tratar de extraer de un simple núcleo funcional que el marco de la llamada. Pero, ¿cómo hacer eso y seguir siendo compatible con el código actual es todavía un problema abierto...

Answer 4

Usted también debe usar make_shared() en lugar de llamar a new. Ver

https://stackoverflow.com/questions/20895648/difference-in-make-shared-and-normal-shared-ptr-in-c