TinyComputers.io (Posts about rho)

Pricing Options: Finite Differences with Crank-Nicolson

A.C. Jokela — Wed, 05 Jun 2024 20:13:45 GMT

Discover how the Crank-Nicolson and finite differences methods revolutionized the world of option pricing. In this blog post, we dive deep into these powerful numerical techniques that have become essential tools for quantitative analysts and financial engineers.

We start by exploring the fundamentals of option pricing and the challenges posed by the Black-Scholes-Merton partial differential equation (PDE). Then, we introduce the finite differences method, a numerical approach that discretizes the PDE into a grid of points, enabling us to approximate option prices and calculate crucial risk measures known as the Greeks.

Next, we focus on the Crank-Nicolson method, a more advanced finite difference scheme that combines the best of both explicit and implicit methods. We explain how this method provides second-order accuracy in time and space, ensuring faster convergence and more accurate results.

Through step-by-step explanations and illustrative examples, we demonstrate how these methods are implemented in practice, including the treatment of boundary conditions and the incorporation of the early exercise feature for American options.

Whether you're a curious investor, a financial enthusiast, or an aspiring quantitative analyst, this blog post will provide you with valuable insights into the world of option pricing. Join us as we unravel the secrets behind these powerful numerical methods and discover how they have transformed the way we value and manage options in modern finance.

The Black-Scholes-Merton (BSM) partial differential equation

The Black-Scholes-Merton (BSM) partial differential equation is a mathematical model used for pricing options and other financial derivatives. It was developed by Fischer Black, Myron Scholes, and Robert Merton in the early 1970s and has become a cornerstone of modern financial theory.

Fundamentals of Options Pricing: Options are financial contracts that give the holder the right, but not the obligation, to buy (call option) or sell (put option) an underlying asset at a predetermined price (strike price) on or before a specific date (expiration date). The price of an option depends on several factors, including the current price of the underlying asset, the strike price, the time to expiration, the risk-free interest rate, and the volatility of the underlying asset.

The BSM equation is based on the following assumptions: 1. The market is efficient, and there are no arbitrage opportunities. 2. The underlying asset follows a geometric Brownian motion with constant drift and volatility. 3. The risk-free interest rate is constant and known. 4. There are no transaction costs or taxes. 5. The underlying asset pays no dividends.

Black-Scholes-Merton Partial Differential Equation: The BSM equation describes the price of a European option as a function of time and the underlying asset price. It is a second-order partial differential equation:

\frac{\partial V}{\partial t} + \frac{1}{2} σ^{2} S^{2} \frac{\partial^{2} V}{\partial S^{2}} + r S \frac{\partial V}{\partial S} - r V = 0

Where:

- V is the option price
- S is the underlying asset price
- t is time
- r is the risk-free interest rate
- σ is the volatility of the underlying asset

Challenges Posed by the BSM Equation:

Volatility Estimation: The BSM equation assumes constant volatility, which is not always the case in real markets. Estimating volatility accurately is crucial for option pricing.
Model Assumptions: The assumptions underlying the BSM model, such as no transaction costs and continuous trading, do not hold in practice. This can lead to discrepancies between theoretical and market prices.
Numerical Methods: Solving the BSM equation often requires numerical methods, such as finite difference or Monte Carlo simulations, which can be computationally intensive.
Market Anomalies: The BSM model does not account for market anomalies, such as the volatility smile or skew, which suggest that implied volatility varies with strike price and time to expiration.
Model Extensions: The basic BSM model has been extended to account for dividends, early exercise (for American options), and other factors. These extensions add complexity to the model and its implementation.

Despite these challenges, the Black-Scholes-Merton model remains a foundational tool in options pricing and financial risk management. It provides a framework for understanding the factors that influence option prices and serves as a benchmark for more advanced models.

The Finite Difference Method

The finite difference method is a numerical technique used to solve partial differential equations (PDEs) by approximating derivatives with finite differences. It is particularly useful when analytical solutions are difficult or impossible to obtain. The method discretizes the continuous PDE problem into a discrete set of points in space and time, called a grid or mesh.

To illustrate the basics of the finite difference method, consider a simple one-dimensional heat equation:

\frac{\partial u}{\partial t} = α \frac{\partial^{2} u}{\partial x^{2}}

Where:

- u is the temperature
- t is time
- x is the spatial coordinate
- α is the thermal diffusivity

To apply the finite difference method, we discretize the space and time domains into a grid with uniform step sizes Δx and Δt, respectively. We denote the temperature at grid point i and time step n as u(i, n) = u(i Δx, n Δt).

The finite difference method approximates the derivatives using Taylor series expansions. For example, the first-order time derivative can be approximated using the forward difference:

\frac{\partial u}{\partial t} \approx \frac{u (i, n + 1) - u (i, n)}{Δ t}

Similarly, the second-order spatial derivative can be approximated using the central difference:

\frac{\partial^{2} u}{\partial x^{2}} \approx \frac{u (i + 1, n) - 2 u (i, n) + u (i - 1, n)}{Δ^{x} 2}

By substituting these approximations into the original PDE, we obtain a system of algebraic equations that can be solved numerically. The finite difference method provides an approximation of the solution at each grid point and time step.

There are various schemes for discretizing time, such as the explicit (forward Euler/01%3A_Chapters/1.02%3A_Forward_Euler_method)), implicit (backward Euler/01%3A_Chapters/1.03%3A_Backward_Euler_method)), and the Crank-Nicolson methods. Each scheme has its own stability, accuracy, and computational requirements.

The finite difference method is widely used in computational finance, particularly in the numerical solution of the Black-Scholes-Merton PDE for option pricing. It is also applied in other fields, such as heat transfer, fluid dynamics, and electromagnetism.

Let's walk through a simple example using the one-dimensional heat equation mentioned earlier. We'll solve the equation numerically using the explicit (forward Euler) finite difference method.

Consider a one-dimensional rod of length L = 1 m, with an initial temperature distribution u(x, 0) = sin(πx) and fixed boundary conditions u(0, t) = u(L, t) = 0. The thermal diffusivity is α = 0.1 m²/s. We'll solve for the temperature distribution over a time period of T = 0.5 s.

Step 1: Discretize the space and time domains Let's divide the rod into N = 10 equally spaced points, with Δx = L / (N - 1) = 0.1 m. We'll use a time step of Δt = 0.01 s, resulting in M = T / Δt = 50 time steps.

Step 2: Set up the initial condition At t = 0, the temperature at each grid point is: u(i, 0) = sin(πx_i), where x_i = i Δx, for i = 0, 1, ..., N-1.

For example:

u(0, 0) = sin(π × 0) = 0
u(1, 0) = sin(π × 0.1) ≈ 0.309
...
u(9, 0) = sin(π × 0.9) ≈ 0.309
u(10, 0) = sin(π × 1) = 0

Step 3: Apply the explicit finite difference scheme For each time step n = 0, 1, ..., M-1 and each interior grid point i = 1, 2, ..., N-2, update the temperature using the explicit scheme:

u(i, n+1) = u(i, n) + α Δt / (Δx)² × [u(i+1, n) - 2u(i, n) + u(i-1, n)]

For example, at the first time step (n = 0) and the first interior grid point (i = 1):

u(1, 1) = u(1, 0) + 0.1 × 0.01 / (0.1)² × [u(2, 0) - 2u(1, 0) + u(0, 0)]
        ≈ 0.309 + 0.1 × [0.588 - 2 × 0.309 + 0] ≈ 0.306

Repeat this process for all interior grid points and time steps, while keeping the boundary conditions fixed at 0.

Step 4: Analyze the results After completing all time steps, you will have approximated the temperature distribution u(x, t) at each grid point and time step. You can visualize the results by plotting the temperature profile at different times or creating an animation showing the evolution of the temperature over time.

Note that the explicit scheme used in this example has a stability condition: α Δt / (Δx)² ≤ 0.5. If this condition is not met, the numerical solution may become unstable and diverge from the actual solution. In such cases, an implicit scheme or a smaller time step may be necessary.

The Crank-Nicolson Method

Let's dive into the Crank-Nicolson method and see how it can be applied to the Black-Scholes-Merton partial differential equation for options pricing.

The Black-Scholes-Merton PDE for a European call option is:

\frac{\partial V}{\partial t} + \frac{1}{2} σ^{2} S^{2} \frac{\partial^{2} V}{\partial S^{2}} + r S \frac{\partial V}{\partial S} - r V = 0

Where:

- V is the option price
- S is the underlying asset price
- t is time
- r is the risk-free interest rate
- σ is the volatility of the underlying asset

The Crank-Nicolson method discretizes the PDE using a weighted average of the explicit and implicit schemes, with equal weights of 0.5. This approach results in second-order accuracy in both time and space.

Let's denote the option price at grid point i and time step n as V(i, n) = V(i ΔS, n Δt), where ΔS and Δt are the step sizes in the asset price and time dimensions, respectively.

The Crank-Nicolson scheme for the Black-Scholes-Merton PDE can be written as:

\frac{V (i, n + 1) - V (i, n)}{Δ t} = \frac{1}{2} [α V_{i - 1} (n) - 2 V_{i} (n) + α V_{i + 1} (n) + α V_{i - 1} (n + 1) - 2 V_{i} (n + 1) + α V_{i + 1} (n + 1)]

Where:

- α = 1/2 σ² S_i² Δt / (ΔS)²
- β = r S_i Δt / (2 ΔS)
- γ = r Δt / 2

This scheme leads to a tridiagonal system of linear equations that can be solved efficiently using the Thomas algorithm or other methods for tridiagonal matrices.

To illustrate the Crank-Nicolson method with an example, consider a European call option with the following parameters:

- S = 100 (current stock price)
- K = 100 (strike price)
- T = 1 (time to maturity in years)
- r = 0.05 (risk-free interest rate)
- σ = 0.2 (volatility)

We can discretize the asset price dimension into N = 200 points, with S_min = 0 and S_max = 200, and the time dimension into M = 100 steps.

At each time step, we construct the tridiagonal matrix and solve the resulting system of equations to obtain the option prices at the next time step. The boundary conditions are:

- V(0, n) = 0 (option value is zero when the stock price is zero)
- V(N, n) = S_max - K exp(-r(T - n Δt)) (option value at the maximum stock price)

After the final time step, the option price at the initial stock price S is the desired result.

The Crank-Nicolson method provides a stable and accurate solution to the Black-Scholes-Merton PDE. Its second-order accuracy in both time and space ensures faster convergence and more precise results compared to the explicit or implicit methods alone. However, it requires solving a system of equations at each time step, which can be computationally more expensive than the explicit method.

In practice, the Crank-Nicolson method is widely used in financial engineering for options pricing and other applications involving parabolic PDEs. It strikes a balance between accuracy and computational efficiency, making it a popular choice among practitioners.

Crank-Nicolson in Rust as a Python library

Complete Repo on Github

Jupyter Notebook for using the python library

extern crate nalgebra as na;
use na::{DMatrix};
use numpy::{PyArray2, PyArray};
use numpy::PyArrayMethods;
use pyo3::prelude::*;
use pyo3::wrap_pyfunction;
use pyo3::exceptions::PyValueError;

/// Constructs a tridiagonal matrix with specified diagonals.
///
/// # Arguments
///
/// * `n` - The size of the matrix.
/// * `a` - The value of the subdiagonal.
/// * `b` - The value of the main diagonal.
/// * `c` - The value of the superdiagonal.
///
/// # Returns
///
/// A tridiagonal matrix with the specified diagonals.
fn tridiag(n: usize, a: f64, b: f64, c: f64) -> DMatrix<f64> {
    let mut mat = DMatrix::<f64>::zeros(n, n);
    for i in 0..n {
        if i > 0 {
            mat[(i, i - 1)] = a;
        }
        mat[(i, i)] = b;
        if i < n - 1 {
            mat[(i, i + 1)] = c;
        }
    }
    mat
}

/// Solves the option pricing problem using the Crank-Nicolson method.
/// 
/// # Arguments
/// 
/// * `py` - The Python interpreter instance.
/// * `s0` - Initial stock price.
/// * `k` - Strike price.
/// * `r` - Risk-free rate.
/// * `sigma` - Volatility.
/// * `t` - Time to maturity.
/// * `n` - Number of time steps.
/// * `m` - Number of stock price steps.
/// 
/// # Returns
/// 
/// A 2D numpy array containing the option prices.
#[pyfunction]
fn crank_nicolson(
    py: Python,
    s0: f64,
    k: f64,
    r: f64,
    sigma: f64,
    t: f64,
    n: usize,
    m: usize,
) -> PyResult<Py<PyArray2<f64>>> {
    // Time step size
    let dt = t / n as f64;
    // Spatial step size
    let dx = sigma * (t / n as f64).sqrt();
    // Drift term
    let nu = r - 0.5 * sigma.powi(2);
    // Square of spatial step size
    let dx2 = dx * dx;

    // Initialize the grid for option prices
    let mut grid = DMatrix::<f64>::zeros(n + 1, m + 1);

    // Set terminal condition (payoff at maturity)
    for j in 0..=m {
        let stock_price = s0 * (-((m as isize / 2) as f64 - j as f64) * dx).exp();
        grid[(n, j)] = (k - stock_price).max(0.0);
    }

    // Coefficients for the tridiagonal matrices
    let alpha = 0.25 * dt * (sigma.powi(2) / dx2 - nu / dx);
    let beta = -0.5 * dt * (sigma.powi(2) / dx2 + r);
    let gamma = 0.25 * dt * (sigma.powi(2) / dx2 + nu / dx);

    // Construct tridiagonal matrices A and B
    let a = tridiag(m + 1, -alpha, 1.0 - beta, -gamma);
    let b = tridiag(m + 1, alpha, 1.0 + beta, gamma);

    // Perform LU decomposition of matrix A
    let lu = a.lu();

    // Backward time-stepping to solve the PDE
    for i in (0..n).rev() {
        let rhs = &b * grid.row(i + 1).transpose();
        let sol = lu.solve(&rhs).ok_or_else(|| PyValueError::new_err("Failed to solve LU"))?;
        grid.set_row(i, &sol.transpose());
    }

    // Convert DMatrix to Vec<Vec<f64>> for PyArray2
    let rows = grid.nrows();
    let cols = grid.ncols();
    let mut vec_2d = Vec::with_capacity(rows);
    for i in 0..rows {
        let mut row = Vec::with_capacity(cols);
        for j in 0..cols {
            row.push(grid[(i, j)]);
        }
        vec_2d.push(row);
    }

    // Create a numpy array from the Vec<Vec<f64>>
    let array = PyArray::from_vec2_bound(py, &vec_2d).map_err(|_| PyValueError::new_err("Failed to create numpy array"))?;
    Ok(array.unbind())
}

/// Calculates the Greeks (delta, gamma, theta, vega, and rho) for the option.
/// 
/// # Arguments
/// 
/// * `py` - The Python interpreter instance.
/// * `s0` - Initial stock price.
/// * `k` - Strike price.
/// * `r` - Risk-free rate.
/// * `sigma` - Volatility.
/// * `t` - Time to maturity.
/// * `n` - Number of time steps.
/// * `m` - Number of stock price steps.
/// 
/// # Returns
/// 
/// A tuple containing the values of delta, gamma, theta, vega, and rho.
#[pyfunction]
fn calculate_greeks(
    py: Python,
    s0: f64,
    k: f64,
    r: f64,
    sigma: f64,
    t: f64,
    n: usize,
    m: usize,
) -> PyResult<(f64, f64, f64, f64, f64)> {
    let grid = crank_nicolson(py, s0, k, r, sigma, t, n, m)?;
    let grid = grid.bind(py).readonly();
    let ds = s0 * (sigma * (t / n as f64).sqrt()).exp();
    let dt = t / n as f64;

    let price_idx = m / 2;
    let price = grid.as_slice().unwrap()[price_idx];
    let price_up = grid.as_slice().unwrap()[price_idx + 1];
    let price_down = grid.as_slice().unwrap()[price_idx - 1];

    // Calculate delta, gamma, and theta
    let delta = (price_up - price_down) / (2.0 * ds);
    let gamma = (price_up - 2.0 * price + price_down) / (ds * ds);
    let theta = (grid.as_slice().unwrap()[price_idx + 1] - price) / dt;

    // Calculate vega
    let eps = 0.01;
    let sigma_vega = sigma + eps;
    let grid_vega = crank_nicolson(py, s0, k, r, sigma_vega, t, n, m)?;
    let grid_vega = grid_vega.bind(py).readonly();
    let price_vega = grid_vega.as_slice().unwrap()[price_idx];
    let vega = (price_vega - price) / eps;

    // Calculate rho
    let r_rho = r + eps;
    let grid_rho = crank_nicolson(py, s0, k, r_rho, sigma, t, n, m)?;
    let grid_rho = grid_rho.bind(py).readonly();
    let price_rho = grid_rho.as_slice().unwrap()[price_idx];
    let rho = (price_rho - price) / eps;

    Ok((delta, gamma, theta, vega, rho))
}

/// Extracts the option price from the grid at the initial time step for the given parameters.
/// 
/// # Arguments
/// 
/// * `py` - The Python interpreter instance.
/// * `grid` - The option price grid.
/// * `_s0` - Initial stock price (not used).
/// * `_k` - Strike price (not used).
/// * `_r` - Risk-free rate (not used).
/// * `_sigma` - Volatility (not used).
/// * `_t` - Time to maturity (not used).
/// * `_n` - Number of time steps (not used).
/// * `m` - Number of stock price steps.
/// 
/// # Returns
/// 
/// The option price at the initial time step.
#[pyfunction]
fn extract_option_price(
    py: Python,
    grid: Py<PyArray2<f64>>,
    m: usize,
) -> PyResult<f64> {
    let grid = grid.bind(py).readonly();
    // Assuming s0 is near the middle of the grid
    let price_idx = m / 2;
    Ok(grid.as_slice().unwrap()[price_idx])
}

/// Module definition for the finite_differences_options_rs Python module.
#[pymodule]
fn libfinite_differences_options_rs(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(crank_nicolson, m)?)?;
    m.add_function(wrap_pyfunction!(calculate_greeks, m)?)?;
    m.add_function(wrap_pyfunction!(extract_option_price, m)?)?;
    Ok(())
}

Numerical Methods of Pricing Options

A.C. Jokela — Sun, 26 May 2024 18:27:00 GMT

Stock options are financial derivatives that give the holder the right, but not the obligation, to buy (call options) or sell (put options) an underlying stock at a predetermined price (strike price) on or before a specified date (expiration date). Options are valuable tools for investors and traders to hedge risk, generate income, or speculate on price movements. I may write a post how to use options to generate regular income with only a modicum of risk.

The value of an option is influenced by several factors, including the current stock price, strike price, time to expiration, risk-free interest rate, and the stock's volatility. These factors are quantified using "greeks," which measure the sensitivity of the option's price to changes in these variables. The primary greeks are:

Delta (Δ): The rate of change of the option price with respect to the change in the underlying stock price.
Gamma (Γ): The rate of change of delta with respect to the change in the underlying stock price.
Theta (Θ): The rate of change of the option price with respect to the passage of time.
Vega (ν): The rate of change of the option price with respect to the change in the implied volatility of the underlying stock.
Rho (ρ): The rate of change of the option price with respect to the change in the risk-free interest rate.

To price options and calculate greeks, closed-form models like the Black-Scholes and Bjerksund-Stensland are commonly used. The Black-Scholes model is widely used for European-style options, which can only be exercised at expiration. The model assumes that the underlying stock price follows a geometric Brownian motion with constant volatility and risk-free interest rate. The Black-Scholes formula for a call option is:

Formula
$C = S N (d_{1}) - K e^{- r T} N (d_{2})$
where: $d_{1} = \frac{\ln (\frac{S}{K}) + (r + \frac{σ^{2}}{2}) T}{σ \sqrt{T}}$
$d_{2} = d_{1} - σ \sqrt{T}$

The Bjerksund-Stensland model is an extension of the Black-Scholes model that allows for early exercise, making it suitable for American-style options. The closed-form solution is more complex and involves additional calculations.

The closed-form formulas for the Black-Scholes greeks are:

Greek	Formula
Delta (Δ)	$Δ = N (d_{1})$
Gamma (Γ)	$Γ = \frac{N' (d_{1})}{S σ \sqrt{T}}$
Theta (Θ)	$Θ = - \frac{S N' (d_{1}) σ}{2 \sqrt{T}} - r K e^{- r T} N (d_{2})$
Vega (ν)	$ν = S \sqrt{T} N' (d_{1})$
Rho (ρ)	$ρ = K T e^{- r T} N (d_{2})$

Understanding options and their greeks is crucial for effective risk management and trading strategies. Closed-form models provide a quick and efficient way to price options and calculate greeks, although they rely on certain assumptions that may not always hold in real-world market conditions.

I go over Black-Scholes and Bjerksund-Stensland in more detail in my post on pricing options. In this post, I will focus on numerical methods used to price options, including binomial trees and the Leisen-Reimer method.

Numerical methods and closed-form methods are two different approaches to solving mathematical problems, including the pricing of options and calculation of greeks. Here's how they differ:

Closed-form methods:

Closed-form methods provide an exact solution to a problem using a mathematical formula or equation. These methods give a precise answer that can be calculated directly from the inputs without the need for iterative calculations or approximations. The Black-Scholes model is an example of a closed-form solution for pricing European-style options.

Advantages:

Exact solution
Fast computation
Easy to implement and interpret

Disadvantages:

Rely on assumptions that may not hold in real-world conditions
Limited flexibility to accommodate complex scenarios or non-standard options

Numerical methods:

Numerical methods provide approximate solutions to problems that cannot be solved analytically or have complex closed-form solutions. These methods involve iterative calculations and approximations to arrive at a solution within a specified tolerance level. Examples of numerical methods for option pricing include the Binomial Option Pricing Model (BOPM), Monte Carlo simulations, and Finite Difference Methods%20difference%20equations.) (FDM).

Advantages:

Can handle complex scenarios and non-standard options
Flexible and adaptable to various assumptions and market conditions
Provide insights into option price behavior over time and across various input parameters

Disadvantages:

Approximate solution
Computationally intensive and time-consuming
Requires more programming expertise to implement and interpret

In practice, closed-form methods are preferred when available due to their simplicity and speed. However, numerical methods are essential for dealing with more complex options and market conditions that violate the assumptions of closed-form models.

Numerical methods can also be used to validate closed-form solutions and to provide additional insights into option price behavior. In some cases, a combination of closed-form and numerical methods may be used to balance the trade-offs between accuracy, speed, and flexibility.

We will be focusing on the Binomial Option Pricing Model (BOPM) in this post, which is a popular numerical method for pricing options. The BOPM is based on the concept of a binomial tree, where the option price is calculated at each node of the tree by considering the possible price movements of the underlying stock.

The binomial tree consists of nodes representing the possible stock prices at each time step and branches representing the up and down movements of the stock price. The option price at each node is calculated using the risk-neutral pricing formula, which considers the expected value of the option price at the next time step.

The BOPM can be used to price both European and American-style options and can handle complex scenarios such as dividend payments, early exercise, and multiple time steps. The flexibility and adaptability of the BOPM make it a valuable tool for pricing options in real-world market conditions.

The Leisen-Reimer method is an enhancement of the BOPM that improves the accuracy of option pricing by adjusting the probabilities of up and down movements in the binomial tree. The Leisen-Reimer method uses a modified version of the risk-neutral pricing formula that accounts for skewness and kurtosis in the stock price distribution.

The Leisen-Reimer binomial tree is an improvement over the simple binomial tree method for pricing options. It uses a more accurate approximation for the up and down factors in the tree, leading to faster convergence and more precise results. Here's a simple pseudo-code comparison between the two methods:

Simple Binomial Tree:

function SimpleBinomialTree(S, K, T, r, sigma, N):
    dt = T / N
    u = exp(sigma * sqrt(dt))
    d = 1 / u
    p = (exp(r * dt) - d) / (u - d)

    Initialize asset_prices[N+1] to 0
    asset_prices[0] = S * d^N

    for i from 1 to N:
        asset_prices[i] = u * asset_prices[i-1]

    Initialize option_values[N+1] to 0

    for i from 0 to N:
        option_values[i] = max(0, asset_prices[i] - K)

    for i from N-1 down to 0:
        for j from 0 to i:
            option_values[j] = exp(-r * dt) * (p * option_values[j+1] + (1-p) * option_values[j])

    return option_values[0]

Leisen-Reimer Binomial Tree:

function LeisenReimerBinomialTree(S, K, T, r, sigma, N):
    dt = T / N
    d1 = (log(S / K) + (r + 0.5 * sigma^2) * T) / (sigma * sqrt(T))
    d2 = d1 - sigma * sqrt(T)

    p = 0.5 + copysign(1, d2) * 0.5 * sqrt(1 - exp(-((d2 / (N + 1/3 + 0.1/(N+1)))^2) * (N + 1/6)))
    u = exp(sigma * sqrt(dt / p))
    d = exp(-sigma * sqrt(dt / (1 - p)))

    Initialize asset_prices[N+1] to 0
    asset_prices[0] = S * d^N

    for i from 1 to N:
        asset_prices[i] = u * asset_prices[i-1]

    Initialize option_values[N+1] to 0

    for i from 0 to N:
        option_values[i] = max(0, asset_prices[i] - K)

    for i from N-1 down to 0:
        for j from 0 to i:
            option_values[j] = exp(-r * dt) * (p * option_values[j+1] + (1-p) * option_values[j])

    return option_values[0]

The main differences between the two methods are:

The Leisen-Reimer binomial tree method incorporates the d1 and d2 values from the Black-Scholes model to determine the up and down factors (u and d) in the binomial tree. In the Black-Scholes model, d1 and d2 are used to calculate the probability of the option expiring in-the-money under the assumption of a log-normal distribution of stock prices. By using these values in the binomial tree, the Leisen-Reimer method captures the essence of the Black-Scholes model's assumptions while retaining the flexibility and intuitive appeal of the binomial tree framework. This approach leads to a more accurate approximation of the continuous-time process assumed by the Black-Scholes model, resulting in faster convergence and more precise option pricing compared to the simple binomial tree method.
The probability p is calculated differently in the Leisen-Reimer method, using a more complex formula that includes a correction term (1/3 + 0.1/(N+1)) to improve convergence.

These modifications lead to faster convergence and more accurate results compared to the simple binomial tree method, especially for a smaller number of time steps (N). The Leisen-Reimer method is particularly useful for options with high volatility or near-the-money strike prices, where the standard BOPM may produce inaccurate results.

When comparing the computational complexity of the binomial tree methods (both simple and Leisen-Reimer) to the Black-Scholes model, there is a significant difference in their time and space complexities.

Time Complexity: - Black-Scholes: O(1) The Black-Scholes formula involves a fixed number of arithmetic operations and standard normal distribution function evaluations, resulting in a constant time complexity. Regardless of the input parameters, the computation time remains the same.

Binomial Trees (Simple and Leisen-Reimer): O(N^2) Both the simple binomial tree and the Leisen-Reimer binomial tree have a time complexity of O(N^2), where N is the number of time steps in the tree. The computation time grows quadratically with the number of time steps, making them significantly slower than the Black-Scholes model, especially for large values of N.

Space Complexity: - Black-Scholes: O(1) The Black-Scholes formula only requires a constant amount of memory to store the input parameters and the calculated option price, resulting in a space complexity of O(1).

Binomial Trees (Simple and Leisen-Reimer): O(N) Both the simple binomial tree and the Leisen-Reimer binomial tree have a space complexity of O(N), as they require storing the asset price tree and the option value array, each of size N+1. The memory requirements grow linearly with the number of time steps.

The Black-Scholes model has a significantly lower computational complexity compared to the binomial tree methods. The Black-Scholes model has a constant time complexity of O(1) and a constant space complexity of O(1), while the binomial tree methods have a quadratic time complexity of O(N^2) and a linear space complexity of O(N).

However, it's important to note that the binomial tree methods offer more flexibility in handling complex options and relaxing assumptions, which may justify their use in certain situations despite their higher computational complexity. The choice between the Black-Scholes model and binomial tree methods depends on the specific requirements of the problem and the trade-offs between accuracy, flexibility, and computational efficiency.

// binomial_lr_with_greeks.rs

use crate::binomial_lr_option::BinomialLROption;

/// Represents a binomial LR (Leisen-Reimer) option with Greeks calculation.
///
/// This struct extends the `BinomialLROption` to include the calculation of option Greeks,
/// such as delta, gamma, theta, vega, and rho.
pub struct BinomialLRWithGreeks {
    /// The underlying binomial LR option.
    pub lr_option: BinomialLROption,
}

impl BinomialLRWithGreeks {
    /// Creates a new `BinomialLRWithGreeks` instance with the given `BinomialLROption`.
    ///
    /// # Arguments
    ///
    /// * `lr_option` - The binomial LR option to be used for Greeks calculation.
    pub fn new(lr_option: BinomialLROption) -> Self {
        BinomialLRWithGreeks { lr_option }
    }

    /// Generates a new stock price tree based on the binomial LR option parameters.
    ///
    /// This method calculates the stock prices at each node of the binomial tree using
    /// the up and down factors from the binomial LR option.
    fn new_stock_price_tree(&mut self) {
        let u_over_d = self.lr_option.tree.u / self.lr_option.tree.d;
        let d_over_u = self.lr_option.tree.d / self.lr_option.tree.u;

        self.lr_option.tree.option.sts = vec![vec![
            self.lr_option.tree.option.s0 * u_over_d,
            self.lr_option.tree.option.s0,
            self.lr_option.tree.option.s0 * d_over_u,
        ]];

        for _ in 0..self.lr_option.tree.option.n {
            let prev_branches = &self.lr_option.tree.option.sts[self.lr_option.tree.option.sts.len() - 1];
            let mut st = prev_branches
                .iter()
                .map(|&x| x * self.lr_option.tree.u)
                .collect::<Vec<_>>();
            st.push(prev_branches[prev_branches.len() - 1] * self.lr_option.tree.d);
            self.lr_option.tree.option.sts.push(st);
        }
    }

    /// Calculates the option price and Greeks (delta, gamma, theta, vega, rho).
    ///
    /// This method first sets up the binomial LR option parameters and generates the stock price tree.
    /// It then calculates the option payoffs using the `begin_tree_traversal` method from the binomial LR option.
    /// Finally, it computes the option price and various Greeks based on the calculated payoffs and stock prices.
    ///
    /// # Returns
    ///
    /// A tuple containing the following values:
    /// - `option_value`: The calculated option price.
    /// - `delta`: The option's delta (rate of change of option price with respect to the underlying asset price).
    /// - `gamma`: The option's gamma (rate of change of delta with respect to the underlying asset price).
    /// - `theta`: The option's theta (rate of change of option price with respect to time).
    /// - `vega`: The option's vega (sensitivity of option price to changes in volatility).
    /// - `rho`: The option's rho (sensitivity of option price to changes in the risk-free interest rate).
    pub fn price(&mut self) -> (f64, f64, f64, f64, f64, f64) {
        self.lr_option.setup_parameters();
        self.new_stock_price_tree();

        let payoffs = self.lr_option.tree.begin_tree_traversal();
        let option_value = payoffs[payoffs.len() / 2];
        let payoff_up = payoffs[0];
        let payoff_down = payoffs[payoffs.len() - 1];

        let s_up = self.lr_option.tree.option.sts[0][0];
        let s_down = self.lr_option.tree.option.sts[0][2];

        let ds_up = s_up - self.lr_option.tree.option.s0;
        let ds_down = self.lr_option.tree.option.s0 - s_down;
        let ds = s_up - s_down;
        let dv = payoff_up - payoff_down;

        // Calculate delta as the change in option value divided by the change in stock price
        let delta = dv / ds;

        // Calculate gamma as the change in delta divided by the change in stock price
        let gamma = ((payoff_up - option_value) / ds_up - (option_value - payoff_down) / ds_down)
            / ((self.lr_option.tree.option.s0 + s_up) / 2.0 - (self.lr_option.tree.option.s0 + s_down) / 2.0);

        let dt = 0.0001; // Small perturbation in time
        let original_t = self.lr_option.tree.option.t;
        self.lr_option.tree.option.t -= dt;
        self.lr_option.setup_parameters();
        let payoffs_theta = self.lr_option.tree.begin_tree_traversal();
        let option_value_theta = payoffs_theta[payoffs_theta.len() / 2];

        // Calculate theta as the negative of the change in option value divided by the change in time
        let theta = -(option_value_theta - option_value) / dt;
        self.lr_option.tree.option.t = original_t;

        let dv = 0.01;
        self.lr_option.tree.option.sigma += dv;
        self.lr_option.setup_parameters();
        let payoffs_vega = self.lr_option.tree.begin_tree_traversal();
        let option_value_vega = payoffs_vega[payoffs_vega.len() / 2];

        // Calculate vega as the change in option value divided by the change in volatility
        let vega = (option_value_vega - option_value) / dv;
        self.lr_option.tree.option.sigma -= dv;

        let dr = 0.01;
        self.lr_option.tree.option.r += dr;
        self.lr_option.setup_parameters();
        let payoffs_rho = self.lr_option.tree.begin_tree_traversal();
        let option_value_rho = payoffs_rho[payoffs_rho.len() / 2];

        // Calculate rho as the change in option value divided by the change in interest rate
        let rho = (option_value_rho - option_value) / dr;
        self.lr_option.tree.option.r -= dr;

        (option_value, delta, gamma, theta, vega, rho)
    }
}

Numerical methods like the Binomial Option Pricing Model and the Leisen-Reimer method are essential tools for pricing options and calculating greeks in real-world market conditions. These methods provide flexibility, accuracy, and insights into option price behavior that closed-form models may not capture. By understanding the strengths and limitations of numerical methods, traders and investors can make informed decisions and manage risk effectively in the options market.

The complete source code for this project can be found on Github. Binomial Option Pricing Model with Greeks This code is written in Rust, but is based off of the Python code in the book "Mastering Python for Finance" Second Edition by James Ma Weiming. The book is a great resource for learning how to price options using numerical methods among many finance topic problems all solvable and explorable in Python. The Rust code is a translation of the Python code with the addition of calculating all of the Greeks.

The Rust code compiles to a library that can then be imported in Python. Making this a Python module allows for easier integration with other Python libraries and tools. The Python code can be used to visualize the results and provide a user interface for the Rust code.

Modeling Stock Options with the Greeks

A.C. Jokela — Sun, 12 May 2024 00:50:20 GMT

Investing in stocks is a popular way for individuals to grow their wealth over time. When you buy a stock, you are purchasing a small piece of ownership in a company. As a shareholder, you have the potential to earn money through capital appreciation (when the stock price increases) and dividends (a portion of the company's profits distributed to shareholders). The stock market allows investors to buy and sell shares of publicly traded companies.

To invest in stocks, you typically need to open a brokerage account with a financial institution. You can then research and select stocks that align with your investment goals and risk tolerance. It's important to diversify your portfolio by investing in a variety of companies across different sectors to minimize risk. While stocks have historically provided higher returns compared to other investments like bonds, they also carry more risk due to market volatility.

Then there are options. Options are a type of financial derivative that give the holder the right, but not the obligation, to buy or sell an underlying stock at a predetermined price (called the strike price) on or before a specific date (the expiration date). It is important to note "or before a specific date" because this is a uniquely American attribute of options. European options can only be exercised on the expiration date. This American quirk is why the Black-Scholes model is not perfect for American options. The Bjerksund-Stensland model is a better fit for American options. We will possibly look at Bjerkund-Stensland in a future post, but for our purposes, we will mostly ignore the American quirk.

There are two types of options:

Call Options: A call option gives the holder the right to buy the underlying asset at the strike price. Investors buy call options when they believe the price of the underlying asset will increase. If the price rises above the strike price, the investor can exercise their right to buy the asset at the lower strike price and sell it at the higher market price, making a profit.
Put Options: A put option gives the holder the right to sell the underlying asset at the strike price. Investors buy put options when they believe the price of the underlying asset will decrease. If the price drops below the strike price, the investor can buy the asset at the lower market price and exercise their right to sell it at the higher strike price, making a profit.

Options are often used for hedging, speculation, and income generation. They offer leverage, allowing investors to control a larger position with a smaller investment. However, options trading carries significant risks, as options can expire worthless if the underlying asset doesn't move in the anticipated direction. It's important to understand the risks and rewards of options trading before getting started. None of this is investment advice. Consult a financial advisor before making any investment decisions.

In the context of stock options, "the Greeks" refer to a set of risk measures that quantify the sensitivity of an option's price to various factors. These measures are named after Greek letters and help options traders and investors understand and manage the risks associated with their options positions. The main Greeks are:

Delta (Δ): Delta measures the rate of change in an option's price with respect to changes in the underlying asset's price. It represents how much the option's price is expected to move for a $1 change in the underlying stock price. Call options have positive delta (between 0 and 1), while put options have negative delta (between -1 and 0).
Gamma (Γ): Gamma measures the rate of change in an option's delta with respect to changes in the underlying asset's price. It indicates how much the option's delta is expected to change for a $1 change in the underlying stock price. Options with high gamma are more sensitive to price changes in the underlying asset.
Theta (Θ): Theta measures the rate of change in an option's price with respect to the passage of time, assuming all other factors remain constant. It represents how much the option's price is expected to decay per day as it approaches expiration. Options lose value over time due to time decay, and theta is typically negative.
Vega (ν): Vega measures the rate of change in an option's price with respect to changes in the implied volatility of the underlying asset. It represents how much the option's price is expected to change for a 1% change in implied volatility. Options with higher vega are more sensitive to changes in volatility.
Rho (ρ): Rho measures the rate of change in an option's price with respect to changes in interest rates. It represents how much the option's price is expected to change for a 1% change in the risk-free interest rate. Rho is typically positive for call options and negative for put options.

Understanding and monitoring the Greeks is essential for options traders to make informed decisions about their positions. The Greeks help traders assess the potential risks and rewards of their options trades, as well as how their positions might be affected by changes in the underlying asset's price, time to expiration, volatility, and interest rates. Traders can use this information to adjust their positions, implement hedging strategies, and manage their overall risk exposure.

Most trading platforms and options analysis tools provide real-time data on the Greeks for individual options and option strategies. As such, most people do not need to calculate the Greeks by hand. However, it is important to understand the concepts behind the Greeks and how they influence options pricing and behavior. By mastering the Greeks, options traders can enhance their trading strategies and improve their overall performance in the options market.

But, what if you want to calculate the Greeks yourself? The Black-Scholes model is a mathematical formula used to price options and calculate the Greeks. It assumes that the underlying asset follows a lognormal distribution and that the option can only be exercised at expiration. The Black-Scholes model provides theoretical values for call and put options based on the current stock price, strike price, time to expiration, risk-free interest rate, and implied volatility.

Before we get started, let's define an important intermediate function, calculate_d1, that calculates the d1 parameter for many of the Greeks.

The d1 parameter, also known as the d+ parameter, is a component of the Black-Scholes option pricing model used to calculate various Greeks, such as delta, gamma, and vega. It represents the number of standard deviations the logarithm of the stock price is above the logarithm of the present value of the strike price.

The formula for d1 is:

d_{1} = \frac{\ln (\frac{S}{K}) + (r + \frac{σ^{2}}{2}) T}{σ \sqrt{T}}

Where:

S is the current price of the underlying asset
K is the strike price of the option
r is the risk-free interest rate
σ is the volatility of the underlying asset
T is the time to expiration of the option (in years)

The d1 parameter is used in the calculation of the cumulative standard normal distribution function N(x) and the standard normal probability density function N'(x) in the Black-Scholes formulas for various Greeks.

For example, in the delta formula:

Δ = N (d_{1})

And in the gamma formula:

Γ = \frac{N' (d_{1})}{S σ \sqrt{T}}

The d1 parameter helps to determine the sensitivity of the option price to changes in the underlying asset price, volatility, and time to expiration. It is a crucial component in understanding and calculating the Greeks for options trading and risk management.

/**
 * Calculate the d1 parameter for the Black-Scholes model.
 * 
 * Parameters
 * ----------
 * s : float
 *     The current price of the underlying asset.
 * k : float
 *     The strike price of the option.
 * t : float
 *     The time to expiration of the option in years.
 * r : float
 *     The risk-free interest rate.
 * sigma : float
 *     The volatility of the underlying asset.
 * q : float
 *     The dividend yield of the underlying asset.
 * 
 * Returns
 * -------
 * float
 *     The d1 parameter.
 */
fn calculate_d1(s: f64, k: f64, t: f64, r: f64, sigma: f64, q: f64) -> f64 {
    (f64::ln(s / k) + (r - q + 0.5 * sigma.powi(2)) * t) / (sigma * f64::sqrt(t))
}

`Delta` Calculation

The delta of an option measures the rate of change in the option's price with respect to changes in the underlying asset's price. It represents how much the option's price is expected to move for a $1 change in the underlying stock price. The delta of a call option is between 0 and 1, while the delta of a put option is between -1 and 0. The formula for calculating the delta of a call option using the Black-Scholes model is:

Δ = N (\frac{\ln (\frac{S}{K}) + (r + \frac{σ^{2}}{2}) T}{σ \sqrt{T}})

Where:

Δ is the delta of the option
N(x) is the standard normal cumulative distribution function
S is the current price of the underlying asset
K is the strike price of the option
r is the risk-free interest rate
σ is the volatility of the underlying asset
T is the time to expiration of the option (in years)

Rust Implementation

/**
 * Calculate the delta of an approximate American option using the Black-Scholes model.
 * 
 * Parameters
 * ----------
 * s : float
 *     The current price of the underlying asset.
 * k : float
 *     The strike price of the option.
 * t : float
 *     The time to expiration of the option in years.
 * r : float
 *     The risk-free interest rate.
 * sigma : float
 *     The volatility of the underlying asset.
 * q : float
 *     The dividend yield of the underlying asset.
 * option_type : str
 *     The type of option. Use 'call' for a call option and 'put' for a put option.
 * 
 * Returns
 * -------
 * float
 *     The delta of the option.
 */
#[pyfunction]
fn black_scholes_delta(s: f64, k: f64, t: f64, r: f64, sigma: f64, q: f64, option_type: &str) -> PyResult<f64> {
    let d1 = calculate_d1(s, k, t, r, sigma, q) as f64;
    let norm = Normal::new(0.0, 1.0).unwrap();

    let delta = match option_type {
        "call" => f64::exp(-q * t) * norm.cdf(d1),
        "put" => -f64::exp(-q * t) * norm.cdf(-d1),
        _ => return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>("Invalid option type. Use 'call' or 'put'."))
    };

    Ok(delta)
}

`Gamma` Calculation

The gamma of an option measures the rate of change in the option's delta with respect to changes in the underlying asset's price. It indicates how much the option's delta is expected to change for a $1 change in the underlying stock price. The formula for calculating the gamma of an option using the Black-Scholes model is:

Γ = \frac{N' (\frac{\ln (\frac{S}{K}) + (r + \frac{σ^{2}}{2}) T}{σ \sqrt{T}})}{S σ \sqrt{T}}

Where:

Γ is the gamma of the option
N'(x) is the standard normal probability density function
S is the current price of the underlying asset
K is the strike price of the option
r is the risk-free interest rate
σ is the volatility of the underlying asset
T is the time to expiration of the option (in years)

Rust Implementation

/**
 * Calculate the gamma of an approximate American option using the Black-Scholes model.
 * 
 * Parameters
 * ----------
 * s : float
 *     The current price of the underlying asset.
 * k : float
 *     The strike price of the option.
 * t : float
 *     The time to expiration of the option in years.
 * r : float
 *     The risk-free interest rate.
 * sigma : float
 *     The volatility of the underlying asset.
 * q : float
 *     The dividend yield of the underlying asset.
 * 
 * Returns
 * -------
 * float
 *     The gamma of the option.
 */
#[pyfunction]
fn black_scholes_gamma(s: f64, k: f64, t: f64, r: f64, sigma: f64, q: f64) -> f64 {
    let d1 = calculate_d1(s, k, t, r, sigma, q) as f64;
    let norm_dist = Normal::new(0.0, 1.0).unwrap();
    let gamma = norm_dist.pdf(d1) * E.powf(-q * t) / (s * sigma * f64::sqrt(t));

    gamma
}

`Theta` Calculation

The theta of an option measures the rate of change in the option's price with respect to the passage of time, assuming all other factors remain constant. It represents how much the option's price is expected to decay per day as it approaches expiration. The formula for calculating the theta of an option using the Black-Scholes model is:

Θ = - \frac{S N' (\frac{\ln (\frac{S}{K}) + (r + \frac{σ^{2}}{2}) T}{σ \sqrt{T}})}{2 T}

Where:

Θ is the theta of the option
N'(x) is the standard normal probability density function
S is the current price of the underlying asset
K is the strike price of the option
r is the risk-free interest rate
σ is the volatility of the underlying asset
T is the time to expiration of the option (in years)

Rust Implementation

/**
 * Calculate the theta of an approximate American option using the Black-Scholes model.
 * 
 * Parameters
 * ----------
 * s : float
 *     The current price of the underlying asset.
 * k : float
 *     The strike price of the option.
 * t : float
 *     The time to expiration of the option in years.
 * r : float
 *     The risk-free interest rate.
 * sigma : float
 *     The volatility of the underlying asset.
 * q : float
 *     The dividend yield of the underlying asset.
 * option_type : str
 *     The type of option. Use 'call' for a call option and 'put' for a put option.
 * 
 * Returns
 * -------
 * float
 *     The theta of the option.
 */

#[pyfunction]
fn black_scholes_theta(s: f64, k: f64, t: f64, r: f64, sigma: f64, q: f64, option_type: &str) -> PyResult<f64> {
    let d1 = calculate_d1(s, k, t, r, sigma, q) as f64;
    let d2 = d1 - sigma * f64::sqrt(t);
    let norm = Normal::new(0.0, 1.0).unwrap();

    let theta = match option_type {
        "call" => {
            - (s * sigma * f64::exp(-q * t) * norm.pdf(d1)) / (2.0 * f64::sqrt(t))
            - r * k * f64::exp(-r * t) * norm.cdf(d2)
            + q * s * f64::exp(-q * t) * norm.cdf(d1)
        },
        "put" => {
            - (s * sigma * f64::exp(-q * t) * norm.pdf(d1)) / (2.0 * f64::sqrt(t))
            + r * k * f64::exp(-r * t) * norm.cdf(-d2)
            - q * s * f64::exp(-q * t) * norm.cdf(-d1)
        },
        _ => return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>("Invalid option type. Use 'call' or 'put'."))
    };

    // Convert to per-day theta
    Ok(theta / 365.0)
}

`Vega` Calculation

The vega of an option measures the rate of change in the option's price with respect to changes in the implied volatility of the underlying asset. It represents how much the option's price is expected to change for a 1% change in implied volatility. The formula for calculating the vega of an option using the Black-Scholes model is:

ν = S N' (\frac{\ln (\frac{S}{K}) + (r + \frac{σ^{2}}{2}) T}{σ \sqrt{T}})

Where:

ν is the vega of the option
N'(x) is the standard normal probability density function
S is the current price of the underlying asset
K is the strike price of the option
r is the risk-free interest rate
σ is the volatility of the underlying asset
T is the time to expiration of the option (in years)

Rust Implementation

/**
 * Calculate the vega of an approximate American option using the Black-Scholes model.
 * 
 * Parameters
 * ----------
 * s : float
 *     The current price of the underlying asset.
 * k : float
 *     The strike price of the option.
 * t : float
 *     The time to expiration of the option in years.
 * r : float
 *     The risk-free interest rate.
 * sigma : float
 *     The volatility of the underlying asset.
 * q : float
 *     The dividend yield of the underlying asset.
 * 
 * Returns
 * -------
 * float
 *     The vega of the option.
 */
#[pyfunction]
fn black_scholes_vega(s: f64, k: f64, t: f64, r: f64, sigma: f64, q: f64) -> PyResult<f64> {
    let d1 = calculate_d1(s, k, t, r, sigma, q) as f64;
    let norm = Normal::new(0.0, 1.0).unwrap();

    let vega = s * f64::exp(-q * t) * norm.pdf(d1) * f64::sqrt(t);

    Ok(vega)
}

`Rho` Calculation

The rho of an option measures the rate of change in the option's price with respect to changes in interest rates. It represents how much the option's price is expected to change for a 1% change in the risk-free interest rate. The formula for calculating the rho of an option using the Black-Scholes model is:

ρ = K T N' (\frac{\ln (\frac{S}{K}) + (r + \frac{σ^{2}}{2}) T}{σ \sqrt{T}})

Where:

ρ is the rho of the option
N'(x) is the standard normal probability density function
S is the current price of the underlying asset
K is the strike price of the option
r is the risk-free interest rate
σ is the volatility of the underlying asset
T is the time to expiration of the option (in years)

Rust Implementation

/**
 * Calculate the rho of an approximate American option using the Black-Scholes model.
 * 
 * Parameters
 * ----------
 * s : float
 *     The current price of the underlying asset.
 * k : float
 *     The strike price of the option.
 * t : float
 *     The time to expiration of the option in years.
 * r : float
 *     The risk-free interest rate.
 * sigma : float
 *     The volatility of the underlying asset.
 * q : float
 *     The dividend yield of the underlying asset.
 * option_type : str
 *     The type of option. Use 'call' for a call option and 'put' for a put option.
 * 
 * Returns
 * -------
 * float
 *     The rho of the option.
 */
#[pyfunction]
fn black_scholes_rho(s: f64, k: f64, t: f64, r: f64, sigma: f64, q: f64, option_type: &str) -> PyResult<f64> {
    let d1 = calculate_d1(s, k, t, r, sigma, q) as f64; 
    let d2 = d1 - sigma * f64::sqrt(t);
    let norm = Normal::new(0.0, 1.0).unwrap();

    let rho = match option_type {
        "call" => k * t * f64::exp(-r * t) * norm.cdf(d2),
        "put" => -k * t * f64::exp(-r * t) * norm.cdf(-d2),
        _ => return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>("Invalid option type. Use 'call' or 'put'."))
    };

    Ok(rho)
}

Notes on Implied Volatility

Implied volatility is the volatility value that makes the theoretical option price calculated using the Black-Scholes model equal to the observed market price of the option. It represents the market's expectation of future volatility and is a crucial input in options pricing models. Traders use implied volatility to assess the relative value of options and make informed trading decisions. For my purposes, I use an IV that is provided by my market data subscription. I do not calculate it myself. However, here is a Rust implementation of the Black-Scholes formula for implied volatility.

Rust Implementation

use std::f64::consts::PI;

fn implied_volatility(stock_price: f64, strike_price: f64, risk_free_rate: f64, time_to_expiry: f64, option_price: f64, option_type: &str) -> f64 {
    let mut implied_vol = 0.5;
    let max_iterations = 100;
    let precision = 0.00001;

    for _ in 0..max_iterations {
        let d1 = (f64::ln(stock_price / strike_price) + (risk_free_rate + implied_vol.powi(2) / 2.0) * time_to_expiry) / (implied_vol * time_to_expiry.sqrt());
        let d2 = d1 - implied_vol * time_to_expiry.sqrt();
        let normal_cdf_d1 = (1.0 + erf(d1 / 2.0_f64.sqrt())) / 2.0;
        let normal_cdf_d2 = (1.0 + erf(d2 / 2.0_f64.sqrt())) / 2.0;
        let call_price = stock_price * normal_cdf_d1 - strike_price * f64::exp(-risk_free_rate * time_to_expiry) * normal_cdf_d2;
        let put_price = strike_price * f64::exp(-risk_free_rate * time_to_expiry) * (1.0 - normal_cdf_d2) - stock_price * (1.0 - normal_cdf_d1);

        let price_diff = match option_type {
            "call" => call_price - option_price,
            "put" => put_price - option_price,
            _ => panic!("Invalid option type. Use 'call' or 'put'."),
        };

        if price_diff.abs() < precision {
            break;
        }

        implied_vol -= price_diff / (stock_price * time_to_expiry.sqrt() * normal_pdf(d1));
    }

    implied_vol
}

fn normal_pdf(x: f64) -> f64 {
    f64::exp(-x.powi(2) / 2.0) / (2.0 * PI).sqrt()
}

/**
 * This function approximates the error function using a polynomial approximation.
 */
fn erf(x: f64) -> f64 {
    // Approximation of the error function
    let a1 = 0.254829592;
    let a2 = -0.284496736;
    let a3 = 1.421413741;
    let a4 = -1.453152027;
    let a5 = 1.061405429;
    let p = 0.3275911;

    let sign = if x < 0.0 { -1.0 } else { 1.0 };
    let x = x.abs();

    let t = 1.0 / (1.0 + p * x);
    let y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * f64::exp(-x.powi(2));

    sign * y
}

If you are wondering where the magic numbers in erf come from, the constants used in the approximation of the error function (erf) in the code example are derived from a specific approximation formula known as the "Abramowitz and Stegun approximation" or the "Rational Chebyshev approximation." This approximation was introduced by Milton Abramowitz and Irene Stegun in their book "Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables" (1964).

The approximation formula is as follows:

\erf (x) \approx 1 - (a 1 * t + a 2 * t^{2} + a 3 * t^{3} + a 4 * t^{4} + a 5 * t^{5}) * \exp (- x^{2})

where:

t = \frac{1}{1 + p x}

and the constants are:

a1 = 0.254829592
a2 = -0.284496736
a3 = 1.421413741
a4 = -1.453152027
a5 = 1.061405429
p = 0.3275911

These constants were determined by fitting the approximation formula to the actual values of the error function over a specific range. The approximation is accurate to within ±1.5 × 10^-7 for all real values of x.

It's important to note that this approximation is just one of many possible approximations for the error function. Other approximations with different constants and formulas may also be used, depending on the required accuracy and performance trade-offs.

In most cases, it is recommended to use a well-tested and optimized implementation of the error function provided by standard libraries or numerical computation libraries, rather than implementing the approximation yourself, unless you have specific requirements or constraints. I used Anthropic's "Claude Opus-3" large language model to generate the constants for the approximations.

Conclusion

The Greeks are essential tools for options traders to understand and manage the risks associated with their options positions. By calculating the Greeks using the Black-Scholes model, traders can estimate and assess the potential risks and rewards of their options trades and make informed decisions about their positions.

Here is a repository for the Rust implementation of the Black-Scholes model and the calculation of the Greeks for options trading. The repository contains the functions discussed in this article.

TinyComputers.io (Posts about rho)

Pricing Options: Finite Differences with Crank-Nicolson

The Black-Scholes-Merton (BSM) partial differential equation

The Finite Difference Method

The Crank-Nicolson Method

Crank-Nicolson in Rust as a Python library

Numerical Methods of Pricing Options

Closed-form methods:

Advantages:

Disadvantages:

Numerical methods:

Advantages:

Disadvantages:

Modeling Stock Options with the Greeks

Delta Calculation

Rust Implementation

Gamma Calculation

Rust Implementation

Theta Calculation

Rust Implementation

Vega Calculation

Rust Implementation

Rho Calculation

Rust Implementation

Notes on Implied Volatility

Rust Implementation

Conclusion

`Delta` Calculation

`Gamma` Calculation

`Theta` Calculation

`Vega` Calculation

`Rho` Calculation