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: Estimating partials. Up: Binomial option pricing. Previous: European Options.   Contents   Index
Bernt Arne Odegaard
1999-09-09