Steven R. Dunbar
Department of Mathematics
203 Avery Hall
University of Nebraska-Lincoln
Lincoln, NE 68588-0130
Voice: 402-472-3731
Fax: 402-472-8466

Stochastic Processes and
Advanced Mathematical Finance


Implied Volatility


Note: These pages are prepared with MathJax. MathJax is an open source JavaScript display engine for mathematics that works in all browsers. See for details on supported browsers, accessibility, copy-and-paste, and other features.




Mathematically Mature: may contain mathematics beyond calculus with proofs.


Section Starter Question

Section Starter Question

What are some methods you could use to find the solution of f(x) = c for x where f is a function that is so complicated that you cannot use elementary functions and algebraic operations to isolate x ?


Key Concepts

Key Concepts

  1. We estimate historical volatility by applying the standard deviation estimator from statistics to the observations ln(SiSi1).
  2. We deduce implied volatility by numerically solving the Black-Scholes formula for σ.




  1. Historical volatility of a security is the variance of the changes in the logarithm of the price of the underlying asset, obtained from past data.
  2. Implied volatility of a security is the numerical value of the volatility parameter that makes the market price of an option equal to the value from the Black-Scholes formula.


Mathematical Ideas

Mathematical Ideas

Historical volatility

Estimates of historical volatility of security prices use statistical estimators, usually one of the estimators of variance. A main problem for historical volatility is to select the sample size, or window of observations, used to estimate σ2. Different time-windows usually give different volatility estimates. Furthermore, for some customized “over the counter” derivatives the necessary price data may not exist.

Another problem with historical volatility is that it assumes future market performance is the same as past market data. Although this is a natural scientific assumption, it does not take into account historical anomalies such as the October 1987 stock market drop that may be unusual. That is, computing historical volatility has the usual statistical difficulty of how to handle outliers. The assumption that future market performance is the same as past performance also does not take into account underlying changes in the market such as new economic conditions.

To estimate the volatility of a security price empirically observe the security price at regular intervals, such as every day, every week, or every month. Define:

We are modeling the security price as a Geometric Brownian Motion, so that ln(Si) ln(Si1) N(rτ,σ2τ).

Inverting ui = ln(SiSi1) to obtain Si = Si1eui, we see that ui is the continuously compounded return (not annualized) in the ith interval. Then the usual estimate s of the standard deviation of the uis is

s = 1 n 1 i=1n(ui ū)2

where ū is the mean of the ui’s. Sometimes it is more convenient to use the equivalent formula

s = 1 n 1 i=1nui2 1 n(n 1) i=1nui 2.

We assume the security price varies as a Geometric Brownian Motion. That means that the logarithm of the security price is a Wiener process with some drift and on the period of time τ, would have a variance σ2τ. Therefore, s is an estimate of στ. It follows that σ can be estimated as

σ s τ.

Choosing an appropriate value for n is not obvious. Remember the variance expression for Geometric Brownian Motion is an increasing function of time. If we model security prices with Geometric Brownian Motion, then σ does change over time, and data that are too old may not be relevant for the present or the future. A compromise that seems to work reasonably well is to use closing prices from daily data over the most recent 90 to 180 days. Empirical research indicates that only trading days should be used, so days when the exchange is closed should be ignored for the purposes of the volatility calculation [2, page 215].

Economists and financial analysts often estimate historical volatility with more sophisticated statistical time series methods.

Implied Volatility

The implied volatility is the parameter σ in the Black-Scholes formula that would give the option price that is observed in the market, all other parameters being known.

The Black-Scholes formula is too complicated to “invert” to explicitly express σ as a function of the other parameters. Therefore, we use numerical techniques to implicitly solve for σ. A simple idea is to use the method of bisection search to find σ.


Suppose the value C of a call on a non-dividend-paying security is 1.85 when S = 21, K = 20, r = 0.10, and T t = 0.25 and σ is unknown. We start by arbitrarily guessing σ = 0.20. The Black-Scholes formula gives C = 1.7647, which is too low. Since C is a increasing function of σ, this suggests we try a value of σ = 0.30. This gives C = 2.1010, too high, so we bisect the interval [0.20, 0.30] and try σ = 0.25. This value of σ gives a value of C = 1.9268, still too high. Bisect the interval [0.20, 0.25] and try a value of σ = 0.225, which yields C = 1.8438, slightly too low. Try σ = 0.2375, giving C = 1.8849. Finally try σ = 0.23125 giving C = 1.8642. To 2 significant digits, the significance of the data, σ = 0.23, with a predicted value of C = 1.86.


Figure 1: Schematic diagram of using Newton’s Method to solve for implied volatility. The current call option value is plotted in blue. The value of the call option as a function of σ is plotted in black. The tangent line is plotted in red

Another procedure is to use Newton’s method which is also iterative. Essentially we are trying to solve

f(σ,S,K,r,T t) C = 0,

so from an initial guess σ0, we form the Newton iterates

σi+1 = σi f(σi)(df(σi)dσ).

See Figure 1. Using Newton’s method means one has to differentiate the Black-Scholes formula with respect to σ. This derivative is one of the “greeks” known as vega which we will look at more extensively in the next section. A formula for vega for a European call option is

df dσ = ST tΦ(d 1) exp(r(T t)).

A natural way to do the iteration is with a computer program rather than by hand.

Implied volatility is a “forward-looking” estimation technique, in contrast to the “backward-looking” historical volatility. That is, it incorporates the market’s expectations about the prices of securities and their derivatives, or more concisely, market expectations about risk. More sophisticated combinations and weighted averages combining estimates from several different derivative claims can be developed.


This section is adapted from: Quantitative modeling of Derivative Securities by Marco Avellaneda, and Peter Laurence, Chapman and Hall, Boca Raton, 2000, page 66; and Options, Futures, and other Derivative Securities second edition, by John C. Hull, Prentice Hall, 1993, pages 229–230.


Algorithms, Scripts, Simulations

Algorithms, Scripts, Simulations


First define the function f = V C C as a function of σ and parameters S, K, r, T t, and C. Next define the derivative of f with respect to σ. For given numerical values for σ0, the guess for the volatility; S, the current security price; K, the strike price; r, the risk-free interest rate; T t, the time to expiration; and C, the current call option price, the script uses Newton’s method to find the implied volatility with error tolerance 𝜖. The implied volatility is the value of σ which makes f 0 to within 𝜖. The Newton’s method iteration uses a “repeat–until” loop construction which means that at least one iteration of the loop is computed.



R script for implied volatility..

2f <- function(sigma, S, K, r, Tminust, C) { 
3  d1 <- (log(S/K) + ( (r + sigma^2/2)*(Tminust)))/(sigma*sqrt(Tminust)); 
4  d2 <- (log(S/K) + ( (r - sigma^2/2)*(Tminust)))/(sigma*sqrt(Tminust)); 
5  part1 <- pnorm(d1) * S; 
6  part2 <- K*exp(-r*(Tminust)) * pnorm(d2); 
7  VC <- part1 - part2; 
8  f <- VC - C; 
9  f 
12fprime <- function(sigma, S, K, r, Tminust, C) { 
13  d1 <- (log(S/K) + ( (r + sigma^2/2)*(Tminust)))/(sigma*sqrt(Tminust)); 
14  fprime <- S*sqrt(Tminust)*dnorm(d1)*exp(-r*Tminust); 
15  fprime 
18S <- 21; 
19K <- 20; 
20Tminust <- 0.25; 
21r <- 0.10; 
22C <- 1.85; 
24sigmaNew <- 0.20; 
25epsilon <- 10^(-5); 
27repeat { 
28  sigmaOld <- sigmaNew; 
29  sigmaNew <- sigmaOld - f(sigmaOld, S, K, r, Tminust, C)/fprime(sigmaOld, S, K, r, Tminust); 
30  if ( abs( sigmaNew - sigmaOld ) < epsilon ) { 
31    break; 
32  } 
35cat(sprintf("%f\n", sigmaNew));

Octave script for implied volatility..

1# Prevent Octave from thinking that this 
2# is a function file: 
6function retval = f(sigma, S, K, r, Tminust, C) 
7  d1 = (log(S/K) + ( (r + sigma.^2/2)*(Tminust)))./(sigma*sqrt(Tminust)); 
8  d2 = (log(S/K) + ( (r - sigma.^2/2)*(Tminust)))./(sigma*sqrt(Tminust)); 
9  part1 = normcdf(d1) * S; 
10  part2 = K*exp(-r*(Tminust)) * normcdf(d2); 
11  VC = part1 - part2; 
12  retval = VC - C; 
15function retval = fprime(sigma, S, K, r, Tminust, C) 
16  d1 = (log(S/K) + ( (r + sigma^2/2)*(Tminust)))./(sigma*sqrt(Tminust)); 
17  retval = S*sqrt(Tminust)*normpdf(d1)*exp(-r*Tminust); 
20S = 21; 
21K = 20; 
22Tminust = 0.25; 
23r = 0.10; 
24C = 1.85; 
27sigmaNew = 0.20; 
28epsilon = 10^(-5); 
31  sigmaOld = sigmaNew; 
32  sigmaNew = sigmaOld - f(sigmaOld, S, K, r, Tminust, C)/fprime(sigmaOld, S, K, r, Tminust); 
33until ( abs( sigmaNew - sigmaOld ) < epsilon ) 

Perl PDL script for implied volatility..

2use PDL::NiceSlice; 
3use PDL::Constants qw(PI); 
5sub pnorm { 
6    my ( $x, $sigma, $mu ) = @_; 
7    $sigma = 1 unless defined($sigma); 
8    $mu    = 0 unless defined($mu); 
10    return 0.5 * ( 1 + erf( ( $x - $mu ) / ( sqrt(2) * $sigma ) ) ); 
13sub dnorm { 
14    my ( $x ) = @_; 
15    return (1/sqrt(2*PI))*exp(-$x**2/2); 
18sub f { 
19  my ($sigma, $S, $K, $r, $Tminust, $C) = @_; 
20  $d1 = (log($S/$K) + ( ($r + $sigma**2/2)*($Tminust)))/($sigma*sqrt($Tminust)); 
21  $d2 = (log($S/$K) + ( ($r - $sigma**2/2)*($Tminust)))/($sigma*sqrt($Tminust)); 
22  $part1 = pnorm($d1) * $S; 
23  $part2 = $K*exp(-$r*($Tminust)) * pnorm($d2); 
24  $VC = $part1 - $part2; 
26  return $VC - $C; 
29sub fprime{ 
30    my ($sigma, $S, $K, $r, $Tminust, $C) = @_; 
31    $d1 = (log($S/$K) + ( ($r + $sigma**2/2)*($Tminust)))/($sigma*sqrt($Tminust)); 
33    return $S*sqrt($Tminust)*dnorm($d1)*exp(-$r*$Tminust); 
36$S = 21; 
37$K = 20; 
38$Tminust = 0.25; 
39$r = 0.10; 
40$C = 1.85; 
42$sigmaNew = 0.10; 
43$epsilon = 10**(-5); 
45do { 
46  $sigmaOld = $sigmaNew; 
47  $sigmaNew = $sigmaOld - f($sigmaOld, $S, $K, $r, $Tminust, $C)/fprime($sigmaOld, $S, $K, $r, $Tminust); 
48} until ( abs( $sigmaNew - $sigmaOld ) < $epsilon ); 
50print $sigmaNew, "\n";

Scientific Python script for implied volatility..

2import scipy 
4from scipy.stats import norm 
6def f(sigma, S, K, r, Tminust, C): 
8    logSoverK = scipy.log(S/K) 
9    n12 = ((r + sigma**2/2)*Tminust) 
10    n22 = ((r - sigma**2/2)*Tminust) 
11    numerd1 = logSoverK + n12 
12    numerd2 = logSoverK + n22 
13    d1 = numerd1/(sigma*scipy.sqrt(Tminust)) 
14    d2 = numerd2/(sigma*scipy.sqrt(Tminust)) 
15    part1 = norm.cdf(d1) * S 
16    part2 = K*scipy.exp(-r*(Tminust)) * norm.cdf(d2) 
17    VC = part1 - part2 
18    return VC - C 
20def fprime(sigma, S, K, r, Tminust, C): 
22    logSoverK = scipy.log(S/K) 
23    n12 = ((r + sigma**2/2)*Tminust) 
24    numerd1 = logSoverK + n12 
25    d1 = numerd1/(sigma*scipy.sqrt(Tminust)) 
26    return S*scipy.sqrt(Tminust)*norm.pdf(d1)*scipy.exp(-r*Tminust) 
28S = 21. 
29K = 20. 
30Tminust = 0.25 
31r = 0.10 
32C = 1.85 
34sigmaNew = 0.20 
35epsilon = 10.**(-5) 
37while( True ): 
38    sigmaOld = sigmaNew 
39    sigmaNew = sigmaOld - f(sigmaOld, S, K, r, Tminust, C)/fprime(sigmaOld, S, K, r, Tminust, C) 
40    if ( scipy.absolute( sigmaNew - sigmaOld ) < epsilon ): 
41        break 
43print sigmaNew


Problems to Work

Problems to Work for Understanding

  1. Suppose that the observations on a security price (in dollars) at the end of each of 15 consecutive weeks are as follows: 30.25, 32, 31.125, 30.25, 30.375, 30.625, 33, 32.875, 33, 33.5, 33.5 33.75, 33.5, 33.25. Estimate the security price volatility.
  2. Pick a publicly traded security, obtain a record of the last 90 days of that security’s prices, and compute the historical volatility of the security.
  3. A call option on a non-dividend paying security has a market price of $2.50. The security price is $15, the exercise price is $13, the time to maturity is 3 months, and the risk-free interest rate is 5% per year. Using repeated bisection, what is the implied volatility?
  4. For a particular scripting language of your choice, create a script within that language that will compute implied volatility by repeated bisection.
  5. A call option on a non-dividend paying security has a market price of $2.50. The security price is $15, the exercise price is $13, the time to maturity is 3 months, and the risk-free interest rate is 5% per year. Using Newton’s method, what is the implied volatility?
  6. Sources of financial data on options typically provide information on the current security price on a quote date, a variety of strike prices, the current quote date and the expiration date, the option price and the implied volatility. (Some even provide additional data on the values of the greeks.) However, the risk-free interest rate is not provided. For a particular scripting language of your choice, create a script within that language that will compute the risk-free interest rate by repeated bisection. Compare that computed rate to historical interest rate on U.S. Treasury bonds. For example, on October 1, 2010, a call option on Google stock valued at $525.62 with a strike price of $620 on the expiration date of January 22, 2011 had a price of $4.75 and an implied volatility of 0.2529. What was the risk-free interest rate on that date? What was the interest rate on U.S. Treasury bonds on that date?



Reading Suggestion:


[1]   Marco Allavenada and Peter Laurence. Quantitative Modeling of Derivative Securities. Chapman and Hall, 2000. HG 6024 A3A93 2000.

[2]   John C. Hull. Options, Futures, and other Derivative Securities. Prentice-Hall, second edition, 1993. economics, finance, HG 6024 A3H85.



Outside Readings and Links:

  1. Peter Hoadley, Options Strategy Analysis Tools. has a Historic Volatility Calculator that calculates and graphs historic volatility using historical price data retrieved from Submitted by Bashar Al-Salim, Dec. 2, 2003.
  2. Analysis of asset allocation. A calculator to compute implied volatility using Black and Scholes. Submitted by Bashar Al-Salim, Dec. 2, 2003.
  3. MindXpansion,a Tool for Option Traders. This option calculator packages an enormous amount of functionality onto one screen, calculating implied volatility or historical volatility with Midas Touch. Submitted by Chun Fan, Dec. 3, 2003.


I check all the information on each page for correctness and typographical errors. Nevertheless, some errors may occur and I would be grateful if you would alert me to such errors. I make every reasonable effort to present current and accurate information for public use, however I do not guarantee the accuracy or timeliness of information on this website. Your use of the information from this website is strictly voluntary and at your risk.

I have checked the links to external sites for usefulness. Links to external websites are provided as a convenience. I do not endorse, control, monitor, or guarantee the information contained in any external website. I don’t guarantee that the links are active at all times. Use the links here with the same caution as you would all information on the Internet. This website reflects the thoughts, interests and opinions of its author. They do not explicitly represent official positions or policies of my employer.

Information on this website is subject to change without notice.

Steve Dunbar’s Home Page,

Email to Steve Dunbar, sdunbar1 at unl dot edu

Last modified: Processed from LATEX source on August 12, 2016