QuantLib BlackProcess Requires Spot Input and Separate Dividend Yield
Summary
The document explains how to supply the initial value to QuantLib’s BlackProcess when pricing European options. The accepted answer clarifies that the process should receive the spot price; the analytic pricing engine derives the forward price from that spot, the risk-free curve, and option maturity. Passing a maturity-specific forward as the process input can therefore lead to an incorrect setup.
The answer also identifies a model limitation: BlackProcess assumes no dividend yield. To represent an implied yield, it recommends a more general process such as BlackScholesMertonProcess with an estimated dividend yield supplied separately. The question reports small, roughly parallel pricing differences against market books for EURO STOXX 50 options, but provides no diagnosis from independently checked inputs or calculations. The explanation is specific to this QuantLib model setup; the source does not quantify the pricing impact or discuss other causes of discrepancies.
Key ideas
- BlackProcess should be initialized with the underlying spot price.
- The analytic European engine computes the forward using the spot, risk-free term structure, and maturity.
- BlackProcess assumes zero dividend yield.
- Use a more general process and supply an estimated dividend yield when modeling implied yield.
Tags
Full text
# BlackProcess' constructor $x_{0}$ argument in QuantLib
# BlackProcess' constructor $x_{0}$ argument in QuantLib
I am currently using BlackProcess to price options and I have a doubt related to the $x_{0}$ argument of the constructor: I've figured out it should be the forward price of the security, because Black's model uses that to take into account e.g. implied dividend yield and in the end it uses risk free term structure to discount options' prices.
This is my snippet of code:
```
// ...
// Exercise
boost::shared_ptr< Exercise > europeanExercise(
new EuropeanExercise(maturity));
// Select underlying price according to maturity date
boost::shared_ptr< Quote > underlyingQ;
for(int i = 0; i < maturityArray_.size(); i++)
{
if(maturity == maturityArray_[i])
{
underlyingQ.reset(new SimpleQuote(forwardPrices[i]));
break;
}
}
if (!underlyingQ)
return -1.0; // Error?
Handle< Quote > underlyingH(underlyingQ);
// Bootstrap interest rates curve
Handle< YieldTermStructure > riskFreeTSH(riskFreeTS);
// Payoff
boost::shared_ptr< StrikedTypePayoff > payoff(
new PlainVanillaPayoff(type, strike));
// Process
boost::shared_ptr< BlackProcess > blackProcess(
new BlackProcess(underlyingH, riskFreeTSH, Handle< BlackVolTermStructure >(forwardVolSurface_)));
// Options
VanillaOption europeanOption(payoff, europeanExercise);
europeanOption.setPricingEngine(boost::shared_ptr< PricingEngine >(
new AnalyticEuropeanEngine(blackProcess)));
//...
```
`maturityArray_` and `forwardPrices` are arrays of the same length that have forward dates and forward prices inside.
As you can see, `underlyingQ` is chosen from an array of forward prices by matching maturity date from `maturityArray_` array, and then used in `BlackProcess` constructor as $x_{0}$: is this correct? Or is $x_{0}$ supposed to be the underlying spot price?
I ask this because pricing some hundreds of options using Bloomberg's inputs (mid implied volatility, implied forward prices and deposit rates curve) returns fair values that are slightly different than what I see on books. I am currently working on EURO STOXX 50® Index Options (OESX) and the kind of pricing error is something like a parallel shift: this suggests me an issue related to term structures, not implied volatilities or other inputs.
## Answer by Luigi Ballabio (score 4, accepted)
https://quant.stackexchange.com/a/15487
The process must contain the spot price. The `AnalyticEuropeanEngine` will take care of calculating the forward price from the data you're passing in the process (in this case spot and risk-free-rate) and the maturity of the option.
As implemented in QuantLib, though, The `BlackProcess` class assumes there's no dividend yield. If you want to model some kind of implied yield, you'll probably have to use a more generic class (such as `BlackScholesMertonProcess`) and pass it the dividend yield you've estimated.Shown in full with attribution under the source's licence. Licence: CC BY-SA 4.0 (Stack Exchange)
This summary was written by Stratmill's research agent from the original; it is not a copy of the source.