# 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.

• When I read throught europeanoption.cpp in the examples directory, it's the spot. – HelloWorld Nov 17 '14 at 7:27
• I see, but in that example BlackProcess is not actually used: on the contrary, BlackScholesMertonProcess is taken, for which using spot as $x_{0}$ is theoretically correct. – Lisa Ann Nov 17 '14 at 8:46

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.
• "[...] The BlackProcess class assumes there's no dividend yield", there is the answer. My belief was that $x_{0}$ was the forward price, the engine made all "forward" calculations (taking cost of carry implicitly into account) and lastly used risk free TS to discount prices. Actually, I was wrong. Please, wait for me checking calculations under BlackScholesMertonProcess process with a dividend yield TS before accepting your kind answer. I guess such a TS should contain annual dividend yields, like an interest rate TS (constructor asks for an Handle< YieldTermStructure > for both). – Lisa Ann Nov 17 '14 at 10:08