29
$\begingroup$

There are many models available for calculating the implied volatility of an American option. The most popular method, employed by OptionMetrics and others, is probably the Cox-Ross-Rubinstein model. However, since this method is numerical, it yields a computationally intensive algorithm which may not be feasible (at least for my level of hardware) for repeated re-calculation of implied volatility on a hundreds of option contracts and underlying instruments with ever-changing prices. I am looking for an efficient and accurate closed form algorithm for calculating implied volatility. Does anyone have any experience with this problem?

The most popular closed-form approximation appears to be Bjerksund and Stensland (2002), which is recommended by Matlab as the top choice for American options, although I've also seen Ju and Zhong (1999) mentioned on Wilmott. I am interested in knowing which of these (or other) methods gives the most reasonable and accurate approximations in a real-world setting.

$\endgroup$
28
$\begingroup$

I have worked on this topic extensively (pricing and calculating IV in production) and believe can offer an informed opinion. First of all Mathworks - the company that creates Matlab is not a trading firm so you should probably not rely on their advice so much.

There are few closed form options pricing models, and all have practical shortcomings. Barone-Adesi and Whaley (please correct my spelling of last names as I'm typing from memory) model is simple approximation for American options but is unfortunately not very accurate, and does not deal with dividends. Roll-Geske-Whaley deals with dividends, but not very well - there are arbitrage situations that are possible in the model. Ju and Zhong have another approximation but again not very accurate. Finally Bjerksund and Stensland seem to have the best approximation (2002 version, not 1993) but that still does not solve the discrete dividend problem.

In my experience the tree is the way to go. CRR trees are slow but Leisen and Reimer, 1995 came up with a scheme that converges much faster. Also Mark Joshi created his own binomial scheme that converges slightly faster. Instead of discrete dividend you can use discrete proportional dividend - so you don't end up with a bushy tree. Alternatively you can try a trinomial tree and extra DF will give you better resolution on dividend, but I did not find that big of an improvement in production. That in my opinion is the best combination for speed and accuracy. If you're looking for alternative opinions check out these two articles - http://www.nccr-finrisk.uzh.ch/media/pdf/ODD.pdf about discrete dividend problem, and http://ssrn.com/abstract=1567218 on pricing American options.

Still the most important speed improvements will come in from your code: one technique that is extensively used in quoting servers is pre-computation. Basically you continuously compute prices for the stock price $\pm 0.1$ and volatility $\pm 0.01$, so when spot or vol moves you used pre-computed cached value (or interpolated from closest values).

$\endgroup$
  • $\begingroup$ Here is a link to the Leisen-Reimer article: u.cs.biu.ac.il/~mschaps/finance/readings/options/… $\endgroup$ – zoom Sep 17 '11 at 18:00
  • $\begingroup$ @zoom, could you please give the work link or full title of article? $\endgroup$ – Nick Nov 15 '16 at 7:31
  • $\begingroup$ What does "extra DF" mean? $\endgroup$ – user357269 Dec 9 '17 at 22:50
  • $\begingroup$ Degree of freedom $\endgroup$ – onlyvix.blogspot.com Dec 11 '17 at 17:49
3
$\begingroup$

If you think it is too computationally intensive, you are probably not using enough numerical analytic "tricks", such as control variates. Using them, you will generally find american option pricing to be faster on trees than with the analytic approximations.

$\endgroup$
  • $\begingroup$ Thanks! Do you know of any good references on control variates? I am not familiar with the technique. What is it, broadly? Are there other techniques? Are any of these already built in to the Matlab CRRTree toolbox function? $\endgroup$ – Tal Fishman Aug 12 '11 at 18:03
  • $\begingroup$ I have not looked at Matlab in a while. For tricks, I suggest Quantitative Methods in Derivatives Pricing by Domingo Tavella. $\endgroup$ – Brian B Aug 12 '11 at 18:09
  • 1
    $\begingroup$ Control variates? He's pricing vanillas, why would he be doing MC? $\endgroup$ – onlyvix.blogspot.com Sep 14 '11 at 17:18
  • $\begingroup$ Control variates are not just for Monte Carlo. $\endgroup$ – Brian B Sep 15 '11 at 19:54
  • 1
    $\begingroup$ @Brian, please elaborate. $\endgroup$ – onlyvix.blogspot.com Mar 4 '12 at 15:33
3
$\begingroup$

I like the fast calibration versus slow calibration method which should suffice for your purposes. The slow calibration method calculates the implied vol and the Greeks in the usual way. Then a fast calibration method can use the prior slow calculation's implied vol, delta, gamma and vega - we can assume rho/theta are zero over your timespan. Then use the price from the slow calibration and this approximation ($P$ is for the option price, $S$ for the underlying, and $\nu$ for vega:

$$P_{t}\approx P_{t-1}+\Delta(S_t-S_{t-1})+0.5\Gamma(S_t-S_{t-1})^2+\nu(\sigma_t-\sigma_{t-1})$$

Everything you need is there to solve for $\sigma_t$ in the fast calibration. Have the slow calibration run in the background and each time it completes, use it as the new benchmark for the fast calibration.

This is still a significant amount of technical work, but doable and almost certainly sufficient for the application. You can probably omit the use of $\Gamma$ over such a short time step, but it is there if you want it. Watch out for bid/ask anomalies too (i.e. pulling bid and putting them back can make the mid vols look like they move a lot when they don't really), but that goes for any method and not just this one.

$\endgroup$
2
$\begingroup$

Without using any tricks or optimization, I wrote some C++ code that prices an American option with 5 different variations of the binomial method, including CRR. It calculates all five prices and prints them on the console seemingly instantly (far less than 1 second; I didn't measure). I would say if your computation is taking long time, the problem is the implementation, not the algorithm.

Recommendation: get something coded specific to your needs. This is high-level form of optimization. For example, if you are usually working in a given time frame to expiration, you can experiment to find out the number of branchings needed to get your target precision. Or, you might use a lower target precision on the full set of contracts, then "zoom" to a higher precision for contracts of interests.

$\endgroup$
0
$\begingroup$

To me this aims at computing a daily implied volatility surface. For some stocks/indices you may have either vanillas options or american options quoted in the market. If your implied volatility is computed from hybrid vanilla/american call/put options then your implied volatility computation methodology should be as close as possible. You should not directly consider approximating here as we would like to stay close to, for instance, a Monte-Carlo local volatility pricing framework where the dividends are detached accurately and so on.

You may want to consider PDE solving in a production environment (with update rule for discrete dividends handling). If well implemented it is fast and well-behaved. You should use Newton-Raphson for high vega zones (close to ATM and more and more widespread for long maturities) and Brent for the rest. Good first guess will speed up the process.

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.