Black Scholes Options Pricing Model in R

The Black Scholes model estimates the value of a European call or put option by using the following parameters:

1_S = Stock Price_
2
3_K = Strike Price at Expiration_ 
4
5_r = Risk-free Interest Rate_
6
7_T = Time to Expiration_
8
9_sig = Volatility of the Underlying asset_
10

Using R, we can write a function to compute the option price once we have the values of these 5 parameters. The BlackScholes function takes these parameters and returns the value of the call or put option.

1BlackScholes <- function(S, K, r, T, sig, type){
2  
3  if(type=="C"){
4  d1 <- (log(S/K) + (r + sig^2/2)*T) / (sig*sqrt(T))
5  d2 <- d1 - sig*sqrt(T)
6  
7  value <- S*pnorm(d1) - K*exp(-r*T)*pnorm(d2)
8  return(value)}
9  
10  if(type=="P"){
11  d1 <- (log(S/K) + (r + sig^2/2)*T) / (sig*sqrt(T))
12  d2 <- d1 - sig*sqrt(T)
13  
14  value <-  (K*exp(-r*T)*pnorm(-d2) - S*pnorm(-d1))
15  return(value)}
16}
17

This function first calculates the d1 and d2 parameters required for the Black-Scholes model  and then uses pnorm() command of R which simulates a cumulative normal distribution. In order to use the BlackScholes function to value a call and a put option, we can run the following lines:

1call <- BlackScholes(110,100,0.04,1,0.2,"C")
2put <- BlackScholes(110,100,0.04,1,0.2,"P")
3

Some basic assumption that this model has is that assumes that the volatility is constant over the life of the option. There are two ways to estimate the volatility that is plugged in the Black Scholes model. The first approach is by calculating the historical standard deviations of the stock returns and the second method uses the option market prices to find the Implied Volatility or the volatility that the market estimate for the stock.

As an example we can download data for AAPL stock from Quandl and compute the standard deviation of the returns for a 50 days period.

1# Get the Close column(4) from the WIKI dataset from Quandl of the APPL stock 
2
3data <- Quandl("WIKI/AAPL.4")
4
5# Retrieve the first 50 values
6
7recent_data <- data[1:50,]
8
9# Use the arrange function from dplyr package to get old values at top. This would guarantee that the calculations are performed with the oldest values of the series at first.
10
11recent_data <- arrange(recent_data, -row_number())
12
13# Add a new column with the returns of prices. Input NA to the first value of the column in order to fit the column in the recent_data data frame.
14
15recent_data$returns <- c('NA',round(diff(log(recent_data$Close)),3))
16
17# Convert the column to numeric
18
19recent_data$returns <- as.numeric(recent_data$returns)
20 
21# Calculate the standard deviation of the log returns
22
23Standard_deviation <- sd(recent_data$returns,na.rm=TRUE)
24

The result of this is a standard deviation of the returns of 0.01807. If we are dealing with Time until Expiration and Interest Rate on a year basis we need to convert the standard deviation measure to year values. This can be done with the following formula using 250 trading days in a year:

The annual standard deviation is 0.2857366.

The second approach to calculate volatility is to find the Implied Volatility value that the market estimates for a specific option. We can use the Black Scholes model to calculate the Implied Volatility by using known values of the stock price, strike price, time to expiration, interest rate and an array of standard deviation values that would allow us to find an option price which is the nearest price related to the option market price. 

Suppose that the parameters of the Black Scholes model are the following:

1_S <- 50_
2
3_K <- 70_
4
5_C <- 1.5 (Actual Call Price)_
6
7_r <- 0_
8
9_Time <- 1_
10
11_sigma <- seq(0.01,0.5,0.005)_
12

The variable CallValueperSigma would store all the option prices that are calculated with the different values of sigma along the sigma vector.

1# The variable CallValueperSigma would store all the option prices that are 
2# calculated with the different values of sigma along the sigma vector. 
3
4CallValueperSigma <- BlackScholes(S,K,r,Time,sigma) 
5

The next step is to find which of these values is the nearest compared to the actual call price which is 1.5.

1# IV is the the min value of the difference between each value of the  #CallValueperSigma  vector and the call price. 
2
3IV <- which.min(abs(CallValueperSigma-C))/2 
4
5#The “which” command would return the index of the value in the sigma vector that #correspond to the option price derived from the BlackScholes  function  that is #nearest respect  the call market price. 
6#This value is divided by two in order to get the specific Implied Volatility value from the sigma vector, because sigma starts from 0 to 0.5.
7

The Implied Volatility value from  above is 32%. So we can conclude that the market assign a 32 % of Implied Volatility to this contract option.