nag_specfun_opt_jumpdiff_merton_price (s30ja) uses Merton's jump-diffusion model (Merton (1976)) to compute the price of a European option. This assumes that the asset price is described by a Brownian motion with drift, as in the Black–Scholes–Merton case, together with a compound Poisson process to model the jumps. The corresponding stochastic differential equation is,

\frac{d S}{S} = (α - λ k) d t + \hat{σ} {d W}_{t} + {d q}_{t} .

Here

α

is the instantaneous expected return on the asset price,

S

;

{\hat{σ}}^{2}

is the instantaneous variance of the return when the Poisson event does not occur;

{d W}_{t}

is a standard Brownian motion;

q_{t}

is the independent Poisson process and

k = E [Y - 1]

where

Y - 1

is the random variable change in the stock price if the Poisson event occurs and

E

is the expectation operator over the random variable

Y

This leads to the following price for a European option (see Haug (2007))

P_{call} = \sum_{j = 0}^{\infty} \frac{e^{- λ T} {(λ T)}^{j}}{j!} C_{j} (S, X, T, r, σ_{j}^{'}),

where

T

is the time to expiry;

X

is the strike price;

r

is the annual risk-free interest rate;

C_{j} (S, X, T, r, σ_{j}^{'})

is the Black–Scholes–Merton option pricing formula for a European call (see nag_specfun_opt_bsm_price (s30aa)).

\begin{array}{l} σ_{j}^{'} = \sqrt{z^{2} + δ^{2} (\frac{j}{T})}, \\ z^{2} = σ^{2} - λ δ^{2}, \\ δ^{2} = \frac{γ σ^{2}}{λ}, \end{array}

where

σ

is the total volatility including jumps;

λ

is the expected number of jumps given as an average per year;

γ

is the proportion of the total volatility due to jumps.

The value of a put is obtained by substituting the Black–Scholes–Merton put price for

C_{j} (S, X, T, r, σ_{j}^{'})

The option price

P_{i j} = P (X = X_{i}, T = T_{j})

is computed for each strike price in a set

X_{i}

i = 1, 2, \dots, m

, and for each expiry time in a set

T_{j}

j = 1, 2, \dots, n

References

Haug E G (2007) The Complete Guide to Option Pricing Formulas (2nd Edition) McGraw-Hill

Merton R C (1976) Option pricing when underlying stock returns are discontinuous Journal of Financial Economics 3 125–144

Parameters

Compulsory Input Parameters

1: $calput$ – string (length ≥ 1)

Determines whether the option is a call or a put.

$calput ='C'$: A call; the holder has a right to buy.
$calput ='P'$: A put; the holder has a right to sell.

Constraint:

calput ='C'

'P'

2: $x (m)$ – double array

x (i)

must contain

X_{i}

, the

i

th strike price, for

i = 1, 2, \dots, m

Constraint:

x (i) \geq z ​ and ​ x (i) \leq 1 / z

, where

z = x02am ()

, the safe range parameter, for

i = 1, 2, \dots, m

3: $s$ – double scalar

S

, the price of the underlying asset.

Constraint:

s \geq z ​ and ​ s \leq 1.0 / z

, where

z = x02am ()

, the safe range parameter.

4: $t (n)$ – double array

t (i)

must contain

T_{i}

, the

i

th time, in years, to expiry, for

i = 1, 2, \dots, n

Constraint:

t (i) \geq z

, where

z = x02am ()

, the safe range parameter, for

i = 1, 2, \dots, n

5: $sigma$ – double scalar

σ

, the annual total volatility, including jumps.

Constraint:

sigma > 0.0

6: $r$ – double scalar

r

, the annual risk-free interest rate, continuously compounded. Note that a rate of 5% should be entered as 0.05.

Constraint:

r \geq 0.0

7: $lambda$ – double scalar

λ

, the number of expected jumps per year.

Constraint:

lambda > 0.0

8: $jvol$ – double scalar

The proportion of the total volatility associated with jumps.

Constraint:

0.0 \leq jvol < 1.0

Optional Input Parameters

1: $m$ – int64int32nag_int scalar: Default: the dimension of the array x.
The number of strike prices to be used.

Constraint: $m \geq 1$ .
2: $n$ – int64int32nag_int scalar: Default: the dimension of the array t.
The number of times to expiry to be used.

Constraint: $n \geq 1$ .

Output Parameters

1: $p (ldp, n)$ – double array: $ldp = m$ .
$p (i, j)$ contains $P_{i j}$ , the option price evaluated for the strike price $x_{i}$ at expiry $t_{j}$ for $i = 1, 2, \dots, m$ and $j = 1, 2, \dots, n$ .
2: $ifail$ – int64int32nag_int scalar: $ifail = 0$ unless the function detects an error (see Error Indicators and Warnings).

Error Indicators and Warnings

Errors or warnings detected by the function:

$ifail = 1$: On entry, $calput =_$ was an illegal value.

$ifail = 2$: Constraint: $m \geq 1$ .

$ifail = 3$: Constraint: $n \geq 1$ .

$ifail = 4$: Constraint: $x (i) \geq_$ and $x (i) \leq_$ .

$ifail = 5$: Constraint: $s \geq_$ and $s \leq_$ .

$ifail = 6$: Constraint: $t (i) \geq_$ .

$ifail = 7$: Constraint: $sigma > 0.0$ .

$ifail = 8$: Constraint: $r \geq 0.0$ .

$ifail = 9$: Constraint: $lambda > 0.0$ .

$ifail = 10$: Constraint: $jvol \geq 0.0$ and $jvol < 1.0$ .

$ifail = 12$: Constraint: $ldp \geq m$ .

$ifail = - 99$: An unexpected error has been triggered by this routine. Please contact NAG.

$ifail = - 399$: Your licence key may have expired or may not have been installed correctly.

$ifail = - 999$: Dynamic memory allocation failed.

Accuracy

The accuracy of the output is dependent on the accuracy of the cumulative Normal distribution function,

Φ

, occurring in

C_{j}

. This is evaluated using a rational Chebyshev expansion, chosen so that the maximum relative error in the expansion is of the order of the machine precision (see nag_specfun_cdf_normal (s15ab) and nag_specfun_erfc_real (s15ad)). An accuracy close to machine precision can generally be expected.

Further Comments

None.

Example

This example computes the price of a European call with jumps. The time to expiry is

3

months, the stock price is

45

and the strike price is

55

. The number of jumps per year is

3

and the percentage of the total volatility due to jumps is

40 %

. The risk-free interest rate is

10 %

per year and the total volatility is

25 %

per year.

Open in the MATLAB editor: s30ja_example

function s30ja_example


fprintf('s30ja example results\n\n');

put = 'C';
lambda = 3;
s = 45;
sigma = 0.25;
r = 0.1;
jvol = 0.4;
x = [55.0];
t = [0.25];

[p, ifail] = s30ja( ...
                    put, x, s, t, sigma, r, lambda, jvol);


fprintf('\nMerton Jump-Diffusion Model\n European Call :\n');
fprintf('  Spot       =   %9.4f\n', s);
fprintf('  Volatility =   %9.4f\n', sigma);
fprintf('  Rate       =   %9.4f\n', r);
fprintf('  Jumps      =   %9.4f\n', lambda);
fprintf('  Jump Vol   =   %9.4f\n\n', jvol);

fprintf('   Strike    Expiry   Option Price\n');
for i=1:1
  for j=1:1
    fprintf('%9.4f %9.4f %9.4f\n', x(i), t(j), p(i,j));
  end
end

s30ja example results


Merton Jump-Diffusion Model
 European Call :
  Spot       =     45.0000
  Volatility =      0.2500
  Rate       =      0.1000
  Jumps      =      3.0000
  Jump Vol   =      0.4000

   Strike    Expiry   Option Price
  55.0000    0.2500    0.2417

PDF version (NAG web site, 64-bit version, 64-bit version)

Chapter Contents

Chapter Introduction

NAG Toolbox