A comprehensive C++ library for calculating options Greeks using the Black-Scholes-Merton model. This library is designed for quantitative traders, risk managers, and anyone working with options pricing and risk analysis.
Greeks are mathematical measures that describe how an option's price changes when different market conditions change. Think of them as "sensitivity measures" - they tell you how much your option's value will move when the underlying stock price, volatility, time, or interest rates change.
Just like a car's speedometer tells you how fast you're going, Greeks tell you how your options portfolio will react to market movements.
The Problem: Traditional options libraries assume you always want daily time decay and 1% sensitivity measures. But if you're:
- Intraday trading: Daily theta scaling is useless - you need annual or hourly
- Institutional trading: You might want 1 basis point (0.01%) sensitivity instead of 1%
- Risk management: You need unscaled values for your own calculations
The Solution: User-configurable scaling parameters.
// For intraday trading - no time scaling
Greeks intraday = calculate_all(call, S, K, T, r, vol, q, ScalingParams::intraday());
// For institutional - 1 basis point sensitivity
ScalingParams institutional;
institutional.rho_scale = 10000.0; // 1bp instead of 1%
Greeks precise = calculate_all(call, S, K, T, r, vol, q, institutional);
// Traditional daily scaling
Greeks standard = calculate_all(call, S, K, T, r, vol, q, ScalingParams::standard());This library calculates Greeks up to 6th order derivatives:
- 1st Order: Basic sensitivities (Delta, Vega, Theta, Rho, Epsilon)
- 2nd Order: Rate of change of 1st order Greeks (Gamma, Vanna, Charm, etc.)
- 3rd-6th Order: Higher-order sensitivities for advanced risk management
- Numerical stability: Safe division and logarithm functions prevent crashes
- Boundary conditions: Higher-order Greeks automatically return NaN for extreme parameters
- Comprehensive testing: Full test suite ensures mathematical accuracy
#include "Greeks.h"
using namespace GreeksCalculator;
// Standard European call option
double S = 100.0; // Stock price
double K = 105.0; // Strike price
double T = 0.25; // Time to expiration (0.25 = 3 months)
double r = 0.05; // Risk-free rate (5%)
double vol = 0.20; // Volatility (20%)
double q = 0.02; // Dividend yield (2%)
// Calculate all Greeks with standard scaling
Greeks g = calculate_all(true, S, K, T, r, vol, q);
printf("Delta: %.4f (per $1 stock move)\n", g.delta);
printf("Vega: %.4f (per 1%% vol change)\n", g.vega);
printf("Theta: %.4f (per day)\n", g.theta);// Intraday trading - get theta per year, not per day
Greeks intraday = calculate_all(true, S, K, T, r, vol, q, ScalingParams::intraday());
printf("Annual theta: %.4f\n", intraday.theta); // No daily scaling
// High-frequency trading - get vega per 0.1% vol change
ScalingParams hft;
hft.vega_scale = 1000.0; // 0.1% instead of 1%
Greeks precise = calculate_all(true, S, K, T, r, vol, q, hft);
printf("Vega per 10bp vol: %.4f\n", precise.vega);
// Risk management - unscaled values for your own calculations
Greeks raw = calculate_all(true, S, K, T, r, vol, q, ScalingParams::no_scaling());
printf("Raw vega: %.6f\n", raw.vega); // Unscaled mathematical value- Delta (Δ): Price sensitivity to stock price changes
- Vega (ν): Price sensitivity to volatility changes
- Theta (Θ): Price sensitivity to time decay
- Rho (ρ): Price sensitivity to interest rate changes
- Epsilon (ε): Price sensitivity to dividend yield changes
- Gamma (Γ): Rate of change of Delta
- Vanna: Rate of change of Delta with respect to volatility
- Charm: Rate of change of Delta with respect to time
- Volga: Rate of change of Vega with respect to volatility
These measure how the 2nd order Greeks change, providing insights into portfolio convexity and stability under extreme market conditions.
mkdir build && cd build
cmake ..
make./greeks_testsThe test suite verifies mathematical accuracy against known benchmark values and tests the scaling functionality.
The library includes robust handling of edge cases:
- Safe logarithms for extreme stock prices
- Safe division to prevent overflow/underflow
- Automatic NaN return for invalid parameter combinations
Higher-order Greeks automatically return NaN when:
- Time to expiration is too short
- Volatility is too low
- Other parameters are outside stable calculation ranges
This prevents misleading results from numerically unstable calculations.
src/
├── 1stOrder/ # Primary Greeks (Delta, Vega, Theta, Rho, Epsilon)
├── 2ndOrder/ # Second derivatives (Gamma, Vanna, Charm, etc.)
├── 3rdOrder/ # Third derivatives (Speed, Zomma, Color, etc.)
├── 4thOrder/ # Fourth derivatives
├── 5thOrder/ # Fifth derivatives
├── 6thOrder/ # Sixth derivatives
├── math/ # Mathematical foundations (d1, d2, CDF, PDF)
├── bsm/ # Black-Scholes-Merton pricing functions
└── Greeks.h # Main interface and ScalingParams
Each directory contains a detailed README explaining the specific Greeks calculated there.
I maintain a few branches, if you have an idea, try to follow this scheme.
- Main - this will be the portable stable branch, "generically" written.
- Vectorized - Main + Vector Extensions
- Vectorized_* - The vectorized extensions + other optimizations.
- Ensure your changes pass all existing tests
- Add tests for new functionality
- Update relevant README files
- Follow the existing code style and structure
The library is designed to be mathematically rigorous while remaining accessible to practitioners across different trading styles and timeframes.