LINEBURG


<< . .

 9
( 20)



. . >>

double S=50.0; double K=40.0;
double r=0.05; double q=0.02;
double sigma=0.05;
double price = option price american perpetual call(S,K,r,q,sigma);
cout << " perpetual call price = " << price << endl;
};


provides the output
perpetual call price = 19.4767

Example 8.4: Example of pricing of perpetual call

Exercise 9.
1 Such options would be like the classical April fools present, a perpetual zero coupon bond. . .




60
The price for a perpetual american put is
h2
h2 ’ 1 S
K
p
P=
1 ’ h2 h2 K

where
2
1 r’q r’q 1 2r
h2 = ’ ’ ’ +
σ2 σ2 σ2
2 2

1. Implement the calculation of this formula.


8.6 Readings

Hull [2003] and McDonald [2002] are general references. A ¬rst formulation of an analytical call price with
dividends was in Roll [1977]. This had some errors, that were partially corrected in Geske [1979], before
Whaley [1981] gave a ¬nal, correct formula. See Hull [2003] for a textbook summary. Black [1976] is the
original development of the futures option. The original formulations of European foreign currency option
prices are in Garman and Kohlhagen [1983] and Grabbe [1983]. The price of a perpetual put was ¬rst shown
in Merton [1973]. For a perpetual call see McDonald and Siegel [1986]. The notation for perpetual puts and
calls follows the summary in [McDonald, 2002, pg. 393].




61
Chapter 9

Option pricing with binomial approximations
Contents
9.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
9.2 Pricing of options in the Black Scholes setting . . . . . . . . . . . . . . . . . . . 63
9.2.1 European Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
9.2.2 American Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
9.2.3 Estimating partials. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
9.3 Adjusting for payouts for the underlying . . . . . . . . . . . . . . . . . . . . . . 69
9.4 Pricing options on stocks paying dividends using a binomial approximation . 70
9.4.1 Checking for early exercise in the binomial model. . . . . . . . . . . . . . . . . . . 70
9.4.2 Proportional dividends. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
9.4.3 Discrete dividends . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
9.5 Option on futures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
9.6 Foreign Currency options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
9.7 References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76



9.1 Introduction

We have shown binomial calculations given an up and down movement in chapter 5. However, binomial
option pricing can also be viewed as an approximation to a continuous time distribution by judicious choice
of the constants u and d. To do so one has to ask: Is it possible to ¬nd a parametrization (choice of u and
d) of a binomial process

uuS
¨
B
¨¨
¨
¨
¨¨
¨ uS
¨
¨ rr
B
¨¨ r
rr
¨
¨ r
¨¨ r
r
j
S udS
rr ¨
B
¨
¨¨
rr
¨¨
rr
¨

r dS
j
r
rr
r
rr
r ddS
j
r

which has the same time series properties as a (continous time) process with the same mean and volatility?
There is actually any number of ways of constructing this, hence one uses one degree of freedom on imposing
1
that the nodes reconnect, by imposing u = d .
To value an option using this approach, we specify the number n of periods to split the time to maturity
(T ’ t) into, and then calculate the option using a binomial tree with that number of steps.
Given S, X, r, σ, T and the number of periods n, calculate
T ’t
∆t =
n

62

u = eσ ∆t


’σ ∆t
d=e

We also rede¬ne the “risk neutral probabilities”

R = er∆t

R’d
q=
u’d

To ¬nd the option price, will “roll backwards:” At node t, calculate the call price as a function of the two
possible outcomes at time t + 1. For example, if there is one step,


¨ Cu = max(0, Su ’ X)
B
¨¨
¨
¨¨
¨¨0
C
rr
rr
r
rr
r C = max(0, S ’ X)
j
d d



¬nd the call price at time 0 as

C0 = e’r (qCu + (1 ’ q)Cd )

With more periods one will “roll backwards” as discussed in chapter 5


9.2 Pricing of options in the Black Scholes setting

Consider options on underlying securities not paying dividend.

9.2.1 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.
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.

9.2.2 American Options

An American option di¬ers 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.



63
#include <cmath> // standard mathematical library
#include <algorithm> // de¬ning the max() operator
#include <vector> // STL vector templates
using namespace std;

double option price call european binomial( const double& S, // spot price
const double& X, // exercice price
const double& r, // interest rate
const double& sigma, // volatility
const double& t, // time to maturity
const 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); // ¬ll 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 payo¬s 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];
};


Code 9.1: Option price for binomial european


It is in the case of American options, allowing for the possibility of early exercise, that binomial approxima-
tions 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
Code 9.2 illustrates the calculation of the price of an American call. Actually, for this particular case, the
american price will equal the european.




64
#include <cmath> // standard mathematical library
#include <algorithm> // de¬nes the max() operator
#include <vector> // STL vector templates
using namespace std;

double option price call american binomial( const double& S, // spot price
const double& X, // exercice price
const double& r, // interest rate
const double& sigma, // volatility
const double& t, // time to maturity
const 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); // ¬ll 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 payo¬s 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];
};


Code 9.2: Binomial option price american opstion



The program


void test binomial approximations option pricing(){
double S = 100.0; double K = 100.0;
double r = 0.1; double sigma = 0.25;
double time=1.0;
int no steps = 100;
cout << " european call = "
<< option price call european binomial(S,K,r,sigma,time,no steps)
<< endl;
cout << " american call = "
<< option price call american binomial(S,K,r,sigma,time,no steps)
<< endl;
};


provides the output
european call = 14.9505
american call = 14.9505

Example 9.1: Option pricing using binomial approximations



65
9.2.3 Estimating partials.

It is always necessary to calculate the partial derivatives as well as the option price.
The binomial methods gives us ways to approximate these as well. How to ¬nd them in the binomial case
are described in Hull [2003]. The code below is for the non“dividend case.

Delta , the derivative of the option price with respect to the underlying.

#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;

double option price delta american call binomial(const double& S,
const double& X,
const double& r,
const double& sigma,
const double& t,
const int& no steps){ // steps in binomial
vector<double> prices (no steps+1);
vector<double> call values (no steps+1);
double R = exp(r*(t/no steps));
double Rinv = 1.0/R;
double u = exp(sigma*sqrt(t/no steps));
double d = 1.0/u;
double uu= u*u;
double pUp = (R’d)/(u’d);
double pDown = 1.0 ’ pUp;
prices[0] = S*pow(d, no steps);
int i;
for (i=1; i<=no steps; ++i) prices[i] = uu*prices[i’1];
for (i=0; i<=no steps; ++i) call values[i] = max(0.0, (prices[i]’X));
for (int CurrStep=no steps’1 ; CurrStep>=1; ’’CurrStep) {
for (i=0; i<=CurrStep; ++i) {
prices[i] = d*prices[i+1];
call values[i] = (pDown*call values[i]+pUp*call values[i+1])*Rinv;
call values[i] = max(call values[i], prices[i]’X); // check for exercise
};
};
double delta = (call values[1]’call values[0])/(S*u’S*d);
return delta;
};


Code 9.3: Delta


Other hedge parameters.




66
#include <cmath>
#include <algorithm>
#include "fin_recipes.h"

void option price partials american call binomial(const double& S, // spot price
const double& X, // Exercise price,
const double& r, // interest rate
const double& sigma, // volatility
const double& time, // time to maturity
const int& no steps, // steps in binomial
double& delta, // partial wrt S
double& gamma, // second prt wrt S
double& theta, // partial wrt time
double& vega, // partial wrt sigma
double& rho){ // partial wrt r
vector<double> prices(no steps+1);
vector<double> call values(no steps+1);
double delta t =(time/no steps);
double R = exp(r*delta t);
double Rinv = 1.0/R;
double u = exp(sigma*sqrt(delta t));
double d = 1.0/u;
double uu= u*u;
double pUp = (R’d)/(u’d);
double pDown = 1.0 ’ pUp;
prices[0] = S*pow(d, no steps);
for (int i=1; i<=no steps; ++i) prices[i] = uu*prices[i’1];
for (int i=0; i<=no steps; ++i) call values[i] = max(0.0, (prices[i]’X));
for (int CurrStep=no steps’1; CurrStep>=2; ’’CurrStep) {
for (int i=0; i<=CurrStep; ++i) {
prices[i] = d*prices[i+1];
call values[i] = (pDown*call values[i]+pUp*call values[i+1])*Rinv;
call values[i] = max(call values[i], prices[i]’X); // check for exercise
};
};
double f22 = call values[2];
double f21 = call values[1];
double f20 = call values[0];
for (int i=0;i<=1;i++) {

<< . .

 9
( 20)



. . >>

Copyright Design by: Sunlight webdesign