NFCP (version 0.1.0)

European.Option.Value: European.Option.Value

Description

Value European Option Put and Calls under the parameters of an N-factor model.

Usage

European.Option.Value(X.0, parameters, t, TTM, K, r, call, verbose = FALSE)

Arguments

X.0

Initial values of the state vector.

parameters

Named vector of parameter values of a specified N-factor model. Function NFCP.Parameters is recommended.

t

Time to expiration of the option

TTM

Time to maturity of the Futures contract.

K

Strike price of the European Option

r

Risk-free interest rate.

call

logical is the European option a call or put option?

verbose

logical. Should additional information be output? see details

Value

The European.Option.Value function returns a numeric value corresponding to the present value of an option when verbose = F. When verbose = T, European.Option.Value returns a list with three objects:

Value

Present value of the option.

Annualized.Volatility

Annualized volatility of the option.

Parameter.Sensitivity

Sensitivity of the option value to each parameter of the N-factor model.

Greeks

Sensitivity of the option value to different option parameters.

Details

The European.Option.Value function calculates analytic expressions of the value of European call and put options on futures contracts within the N-factor model. Under the assumption that future futures prices are log-normally distributed under the risk-neutral process, there exist analytic expressions of the value of European call and put options on futures contracts. The following analytic expression follows from that presented by Schwartz and Smith (2000) extended to the N-factor framework. The value of a European option on a futures contract is given by calculating its expected future value using the risk-neutral process and subsequently discounting at the risk-free rate.

One can verify that under the risk-neutral process, the expected futures price at time tt is:

E^*[F_T,t] = exp(_i=1^Ne^-_iTx_i(0) + ^*t + A(T-t) + 12(_1^2t+_i.j1e^-(_i+_j)(T-t)_i_j_i,j.1-e^-(_i+_j)t_i+_j)) F_T,0 E^*[F[T,t]] = exp(sum_i=1^N (e^(-kappa[i]*T) * x[i](0) + mu^* * t + A(T-t) + 1/2 (sigma[1]^2 + sum_[i.j != 1] (e^(- (kappa[i] + kappa[j])(T-t)) * sigma[i] * sigma[j] * rho[i,j] * (1 - e^(-(kappa[i] * kappa[j])t)) /(kappa[i] + kappa[j]))) equiv F[T,0]

This follows from the derivation provided within the vignette of the NFCP package as well as the details of the Futures.Price.Forecast package. The equality of expected futures price at time tt being equal to the time-tt current futures price F_T,0F[T,0] is proven by Futures prices being given by expected spot prices under the risk-neutral process (F_T,t=E_t^[S_T])F[T,t] = E[t]^*(S[T]) and the law of iterated expectations (E^[E_t^[S_T]]=E^[S_T])E^*(E[t]^*(S[T])) = E^*(S[T])

Because future futures prices are log-normally distributed under the risk-neutral process, we can write a closed-form expression for valuing European put and call options on these futures. When T=0T=0 these are European options on the spot price of the commodity itself. The value of a European call option on a futures contract maturing at time TT, with strike price KK, and with time tt until the option expires, is:

e^-rtE^[(F_T,t-K,0)]e^(-rt) * E^*(max(F[T,t] - K, 0)) = e^-rt( F_T,0N(d) - KN(d-_(t,T)))e^(-rt) * (F[T,0] * N(d) - K * N(d - sigma[phi](t,T)))

Where: d=(F/K)_(t,T)+12_(t,T)d = ln(F/K) / sigma[phi](t,T) + 1/2 sigma[phi](t,T)

and:

_(t,T) = (_1^2t+_i.j1e^-(_i+_j)(T-t)_i_j_i,j. 1-e^-(_i+_j)t_i+_j) sigma[phi](t,T) = sqrt( sigma[1]^2 + sum_[i.j != 1]( e^(-(kappa[i] + kappa[j])(T-t)) sigma[i] sigma[j] rho[i,j] * (1 - e^(-(kappa[i] + kappa[j])t))/(kappa[i] + kappa[j])))

Parameter N(d) N(d) indicates cumulative probabilities for the standard normal distribution (ie, P(Z<d)P(Z<d)).

Similarly, the value of a European put with the same parameters is given by:

e^-rt E^*[max(K-F_T,t,0)]e^(-rt) E^*(max(K - F[T,t],0))

=e^-rt(-F_T,0N(-d)+KN(_(t,T)-d))e^(-rt) * (- F[T,0] * N(-d) + K * N(sigma[phi](t,T) - d))

The presented option valuation formulas are analogous to the Black-Scholes formulas for valuing European options on stocks that do not pay dividends

Under this terminology, the stock price corresponds to the present value of the futures commitment (e^-rtF_T,0)e^(-rt) F[T,0] and the equivalent annualized volatility would be _(t,T)/ tsigma[phi](t,T) / sqrt(t)

When verbose = T, the European.Option.Value function numerically calculates the sensitivity of option prices to the underlying parameters specified within the N-factor model, as well as some of the most common "Greeks" related to European put and call option pricing. All gradients are calculated numerically by calling the grad function from the numDeriv package.

References

Schwartz, E. S., and J. E. Smith, (2000). Short-Term Variations and Long-Term Dynamics in Commodity Prices. Manage. Sci., 46, 893-911.

Cortazar, G., and L. Naranjo, (2006). An N-factor Gaussian model of oil futures prices. Journal of Futures Markets: Futures, Options, and Other Derivative Products, 26(3), 243-268.

Examples

Run this code
# NOT RUN {
##Example 1 - A European 'put' option on a stock following 'GBM'
##growing at the risk-free rate:

### Risk-free rate:
rf <- 0.05
### Stock price:
S0 <- 20
### Stock volatility:
S.sigma <- 0.2
### Option maturity:
Tt <- 1
### Exercise price:
K <- 20
### Calculate 'put' option price:
European.Option.Value(X.0 = log(S0), parameters = c(mu_star = rf, sigma_1 = S.sigma),
t = Tt, TTM = Tt, K = K, r = rf, call = FALSE)

##Example 2 - A European call option under a two-factor crude oil model:

##Step 1 - Obtain current (i.e. most recent) state vector by filtering the
##two-factor oil model:
Schwartz.Smith.Oil <- NFCP.Kalman.filter(parameter.values = SS.Oil$Two.Factor,
                                      parameters = names(SS.Oil$Two.Factor),
                                      log.futures = log(SS.Oil$Stitched.Futures),
                                      dt = SS.Oil$dt,
                                      TTM = SS.Oil$Stitched.TTM,
                                      verbose = TRUE)

##Step 2 - Calculate 'call' option price:
European.Option.Value(X.0 = Schwartz.Smith.Oil$X.t,
                      parameters = SS.Oil$Two.Factor,
                      t = Tt,
                      TTM = Tt,
                      K = K,
                      r = rf,
                      call = TRUE,
                      verbose = FALSE)
# }

Run the code above in your browser using DataLab