Options Pricing Engine GitHub

Quantitative Finance • C++17 / Python

A European options pricing engine based on the Black-Scholes model, written in modern C++17 to production-code standards: a clean architecture, a reproducible build, and a test suite that checks the maths rather than just the code paths.

Usage

C++

EuropeanOption call{100, 1.0, OptionType::Call};   // strike, maturity, type
MarketData     market{100, 0.2, 0.05};              // spot, volatility, rate

pricing::PricingResult res = pricing::price(call, market);
// res.price ≈ 10.4506, plus res.delta, res.gamma, res.vega, res.theta, res.rho

Python (pybind11)

import pricing

res = pricing.price(pricing.EuropeanOption(100, 1.0, pricing.OptionType.Call),
                    pricing.MarketData(100, 0.2, 0.05))
print(res.price, res.delta, res.gamma)

Features & Design

Analytical Black-Scholes pricer for European calls and puts, returning the price and the full set of Greeks: delta, gamma, vega, theta and rho.
Instrument / Market / Model separation: EuropeanOption, MarketData and the pricer are independent. New pricing engines (e.g. Monte Carlo) can be added without touching the instrument or market code.
Explicit degenerate cases: T→0 returns the intrinsic payoff and σ→0 returns the discounted intrinsic value. Short-circuiting these cases avoids NaN from log(S/K)/(σ√T).
Modern C++17: const-correctness, RAII and value types, internal-linkage helpers (anonymous namespace), std::erf-based normal CDF.
Python bindings via pybind11: desk-style scripting and analysis on top of the fast C++ core.
Reproducible CMake build: the library, demo, tests and Python module are separate targets, and dependencies are fetched automatically with FetchContent.

Testing (Catch2)

Reference values: ATM call/put checked against known Black-Scholes prices (10.4506 / 5.5736).
Put-call parity C − P = S − K·e^−rT checked across ATM, ITM, OTM, high-vol, short-maturity and zero-rate scenarios.
Finite-difference validation of the Greeks: each analytical Greek is checked against a bump-and-reprice approximation.
Boundary cases: zero maturity, zero volatility, and deep in/out-of-the-money convergence.
NaN safety: an at-the-money option at T = 0 never produces NaN.

Model assumptions: constant volatility and interest rate, no dividends, European exercise only.

Technical Details

C++17 CMake Catch2 Black-Scholes pybind11 Python