A high-performance Rust library for simulating stochastic processes, with first-class bindings. Built for quantitative finance, statistical modeling and synthetic data generation.

• 85+ stochastic models - 31 diffusions (OU, CIR, GBM, CEV, CKLS, Aït-Sahalia, Pearson, Jacobi, regime-switching, ...), 15 jump processes (Merton, Kou, CGMY, bilateral gamma, ...), 9 stochastic volatility models (Heston, SABR, Bergomi, rough Bergomi, HKDE, ...), 13 interest rate models (Hull-White, HJM, Vasicek, ...), and base processes (fBM, Poisson, LFSM, ...)
• MLE engine - maximum likelihood estimation for 1-D diffusion models with 6 transition density approximations (Euler, Ozaki, Shoji-Ozaki, Elerian, Kessler, Aït-Sahalia), L-BFGS optimizer via argmin, and 22 built-in process implementations
• Quant toolbox - option pricing (Fourier, barrier, lookback, Asian, variance swaps, regime-switching), calibration (Heston, SABR, Lévy, SVJ, rough Bergomi), and finite-difference methods
• Copulas - bivariate, multivariate, and empirical copulas with correlation utilities
• Statistics - kernel density estimation, fractional OU estimation, and CIR parameter fitting
• SIMD-optimized - fractional Gaussian noise, fractional Brownian motion, and all probability distributions use wide SIMD for fast sample generation
• Parallel sampling - sample_par(m) generates m independent paths in parallel via rayon
• Generic precision - most models support both f32 and f64
• Python bindings - full stochastic model coverage with numpy integration; all models return numpy arrays (others coming soon)

[dependencies]
stochastic-rs = "1.5.0"

pip install stochastic-rs

For development builds from source (requires maturin):

pip install maturin
maturin develop --release

The openblas feature enables ndarray-linalg for linear algebra operations. It requires a system OpenBLAS installation with LAPACK support.

Linux (Debian/Ubuntu)

sudo apt install libopenblas-dev

Linux (Fedora/RHEL)

sudo dnf install openblas-devel

macOS

brew install openblas
export OPENBLAS_DIR=$(brew --prefix openblas)

Windows

Download prebuilt OpenBLAS from OpenMathLib/OpenBLAS releases (pick the x64.zip), extract it, and install vcpkg:

git clone https://github.com/microsoft/vcpkg C:\vcpkg
C:\vcpkg\bootstrap-vcpkg.bat
$env:VCPKG_ROOT = "C:\vcpkg"

Then copy the prebuilt libopenblas.lib and libopenblas.dll into $VCPKG_ROOT\installed\x64-windows\lib\ and $VCPKG_ROOT\installed\x64-windows\bin\ respectively. The prebuilt release includes LAPACK (the vcpkg openblas port does not).

Build with OpenBLAS

cargo build --features openblas

Requires NVIDIA CUDA Toolkit (12.x+) and a compatible GPU.

cargo build --features cuda-native

use stochastic_rs::stochastic::process::fbm::FBM;
use stochastic_rs::stochastic::volatility::heston::Heston;
use stochastic_rs::stochastic::volatility::HestonPow;
use stochastic_rs::traits::ProcessExt;

fn main() {
    // Fractional Brownian Motion
    let fbm = FBM::new(0.7, 1000, None);
    let path = fbm.sample();

    // Parallel batch sampling
    let paths = fbm.sample_par(1000);

    // Heston stochastic volatility
    let heston = Heston::new(
        Some(100.0),   // s0
        Some(0.04),    // v0
        2.0,           // kappa
        0.04,          // theta
        0.3,           // sigma
        -0.7,          // rho
        0.05,          // mu
        1000,          // n
        None,          // t
        HestonPow::Sqrt,
        Some(false),
    );
    let [price, variance] = heston.sample();
}

All models return numpy arrays. Use dtype="f32" or dtype="f64" (default) to control precision.

import stochastic_rs as sr

# Basic processes
fbm = sr.PyFBM(0.7, 1000)
path = fbm.sample()           # shape (1000,)
paths = fbm.sample_par(500)   # shape (500, 1000)

# Stochastic volatility
heston = sr.PyHeston(mu=0.05, kappa=2.0, theta=0.04, sigma=0.3, rho=-0.7, n=1000)
price, variance = heston.sample()

# Models with callable parameters
hw = sr.PyHullWhite(theta=lambda t: 0.04 + 0.01*t, alpha=0.1, sigma=0.02, n=1000)
rates = hw.sample()

# Jump processes with custom jump distributions
import numpy as np
merton = sr.PyMerton(
    alpha=0.05, sigma=0.2, lambda_=3.0, theta=0.01,
    distribution=lambda: np.random.normal(0, 0.1),
    n=1000,
)
log_prices = merton.sample()

cuda-native backend: cudarc + cuFFT + fused Philox RNG kernel (no .cu files, no nvcc).

cargo bench --features cuda-native --bench fgn_cuda_native

Environment: NVIDIA GPU, CUDA 12.x, Rust nightly, --release with LTO.

Single path (sample vs sample_cuda_native(1), f32, H=0.7):

Batch (sample_par(m) vs sample_cuda_native(m), f32, H=0.7):

CUDA wins for large n (>= 16k) and is competitive at n=65k batches. CPU rayon parallelism dominates for medium n due to zero transfer overhead.

Measured with:

cargo bench --bench dist_multicore

Configuration in this run:

• sample_matrix benchmark
• 1-thread vs 14-thread rayon pools
• size is mostly 1024 x 1024; heavy discrete samplers use 512 x 512

Normal single-thread kernel comparison (fill_slice, same run):

• vs rand_distr + SimdRng: ~1.21x to 1.35x
• vs rand_distr + rand::rng(): ~4.09x to 4.61x

Turning stochastic-rs into a comprehensive quantitative finance library — a full QuantLib competitor in Rust.

Items are ordered by dependency: each tier builds on the one above it. Independent modules (stats, factors) can be done in parallel at any time.

• Cash flow engine (quant::cashflows) ← calendar ✓, curves ✓
  • Fixed-rate coupon, floating-rate coupon (IBOR, OIS), CMS coupon
  • Leg abstraction — ordered sequence of cash flows with notional schedule
  • Amortizing and accreting notionals
  • Cash flow NPV, accrued interest
• Trinomial tree & lattice framework (quant::lattice)
  • General trinomial / binomial tree
  • Hull-White, Black-Karasinski, G2++ tree engines

• Interest rate swaps (quant::instruments) ← cashflows, curves ✓
  • Vanilla IRS (fixed vs floating)
  • Overnight Indexed Swap (OIS)
  • Basis swap and cross-currency basis swap
  • NPV, fair rate, DV01 / BPV
• Fixed-income instruments (quant::instruments) ← cashflows, curves ✓
  • Fixed-rate bond — dirty/clean price, YTM, duration (Macaulay, modified), convexity
  • Floating-rate bond / FRN
  • Zero-coupon bond pricing from yield curve
  • Amortizing bond, inflation-linked bond
  • Z-spread, ASW spread, OAS

• Caps, floors & swaptions (quant::instruments) ← IRS, lattice
  • Cap / Floor / Collar pricing (Black, Bachelier, SABR)
  • European and Bermudan swaptions
  • Hull-White / G2++ tree-based engines
  • Short-rate model calibration to swaption / cap vols
• Market data framework (quant::market) ← IRS, fixed-income (rate helpers)
  • Quote / Handle / Observable abstraction for reactive repricing
  • Rate index objects (SOFR, EURIBOR, TONAR) with fixing history
  • FRA and money market instrument helpers
  • Rate helpers for curve bootstrapping
• Credit models (quant::credit) ← fixed-income (CDS cash flows)
  • Merton structural model
  • Reduced-form / intensity-based models
  • CDS pricing (ISDA standard) and hazard rate bootstrapping
  • Default probability term structure
  • Credit migration matrices
• Risk metrics (quant::risk) ← instruments (Greeks, bucket DV01)
  • Value at Risk — parametric, historical simulation, Monte Carlo
  • CVaR / Expected Shortfall
  • Stress testing and scenario analysis framework
  • Drawdown metrics, Sharpe, Sortino, Information Ratio, Calmar
  • Instrument-level Greeks — bump-and-reprice, bucket DV01, scenario engine

• Exotic derivatives (quant::pricing) ← lattice, pricing ✓, optionally swaptions
  • Bermudan options (LSM and PDE)
  • Basket and rainbow options
  • Cliquet / ratchet options
  • Auto-callable structures
  • Digital / binary options (cash-or-nothing, asset-or-nothing)
  • Chooser, compound, spread options
• Inflation (quant::inflation) ← fixed-income, cashflows
  • Zero-coupon and year-on-year inflation term structures
  • CPI / RPI / HICP index objects
  • Inflation-linked swaps and bonds

• Realized volatility & microstructure noise (stats::realized)
  • Realized variance, bipower variation, kernel-based RV
  • Realized semivariance, realized skewness and kurtosis
  • HAR (Heterogeneous Autoregressive) model
  • Noise-robust estimators — pre-averaging, two-scale RV
• Econometrics (stats::econometrics)
  • Cointegration — Johansen test, Engle-Granger two-step
  • Granger causality
  • Hidden Markov Models for regime detection
  • Changepoint detection
• Bayesian inference & filtering (stats::filtering)
  • Particle filters for general state-space models
  • Unscented Kalman Filter
  • MCMC samplers (Metropolis-Hastings, HMC) for calibration
• Factor models & statistical arbitrage (quant::factors)
  • PCA-based factor models
  • Cross-sectional regression (Fama-MacBeth)
  • Covariance shrinkage (Ledoit-Wolf)
  • Pairs trading / stat arb framework
• Market microstructure (quant::microstructure) ← order_book ✓, hawkes ✓
  • Almgren-Chriss optimal execution
  • Market impact models (Kyle, transient impact)
  • Bid-ask spread models

These should be addressed before or alongside Tier 0 work to ensure new modules build on a solid foundation.

• Stability: replace .unwrap() in core pricing — bsm.rs (40+), sabr.rs, heston.rs panic on None tau / optional fields. Switch to Result or validated builder pattern.
• Missing derives on public types — OrderBook (no Debug/Clone), BSMPricer, BSMPricerBuilder lack standard derives. All public structs need Debug, Clone; enums need Display.
• Vec<Vec<f64>> → Array2<T> — portfolio/data.rs, portfolio/momentum.rs, calibration/rbergomi.rs, pricing/dupire.rs, pricing/breeden_litzenberger.rs use nested Vec for numerical data instead of ndarray.
• Mixed linalg libraries — calibration.rs uses nalgebra::DVector while the rest of the codebase uses ndarray. Consolidate to ndarray.
• Hardcoded day count constants — sabr_smile.rs (/365.0), fmvol_regime.rs (/252.0), variance_swap.rs (/252.0). Use DayCountConvention or accept as parameter.
• Global #![allow(dead_code)] — lib.rs suppresses all dead code warnings. Remove and audit.
• Test coverage gaps — calendar/*, bonds/*, curves/*, fx/*, interest/* have zero tests. Add comparison tests against QuantLib / reference implementations.
• Module documentation — curves/*, bonds/*, calendar/holiday.rs, pricing/dupire.rs and others missing //! doc headers and paper citations.
• Re-export consistency — bonds.rs has no re-exports; stochastic.rs only re-exports traits. Match the pricing.rs / calibration.rs pattern everywhere.
• Naming conventions — XxxConfig vs XxxParams vs XxxCalibrationConfig; inconsistent abbreviation style (cir_2f vs duffie_kan). Standardize.

• Advanced Monte Carlo (stochastic::mc)
  • Variance reduction — antithetic variates, control variates, importance sampling, stratified sampling
  • Quasi-Monte Carlo sequences — Sobol, Halton
  • Multi-Level Monte Carlo (MLMC)
  • Longstaff-Schwartz (LSM) for American option pricing
• Volatility surface (quant::vol_surface)
  • Implied volatility surface construction from market data
  • SVI parameterization (Gatheral) and SSVI
  • Arbitrage-free interpolation and extrapolation
  • Smile and skew analytics
• Calendar & day count (quant::calendar)
  • Day count conventions — ACT/360, ACT/365, 30/360, ACT/ACT
  • Business day adjustment rules — Following, Modified Following, Preceding
  • Holiday calendars — US, UK, TARGET, Tokyo
  • Schedule generation for coupon and payment dates
• FX & currencies (quant::fx)
  • ISO 4217 currency definitions and metadata
  • FX quoting and cross-rate conventions
  • FX forward pricing
• Yield curve construction (quant::curves)
  • Bootstrapping from deposit, FRA, futures, and swap rates
  • Nelson-Siegel / Svensson parameterization
  • Discount factor and forward rate extraction
  • Multi-curve framework (OIS vs SOFR discounting)
  • Interpolation — monotone convex, log-linear, cubic spline
• Stochastic local volatility (quant::pricing)
  • Heston SLV model — Guyon–Labordère particle calibration of leverage function
  • Combined stochastic + Dupire local vol with mixing factor η

Contributions are welcome - bug reports, feature suggestions, or PRs. Open an issue or start a discussion on GitHub.

MIT - see LICENSE.