Vous êtes sur la page 1sur 37

Quantitative Finance

New Delhi

One Grook

This Session

Overview of C++

Using Numerical Recipes

Program syntax
Classes
Pointers
Arrays
Strings
Integrating with your project
Sample program Geometric Brownian Motion (if time)

Next Session using C++ to model a derivative

Things we wont cover


Object-oriented Design / Programming
The right way to do anything

Software

developers are fond of having


religious discussions
In the MFE, there is no time

Professional-level programming practice

C++ Overview

C++ is about 25 years old


Originally

created as a successor to C

C was created about 35 years ago as a more generic


assembly language

C++ is a very big language


It

has many, many features


Recommendation: during MFE program, only use
fundamental language features

Unless you are an expert, avoid constructs like templates,


polymorphism, operator overloading, multiple inheritance

C++ Overview cont

C++ is a dangerous language


It

is easy to introduce bugs


It is often difficult to track them down
Tip: build and test your programs
incrementally

Language Features Program


Syntax

Program Syntax
Functions

/ methods

Loops
Conditional

statements

Hopefully, syntax is not completely new to


you. If it is, think about using a more
familiar computer language.
7

Program Syntax (cont)

Functions

Function
return type

...
// this is a comment

Function name

int myFirstFunction(int a, int b, double c)


{
int rc = a + b + c;
The functions

code

return rc;
}
...

Return the value

Program Syntax (cont)

For loop
...
for (int i = 0; i < 100; i++)
{
... do something ...
}
...

Do loop

...
i = 0;
do
{
... do something ...
i++;
} while (i < 100);

Program Syntax (cont)

If statement
...
if (i == 10)
{
.. do something ..
} else {
.. do something else
}
...

IMPORTANT: Note the


double equal signs (==) to
test for equality

10

Classes

Classes provide the basic data/code


organization construct within C++
Classes are (roughly) comprised of two parts:
Data

members (properties)
Code members (methods)

Class support inheritance we dont have time


to cover this
Recommendation

if you are not familiar with


inheritance, do not try to learn how to use it during the
MFE
11

Classes (cont)
class myFirstClass
{
public:
// Some properties
int integerProperty;
double floatingPointProperty;
char
characterArray[254];
// some methods
// a constructor
myFirstClass()
{
integerProperty = 12;
floatingPointProperty = 25.2;
strcpy(characterArray, "yo yo yo");
}
// a destructor
virtual ~myFirstClass()
{
}
void doSomething()
{
... some code would go here ...
}
};

12

Classes cont

There are other features to classes


including:
Information

hiding (public, protected, private)


Virtual functions

They are extremely powerful and useful,


but now is not the time to play with these.

13

Classes cont

Classic interview question: What is the


difference between a class and an object?

Better interview question: Can an object


ever be a class?

14

Pointers
Pointers are a special type of variable
Pointers hold the address of data, not the
data
Pointers must be assigned values before
they can be used.

15

Pointers (cont)

Pointers are a special type of variable


Pointers hold the address of data, not the data
...
int a1;

// a1 is not a pointer

int *a2;

// a2 is a pointer

a1 = 10;
a2 = &a1;
*a2 = 5;

// a2 now points to a1
// we dereference a2 to assign a value

printf("%d %d\n", a1, *a2);

// what will this print?

...
16

Pointers (cont)

Be very careful with pointers


Someone once estimated that 90% of all C++
bugs can be traced back to bad pointers

17

Memory Allocation / Arrays


C++ supports both statically and
dynamically allocated arrays
If you dynamically allocate an array, make
sure to deallocate it when you are done
using it.

Make

sure you are really done using it before


you deallocate!

18

Memory Allocation / Arrays (cont)


...
int myArray[10];

// this is statically allocated array

for (int i = 0; i < 10; i++)


{
// Assign a value to each member of the array
// Notice that the array is 'referenced' from 0 to 9
// Arrays in C++ 'start' at 0
myArray[i] = i * i + 1;
}
...

19

Memory Allocation / Arrays (cont)


...
// this is dynamically allocated array
// it looks suspiciously like a pointer!
int *myArray;
// first we allocate it
myArray = new int[10];
// this is what a for loop looks like
for (int i = 0; i < 10; i++)
{
// Assign a value to each member of the array
// Notice that the array is 'reference' from 0 to 9
// Arrays in C++ 'start' at 0
myArray[i] = i * i + 1;
}
// now we deallocate it
delete[] myArray;
...

20

Memory Allocation / Arrays cont

Question: when should you dynamically


allocate an array?

When should static allocation be used?

21

Strings (or lack thereof)

C++ does not have a standard string class


There

is a string class within the Standard Template


Library (STL)
Unless you know how to use the STL, ignore it for this
term
Recommendation: for output, debugging purposes
learn how to use printf, sprintf, fprintf
The classic way of handling strings is to treat them
as arrays of chars. Then use strcpy, strcmp, etc.
22

Strings (or lack thereof) printf()


printf()

enables the formatting of character

data
printf(format_string, data1, data2, )
Example:

printf(This is a %s %d %lf test\n,


printing, 2, 5.005)

Produces: This is a printing 2 5.005 test<lf>

23

Using Numerical Recipes

There are many numerical libraries available


Numerical Recipes for C++ is easy to use
DO NOT RE-INVENT THE WHEEL

If you do not have NR, search on-line for numerical class


libraries
Do not write your own random-number generator
Do not write your own matrix classes
Do not implement complex numerical algorithms if there are
canned routines already available
Exception: if the goal of a homework assignment is to implement
an algorithm.

24

Using Numerical Recipes cont


Warning: there are Numerical Recipes
books for FORTRAN, C, C++, etc.
Each one is slightly different
NR originally implemented in FORTRAN
C & C++ versions different enough from
each other to cause problems

For

example, arrays in C version are handled


differently than in C++ version
25

Using Numerical Recipes cont

Three different ways to add NR to your project


1.

2.
3.

Recommended : copy the files you need (including


nr.h) to your project directory and add the cpp files
to your project
Build a static library or DLL with all the NR routines
in them
Copy the code directly from the NR files into your
code files

26

Using Numerical Recipes cont


Example: Using an NR random number
generator
Problem: Want standard normal
pseudorandom variable
Solution: use gasdev() from NR

27

Using Numerical Recipes cont


#include <time.h>
#include "nr.h"
...
// let's generate 100 standard normal variables
double normals[100];
// seed the random number generator
int idum = -time(NULL);
for (int i = 0; i < 100; i++)
{
normals[i] = NR::gasdev(idum);
}
...

28

Putting it All Together A


Geometric Brownian Motion Class

We want to:
Model

drift, diffusion
Reuse the same object over and over to
generate different paths

29

GBM cont

Our class properties

m_nSInitial the initial security value (constant)


m_nDrift the drift term (constant)
m_nSigma our volatility term (constant)
m_nCurrentTime the current time in our simulation
m_nSCurrent the current security value

Our class methods

CGBMotion - our constructor


void step moves time forward
double getCurrentValue returns m_nSCurrent
void reset - resets current time & security value
30

Code
#include <math.h>
#include "nr.h"
class CGBMotion
{
public:
// our properties
int m_nIdum; // used by NR::gasdev
double m_nSInitial; // initial security value (constant)
double m_nDrift; // our drift (constant)
double m_nSigma; // our volatility (constant)
double m_nCurrentTime; // the current elapsed time
double m_nCurrentDiffusion; // how much the process has diffused

31

Code cont
. . .
public:
// our constructor
CGBMotion(double nSInitial, double nDrift, double nSigma, int seed)
{
m_nSInitial = nSInitial;
m_nDrift = nDrift;
m_nSigma = nSigma;
m_nCurrentTime = 0;
m_nCurrentDiffusion = 0;
m_nIdum = seed;
}

32

Code cont
. . .
void step(double nTime)
{
double nDeltaT = nTime - m_nCurrentTime; // how much time has elapsed?
if (nDeltaT > 0)
{
// some time has elapsed
// add to our diffusion relative to sqrt of elapsed time
m_nCurrentDiffusion += sqrt(nDeltaT) * NR::gasdev(m_nIdum);
// update our current time
m_nCurrentTime = nTime;
}
}

33

Code cont
. . .
double getCurrentValue()
{
return m_nSInitial * exp(m_nDrift*m_nCurrentTime
- .5* m_nSigma * m_nSigma*m_nCurrentTime
+ m_nSigma*m_nCurrentDiffusion)
);
}
double reset()
{
m_nCurrentTime = 0;
m_nCurrentDiffusion = 0;
}
};

34

GBM Sample Program


int main(int argc, char* argv[])
{
CGBMotion oGBM(100.0, .05, .2, -10);

// our brownian motion object

// run 10000 simulations


for (int i = 0; i < 10000; i++)
{
double t = 0;
oGBM.reset();
// run 100 time steps
for (int j = 0; j < 100; j++)
{
t = t + .01;
oGBM.step(t);
}
// print the results
printf("%02d: Simulated value %lf\n", i,
oGBM.getCurrentValue());
}
return 0;
}

35

3 Great Resources
Wikipedia: http://www.wikipedia.org
Wilmott: http://www.wilmott.com
Google (of course) :
http://www.google.com

36

Questions / Discussion

37