LINEBURG

++

Bernt Arne ˜degaard

December 10, 2003

7.3 Readings . . . . . . . . . . . . . . . . . . . . . . . . 48

8 Extending the Black Scholes formula 50

Contents 8.1 Adjusting for payouts of the underlying. . . . . . . . 50

8.1.1 Continous Payouts from underlying. . . . . . 50

8.1.2 Dividends. . . . . . . . . . . . . . . . . . . . 51

1 On C++ and programming. 4

8.2 American options. . . . . . . . . . . . . . . . . . . . 52

1.1 Compiling and linking ................ 4

8.2.1 Exact american call formula when stock is

1.2 The structure of a C++ program .......... 4

paying one dividend. . . . . . . . . . . . . . 52

1.2.1 Types ..................... 4

8.3 Options on futures .................. 56

1.2.2 Operations . . . . . . . . . . . . . . . . . . . 5

8.3.1 Black™s model . . . . . . . . . . . . . . . . . 56

1.2.3 Functions and libraries . . . . . . . . . . . . 5

8.4 Foreign Currency Options .............. 58

1.2.4 Templates and libraries . . . . . . . . . . . . 6

8.5 Perpetual puts and calls ............... 60

1.2.5 Flow control . . . . . . . . . . . . . . . . . . 6

8.6 Readings . . . . . . . . . . . . . . . . . . . . . . . . 61

1.2.6 Input Output . . . . . . . . . . . . . . . . . 7

1.2.7 Splitting up a program . . . . . . . . . . . . 7 9 Option pricing with binomial approximations 62

1.2.8 Namespaces . . . . . . . . . . . . . . . . . . 8 9.1 Introduction . . . . . . . . . . . . . . . . . . . . . . 62

1.3 Extending the language, the class concept. . . . . . 8 9.2 Pricing of options in the Black Scholes setting ... 63

1.3.1 date, an example class ............ 8 9.2.1 European Options . . . . . . . . . . . . . . . 63

1.4 Const references . . . . . . . . . . . . . . . . . . . . 10 9.2.2 American Options . . . . . . . . . . . . . . . 63

9.2.3 Estimating partials. . . . . . . . . . . . . . . 66

2 The value of time 11

9.3 Adjusting for payouts for the underlying ...... 69

2.1 Present value. . . . . . . . . . . . . . . . . . . . . . 11

9.4 Pricing options on stocks paying dividends using a

2.2 Internal rate of return. . . . . . . . . . . . . . . . . 12 binomial approximation . . . . . . . . . . . . . . . . 70

2.2.1 Check for unique IRR . . . . . . . . . . . . . 15 9.4.1 Checking for early exercise in the binomial

2.3 Bonds ......................... 16 model. . . . . . . . . . . . . . . . . . . . . . 70

2.3.1 Bond Price . . . . . . . . . . . . . . . . . . . 16 9.4.2 Proportional dividends. . . . . . . . . . . . . 70

2.3.2 Yield to maturity. . . . . . . . . . . . . . . . 17 9.4.3 Discrete dividends . . . . . . . . . . . . . . . 70

2.3.3 Duration. ................... 19 9.5 Option on futures . . . . . . . . . . . . . . . . . . . 74

9.6 Foreign Currency options . . . . . . . . . . . . . . . 75

3 The term structure of interest rates and an object

9.7 References . . . . . . . . . . . . . . . . . . . . . . . 76

lesson 21

3.1 Term structure calculations . . . . . . . . . . . . . . 21

10 Finite Di¬erences 77

3.2 Using the currently observed term structure. . . . . 22

10.1 Explicit Finite di¬erences . . . . . . . . . . . . . . . 77

3.2.1 Linear Interpolation. ............. 22

10.2 European Options. .................. 77

3.3 The term structure as an object . . . . . . . . . . . 22

10.3 American Options. .................. 79

3.4 Implementing a term structure class . . . . . . . . . 23

3.4.1 Base class . . . . . . . . . . . . . . . . . . . 23 11 Option pricing by simulation 81

3.4.2 Flat term structure. . . . . . . . . . . . . . . 25 11.1 Simulating lognormally distributed random variables 81

3.4.3 Interpolated term structure. . . . . . . . . . 26 11.2 Pricing of European Call options . . . . . . . . . . . 82

3.5 Bond calculations using the term structure class . . 28 11.3 Hedge parameters . . . . . . . . . . . . . . . . . . . 83

11.4 More general payo¬s. Function prototypes ..... 83

4 Futures algoritms. 29

11.5 Improving the e¬ciency in simulation . . . . . . . . 85

4.1 Pricing of futures contract. . . . . . . . . . . . . . . 29

11.5.1 Control variates. ............... 85

11.5.2 Antithetic variates. . . . . . . . . . . . . . . 86

5 Binomial option pricing 30

11.5.3 Example . . . . . . . . . . . . . . . . . . . . 88

5.1 Multiperiod binomial pricing . . . . . . . . . . . . . 32

11.6 More exotic options . . . . . . . . . . . . . . . . . . 90

11.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . 90

6 Basic Option Pricing, the Black Scholes formula 37

6.1 The formula . . . . . . . . . . . . . . . . . . . . . . 37

12 Approximations 91

6.2 Understanding the why™s of the formula . . . . . . . 40

12.1 A quadratic approximation to American prices due

6.2.1 The original Black Scholes analysis ..... 40

to Barone“Adesi and Whaley. . . . . . . . . . . . . 91

6.2.2 The limit of a binomial case . . . . . . . . . 40

6.2.3 The representative agent framework . . . . . 41 13 Average, lookback and other exotic options 95

6.3 Partial derivatives. .................. 41 13.1 Bermudan options . . . . . . . . . . . . . . . . . . . 95

6.3.1 Delta . . . . . . . . . . . . . . . . . . . . . . 41 13.2 Asian options . . . . . . . . . . . . . . . . . . . . . 98

6.3.2 Other Derivatives . . . . . . . . . . . . . . . 41 13.3 Lookback options . . . . . . . . . . . . . . . . . . . 99

6.3.3 Implied Volatility. . . . . . . . . . . . . . . . 44 13.4 Monte Carlo Pricing of options whose payo¬ depend

on the whole price path . . . . . . . . . . . . . . . . 100

7 Warrants 47 13.4.1 Generating a series of lognormally dis-

tributed variables . . . . . . . . . . . . . . . 100

7.1 Warrant value in terms of assets . . . . . . . . . . . 47

7.2 Valuing warrants when observing the stock value . . 48 13.5 Control variate . . . . . . . . . . . . . . . . . . . . 103

1

14 Alternatives to the Black Scholes type option for- 20 Binomial Term Structure models 124

mula 104 20.1 The Rendleman and Bartter model . . . . . . . . . 124

14.1 Merton™s Jump di¬usion model. . . . . . . . . . . . 104 20.2 Readings . . . . . . . . . . . . . . . . . . . . . . . . 125

15 Using a library for matrix algebra 106

21 Term Structure Derivatives 127

15.1 An example matrix class . . . . . . . . . . . . . . . 106

21.1 Vasicek bond option pricing . . . . . . . . . . . . . 127

15.2 Finite Di¬erences . . . . . . . . . . . . . . . . . . . 106

15.3 European Options . . . . . . . . . . . . . . . . . . . 106

A Normal Distribution approximations. 129

15.4 American Options . . . . . . . . . . . . . . . . . . . 106

A.1 The normal distribution function . . . . . . . . . . . 129

A.2 The cumulative normal distribution . . . . . . . . . 129

16 Mean Variance Analysis. 109

A.3 Multivariate normal . . . . . . . . . . . . . . . . . . 130

16.1 Introduction. . . . . . . . . . . . . . . . . . . . . . . 109

A.4 Calculating cumulative bivariate normal probabilities 130

16.2 Mean variance portfolios. . . . . . . . . . . . . . . . 110

A.5 Simulating random normal numbers . . . . . . . . . 132

16.3 Short sales constraints . . . . . . . . . . . . . . . . 111

A.6 Cumulative probabilities for general multivariate

distributions . . . . . . . . . . . . . . . . . . . . . . 132

17 Pricing of bond options, basic models 112

A.7 References . . . . . . . . . . . . . . . . . . . . . . . 132

17.1 Black Scholes bond option pricing . . . . . . . . . . 112

A.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . 133

17.2 Binomial bond option pricing . . . . . . . . . . . . . 114

B C++ concepts 134

18 Credit risk 116

18.1 The Merton Model . . . . . . . . . . . . . . . . . . 116

C Summarizing routine names 135

19 Term Structure Models 117

D Installation 142

19.1 The Nelson Siegel term structure approximation . . 117

D.1 Source availability . . . . . . . . . . . . . . . . . . . 142

19.2 Cubic spline. . . . . . . . . . . . . . . . . . . . . . . 117

19.3 Cox Ingersoll Ross. . . . . . . . . . . . . . . . . . . 120

E Acknowledgements. 146

19.4 Vasicek . . . . . . . . . . . . . . . . . . . . . . . . . 122

2

This book is a a discussion of the calculation of speci¬c formulas in ¬nance. The ¬eld of ¬nance has seen

a rapid development in recent years, with increasing mathematical sophistication. While the formalization

of the ¬eld can be traced back to the work of Markowitz [1952] on investors mean-variance decisions and

Modigliani and Miller [1958] on the capital structure problem, it was the solution for the price of a call option

by Black and Scholes [1973], Merton [1973] which really was the starting point for the mathematicalization

of ¬nance. The ¬elds of derivatives and ¬xed income have since then been the main ¬elds where complicated

formulas are used. This book is intended to be of use for people who want to both understand and use these

formulas, which explains why most of the algorithms presented later are derivatives prices.

This project started when I was teaching a course in derivatives at the University of British Columbia, in

the course of which I sat down and wrote code for calculating the formulas I was teaching. I have always

found that implementation helps understanding these things. For teaching such complicated material it is

often useful to actually look at the implementation of how the calculation is done in practice. The purpose

of the book is therefore primarily pedagogical, although I believe all the routines presented are correct and

reasonably e¬cient, and I know they are also used by people to price real options.

To implement the algorithms in a computer language I choose C++. My students keep asking why anybody

would want to use such a backwoods computer language, they think a spreadsheet can solve all the worlds

problems. I have some experience with alternative systems for computing, and no matter what, in the end

you end up being frustrated with higher end “languages”, such as Matlab og Gauss (Not to mention the

straitjacket which is is a spreadsheet.) and going back to implementation in a standard language. In my

experience with empirical ¬nance I have come to realize that nothing beats knowledge a real computer

language. This used to be FORTRAN, then C, and now it is C++ . All example algorithms are therefore coded

in C++.

The manuscript has been sitting on the internet for a number of years, during which it has been visited by

a large number of people, to judge by the number of mails I have received about the routines. The present

(2003) version mainly expands on the background discussion of the routines, this is much more extensive. I

have also added a good deal of introductory material on how to program in C++, since a number of questions

make it obvious this manuscript is used by a number of people who know ¬nance but not C++. All the

routines have been made to con¬rm to the new ISO/ANSI C++ standard, using such concepts as namespaces

and the standard template library.

The current manscript therefore has various intented audiences. Primarily it is for students of ¬nance who

desires to see a complete discussion and implementation of some formula. But the manuscript is also useful

for students of ¬nance who wants to learn C++, and for computer scientists who want to understand about

the ¬nance algorithms they are asked to implent and embed into their programs.

In doing the implementation I have tried to be as generic as possible in terms of the C++ used, but I have taken

advantage of a some of the possibilities the language provides in terms of abstraction and modularization.

This will also serve as a lesson in why a real computer language is useful. For example I have encapsulated

the term structure of interest rate as an example of the use of classes.

This is not a textbook in the underlying theory, for that there are many good alternatives. For much of the

material the best textbooks to refer to are Hull [2003] and McDonald [2002], which I have used as references,

and the notation is also similar to these books.

3

Chapter 1

On C++ and programming.

Contents

1.1 Compiling and linking . . . . . . . . . . . . . . . . . . . . . .......... . . 4

1.2 The structure of a C++ program . . . . . . . . . . . . . . . .......... . . 4

1.2.1 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ........... . . 4

1.2.2 Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . ........... . . 5

1.2.3 Functions and libraries . . . . . . . . . . . . . . . . . . . . . ........... . . 5

1.2.4 Templates and libraries . . . . . . . . . . . . . . . . . . . . ........... . . 6

1.2.5 Flow control . . . . . . . . . . . . . . . . . . . . . . . . . . ........... . . 6

1.2.6 Input Output . . . . . . . . . . . . . . . . . . . . . . . . . . ........... . . 7

1.2.7 Splitting up a program . . . . . . . . . . . . . . . . . . . . . ........... . . 7

1.2.8 Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . ........... . . 8

1.3 Extending the language, the class concept. . . . . . . . . . .......... . . 8

1.3.1 date, an example class . . . . . . . . . . . . . . . . . . . . . ........... . . 8

1.4 Const references . . . . . . . . . . . . . . . . . . . . . . . . . .......... . . 10

In this chapter I introduce C++ and discuss how to run programs written in C++. This is by no means a

complete reference to programming in C++, it is designed to give enough information to understand the rest

of the book. This chapter also only discusses a subset of C++, it concentrates on the parts of the language

used in the remainder of this book. For really learning C++ a textbook is necessary. I have found Lippman

and Lajoie [1998] an excellent introduction to the language. The authorative source on the language is

Stroustrup [1997].

1.1 Compiling and linking

To program in C++ one has to ¬rst write a separate ¬le with the program, which is then compiled into

low-level instructions (machine language) and linked with libraries to make a complete executable program.

The mechanics of doing the compiling and linking varies from system to system, and we leave these details

as an exercise to the reader.

1.2 The structure of a C++ program

The ¬rst thing to realize about C++ is that it is a strongly typed language. Everything must be declared

before it is used, both variables and functions. C++ has a few basic building blocks, which can be grouped

into types, operations and functions.

1.2.1 Types

The types we will work with in this book are bool, int, long, double and string.

Here are some example de¬nitions

bool this_is_true=true;

int i = 0;

long j = 123456789;

double pi = 3.141592653589793238462643;

string s("this is a string");

4

The most important part of C++ comes from the fact that these basic types can be expanded by use of

classes, of which more later.

1.2.2 Operations

To these basic types the common mathematical operations can be applied, such as addition, subtraction,

multiplication and division:

int i = 100 + 50;

int j = 100 - 50;

int n = 100 * 2;

int m = 100 / 2;

These operations are de¬ned for all the common datatypes, with exception of the string type. Such

operations can be de¬ned by the programmer for other datatypes as well.

Increment and decrement In addition to these basic operations there are some additional operations

with their own shorthand. An example we will be using often is incrementing and decrementing a variable.

When we want to increase the value of one item by one, in most languages this is written:

int i=0;

i = i+1;

i = i-1;

In C++ this operation has its own shorthand

int i=0;

i++;

i--;

While this does not seem intuitive, and it is excusable to think that this operation is not really necessary,

it does come in handy for more abstract data constructs. For example, as we will see later, if one de¬nes a

date class with the necessary operations, to get the next date will simply be a matter of

date d(1,1,1995);

d++;

These two statements will result in the date in d being 2jan95.

1.2.3 Functions and libraries

In addition to the basic mathematical operations there is a large number of additional operations that can

be performed on any type. However, these are not parts of the core language, they are implemented as

standalone functions (most of which are actually written in C or C++). These functions are included in the

large library that comes with any C++ installation. Since they are not part of the core language they must

be de¬ned to the compiler before they can be used. Such de¬nitions are performed by means of the include

statement.

For example, the mathematical operations of taking powers and performing exponentiation are de¬ned in

the mathematical library cmath. In the C++ program one will write

#include <cmath>

cmath is actually a ¬le with a large number of function de¬ntions, among which one ¬nds pow(x,n) which

calculates xn , and exp(r) which calculates er . The following programming stub calculates a = 22 and

b = e1 .

5

#include <cmath>

double a = pow(2,2);

double b = exp(1);

which will give the variables a and b values of 4 and 2.718281828..., respectively.

1.2.4 Templates and libraries

The use of libraries is not only limited to functions. Also included in the standard library is generic data

structures, which can be used on any data type. The example we will be considering the most is the

vector<>, which de¬nes an array, or vector of variables.

#include <vector>

vector<double> M(2);

M[0]=1.0;

M[1]=2.0;

M.push_back(3);

This example de¬nes an array with three elements of type double

®

1

°2»

M=

3

Note some pecularities here. When ¬rst de¬ning the vector with the statement

vector<double> M(2);

we de¬ned an array of 2 elements of type double, which we then proceeded to ¬ll with the values 1 and 2.

When ¬lling the array we addressed each element directly. Note that in the statement

M[0]=1.0;

lies one of the prime traps for programmers coming to C or C++ from another language. Indexing of arrays

starts at zero, not at one. M[0] really means the ¬rst element of the array.

The last statement,

M.push_back(3);

shows the ability of the programmer of changing the size of the array after it has been de¬ned. push back

is a standard operation on arrays which “pushes” the element onto the back of the array, extending the

size of the array by one element. Most programming languages do not allow the programmer to specify

variable-sized arrays “on the ¬‚y.” In FORTRAN or Pascal we would usually have to set a maximum length

for each array, and hope that we would not need to exceed that length. The vector<> template of C++

gets rid of the programmers need for “bookkeeping” in such array manipulations.

1.2.5 Flow control

To repeat statements several times one will use on of the possibilities for ¬‚ow control, such as the for or

while constucts. For example, to repeat an operation n times one can use the following for loop:

for (int i=0; i<n; i++) {

some_operation(i);

};

6

The for statement has tree parts. The ¬rst part gives the initial condition (i=0). The next part the terminal

condition (i<n), which says to stop when i<n is not ful¬lled, which is at the n™th iteration. The last part is

the increment statement (i++), saying what to do in each iteration. In this case the value of i is increased by

one in each iteration. This is the typical for statement. One of the causes of C™s reputation for terseness is

the possibility of elaborate for constructs, which end up being almost impossible to read. In the algorithms

presented in this book we will try to avoid any obfuscated for statements, and stick to the basic cases.

1.2.6 Input Output

For any program to do anything useful it needs to be able to output its results. Input and output operations

is de¬ned in a couple of libraries, iostream and fstream. The ¬rst covers in/output to standard terminals

and the second in/output to ¬les.

To write to standard output cout (the terminal), one will do as follows:

#include <iostream>

cout << "This is a test" << endl;

To write to a ¬le ”test.out”, one will do as follows:

#include <fstream>

ofstream outf;

outf.open("test.out");

outf << "This is a test" << endl;

outf.clear();

outf.close();

1.2.7 Splitting up a program

Any nontrivial program in C++ is split into several pieces. Usually each piece is written as a function which

returns a value of a given type. To illustrate we provide a complete example program, shown in Code 1.1.

The program de¬nes a function performing the mathematical power operation, power(x,n) which calculates

xn through the simple identity xn = en ln(x) . This function is then used to calculate and print the ¬rst 5

powers of 2.

#include <iostream> // input output operations

#include <cmath> // mathematics library

using namespace std; // the above is part of the standard namespace

double power(double x, double n){

// de¬ne a simple power function

double p = exp(n*log(x));

return p;

Copyright Design by: Sunlight webdesign