LINEBURG


 1
( 20)



. . >>

Financial Numerical Recipes in C .
++




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;

 1
( 20)



. . >>

Copyright Design by: Sunlight webdesign