next up previous contents index
Next: American Options. Up: Binomial option pricing. Previous: Introduction   Contents   Index

Subsections

European Options.

For European options, binomial trees are not that much used, since the Black Scholes model will give the correct answer, but it is useful to see the construction of the binomial tree without the checks for early exercise, which is the American case.

Computer algorithm.

The computer algorithm for a binomial in the following merits some comments. There is only one vector of call prices, and one may think one needs two, one at time $t$ and another at time $t+1$. (Try to write down the way you would solve it before looking at the algorithm below.) But by using the fact that the branches reconnect, it is possible to get away with the algorithm below, using one less array. You may want to check how this works. It is also a useful way to make sure one understands binomial option pricing.



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

#include <cmath>             // standard mathematical library
#include <algorithm>             // defining the max() operator
#include <vector>           // STL vector templates
    
double option_price_call_european_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
   prices[0] = S*pow(d, steps);  // fill in the endnodes.
   for (int i=1; i<=steps; ++i) prices[i] = uu*prices[i-1];
   vector<double> call_values(steps+1);       // value of corresponding call 
   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;
      };
   };
   return call_values[0];
};



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