NAG Library Function Document

nag_asian_geom_greeks (s30sbc)

nag_asian_geom_greeks (Nag_OrderType order, Nag_CallPut option, Integer m, Integer n, const double x[], double s, const double t[], double sigma, double r, double b, double p[], double delta[], double gamma[], double vega[], double theta[], double rho[], double crho[], double vanna[], double charm[], double speed[], double colour[], double zomma[], double vomma[], NagError *fail)

3 Description

nag_asian_geom_greeks (s30sbc) computes the price of an Asian geometric continuous average-rate option, together with the Greeks or sensitivities, which are the partial derivatives of the option price with respect to certain of the other input parameters. The annual volatility,

σ

, risk-free rate,

r

, and cost of carry,

b

, are constants (see Kemna and Vorst (1990)). For a given strike price,

X

, the price of a call option with underlying price,

S

, and time to expiry,

T

, is

P_{call} = S e^{(\bar{b} - r) T} Φ ({\bar{d}}_{1}) - X e^{- r T} Φ ({\bar{d}}_{2}),

and the corresponding put option price is

P_{put} = X e^{- r T} Φ (- {\bar{d}}_{2}) - S e^{(\bar{b} - r) T} Φ (- {\bar{d}}_{1}),

where

{\bar{d}}_{1} = \frac{\ln (S / X) + (\bar{b} + {\bar{σ}}^{2} / 2) T}{\bar{σ} \sqrt{T}}

and

{\bar{d}}_{2} = {\bar{d}}_{1} - \bar{σ} \sqrt{T},

with

\bar{σ} = \frac{σ}{\sqrt{3}}, \bar{b} = \frac{1}{2} (b - \frac{σ^{2}}{6}) .

Φ

is the cumulative Normal distribution function,

Φ (x) = \frac{1}{\sqrt{2 π}} \int_{- \infty}^{x} \exp (- y^{2} / 2) d y .

4 References

Kemna A and Vorst A (1990) A pricing method for options based on average asset values Journal of Banking and Finance 14 113–129

5 Arguments

1: order – Nag_OrderTypeInput

On entry: the order argument specifies the two-dimensional storage scheme being used, i.e., row-major ordering or column-major ordering. C language defined storage is specified by

order = Nag_RowMajor

. See Section 3.2.1.3 in the Essential Introduction for a more detailed explanation of the use of this argument.

Constraint:

order = Nag_RowMajor

or Nag_ColMajor.

2: option – Nag_CallPutInput

On entry: determines whether the option is a call or a put.

$option = Nag_Call$: A call. The holder has a right to buy.
$option = Nag_Put$: A put. The holder has a right to sell.

Constraint:

option = Nag_Call

Nag_Put

3: m – IntegerInput

On entry: the number of strike prices to be used.

Constraint:

m \geq 1

4: n – IntegerInput

On entry: the number of times to expiry to be used.

Constraint:

n \geq 1

5: x[m] – const doubleInput

On entry:

x [i - 1]

must contain

X_{i}

, the

i

th strike price, for

i = 1, 2, \dots, m

Constraint:

x [i - 1] \geq z ​ and ​ x [i - 1] \leq 1 / z

, where

z = nag_real_safe_small_number

, the safe range parameter, for

i = 1, 2, \dots, m

6: s – doubleInput

On entry:

S

, the price of the underlying asset.

Constraint:

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

, where

z = nag_real_safe_small_number

, the safe range parameter.

7: t[n] – const doubleInput

On entry:

t [i - 1]

must contain

T_{i}

, the

i

th time, in years, to expiry, for

i = 1, 2, \dots, n

Constraint:

t [i - 1] \geq z

, where

z = nag_real_safe_small_number

, the safe range parameter, for

i = 1, 2, \dots, n

8: sigma – doubleInput

On entry:

σ

, the volatility of the underlying asset. Note that a rate of 15% should be entered as 0.15.

Constraint:

sigma > 0.0

9: r – doubleInput

On entry:

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

10: b – doubleInput

On entry:

b

, the annual cost of carry rate. Note that a rate of 8% should be entered as

0.08

11: p[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix

P

is stored in

$p [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$p [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array p contains the computed option prices.

12: delta[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix is stored in

$delta [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$delta [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array delta contains the sensitivity,

\frac{\partial P}{\partial S}

, of the option price to change in the price of the underlying asset.

13: gamma[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix is stored in

$gamma [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$gamma [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array gamma contains the sensitivity,

\frac{\partial^{2} P}{\partial S^{2}}

, of delta to change in the price of the underlying asset.

14: vega[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix is stored in

$vega [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$vega [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array vega contains the sensitivity,

\frac{\partial P}{\partial σ}

, of the option price to change in the volatility of the underlying asset.

15: theta[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix is stored in

$theta [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$theta [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array theta contains the sensitivity,

- \frac{\partial P}{\partial T}

, of the option price to change in the time to expiry of the option.

16: rho[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix is stored in

$rho [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$rho [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array rho contains the sensitivity,

\frac{\partial P}{\partial r}

, of the option price to change in the annual risk-free interest rate.

17: crho[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix is stored in

$crho [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$crho [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array crho containing the sensitivity,

\frac{\partial P}{\partial b}

, of the option price to change in the annual cost of carry rate,

b

18: vanna[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix is stored in

$vanna [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$vanna [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array vanna contains the sensitivity,

\frac{\partial^{2} P}{\partial S \partial σ}

, of vega to change in the price of the underlying asset or, equivalently, the sensitivity of delta to change in the volatility of the asset price.

19: charm[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix is stored in

$charm [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$charm [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array charm contains the sensitivity,

- \frac{\partial^{2} P}{\partial S \partial T}

, of delta to change in the time to expiry of the option.

20: speed[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix is stored in

$speed [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$speed [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array speed contains the sensitivity,

\frac{\partial^{3} P}{\partial S^{3}}

, of gamma to change in the price of the underlying asset.

21: colour[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix is stored in

$colour [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$colour [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array colour contains the sensitivity,

- \frac{\partial^{3} P}{\partial S^{2} \partial T}

, of gamma to change in the time to expiry of the option.

22: zomma[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix is stored in

$zomma [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$zomma [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array zomma contains the sensitivity,

\frac{\partial^{3} P}{\partial S^{2} \partial σ}

, of gamma to change in the volatility of the underlying asset.

23: vomma[ $m \times n$ ] – doubleOutput

Note: the

(i, j)

th element of the matrix is stored in

$vomma [(j - 1) \times m + i - 1]$ when $order = Nag_ColMajor$ ;
$vomma [(i - 1) \times n + j - 1]$ when $order = Nag_RowMajor$ .

On exit: the

m \times n

array vomma contains the sensitivity,

\frac{\partial^{2} P}{\partial σ^{2}}

, of vega to change in the volatility of the underlying asset.

24: fail – NagError *Input/Output

The NAG error argument (see Section 3.6 in the Essential Introduction).

6 Error Indicators and Warnings

NE_ALLOC_FAIL: Dynamic memory allocation failed.
NE_BAD_PARAM: On entry, argument $〈value〉$ had an illegal value.
NE_INT: On entry, $m = 〈value〉$ .
Constraint: $m \geq 1$ .; On entry, $n = 〈value〉$ .
Constraint: $n \geq 1$ .
NE_INTERNAL_ERROR: An internal error has occurred in this function. Check the function call and any array sizes. If the call is correct then please contact NAG for assistance.
NE_REAL: On entry, $r = 〈value〉$ .
Constraint: $r \geq 0.0$ .; On entry, $s = 〈value〉$ .
Constraint: $s \geq 〈value〉$ and $s \leq 〈value〉$ .; On entry, $sigma = 〈value〉$ .
Constraint: $sigma > 0.0$ .
NE_REAL_ARRAY: On entry, $t [〈value〉] = 〈value〉$ .
Constraint: $t [i] \geq 〈value〉$ .; On entry, $x [〈value〉] = 〈value〉$ .
Constraint: $x [i] \geq 〈value〉$ and $x [i] \leq 〈value〉$ .

7 Accuracy

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

Φ

. 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_cumul_normal (s15abc) and nag_erfc (s15adc)). An accuracy close to machine precision can generally be expected.

8 Further Comments

None.

9 Example

This example computes the price of an Asian geometric continuous average-rate call with a time to expiry of

3

months, a stock price of

80

and a strike price of

97

. The risk-free interest rate is

5 %

per year, the cost of carry is

8 %

and the volatility is

20 %

per year.

NAG Library Function Documentnag_asian_geom_greeks (s30sbc)

+− Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

6 Error Indicators and Warnings

7 Accuracy

8 Further Comments

9 Example

9.1 Program Text

9.2 Program Data

9.3 Program Results

NAG Library Function Document

nag_asian_geom_greeks (s30sbc)