Calculate implied volatility from option premium

Discussion in 'Options' started by as586, Jun 19, 2013.

  1. as586


    Hi, is it possible to calculate an option's implied volatility (σ) if the option premium i.e. c, p is known? Im looking at the Black-76 model where:

    c = e -r(T+2/52) [FN(d1) - XN(d2)]

    p = e -r(T+2/52) [XN(- d2) - FN(- d1)]

    d1 = (ln(F/X) + σ2 T)/2 σ √T

    d2 = d1 – σ √T

    Many thanks in advance
  2. Sure--that is how the implied volatility surface is calculated. This may be helpful: Any trading platform will calculate the implied volatility of an option for you based upon the current price.
  3. It's just algebra. Rearrange the forumula so that volatility is on the left and plug in the other values.

    If you know the option price, days to expiry, etc you can solve for IV with a plug and chug.

    If you're hard up you can always just repeatedly plug in different volatility values until the price result is close to the real quote.
  4. Here you go, from

    #include <cmath>
    #include "fin_recipes.h"

    double option_price_implied_volatility_call_black_scholes_bisections(const double& S,
    const double& K,
    const double& r,
    const double& time,
    const double& option_price){
    if (option_price<0.99*(S-K*exp(-time*r))) { // check for arbitrage violations.
    return 0.0; // Option price is too low if this happens

    // simple binomial search for the implied volatility.
    // relies on the value of the option increasing in volatility
    const double ACCURACY = 1.0e-5; // make this smaller for higher accuracy
    const int MAX_ITERATIONS = 100;
    const double HIGH_VALUE = 1e10;
    const double ERROR = -1e40;

    // want to bracket sigma. first find a maximum sigma by finding a sigma
    // with a estimated price higher than the actual price.
    double sigma_low=1e-5;
    double sigma_high=0.3;
    double price = option_price_call_black_scholes(S,K,r,sigma_high,time);
    while (price < option_price) {
    sigma_high = 2.0 * sigma_high; // keep doubling.
    price = option_price_call_black_scholes(S,K,r,sigma_high,time);
    if (sigma_high>HIGH_VALUE) return ERROR; // panic, something wrong.
    for (int i=0;i<MAX_ITERATIONS;i++){
    double sigma = (sigma_low+sigma_high)*0.5;
    price = option_price_call_black_scholes(S,K,r,sigma,time);
    double test = (price-option_price);
    if (fabs(test)<ACCURACY) { return sigma; };
    if (test < 0.0) { sigma_low = sigma; }
    else { sigma_high = sigma; }
    return ERROR;
  5. Black-Scholes is a differential equation, and you can't rearrange it with just algebra to run backward from price to volatility. But numerically, you can get volatility for a given price by probing for it like panzerman's program does.
  6. Haha, apologies to OP. I wasn't at my programming PC when I wrote that.

    I implemented it in C++ in a similar fashion to the code snippet posted earlier. You try different IV values until the calculated option price is close to the market price. You can do it slowly with a linear search or faster with a binary search.
  7. tayte


    What he said, most applications apply an iterative method to find implied vols
  8. better wilmott dis shit
  9. Almost always, Newton-Raphson off of a decent initial guess is going to be fastest.
  10. Yes, but NR is a derivative technique. If the price-volatility curve is relatively smooth, such as European style exercise, fine. If the curve has discontinuities, or inflection points, then NR can blow up.
    #10     Jun 20, 2013