"高级财务计算与编程：Numerical Recipes in C"

20 浏览量更新于2024-01-02 收藏 428KB PDF 举报

Numerical Recipes in C is a comprehensive discussion of advanced financial algorithms and computer code. Written by Bernt Arne Ødegaard, the book is designed for use in a course teaching derivative securities. It covers a wide range of topics, including option pricing and algorithms for term structure modeling and pricing of fixed income securities. The book provides a detailed overview of the fundamental and advanced algorithms for option pricing. It also delves into the complexities of term structure modeling and the pricing of fixed income securities. Each algorithm is accompanied by computer code written in the C language, allowing for easy implementation as self-contained subroutines that can be compiled on any standard C compiler. One of the key features of Numerical Recipes in C is its practical approach to financial calculations. The algorithms and computer code provided in the book are designed to be easily understandable and usable in real-world applications. This makes it an invaluable resource for professionals working in finance, as well as students and researchers studying derivative securities. The book's focus on the C language for implementing the algorithms is also noteworthy. C is a widely used programming language in finance and offers high performance and flexibility for numerical computations. By providing code in C, Numerical Recipes in C ensures that readers can easily integrate the algorithms into their own financial software and applications. Overall, Numerical Recipes in C is a comprehensive and practical resource for anyone working with advanced financial calculations. It provides a thorough discussion of algorithms and computer code for option pricing, term structure modeling, and fixed income securities, all implemented in the widely used C language. Its clear and practical approach makes it a valuable reference for professionals and a useful learning tool for students and researchers in the field of finance.

Computer algorithm, implied volatility, bisections.

// ﬁle black scholes imp vol bisect.cc

// author: Bernt A Oedegaard

// calculate implied volatility of Black Scholes formula

#include ”fin algoritms.h”

#include <cmath>

double option price implied volatility call black scholes bisections(

double S, double X, double r, double time, double option price)

{ // check for arbitrage violations:

// if price at almost zero volatility greater than price, return 0

double sigma low=0.0001;

double price = option price call black scholes(S,X,r,sigma low,time);

if (price>option price) return 0.0;

// simple binomial search for the implied volatility.

// relies on the value of the option increasing in volatility

const double ACCURACY = 1.0e-5; // make this smaller for higher accuracy

const int MAX ITERATIONS = 100;

const double HIGH VALUE = 1e10;

const double ERROR = -1e40;

// want to bracket sigma. ﬁrst ﬁnd a maximum sigma by ﬁnding a sigma

// with a estimated price higher than the actual price.

double sigma high=0.3;

price = option price call black scholes(S,X,r,sigma high,time);

while (price < option price) {

sigma high = 2.0 ∗ sigma high; // keep doubling.

price = option price call black scholes(S,X,r,sigma high,time);

if (sigma high>HIGH VALUE) return ERROR; // panic, something wrong.

};

for (int i=0;i<MAX ITERATIONS;i++){

double sigma = (sigma low+sigma high)∗0.5;

price = option price call black scholes(S,X,r,sigma,time);

double test = (price-option price);

if (fabs(test)<ACCURACY) { return sigma; };

if (test < 0.0) { sigma low = sigma; }

else { sigma high = sigma; }

};

return ERROR;

};

Implied volatility, Newton-Raphson.

Instead of this simple bracketing, which is actually pretty fast, and will (almost) always ﬁnd the solution,

we can use the Newton–Raphson formula for ﬁnding the root of an equation in a single variable. If

f(x) = 0

is the equation we want to solve, given a ﬁrst guess x

, we iterate by

i+1

= x

−

f(x

)

until

|f(x

)| < 

where  is the desired accuracy.

In our case

f(x) = c

obs

− c

(σ)

and, each new iteration will calculate

i+1

= σ

obs

− c

(σ

)

−

∂c

()

∂σ

Note that to use Newton-Raphson we need the derivative of the option price. For the Black-Scholes formula

this is known, and we can use this. But for pricing formulas like the binomial, where the partial derivatives

are not that easy to calculate, simple bisection is the preferred algorithm.

Computer algoritm, implied volatility, Newton steps.

// ﬁle black scholes imp vol newt.cc

// author: Bernt A Oedegaard

// calculate implied volatility of Black Scholes formula using newton steps

#include ”fin algoritms.h”

#include ”normdist.h”

#include <cmath>

double option price implied volatility call black scholes newton(

double S, double X, double r, double time, double option price)

{

// check for arbitrage violations:

// if price at almost zero volatility greater than price, return 0

double sigma low = 1e-5;

double price = option price call black scholes(S,X,r,sigma low,time);

if (price > option price) return 0.0;

const int MAX ITERATIONS = 100;

const double ACCURACY = 1.0e-4;

double t sqrt = sqrt(time);

double sigma = (option price/S)/(0.398∗t sqrt); // ﬁnd initial value

for (int i=0;i<MAX ITERATIONS;i++){

price = option price call black scholes(S,X,r,sigma,time);

double diﬀ = option price -price;

if (fabs(diﬀ)<ACCURACY) return sigma;

double d1 = (log(S/X)+r∗time)/(sigma∗t sqrt) + 0.5∗sigma∗t sqrt;

double vega = S ∗ t sqrt ∗ n(d1);

sigma = sigma + diﬀ/vega;

};

return -99e10; // something screwy happened, should throw exception

};

Further Reading For the Newton-Raphson formula and bracketing, a good source is chapter 9 of Press

et al. [1992]

3.3 Adjusting for payouts of the underlying.

For options on other ﬁnancial instruments than stocks, we have to allow for the fact that the underlying

may have payouts during the life of the option. For example, in working with commodity options, there is

often some storage costs if one wanted to hedge the option by buying the underlying.

// ﬁle: bserudiv.cc

// author: Bernt A Oedegaard

#include <cmath> // mathematical library

#include ”fin algoritms.h” // deﬁne the black scholes price

#include <vector>

double option price european call dividends( double S,

double X,

double r,

double sigma,

double time to maturity,

vector<double>& dividend times,

vector<double>& dividend amounts )

// reduce the current stock price by the amount of dividends.

{

for (int i=0;i<dividend times.size();i++) {

if (dividend times[i]≤time to maturity){

S -= dividend amounts[i] ∗ exp(-r∗dividend times[i]);

};

return option price call black scholes(S,X,r,sigma,time to maturity);

};

3.4 American options.

American options are much harder to deal with than European ones. The problem is that it may be optimal

to use (exercise) the option before the ﬁnal expiry date. This optimal exercise policy will aﬀect the value of

the option, and the exercise policy needs to be known when solving the pde. There is therefore no general

analytical solutions for American call and put options. There is some special cases. For American Call

options on assets that do not have any payouts, the American call price is the same as the European one,

since the optimal exercise policy is to not exercise. For American Put is this not the case, it may pay to

exercise them early. The known analytical American price is the case of a call on a stock that pays a known

dividend, which is discussed next. In all other cases the American price has to be approximated using one

of the techniques discussed in later chapters: Binomial approximation, numerical solution of the partial

diﬀerential equation, or another numerical approximation.

3.4.1 Exact american call formula when stock is paying one dividend.

When a stock pays dividend, a call option on the stock may be optimally exercised just before the stock goes

ex-dividend. While the general dividend problem is usually approximated somehow, for the special case of

one dividend payment during the life of an option an analytical solution is available, due to Roll–Geske–

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

ch 10.A2 of Hull [1993] for a textbook summary.

We use the following notation:

• S stock price.

• X exercise price.

• D

: amount of dividend paid.

• t

: Time of dividend payment.

• T: Maturity date of option.

剩余80页未读，继续阅读

py_free-物联智能

粉丝: 3w+
资源: 69

"高级财务计算与编程：Numerical Recipes in C"

Numerical recipes in c++

Numerical recipes in C++源代码

Numerical Recipes in c++ 源代码

Financial numerical recipes in C++

Numerical Recipes in C++ Version 2.10

Numerical Recipes in c++ Linux平台 源代码

Financial Numerical Recipes in C++.pdf（2014）

Numerical recipes in C++, source code version 3.01.rar

Numerical Recipes in C++.3nd Edition + source_code

Financial numerical recipes in C++_C++中的财务数字配方（源代码）_NumericalRec

最新资源

Numerical Recipes in c++ Linux平台源代码