Customer Reviews

Modeling Derivatives in C++ (Wiley Finance)

5 star:		(15)
4 star:		(3)
3 star:		(6)
2 star:		(5)
1 star:		(8)

 

 

Like some other reviews (some of which have been removed by Amazon) have pointed out, this book is comprehensive, covers most of the right topics yet have some major flaws that prevent it from being truly useful to the students of financial engineering. It successfully COMPILES and DOCUMENTS the derivatives models in C++ but it is less sucessful in TEACHING the process of building these C++ modules. I look forward to a 2nd edition.

The author makes an honest attempt to show the mathematical and financial theories underpining the models and present the associated C++ code. However, the models and the associate codes are presented in a encyclopedia-like fashion. Moreover the codes are 'borrowed' from various sources, including the open source quantlib project, thus there's a lack of consistency. From page to page, you are directed to codes with very different coding styles. Therefore there's disjointed feel to this book.

What I would like to see a its 2nd edition are the following:
1. Relegate the code snippets to the appendix section (or just put them in the CD) and present only the neccesary codes next to the models.
2. Write his own codes or just adopt quantlib's library directly and change the title to Derivatives C++ 2nd edition: a quantlib approach. Consistency in the coding is important.
3. Decide what's the target audience of the book and what is the main object of this book? is it to teach people 'HOW' to map derivatives models to C++, is it to document 'WHAT' derivatives models and the associated C++ codes are out there.

Overall this book is promising, is ambitious in its coverage, but would benefit from a major revision. For its efforts and intentions, I would rate is 3 stars.

An alternative way (IMHO a much better way) to learn Derivatives C++ programming is to take a bottom up approach and learn the various components separately:

Mathematical Finance: Hull (2005, comprehensive coverage of derivatives models); Wilmott/Howison/Dewynne (1995, The mathematics of financial derivatives); Joshi (2005, The Concepts and practice of mathematical finance)

Mapping of mathematical models to computer programs (pseudocodes): Clewlow/Strickland (1998), Lyuu (2001), Seydel (2003)

Programming in C++: any introductory book in C++ would do (I like Deitel & Deitel); Object-oriented C++ and STL

Also need to learn the linear algebra and how to manipulate matrices and system of linear equations in C++.

The author does not understand what he is writing. He just has done a compilation of existing resources. Mainly Clewlow, Brigo and some open sources

1. The code:
a. Some examples cannot compile and/or crash. Example array[-1]
b. More "funny". He tried to use a control variable to reduce errors in Monte Carlo. Unfortunately (section 2.8) he uses as control ... another Monte Carlo. This is simply crazy, we must use an exact solution as control
c. Even more "funny" the calcul of sigma p 653. After calculating it at the beginning of the program it let it constant for the rest of the program. The key point here is that sigma is not constant but varies as function of the time
It is just some examples but the book is full of mistakes and crazy things

2. The text. The text is a copy of Clewlow for the equity and single factor interest rate part and Brigo for the other part. Unfortunately since the author does not understand what he is writing it is just a BAD copy. incomprehensible.

3. About the comments. It seems that the author has a lot of time to loose writing various comments using different names. With so bad code nobody could give 5 stars. Therefore it is not difficult to know from which are the comments...

This book is expensive and not worth the money. Better take the Clewlow and Brigo.

The codes in the book which are not from the freely distributed source are not properly integrated. The Author claims
that he has written various classes and objects but you can
find few "main()" program in the book that allows you to see
if and how all these classes actually work
by instantiating the classes as working objects and
testing them. A big collection of code fragments, even if it all works, which we cannot be sure of, is not very helpful.

The only good thing about this book is the table of contents ( 1 generous star for that). If you've written C/C++ professionally for a living, you wouldn't stand looking at the code snippets in this book except some parts that's copied from the open source Quant Lib. Furthermore, the computational errors in the book shows you how careless the code examples are: On page 85, it has a function which is pupported to return the smallest prime greater than or equal to N:

inline long generatePrime(long N) {
Long i = N;
bool flag = false;

do {
// check if number is prime
if( ( i%2 != 0 ) && (i%3!=0) && (i%4 != 0) && (i%5 != 0) && (i%6 != 0)
&& (i%7 != 0) && (i%8 !=0) && (i%9 != 0) )
flag = true;
else
i++;
} while ( flag != true);
return i;
}

Is this a great mathematical discovery or what? Try this function with N=121! Just don't bet any money on it!

Tons of errors in Code. Tons of errors in text. If you can walk around all these errors, you will become a master of derivative modelling.

The code in the book can be divided into two categories: first, there is code lifted from the Quantlib project, that Mr. London reprints page after page without apparent credit given the QL project. The only mention to Quantlib in the index refers to page 804! And then, there is Mr. London's code, which has obviously not yet been debugged. Consider for example the trinomial tree code p. 170-171:
- Hard-coded dimensions for S and c arrays, but variable dimensions passed as arguments
- Negative indexing into S array
- recalculation of exp(-rate*dt) at every step of the recursion!

Rather than buying the book, consider donating the price to the quantlib project.

As another wrote the book is really nice, but the code is a mess in many cases. I was interested in the Black-Derman-Toy model. All arrays are of fixed size and worse, London uses 4 times as much memory as needed and he uses negative indices in arrays (in matrices). I don't know how a pointer to a variable like d[i][-i] can find the value. I have to rewrite the most of the code which was a copy of the pseudo code mage by Clewlow and Strickland presented in their book Implementing Derivative Models.
Sorry folks! A nice book, but bad coding!!!

I wasted too much time with the horrible code the book, it is a shame I hadn't read the other reviews before that.
most of the code in the book does not compile.

I used this book for my course in Derivatives Pricing and I faced countless problems in compiling the source code.
I'm using Visual Studio 2005 version 8, and this is a short list of the problems that I had encountered:

1) declarations non in ISO standard
2) loose type conversions
3) Vague description on how to implement the functions
4) Routine inaccuracies

The author seems to have gathered a bunch of code from different sources and libraries such as the Gnu Scientific Library, Quantlib, Numerical Recipes in C, without a clear pattern on how to sew the pieces together.

If you want just a implementation in C++ of a simple option you might find it useful, but as you push your programming to more advanced topics you will encounter countless annoying flaws.

I wish I had never used it.
Best regards

This book has to much code (also for developers!), almost nothing of a high level description of the code (UML? some picture? APIs?), and a quite short mathematical formulation and explanation. The combination is a book that tals about everything but does not help to undersatnd nothing.
I do not know if the problem comes from the many pages (that will imply a bigger price) or to the strategy. I would prefer a better understanding of the patterns involved in the the development...