European.Option.Value: European.Option.Value
In TomAspinall/TSE: N-Factor Commodity Pricing Models

Description Usage Arguments Details Value References Examples

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

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

`X.0`	Initial values of the state vector.
`parameters`	Named vector of parameter values of a specified N-factor model. Function `CPM.Parameters.Generate` 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

\loadmathjax

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 \mjeqntt is:

\mjdeqn

E^*[F_T,t] = exp(\sum_i=1^Ne^-\kappa_iTx_i(0) + \mu^*t + A(T-t) + \frac12(\sigma_1^2t+\sum_i.j\neq1e^-\left(\kappa_i+\kappa_j\right)\left(T-t\right)\sigma_i\sigma_j\rho_i,j.\frac1-e^-\left(\kappa_i+\kappa_j\right)t\kappa_i+\kappa_j)) \equiv 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 NFCPM package as well as the details of the Futures.Price.Forecast package. The equality of expected futures price at time \mjeqntt being equal to the time-\mjeqntt current futures price \mjeqnF_T,0F[T,0] is proven by Futures prices being given by expected spot prices under the risk-neutral process \mjeqn(F_T,t=E_t^\ast\left[S_T\right])F[T,t] = E[t]^*(S[T]) and the law of iterated expectations \mjeqn\left(E^\ast\left[E_t^\ast\left[S_T\right]\right]=E^\ast\left[S_T\right]\right)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 \mjeqnT=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 \mjeqnTT, with strike price \mjeqnKK, and with time \mjeqntt until the option expires, is:

\mjdeqn

e^-rtE^\ast\left[\max\left(F_T,t-K,0\right)\right]e^(-rt) * E^*(max(F[T,t] - K, 0)) \mjdeqn= e^-rt( F_T,0N(d) - KN(d-\sigma_\phi(t,T)))e^(-rt) * (F[T,0] * N(d) - K * N(d - sigma[phi](t,T)))

Where: \mjdeqnd=\frac\ln(F/K)\sigma_\phi(t,T)+\frac12\sigma_\phi\left(t,T\right)d = ln(F/K) / sigma[phi](t,T) + 1/2 sigma[phi](t,T)

and:

\mjdeqn\sigma

_\phi\left(t,T\right) = \sqrt(\sigma_1^2t+\sum_i.j\neq1e^-\left(\kappa_i+\kappa_j\right)\left(T-t\right)\sigma_i\sigma_j\rho_i,j. \frac1-e^-\left(\kappa_i+\kappa_j\right)t\kappa_i+\kappa_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 \mjeqn N(d) N(d) indicates cumulative probabilities for the standard normal distribution (ie, \mjeqnP(Z<d)P(Z<d)).

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

\mjdeqn

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

\mjdeqn

=e^-rt\left(-F_T,0N\left(-d\right)+KN\left(\sigma_\phi\left(t,T\right)-d\right)\right)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 \mjeqn(e^-rtF_T,0)e^(-rt) F[T,0] and the equivalent annualized volatility would be \mjeqn\sigma_\phi(t,T)/\sqrt 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.

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.

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.

##Example 1 - A European Call Option under a Two-Factor Crude Oil Model:

##Step 1 - Obtain the state vector by filtering the Two-Factor Oil Model:
Schwartz.Smith.Oil <- CPM.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 Option Value:
Oil.Option.Value <- European.Option.Value(X.0 = Schwartz.Smith.Oil$X.t,
                                             parameters = SS.Oil$Two.Factor,
                                             t = 1,
                                             TTM = 1,
                                             K = 20,
                                             r = 0.05,
                                             call = TRUE, verbose = TRUE)


##Example 2 - A GBM that grows at the risk-free rate:
European.Option.Value(X.0 = log(20), parameters = c(mu_star = 0.05, sigma_1 = 0.2),
t = 1, TTM = 1, K = 20, r = 0.05, call = TRUE)
##Not run - Verify Results with the 'BS_EC' function from 'OptionPricing':
# requireNamespace("OptionPricing")
# OptionPricing::BS_EC(K = 20, r = 0.05, sigma = 0.2, T = 1, S0 = 20)[1]