naginterfaces.library.specfun.opt_​imp_​vol

naginterfaces.library.specfun.opt_imp_vol(calput, p, k, s0, t, r, mode=1)

opt_imp_vol computes the implied volatility of a European option contract based on the Black–Scholes–Merton formula.

For full information please refer to the NAG Library document for s30ac

https://www.nag.com/numeric/nl/nagdoc_29.3/flhtml/s/s30acf.html

Parameters

calputstr, length 1

Determines whether the option is a call or a put.

$calput=\text{‘C'}$

A call; the holder has a right to buy.

$calput=\text{‘P'}$

A put; the holder has a right to sell.

pfloat, array-like, shape $\left(n\right)$

$p[i-1]$ must contain $P_i$, the $i$th option price, for $i=1,2,\dots ,n$.

kfloat, array-like, shape $\left(n\right)$

$k[i-1]$ must contain $K_i$, the $i$th strike price, for $i=1,2,\dots ,n$.

s0float, array-like, shape $\left(n\right)$

$s0[i-1]$ must contain $S_{0i}$, the $i$th spot price, for $i=1,2,\dots ,n$.

tfloat, array-like, shape $\left(n\right)$

$t[i-1]$ must contain $T_i$, the $i$th time, in years, to maturity, for $i=1,2,\dots ,n$.

rfloat, array-like, shape $\left(n\right)$

$r[i-1]$ must contain $r_i$, the $i$th interest rate, for $i=1,2,\dots ,n$. Note that a rate of 5% should be entered as 0.05.

modeint, optional

Specifies which algorithm will be used to compute the implied volatilities. See Accuracy and Parallelism and Performance for further guidance on the choice of mode.

$mode=0$

The Glau et al. (2018) algorithm will be used. The nodes used in the Chebyshev interpolation will be chosen to achieve relative accuracy to approximately seven decimal places;

$mode=1$

The Glau et al. (2018) algorithm will be used. The nodes used in the Chebyshev interpolation will be chosen to achieve relative accuracy to approximately $15$ decimal places, but limited by the machine precision;

$mode=2$

The Jäckel (2015) algorithm will be used, aiming for accuracy to approximately $15$–$16$ decimal places, but limited by machine precision.

Returns

sigmafloat, ndarray, shape $\left(n\right)$

$sigma[i-1]$ contains ${\sigma }_i$, the $i$th implied volatility, for $i=1,2,\dots ,n$.

ivalidint, ndarray, shape $\left(n\right)$

$ivalid[i-1]$ indicates any errors with the input arguments that prevented ${\sigma }_i$ from being computed. If $ivalid[i-1]\ne 0$, $sigma[i-1]$ contains $0.0$.

$ivalid[i-1]=0$

No error.

$ivalid[i-1]=1$

$P_i<0.0$.

$ivalid[i-1]=2$

$K_i\le 0.0$.

$ivalid[i-1]=3$

$S_{0i}\le 0.0$.

$ivalid[i-1]=4$

$T_i\le 0.0$.

$ivalid[i-1]=5$

The combination of $P_i$, $K_i$, $S_{0i}$, $T_i$ and $r_i$ is out of the domain in which ${\sigma }_i$ can be computed. See Further Comments for further details.

Raises

NagValueError

(errno $2$)

On entry, $n=⟨value⟩$.

Constraint: $n\ge 0$.

(errno $3$)

On entry, $mode=⟨value⟩$.

Constraint: $mode=0$, $1$ or $2$.

(errno $4$)

On entry, $calput=⟨value⟩$.

Constraint: $calput=\text{‘C'}\text{or}\text{‘P'}$.

Warns

NagAlgorithmicWarning

(errno $1$)

On entry at least one input argument was invalid.

Check $ivalid$ for more information.

Notes

The Black–Scholes formula for the price of a European option is

$$P_{call}=S_0\Phi \left(\frac{ln\left(\frac{S_0}{K}\right)+[r+\frac{{\sigma }^2}{2}]T}{\sigma \sqrt{T}}\right)-K{e}^{-rT}\Phi \left(\frac{ln\left(\frac{S_0}{K}\right)+[r-\frac{{\sigma }^2}{2}]T}{\sigma \sqrt{T}}\right)\text{,}$$

for a call option, and

$$P_{put}=K{e}^{-rT}\Phi \left(\frac{-ln\left(\frac{S_0}{K}\right)-[r-\frac{{\sigma }^2}{2}]T}{\sigma \sqrt{T}}\right)-S_0\Phi \left(\frac{-ln\left(\frac{S_0}{K}\right)-[r+\frac{{\sigma }^2}{2}]T}{\sigma \sqrt{T}}\right)\text{,}$$

for a put option, where $\Phi$ is the cumulative Normal distribution function, $T$ is the time to maturity, $S_0$ is the spot price of the underlying asset, $K$ is the strike price, $r$ is the interest rate and $\sigma$ is the volatility.

Given arrays of values $P_i$, $K_i$, $S_{0i}$, $T_i$ and $r_i$, for $i=1,2,\dots n$, opt_imp_vol computes the implied volatilities ${\sigma }_i$.

opt_imp_vol offers the choice of two algorithms. The algorithm of Glau et al. (2018) uses Chebyshev interpolation to compute the implied volatilities, and performs best for long arrays of input data. The algorithm of Jäckel (2015) uses a third order Householder iteration and performs better for short arrays of input data.

References

Glau, K, Herold, P, Madan, D B and Pötz, C, 2018, The Chebyshev method for the implied volatility, Accepted for publication in the Journal of Computational Finance

Jäckel, P, 2015, Let’s be Rational, Wilmott Magazine (2015(75)), 40–53