Target audience: Intermediate

Estimated reading time: 5'

Ever pondered how the pricing of an option on a future or index works? Curious about the underlying formula?

This article offers a succinct summary of the Black-Scholes formula and discusses how it's implemented in Scala, utilizing memoization to enhance execution speed.

Table of contents

Overview

Theory

Implementation

Formulation

Memoization

Monte-Carlo simulation

Evaluation

References

What you will learn: A fast, memoized implementation of option pricing equation of Black-Scholes.

Notes:

For the sake of readability of the implementation of algorithms, all non-essential code such as error checking, comments, exception, validation of class and method arguments, scoping qualifiers or import is omitted.
Familiarity with option trading [ref 1] is not required to understand the topic
Environments: Scala 2.12.10, JDK 11

Overview

You don't need to be a seasoned professional in option trading or asset valuation to grasp the essence of Black-Scholes.

The Black-Scholes model is a method employed to calculate the fair or theoretical value of a call or put option. This calculation is based on six key factors: the volatility, the type of option, the price of the underlying stock, the duration until expiration, the strike price, and the risk-free interest rate.

The Black-Scholes-Merton equations, a notable set of stochastic partial differential formulas, are renowned for pricing options based on underlying security's price, volatility, and expiration time [ref 2]. Functional languages like Scala give developers the flexibility to experiment with and test various volatility and time decay models [ref 3].

Theory

Black-Scholes approach assumes that the price of the underlying security follows a geometric Brownian distribution known as the Wiener process. If we note S(t) the price of security (stock, bond, future), V(t) the price of the option over time, r the annualized compound risk-free interest rate or rate of return, and sigma the volatility of the price of the underlying security S then the Black-Scholes equation can be described as \[\frac{\partial V}{\partial t} + \frac{\sigma ^{2}S^{2}}{2}\frac{\partial^2 V}{\partial S^2} + r (S\frac{\partial V}{\partial S}- V) = 0\] The resolution of the partial differential equations produces the following solution for a call option: \[(1)\ \ C(t) = N(d)S - N(d')Ke^{-r(T-t)}\,\,with\\N(x)=\frac{1}{\sqrt{2 \pi }}\int_{-\infty }^{x}e^{-\frac{t^{2}}{2}}dt\\(2)\ \ d = \frac{1}{\sigma \sqrt{T-t}}[log(\frac{S}{K}) + (r+\frac{\sigma ^{2}}{2})(T-t)]\\(3)\ \ d^{'}=d-\sigma \sqrt{T-t}\] K is the strike price for the underlying security. The price of a put option is computed as \[P(t)=N(-d + \sigma \sqrt{T-t})Ke^{-r(T-t))} - N(-d)S\] As a reminder, a financial call option gives a buyer the right for a premium fee but not the obligation to acquire an agreed amount of assets S (securities, bonds, commodity) from a seller at a future date T for a certain predefined price (strike price: K). The seller is obligated to sell the commodity should the buyer so decide. A put option gives the buyer the right but not the obligation to sell an asset by a future data at a predefined (Strike) price.

Implementation

Calculating the price of an option requires extensive CPU usage. The approach includes several steps:

Establish and encapsulate the parameters used in the Black-Scholes formula.
Carry out the process to calculate the price of a call option.
Identify the various computational elements involved in the Black-Scholes formula.
Create a system for storing temporary results.
Combine these interim outcomes to finalize the call price.
Use Monte Carlo Simulation for determining the security's price.

Formulation

First let's define a data class, BSParams to encapsulate the parameters of the Black-Scholes formula:

S Current price of the underlying security
K Strike price
r Annual compound risk-free interest rate
sigma Volatility of the price of the underlying
T Expiration date for the option

case class BSParams(

   S: Double,

   K: Double,

   r: Double,

   sigma: Double,

   T: Double)

The Scala code snippet below implements the pricing of a call option for a security S and reflect the mathematical equations defined in the previous paragraph.

def callPrice(p: BSParams, t: Double): Double = {
    import Math._

   // Implement the Black-Scholes stochastic equation,
   val sigmaT = p.sigma * sqrt(p.T - t)

   // Formula (2)
   val d = (log(p.S/p.K)+ (p.r + 0.5*sigma*sigma)*(p.T-t)) /sigmaT

   // Formula (3)
   val d' = d1 - sigmaT
   
   val gauss = new Gaussian

   // Computation of the call C(t) as per formula. (1)
   p.S*gauss.value(d) - p.K*exp(-p.r*p.T)*gauss.value(d')

However, professional traders in commodities and futures for instance are more interested simulating the impact of volatility, sigma, time decay t -T or price of the commodity on the price of the option using Monte Carlo simulation. In this use case, the computation of the entire Black-Scholes formula is not necessary.

Memoization

Memoization, in the realm of computing, is a strategy for optimizing program performance. It involves caching the outcomes of costly function calls to pure functions. This way, when inputs are repeated, the program can quickly retrieve the stored result instead of recalculating it.

The aim is to reduce computational expenses by incorporating the algorithm into a workflow. In this approach, steps within the workflow that remain unchanged by the alteration of a single variable's value are not executed. For example, a change in the underlying security's price, denoted as S, necessitates recalculating only a specific part of the workflow, namely \[S=> log(S/X)\] The Black-Scholes algorithm is divided into five distinct internal computational stages:

object BSParams{
   val fLog = (p: BSParams) => Math.log(p.r / p.T)
   val fMul = (p: BSParams) => p.r * p.T
   val fPoly = (p: BSParams) => 0.5 * p.sigma * p.sigma * p.T
   val fExp = (p: BSParams) => -p.K * Math.exp(-p.r * p.T)
}

The 4 computational steps are used to maintain intermediate results so the entire Black-Scholes formula does not have to be computed from scratch each time one of the parameters S, K, r, sigma or T is changed.

The computational state is completely described by

Parameters of Black-Scholes equations S, K, r, sigma, T
Partial or intermediate results {bs1 to bs5}

Next, we need to wrap the computation and update of intermediate results of the Black-Scholes formula.

case class PartialResult(bs1: Double, bs2: Double, bs3: Double, bs4: Double, bs5: Double){
    import BSParams._

    lazy val d1: Double = (bs1 + bs2 + bs3) / bs4

    def f1(p: BSParams): PartialResult = this.copy(bs2 = fLog(p))

    def f2(p: BSParams): PartialResult = this.copy(bs2 = fMul(p), bs5 = fExp(p))

    def f3(p: BSParams): PartialResult = this.copy(bs3 = fPoly(p), bs5 = fExp(p))
 }

As mentioned earlier, the computation state is defined by the Black-Scholes parameters p and intermediate results values, pr.

class State(p: BSParams, pr: PartialResult){


    def setS(newS: Double): State = new State(p.copy(S = newS), pr)

    def setR(newR: Double): State = new State(p.copy(r = newR), pr)

    def setSigma(newSigma: Double): State =

                  new State(p.copy(sigma = newSigma), pr)

    lazy val call: Double = {
       import org.apache.commons.math3.analysis.function.Gaussian


       val gauss = new Gaussian
       p.S * gauss.value(pr.d1) -pr.bs5 * gauss.value(pr.d1 - pr.bs4)
    }
}

Each of the methods setS, setR, setSigma updates one of the Black-Scholes equation parameters that automatically triggers a selective re-computation of some of the intermediate results.

The price of the call is a lazy value computed only once (immutable state). The update of the state of the Black-Scholes computation is rather straight forward.

The following code snippet illustrates the immutable update of sigma in the price of a call

// Initial computation/state of Black-Scholes  
val state0 = new State(0.4, 0.6, 0.1, 2.0, 1.4)

  // Compute the price of a call
val callValue = state0.call

log.info(callValue)
  // Update the value of sigma
val state1 = state0.setSigma(0.14)
val newCallValue = state1.call

log.info(newCallValue)

Monte-Carlo Simulation

A Monte Carlo simulation is a method employed to estimate the various possible outcomes of a process that is challenging to predict owing to the presence of random elements. This technique is instrumental in assessing the effects of risk and uncertainty.

The Monte Carlo simulation finds application in an array of disciplines, such as finance, business, physics, and engineering, among others. It's often used to solve a variety of problems and is sometimes known as a multiple probability simulation.

The Black-Scholes formula can be validated through a Monte-Carlo simulation, using a Gaussian distribution to represent the stochastic component of the formula.

The price of security S(t) at time t is defined as \[(4)\ \ S_{t}=S_{0}+e^{(r - \frac{\sigma^{2}}{2})t+\mathbb{N}(0,1)\sigma\sqrt{t}}\]

The solution S(t) can be approximated using an iterative or recursive process. \[(5)\ \ S_{t}=S_{t-1} + e^{(r - \frac{\sigma^{2}}{2}).dt+\mathbb{N}(0, 1)\sigma\sqrt{dt}}\]

This particular implementation uses a fast tail recursion to simulate the computation of the underlying security at any given time t. The sampling times are normalized as integers with dt =1 for a faster simulation.

 import Random._

def monteCarlo(p: BSParams, s0: Double): List[Double] = {

     // Implementation of equation (4)
   val initialValue = s0*exp((p.r-0.5*p.sigma*p.sigma)+p.sigma*nextGaussian)
   monteCarlo(p, 0, List[Double](initialValue))
}

  
@tailrec
private def monteCarlo(p: BSParams, t: Int, values: List[Double]): List[Double] = {
   import Math._
    
   if(t >= p.T)
     values.reverse
   else {

        // Implementation of equation (5)
     val st = values.last * exp((p.r-0.5*p.sigma*p.sigma)+p.sigma*nextGaussian)
     monteCarlo(p, t+1, st :: values)
   }
}

The implementation of the Monte Carlo simulation relies on the fast Scala tail recursion [ref 4].

Evaluation

Let's predict the price of security using the Monte Carlo method for 100 units of time.

val S0 = 80.0
val r = 0.06
val sigma = 0.2
val K = 0.9
val bsParams = BSParams(S0,  r, K, sigma, 100)
val pricePrediction = monteCarlo(bsParams, S0)

The plot below illustrates the impact of the risk free of interest rate, r (6% and 1%) on the simulated price, pricePrediction of the underlying security.