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 and another at time . (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: American Options. Up: Binomial option pricing. Previous: Introduction   Contents   Index
Bernt Arne Odegaard
1999-09-09