FinancialToolbox.jl

About this Package

FinancialToolbox.jl is a Julia package containing some useful Financial functions for Pricing and Risk Management under the Black and Scholes Model.

The syntax is the same of the Matlab Financial Toolbox. Currently supports classical numerical input and other less common like:

Getting started

In order to get started, just add the package:

pkg> add FinancialToolbox

and load it:

using FinancialToolbox

Example of Usage

Pricing European Options in the Black and Scholes model
Pricing European Options in the Black model
Implied Volatility in the Black and Scholes model
Implied Volatility in the Black model

Pricing a European Option in Black and Scholes framework:
According to Black and Scholes model, the price of a european option can be expressed as follows:

European Call Price

C_{bs}(S,K,r,T,\sigma,d) = S e^{-d\,T} N(d_1) - Ke^{-r\,T} N(d_2)

European Put Price

P_{bs}(S,K,r,T,\sigma,d) = Ke^{-r\,T} N(-d_2) - S e^{-d\,T} N(-d_1)

where:

d_1 = \frac{\ln\left(\frac{S}{K}\right) + \left(r - q + \frac{\sigma^2}{2}\right) T}{\sigma\sqrt{T}}

d_2 = d_1 - \sigma\sqrt{T}

And:

$S$ is the underlying spot price.
$K$ is the strike price.
$r$ is the risk free rate.
$T$ is the time to maturity.
$\sigma$ is the implied volatility of the underlying.
$d$ is the implied dividend of the underlying.

The way to compute the price in this library is:

European Call Price

S=100.0; K=100.0; r=0.02; T=1.2; σ=0.2; d=0.01;
Price_call=blsprice(S,K,r,T,σ,d)

9.169580760087896

European Put Price

S=100.0; K=100.0; r=0.02; T=1.2; σ=0.2; d=0.01;
Price_put=blsprice(S,K,r,T,σ,d,false)

7.990980449685762

Pricing a European Option in Black framework:
According to Black model, the price of a european option can be expressed as follows:

European Call Price

C_{bk}(F,K,r,T,\sigma) = F e^{-r\,T} N(d_1) - Ke^{-r\,T} N(d_2)

European Put Price

P_{bk}(F,K,r,T,\sigma) = Ke^{-r\,T} N(-d_2) - F e^{-r\,T} N(-d_1)

where:

d_1 = \frac{\ln\left(\frac{F}{K}\right) + \frac{\sigma^2}{2}T}{\sigma\sqrt{T}}

d_2 = d_1 - \sigma\sqrt{T}

And:

$F$ is the underlying forward price.
$K$ is the strike price.
$r$ is the risk free rate.
$T$ is the time to maturity.
$\sigma$ is the implied volatility of the underlying.

The way to compute the price in this library is:

European Call Price

F=100.0; K=102.0; r=0.02; T=1.2; σ=0.2;
Price_call=blkprice(S,K,r,T,σ)

7.659923984582901

European Put Price

F=100.0; K=102.0; r=0.02; T=1.2; σ=0.2;
Price_put=blkprice(S,K,r,T,σ,false)

9.612495404098706

Computing Implied Volatility in a Black and Scholes framework: Given an option price

V

, the Black and Scholes implied volatility is defined as the positive number

\sigma

which solves:

From European Call Price

V = S e^{-d\,T} N(d_1) - Ke^{-r\,T} N(d_2)

From European Put Price

V = Ke^{-r\,T} N(-d_2) - S e^{-d\,T} N(-d_1)

where:

d_1 = \frac{\ln\left(\frac{S}{K}\right) + \left(r - q + \frac{\sigma^2}{2}\right) T}{\sigma\sqrt{T}}

d_2 = d_1 - \sigma\sqrt{T}

The way to compute the volatility in this library is:

Implied Volatility from Call Price

S=100.0; K=100.0; r=0.02; T=1.2; d=0.01;
call_price=9.169580760087896
σ=blsimpv(S,K,r,T,call_price,d)

0.20000000000000046

Implied Volatility from Put Price

S=100.0; K=100.0; r=0.02; T=1.2; d=0.01;
put_price=7.990980449685762
σ=blsimpv(S,K,r,T,put_price,d,false)

0.19999999999999976

blsimpv accepts additional arguments such as the absolute tolerance and the maximum numbers of steps of the numerical inversion.

Currently blsimpv is using the rational inversion method based on LetsBeRational method in order to invert the relation between the price and the volatility. If you notice something wrong with the numerical inversion, you are strongly suggested to open a issue.

Computing Implied Volatility in Black framework:
Given an option price

V

, the Black implied volatility is defined as the positive number

\sigma

which solves:

From European Call Price

V = F e^{-r\,T} N(d_1) - Ke^{-r\,T} N(d_2)

From European Put Price

V = Ke^{-r\,T} N(-d_2) - F e^{-r\,T} N(-d_1)

where:

d_1 = \frac{\ln\left(\frac{F}{K}\right) + \frac{\sigma^2}{2}T}{\sigma\sqrt{T}}

d_2 = d_1 - \sigma\sqrt{T}

The way to compute the volatility in this library is:

Implied Volatility from Call Price

S=100.0; K=102.0; r=0.02; T=1.2;
call_price=7.659923984582901
σ=blkimpv(S,K,r,T,call_price)

0.20000000000000026

Implied Volatility from Put Price

S=100.0; K=102.0; r=0.02; T=1.2;
put_price=9.612495404098706
σ=blkimpv(S,K,r,T,put_price,false)

0.19999999999999984

blkimpv accepts additional arguments such as the absolute tolerance and the maximum numbers of steps of the numerical inversion.

Currently blkimpv is using the rational inversion method based on LetsBeRational method in order to invert the relation between the price and the volatility. If you notice something wrong with the numerical inversion, you are strongly suggested to open a issue.

Automatic Differentiation

Pricers and sensitivities functions are differentiable as far as the AD engine is capable of differentiating the erfc function.
Implied volatility computations are fully differentiable by using ChainRulesCore.jl. Explicit support for ForwardDiff, ReverseDiff, TaylorDiff, TaylorSeries is added. In case your package does not support ChainRulesCore.jl APIs, please open an issue if you need the support for implied volatility differentiation.
Automatic Differentiation of Implied Volatility:
In a Black and Scholes setup, let's define

f(S,K,r,T,\sigma,d)

as follows:

For European Call

f = C_{bs}(S,K,r,T,\sigma,d)

For European Put

f = P_{bs}(S,K,r,T,\sigma,d)

Let's fix a feasible option price

V

. Then we can compute the derivative of the implied volatility as follows:
Since

\sigma=\sigma(S,K,r,T,V,d)

solves the inversion, then:

f(S,K,r,T,\sigma(S,K,r,T,V,d),d) = V

By differentating both sides for a generic parameter $\theta$ we get:

\partial_{\theta}\sigma = \frac{\partial_{\theta}(V-f(S,K,r,T,\sigma,d))}{\partial_{\sigma}f(S,K,r,T,\sigma,d)}

Very similar applies to Black model:

\partial_{\theta}\sigma = \frac{\partial_{\theta}(V-f(F,K,r,T,\sigma))}{\partial_{\sigma}f(F,K,r,T,\sigma)}

with:

For European Call

f = C_{bk}(F,K,r,T,\sigma)

For European Put

f = P_{bk}(F,K,r,T,\sigma)

This formulation of the derivative allows to define analytically the frule and the rrule for the function blsimpv and blkimpv, without the need of differentiating the numerical solver, proving once again the superiority of automatic differentiation against numerical one.