Options Pricing in C++

Overview

This project implements several fundamental options pricing models in C++, offering a comprehensive toolkit for financial analysis and research. The models included are the Black-Scholes model, the Binomial model, the Finite Difference Method (FDM), and the Monte Carlo simulation method. Each model has been encapsulated within its own class, following object-oriented programming principles, to provide a clear, modular, and extensible architecture that can be easily expanded with new pricing models.

Installation

To compile and run the project, ensure you have a C++ compiler and make installed on your system. The project is structured to use a Makefile for easy compilation.

# Clone the repository
git clone https://github.com/orlovt/OptionsPricingCPP.git

# Navigate to the project directory
cd OptionsPricingCPP

# Compile the project
make

# Execute the program
./price_opt

# Or execute with args spotPrice, strikePrice, rfRate, annualizedVolatility, timeToMaturity, optionType 
./price_opt 100.00 100.00 0.1 0.1 1.0 call

Usage

The executable price_opt provides a command-line interface to select and run different pricing models with predefined or user-specified parameters.

# Example usage
./price_opt 100.00 100.00 0.1 0.1 1.0 call

Replace the parameters with your desired values to compute the price of an option using the selected model.

Performance Comparison and Improvement

Pricing Model	Initial Time (ms)	Optimized Time (ms)	Improvement
Binomial	0.013708	0.008734	~36.3%
Black-Scholes	0.001708	0.000508	~70.3%
Monte Carlo	2.72567	0.596726	~78.1%

• The Binomial model saw a reduction in execution time by approximately 36%, highlighting the impact of optimized tree traversal and usage of dynamic programing techniques, which has let to cut the number of expencive computations.
• The Black-Scholes model achieved a execution time reduction of around 70%, benefiting from optimized mathematical computations, more efficient library calls and compiler changes.
• The Monte Carlo model exhibited the most significant improvement with a reduction in execution time by over 78%, which can be attributed to optimized random number generation, parallelization of simulations, and variance reduction techniques.

Project Structure

• Makefile: Contains rules for compiling the project.
• include/: Header files for the project.
  • Factory/: Contains the PricingModelFactory for creating model instances.
  • domain/: Domain-specific classes, like Option.
  • models/: Pricing models implementations.
  • util/: Utility functions and helpers, such as mathematical functions.
• src/: Source files mirroring the structure in include/.

Pricing Models

(click to expand)

Black-Scholes Model

The Black-Scholes model provides a closed-form solution for pricing European call and put options. It assumes a constant volatility and risk-free rate.

Call Option Price $C(S, T)$ $$C(S, T) = S_0 \cdot N(d_1) - K \cdot e^{-rT} \cdot N(d_2)$$

Put Option Price $P(S, T)$ $$P(S, T) = K \cdot e^{-rT} \cdot N(-d_2) - S_0 \cdot N(-d_1)$$

where:

• $S_0$ is the current stock price,
• $K$ is the strike price,
• $T$ is the time to expiration (in years),
• $r$ is the risk-free interest rate (annual rate, expressed in terms of continuous compounding),
• $\sigma$ is the volatility of the stock price (standard deviation of the stock's returns),
• $N(\cdot)$ is the cumulative distribution function of the standard normal distribution,

and $d_1$ and $d_2$ are calculated as follows:

$$d_1 = \frac{\ln(\frac{S_0}{K}) + (r + \frac{\sigma^2}{2})T}{\sigma\sqrt{T}}$$

$$d_2 = d_1 - \sigma\sqrt{T}$$

Binomial Model

The Binomial model prices options by constructing a binomial tree to model the underlying's price movements, allowing for the pricing of American options.

1. Step Size: The time to expiration $T$ is divided into $N$ equal intervals of length $\Delta t = \frac{T}{N}$.

2. Up and Down Factors: The model calculates the up ($u$) and down ($d$) factors, which represent the possible price changes in one step. $$u = e^{\sigma \sqrt{\Delta t}}$$ $$d = e^{-\sigma \sqrt{\Delta t}}$$ where $\sigma$ is the volatility of the underlying asset.

3. Risk-neutral Probability: The model uses a risk-neutral probability ($q$) for the price moving up, calculated as: $$q = \frac{e^{r\Delta t} - d}{u - d}$$ where $r$ is the risk-free interest rate.

Formulas for Option Valuation

The value of a European call or put option at each node is calculated using the formula: $$C = e^{-r\Delta t} [qC_u + (1 - q)C_d]$$ $$P = e^{-r\Delta t} [qP_u + (1 - q)P_d]$$ where $C_u$ and $C_d$ (or $P_u$ and $P_d$) are the values of the call (or put) option in the next step if the price moves up or down, respectively.

Finite Difference Method (FDM)

The FDM solves the Black-Scholes PDE numerically using a discretized grid over asset prices and time, applicable to various boundary conditions.

1. Grid Construction: Create a grid over the domain of interest, typically the range of possible underlying asset prices and time until expiration. The grid is defined by intervals $\Delta S$ for the asset price and $\Delta t$ for time.

2. Discretization of the PDE: The continuous PDE is approximated by finite differences. The choice of discretization scheme (explicit, implicit, or Crank-Nicolson) affects the stability and accuracy of the solution.

3. Initial and Boundary Conditions: Apply the initial condition, typically the option's payoff at expiration, and boundary conditions reflecting the option's behavior as the asset price approaches zero or infinity.

4. Backward in Time Solution: Solve the discretized equations backward in time from the known final conditions at expiration to obtain the option's price at the desired earlier time.

Fundamental Equations

The PDE for a vanilla European option under the Black-Scholes framework is: $$\frac{\partial V}{\partial t} + \frac{1}{2} \sigma^2 S^2 \frac{\partial^2 V}{\partial S^2} + rS\frac{\partial V}{\partial S} - rV = 0$$

Where:

• $V$ is the option price,
• $S$ is the underlying asset price,
• $t$ is time,
• $\sigma$ is the volatility of the underlying asset,
• $r$ is the risk-free interest rate.

Discretization Example (Explicit Scheme) The time derivative can be approximated by a forward difference and the second spatial derivative by a central difference: $$\frac{V^{i+1}j - V^i_j}{\Delta t} + \frac{1}{2} \sigma^2 S_j^2 \frac{V^i{j+1} - 2V^i_j + V^i_{j-1}}{\Delta S^2} + rS_j\frac{V^i_{j+1} - V^i_{j-1}}{2\Delta S} - rV^i_j = 0$$

Monte Carlo Simulation

Monte Carlo simulation estimates the price of an option by simulating the underlying asset's price path multiple times and calculating the average outcome.

$$dS_t = \mu S_t dt + \sigma S_t dW_t$$

where:

• $S_t$ is the price of the asset at time $t$,
• $\mu$ is the expected return (drift) of the asset,
• $\sigma$ is the volatility (standard deviation) of the asset's returns,
• $dW_t$ is the increment of a Wiener process (Brownian motion), representing random fluctuations.

Simulation of Price Paths

To simulate the future price of an asset under the GBM model, the discrete counterpart of the SDE over a small time interval $\Delta t$ is used:

$$S_{t+\Delta t} = S_t \exp\left((\mu - \frac{1}{2}\sigma^2)\Delta t + \sigma\sqrt{\Delta t}Z\right)$$

where $Z$ is a random draw from the standard normal distribution $N(0,1)$.

Option Payoff Calculation

For each simulated path of the underlying asset, the payoff of the option is calculated based on the option type. For example, for a European call option, the payoff at maturity $T$ is:

$$\text{Payoff} = \max(S_T - K, 0)$$

and for a European put option:

$$\text{Payoff} = \max(K - S_T, 0)$$

where $S_T$ is the simulated price of the underlying asset at maturity and $K$ is the strike price of the option.

Discounting to Present Value

The expected payoff of the option is computed by averaging the payoffs of all simulated paths. This average is then discounted back to the present value using the risk-free interest rate $r$, to get the option's price:

$$\text{Option Price} = e^{-rT} \times \frac{1}{N} \sum_{i=1}^{N} \text{Payoff}_i$$

where $N$ is the number of simulated paths.

License

This project is licensed under the MIT License - see the LICENSE.md file for details.