regit-blackscholes

Zero-dependency Black-Scholes options pricing engine. Pure Rust.

What it does

regit-blackscholes takes an option's market parameters and returns: price, all 17 Greeks through 3rd order, and implied volatility. Covers four models used in European regulated markets. Ships with no external math dependencies.

Every algorithm is hand-rolled from primary paper sources. A regulator, quant auditor, or new engineer can open any source file and trace every number to a citable formula.

Quick start

[dependencies]
regit-blackscholes = "1.0"

use regit_blackscholes::{OptionParams, OptionType, Pricing, GreeksCalc, ImpliedVol, IvSolver};

let params = OptionParams {
    option_type: OptionType::Call,
    spot:        100.0_f64,
    strike:      100.0_f64,
    rate:        0.05_f64,
    div_yield:   0.02_f64,
    vol:         0.20_f64,
    time:        1.0_f64,
};

// Price
let price = params.price().unwrap();
println!("Price: {price:.4}");  // 9.2270

// All 17 Greeks in one call
let greeks = params.greeks().unwrap();
println!("Delta: {:.4}, Gamma: {:.6}, Vega: {:.4}", greeks.delta, greeks.gamma, greeks.vega);

// Implied volatility from market price
let iv = params.implied_vol(price, IvSolver::Auto).unwrap();
println!("IV: {iv:.6}");  // 0.200000

See examples/quickstart.rs for a complete working example covering all four models.

Models

use regit_blackscholes::{Model, Black76Params, BachelierParams, DisplacedParams, Pricing};

// All models share the same Pricing trait
let models = vec![
    Model::BlackScholes(params),
    Model::Black76(Black76Params { option_type, forward: 100.0, strike: 100.0, rate: 0.05, vol: 0.20, time: 1.0 }),
    Model::Bachelier(BachelierParams { option_type, forward: 100.0, strike: 100.0, rate: 0.05, normal_vol: 5.0, time: 1.0 }),
    Model::Displaced(DisplacedParams { option_type, forward: 100.0, strike: 100.0, rate: 0.05, vol: 0.20, time: 1.0, displacement: 50.0 }),
];

for model in &models {
    println!("{:.4}", model.price().unwrap());
}

Greeks

All 17 analytic Greeks computed in a single call from shared intermediates. No finite differences. No recomputation.

let greeks = params.greeks().unwrap();

// First order
greeks.delta;       // dV/dS
greeks.vega;        // dV/dsigma
greeks.theta;       // dV/dt (daily)
greeks.rho;         // dV/dr

// Second order
greeks.gamma;       // d2V/dS2
greeks.vanna;       // d2V/dS dsigma
greeks.vomma;       // d2V/dsigma2

// Third order
greeks.speed;       // d3V/dS3
greeks.zomma;       // d3V/dS2 dsigma
greeks.ultima;      // d3V/dsigma3

Implied volatility

Multi-strategy solver chain with automatic fallback:

// Automatic strategy selection (recommended)
let iv = params.implied_vol(market_price, IvSolver::Auto)?;

// Or force a specific solver
let iv = params.implied_vol(market_price, IvSolver::Halley)?;
let iv = params.implied_vol(market_price, IvSolver::Brent)?;

Convergence tolerance: |sigma_new - sigma_old| < 1e-10. Native Rust — no C++ FFI, no cc build dependency.

Architecture

src/
  lib.rs                    # Module declarations + re-exports
  types.rs                  # OptionParams, Greeks, Pricing/GreeksCalc/ImpliedVol traits, Model enum
  errors.rs                 # PricingError, IvError
  math.rs                   # Normal CDF/PDF (Horner rational approx), d1/d2

  models/
    black_scholes.rs        # Merton 1973 continuous-dividend
    black76.rs              # Black 1976 futures/forwards
    bachelier.rs            # Normal model (rates)
    displaced.rs            # Shifted log-normal (Rubinstein 1983)

  greeks.rs                 # All 17 analytic Greeks
  iv.rs                     # IV solver chain

One file, one domain. Each function is pure and composable.

Testing

cargo test                        # 336 tests
cargo run --example quickstart    # Library usage demo
cargo bench                       # Criterion benchmarks

203 unit tests covering golden values, edge cases, error paths, and formula consistency across all four models and the IV solver chain.

109 integration tests across 5 suites:

• golden — regression anchors against QuantLib reference values
• parity — put-call parity for all four models
• greeks_tests — cross-Greek relationships, finite-difference verification, homogeneity
• boundaries — T=0, sigma=0, deep OTM/ITM, negative rates
• properties — proptest invariants (1,000 cases each): delta bounds, gamma/vega positivity, price monotonicity

24 doc tests — every public function's example compiles and runs.

Code quality

• #![forbid(unsafe_code)] crate-wide
• clippy::pedantic with zero warnings
• Every public function documented with mathematical references
• No unwrap() or panic!() in library code
• Deterministic: same input produces bit-identical output
• All polynomial evaluation via f64::mul_add (Horner's method)

Dependencies

Runtime: zero. Only std. No statrs, no libm, no nalgebra, no cc FFI.

License policy enforced via cargo-deny. No copyleft dependencies.

Algorithms

All implemented from primary paper sources. No ports from Python, no reading existing Rust crates.

Documentation

• MATH.md — Full mathematical derivations for every algorithm
• CHANGELOG.md — Release history
• SECURITY.md — Vulnerability disclosure policy

License

Apache License 2.0. See LICENSE.

Copyright 2026 Regit.io — Nicolas Koenig

Part of Regit OS — the operating system for investment products. From Luxembourg.