# Learning Option Pricing

## Johan Astborg

December 2013

(for more resources related to this topic, see here.)

# Introduction to options

Options come in two variants, puts and calls. The call option gives the owner of the option the right, but not the obligation, to buy the underlying asset at the strike price. The put gives the holder of the contract, the right but not the obligation to sell the underlying asset. The Black-Scholes formula describes the European option, which can only be exercised on the maturity date, in contrast to for example American options. The buyer of the option pays a premium for this, to cover the risk taken from the counterpart side. Options have become very popular and they are traded on the major exchanges throughout the world, covering most asset-classes.

The theory behind options can become complex pretty quick. In this article we'll look at the basics of options and how to explore them using code written in F#.

## Looking into contract specifications

Options comes in a wide number of variations, some of them will be covered briefly below. The contract specifications for options will also depend on its type. Generally there are some properties that are more or less general to all of them. The general specifications are as follows:

• Side
• Quantity
• Strike price
• Expiration date
• Settlement terms

The contract specifications, or know variables, are used then we valuate options.

## European options

European options are the basic form of options that the other variants derive, American options and exotic options are some examples. We'll stick to European options in this article.

## American options

American options are options that may be exercised on any trading day on or before expiry.

## Exotic options

Exotic options are any of the broad category of options that may include complex financial structures and may be combinations of other instruments as well.

Wiener processes are closely related to stochastic differential equations and volatility. Wiener processes or geometric Brownian motion, is defined as this:

The formula describes the change in the stock price, or underlying, with a drift, μ, and a volatility, σ, and the Wiener process, Wt. This process is used to model the prices in Black-Scholes.

We'll simulate market data using a Brownian motion, or Wiener process implemented in F# as a sequence. Sequences can be infinite and only the values used are evaluated, which suites or needs. We'll implement a generator function, to generate the Wiener process as a sequence as follows:

```// A normally distributed random generator
let normd = new Normal(0.0, 1.0)
let T = 1.0
let N = 500.0
let dt:float = T / N

/// Sequences represent infinite number of elements
// p -> probability mean
// s -> scaling factor
let W s =
let rec loop x = seq { yield x; yield! loop (x + sqrt(dt)*normd.Sample()*s)}
loop s;;```

Here we use the random function in normd.Sample(). Let's explain the parameters and the theory behind Brownian motion before looking at the implementation. The parameter T is the time used to create a discrete time increment dt. Notice that dt will assume there is 500 N:s, 500 items in the sequence, this is of course not always the case but will do fine in here. Next, we use recursion to create the sequence, where we add an increment to the previous value (x+...), where x c] xt-1.

We can easily generate an arbitrary length of the sequence:

```> Seq.take 50 (W 55.00);;
val it : seq<float> = seq [55.0; 56.72907873; 56.96071054;58.72850048; ...]```

Here we create a sequence of length 50. Let's plot the sequence to get a better understanding about the process.

A Wiener process generated from the sequence generator above.

Next we'll look at the code to generate the graph in the figure above.

```open System
open System.Net
open System.Windows.Forms
open System.Windows.Forms.DataVisualization.Charting
open Microsoft.FSharp.Control.WebExtensions
open MathNet.Numerics.Distributions;

// A normally distributed random generator
let normd = new Normal(0.0, 1.0)

// Create chart and form
let chart = new Chart(Dock = DockStyle.Fill)
let area = new ChartArea("Main")

let mainForm = new Form(Visible = true, TopMost = true,
Width = 700, Height = 500)

do mainForm.Text <- "Wiener process in F#"

// Create series for stock price
let wienerProcess = new Series("process")
do wienerProcess.ChartType <- SeriesChartType.Line
do wienerProcess.BorderWidth <- 2
do wienerProcess.Color <- Drawing.Color.Red

let random = new System.Random()
let rnd() = random.NextDouble()
let T = 1.0
let N = 500.0
let dt:float = T / N

/// Sequences represent infinite number of elements
let W s =
let rec loop x = seq { yield x; yield! loop (x +/ sqrt(dt)*normd.Sample()*s)}
loop s;;

do (Seq.take 100 (W 55.00)) |> Seq.iter (wienerProcess.Points.Add>> ignore)```

Most of the code will be familiar to you at this stage, but the interesting part is the last line, where we can simply feed a chosen number of elements from the sequence into the Seq.iter which will plot the values, elegant and efficient.

# Learning the Black-Scholes formula

The Black-Scholes formula was developed by Fischer Black and Myron Scholes in the 1970s. The Black-Scholes formula is a stochastic partial differential equation, which estimates the price an the option. The main idea behind the formula is the delta neutral portfolio. They created the theoretical delta neutral portfolio, to reduce the uncertainty involved.

This was a necessary step to be able to come to the analytical formula which we’ll cover in this section. Below is the assumptions made under Black-Scholes:

• No arbitrage
• Possible to borrow money at a constant risk-free interest rate (throughout the holding of the option)
• Possible to buy, sell and short fractional amounts of underlying asset
• No transaction costs
• Price of underlying follows a Brownian Motion, constant drift and volatility
• No dividends paid from underlying security

The simplest of the two variants is the one for call options. First the stock price is scaled using the cumulative distribution function with d1 as a parameter. Then the stock price is reduced by the discounted strike price scaled by the cumulative distribution function of d2. In other words, it’s the difference between the stock price and the strike using probability scaling of each and discounting the strike price.

The formula for the put is a little more involved, but follows the same principles.

The Black-Scholes formula are often separated into parts, where d1, d2 are the probability factors, describing the probability of the stock price being related to the strike price.

The parameters used in the formula above can be summarized as follows:

• N – The cumulative distribution function
• T - Time to maturity, expressed in years
• S – The stock price, or other underlying
• K – The strike price
• r – The risk free interest rate
• σ – The volatility of the underlying

## Implementing Black-Scholes in F#

Now that we've looked at the basics behind the Black-Scholes formula, and the parameters involved, we can implement it ourselves. The cumulative distribution function is implemented here to avoid dependencies and to illustrate that it's quite simple to implement it yourself too. Below is the Black-Scholes implemented in F#. It takes six arguments; the first is a call-put-flag that determines if it's a call or put option. The constants a1 to a5 are the Taylor series coefficients used in the approximation for the numerical implementation.

```let pow x n = exp(n * log(x))

type PutCallFlag = Put | Call

/// Cumulative distribution function
let cnd x =
let a1 =  0.31938153
let a2 = -0.356563782
let a3 =  1.781477937
let a4 = -1.821255978
let a5 =  1.330274429
let pi = 3.141592654
let l  = abs(x)
let k  = 1.0 / (1.0 + 0.2316419 * l)
let w  = (1.0-1.0/sqrt(2.0*pi)*exp(-l*l/2.0)*(a1*k+a2*k*k+a3*(pow k 3.0)+a4*(pow k 4.0)+a5*(pow k 5.0)))
if x < 0.0 then 1.0 - w else w

/// Black-Scholes
// call_put_flag: Put | Call
// s: stock price
// x: strike price of option
// t: time to expiration in years
// r: risk free interest rate
// v: volatility
let black_scholes call_put_flag s x t r v =
let d1=(log(s / x) + (r+v*v*0.5)*t)/(v*sqrt(t))
let d2=d1-v*sqrt(t)
//let res = ref 0.0

match call_put_flag with
| Put -> x*exp(-r*t)*cnd(-d2)-s*cnd(-d1)
| Call -> s*cnd(d1)-x*exp(-r*t)*cnd(d2)```

Let's use the black_scholes function using some various numbers for call and put options. Suppose we want to know the price of an option, where the underlying is a stock traded at \$58.60 with an annual volatility of 30%. The risk free interest rate is, let's say, 1%. Then we can use our formula, we defined previously to get the theoretical price according the Black-Scholes formula of a call option with 6 month to maturity (0.5 years):

```> black_scholes Call 58.60 60.0 0.5 0.01 0.3;;
val it : float = 4.465202269```

And the value for the put option, just by changing the flag to the function:

```> black_scholes Put  58.60 60.0 0.5 0.01 0.3;;
val it : float = 5.565951021```

Sometimes it's more convenient to express the time to maturity in number of days, instead of years. Let's introduce a helper function for that purpose.

```/// Convert the nr of days to years
let days_to_years d =
(float d) / 365.25```

Note the number 365.25 which includes the factor for leap years. This is not necessary in our examples, but used for correctness. We can now use this function instead, when we know the time in days.

```> days_to_years 30;;
val it : float = 0.08213552361```

Let's use the same example above, but now with 20 days to maturity.

```> black_scholes Call 58.60 60.0 (days_to_years 20) 0.01 0.3;;
val it : float = 1.065115482

> black_scholes Put 58.60 60.0 (days_to_years 20) 0.01 0.3;;
val it : float = 2.432270266```

## Using Black-Scholes together with Charts

Sometimes it's useful to be able to plot the price of an option until expiration. We can use our previously defined functions and vary the time left and plot the values coming out. In this example we'll make a program that outputs the graph seen below.

Chart showing prices for call and put option as function of time

```/// Plot price of option as function of time left to maturity
#r "System.Windows.Forms.DataVisualization.dll"

open System
open System.Net
open System.Windows.Forms
open System.Windows.Forms.DataVisualization.Charting
open Microsoft.FSharp.Control.WebExtensions

/// Create chart and form
let chart = new Chart(Dock = DockStyle.Fill)
let area = new ChartArea("Main")

let mainForm = new Form(Visible = true, TopMost = true,
Width = 700, Height = 500)

do mainForm.Text <- "Option price as a function of time"

/// Create series for call option price
let optionPriceCall = new Series("Call option price")
do optionPriceCall.ChartType <- SeriesChartType.Line
do optionPriceCall.BorderWidth <- 2
do optionPriceCall.Color <- Drawing.Color.Red

/// Create series for put option price
let optionPricePut = new Series("Put option price")
do optionPricePut.ChartType <- SeriesChartType.Line
do optionPricePut.BorderWidth <- 2
do optionPricePut.Color <- Drawing.Color.Blue

/// Calculate and plot call option prices
let opc = [for x in [(days_to_years 20)..(-(days_to_years 1))..0.0]do yield black_scholes Call 58.60 60.0 x 0.01 0.3]
do opc |> Seq.iter (optionPriceCall.Points.Add >> ignore)

/// Calculate and plot put option prices
let opp = [for x in [(days_to_years 20)..(-(days_to_years 1))..0.0]do yield black_scholes Put 58.60 60.0 x 0.01 0.3]
do opp |> Seq.iter (optionPricePut.Points.Add >> ignore)```

The code is just a modified version of the code seen in the previous article, with the options parts added. We have two series in this chart, one for call options and one for put options. We also add a legend for each of the series. The last part is the calculation of the prices and the actual plotting. List comprehensions are used for compact code, and the Black-Scholes formula is called for everyday until expiration, where the days are counted down by one day at each step.

It's up to you as a reader to modify the code to plot various aspects of the option, such as the option price as a function of an increase in the underlying stock price etc.

## Introducing the greeks

The greeks are partial derivatives of the Black-Scholes formula, with respect to a particular parameter such as time, rate, volatility or stock price. The greeks can be divided into two or more categories, with respect to the order of the derivatives. Below we'll look at the first and second order greeks.

### First order greeks

In this section we'll present the first order greeks using the table below.

 Name Symbol Description Delta Δ Rate of change of option value with respect to change in the price of the underlying asset. Vega ν Rate of change of option value with respect to change in the volatility of the underlying asset. Referred to as the volatility sensitivity. Theta Θ Rate of change of option value with respect to time. The sensitivity with respect to time will decay as time elapses, phenomenon referred to as the "time decay." Rho ρ Rate of change of option value with respect to the interest rate.

### Second order greeks

In this section we'll present the second order greeks using the table below.

 Name Symbol Description Gamma Γ Rate of change of delta with respect to change in the price of the underlying asset. Veta - Rate of change in Vega with respect to time. Vera - Rate of change in Rho with respect to volatility.

Some of the second order greeks are omitted for clarity, we'll not cover these in this book.

## Implementing the greeks in F#

Let's implement the greeks; Delta, Gamma, Vega, Theta and Rho. First we look at the formulas for each greek. In some of the cases they vary for calls and puts respectively.

We need the derivative of the cumulative distribution function, which in fact is the normal distribution with zero mean and standard deviation of one:

```/// Normal distribution
open MathNet.Numerics.Distributions;

let normd = new Normal(0.0, 1.0)```

### Delta

Delta is the rate of change of option price with respect to change in the price of the underlying asset.

```/// Black-Scholes Delta
// call_put_flag: Put | Call

// s: stock price
// x: strike price of option
// t: time to expiration in years
// r: risk free interest rate
// v: volatility
let black_scholes_delta call_put_flag s x t r v =
let d1=(log(s / x) + (r+v*v*0.5)*t)/(v*sqrt(t))
match call_put_flag with
| Put -> cnd(d1) - 1.0
| Call -> cnd(d1)```

### Gamma

Gamma is the rate of change of delta with respect to change in the price of the underlying asset. This is the 2nd derivative, with respect to price of the underlying asset. It measures the acceleration of the price of the option with respect to the underlying price.

```/// Black-Scholes Gamma
// s: stock price
// x: strike price of option
// t: time to expiration in years
// r: risk free interest rate
// v: volatility
let black_scholes_gamma s x t r v =
let d1=(log(s / x) + (r+v*v*0.5)*t)/(v*sqrt(t))
normd.Density(d1) / (s*v*sqrt(t)```

### Vega

Vega is the rate of change of option value with respect to change in the volatility of the underlying asset. It is referred to as the volatility sensitivity.

```/// Black-Scholes Vega
// s: stock price
// x: strike price of option
// t: time to expiration in years
// r: risk free interest rate
// v: volatility
let black_scholes_vega s x t r v =
let d1=(log(s / x) + (r+v*v*0.5)*t)/(v*sqrt(t))
s*normd.Density(d1)*sqrt(t)```

### Theta

Theta is the rate of change of option value with respect to time. The sensitivity with respect to time will decay as time elapses, phenomenon referred to as the “time decay.”

```/// Black-Scholes Theta
// call_put_flag: Put | Call
// s: stock price
// x: strike price of option
// t: time to expiration in years
// r: risk free interest rate
// v: volatility
let black_scholes_theta call_put_flag s x t r v =
let d1=(log(s / x) + (r+v*v*0.5)*t)/(v*sqrt(t))
let d2=d1-v*sqrt(t)
let res = ref 0.0
match call_put_flag with
| Put -> -(s*normd.Density(d1)*v)/(2.0*sqrt(t))+r*x*exp(-r*t)*cnd(-d2)
| Call -> -(s*normd.Density(d1)*v)/(2.0*sqrt(t))-r*x*exp(-r*t)*cnd(d2)```

### Rho

Rho is rate of change of option value with respect to the interest rate.

```/// Black-Scholes Rho
// call_put_flag: Put | Call
// s: stock price
// x: strike price of option
// t: time to expiration in years
// r: risk free interest rate
// v: volatility
let black_scholes_rho call_put_flag s x t r v =
let d1=(log(s / x) + (r+v*v*0.5)*t)/(v*sqrt(t))
let d2=d1-v*sqrt(t)
let res = ref 0.0
match call_put_flag with
| Put -> -x*t*exp(-r*t)*cnd(-d2)
| Call -> x*t*exp(-r*t)*cnd(d2)```

### Investigating the sensitivity of the of the greeks

Now that we have all the greeks implemented we'll investigate the sensitivity of some of them and see how they vary when the underlying stock price changes.

The figure below is a surface plot with four of the greeks where time and underlying price is changing. The figure below is generated in MATLAB, and will not be generated in F#. We’ll use a 2D version of the graph to study the greeks below.

Surface plot of Delta, Gamma, Theta and Rho of a call option.

In this section we'll start by plotting the value of Delta for a call option where we vary the price of the underlying. This will result in the following 2D plot:

A plot of call option delta versus price of underlying

The result in the plot seen in figure above will be generated by the code presented next. We'll reuse most of the code from the example where we looked at the option prices for calls and puts. A slightly modified version is presented here, where the price of the underlying varies from \$10.0 to \$70.0.

```/// Plot delta of call option as function of underlying price
#r "System.Windows.Forms.DataVisualization.dll"

open System
open System.Net
open System.Windows.Forms
open System.Windows.Forms.DataVisualization.Charting
open Microsoft.FSharp.Control.WebExtensions

/// Create chart and form
let chart = new Chart(Dock = DockStyle.Fill)
let area = new ChartArea("Main")

let mainForm = new Form(Visible = true, TopMost = true,
Width = 700, Height = 500)

do mainForm.Text <- "Option delta as a function of underlying price"

/// Create series for call option delta
let optionDeltaCall = new Series("Call option delta")
do optionDeltaCall.ChartType <- SeriesChartType.Line
do optionDeltaCall.BorderWidth <- 2
do optionDeltaCall.Color <- Drawing.Color.Red

/// Calculate and plot call delta
let opc = [for x in [10.0..1.0..70.0] do yield black_scholes_delta Call x 60.0 0.5 0.01 0.3]
do opc |> Seq.iter (optionDeltaCall.Points.Add >> ignore)```

We can extend the code to plot all four greeks, as in the figure with the surface plots, but here in 2D. The result will be a graph like seen in the figure below.

Graph showing the for Greeks for a call option with respect to price change (x-axis).

### Code listing for visualizing the four greeks

Below is the code listing for the entire program used to create the graph above.

```#r "System.Windows.Forms.DataVisualization.dll"

open System
open System.Net
open System.Windows.Forms
open System.Windows.Forms.DataVisualization.Charting
open Microsoft.FSharp.Control.WebExtensions

/// Create chart and form
let chart = new Chart(Dock = DockStyle.Fill)
let area = new ChartArea("Main")

let mainForm = new Form(Visible = true, TopMost = true,
Width = 700, Height = 500)

do mainForm.Text <- "Option delta as a function of underlying price"

We’ll create one series for each greek:

```/// Create series for call option delta
let optionDeltaCall = new Series("Call option delta")
do optionDeltaCall.ChartType <- SeriesChartType.Line
do optionDeltaCall.BorderWidth <- 2
do optionDeltaCall.Color <- Drawing.Color.Red

/// Create series for call option gamma
let optionGammaCall = new Series("Call option gamma")
do optionGammaCall.ChartType <- SeriesChartType.Line
do optionGammaCall.BorderWidth <- 2
do optionGammaCall.Color <- Drawing.Color.Blue

/// Create series for call option theta
let optionThetaCall = new Series("Call option theta")
do optionThetaCall.ChartType <- SeriesChartType.Line
do optionThetaCall.BorderWidth <- 2
do optionThetaCall.Color <- Drawing.Color.Green

/// Create series for call option vega
let optionVegaCall = new Series("Call option vega")
do optionVegaCall.ChartType <- SeriesChartType.Line
do optionVegaCall.BorderWidth <- 2
do optionVegaCall.Color <- Drawing.Color.Purple

Next, we’ll calculate the values to plot for each greek:

```/// Calculate and plot call delta
let opd = [for x in [10.0..1.0..70.0] do yield black_scholes_delta Call x 60.0 0.5 0.01 0.3]
do opd |> Seq.iter (optionDeltaCall.Points.Add >> ignore)

/// Calculate and plot call gamma
let opg = [for x in [10.0..1.0..70.0] do yield black_scholes_gamma x 60.0 0.5 0.01 0.3]
do opg |> Seq.iter (optionGammaCall.Points.Add >> ignore)

/// Calculate and plot call theta
let opt = [for x in [10.0..1.0..70.0] do yield black_scholes_theta Call x 60.0 0.5 0.01 0.3]
do opt |> Seq.iter (optionThetaCall.Points.Add >> ignore)

/// Calculate and plot call vega
let opv = [for x in [10.0..1.0..70.0] do yield black_scholes_vega x 60.0 0.1 0.01 0.3]
do opv |> Seq.iter (optionVegaCall.Points.Add >> ignore)```

# Summary

In this article, we looked into using F# for investigating different aspects of volatility. Volatility is an interesting dimension of finance where you quickly dive into complex theories and models. Here it's very much helpful to have a powerful tool such as F# and F# Interactive. We've just scratched the surface of options and volatility in this article. There is a lot more to cover, but that's outside the scope of this book. Most of the content here will be used in the trading system.

## resources for article:

further resources on this subject:

You've been reading an excerpt of: