next up previous contents index
Next: Estimating partials. Up: Binomial option pricing. Previous: European Options.   Contents   Index

American Options.

An American option differs from an European option by the exercise possibility. An American option can be exercised at any time up to the maturity date, unlike the European option, which can only be exercised at maturity. In general, there is unfortunately no analytical solution to the American option problem, but in some cases it can be found. For example, for an American call option on non-dividend paying stock, the American price is the same as the European call.

It is in the case of American options, allowing for the possibility of early exercise, that binomial approximations are useful. At each node we calculate the value of the option as a function of the next periods prices, and then check for the value exercising of exercising the option now



// file bin_am_call.cc
// author: Bernt A Oedegaard
// calculate the binomial option pricing formula for an American call

#include <cmath>                 // standard mathematical library
#include <algorithm>             // defining the max() operator
#include <vector>                // STL vector templates
    
double option_price_call_american_binomial( double S,     // spot price
					    double X,     // exercice price
					    double r,     // interest rate
					    double sigma, // volatility
					    double t,     // time to maturity
					    int steps) {    // no steps in binomial tree
   double R = exp(r*(t/steps));            // interest rate for each step
   double Rinv = 1.0/R;                    // inverse of interest rate
   double u = exp(sigma*sqrt(t/steps));    // up movement
   double uu = u*u;
   double d = 1.0/u;
   double p_up = (R-d)/(u-d);
   double p_down = 1.0-p_up;
   vector<double> prices(steps+1);       // price of underlying
   vector<double> call_values(steps+1);       // value of corresponding call 

   prices[0] = S*pow(d, steps);  // fill in the endnodes.
   for (int i=1; i<=steps; ++i) prices[i] = uu*prices[i-1];
   for (int i=0; i<=steps; ++i) call_values[i] = max(0.0, (prices[i]-X)); // call payoffs at maturity
   for (int step=steps-1; step>=0; --step) {
      for (int i=0; i<=step; ++i) {
	 call_values[i] = (p_up*call_values[i+1]+p_down*call_values[i])*Rinv;
	 prices[i] = d*prices[i+1];
	 call_values[i] = max(call_values[i],prices[i]-X);       // check for exercise
      };
   };
   return call_values[0];
};



next up previous contents index
Next: Estimating partials. Up: Binomial option pricing. Previous: European Options.   Contents   Index
Bernt Arne Odegaard
1999-09-09