Calculate implied volatility from option premium

Hi, is it possible to calculate an option's implied volatility (&#963 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

 

Sure--that is how the implied volatility surface is calculated. This may be helpful: http://en.wikipedia.org/wiki/Volatility_smile Any trading platform will calculate the implied volatility of an option for you based upon the current price.

 

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.

 

Here you go, from

http://finance.bi.no/~bernt/gcc_prog/index.html

#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;
};

 

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.

 

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.

 

What he said, most applications apply an iterative method to find implied vols

 

better wilmott dis shit

 

Almost always, Newton-Raphson off of a decent initial guess is going to be fastest.

 

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.