Deterministic Pricing Engines in C++

Two servers price the same portfolio from the same market snapshot with the same binary, and their deltas disagree in the eleventh digit. Nobody changed the model. A reduction order moved with the thread scheduler, or a compiler fused one multiply-add on one build and not the other. Risk reconciliation stops, and someone spends three days proving the numbers were “basically the same”.

This book shows you how to build pricing engines that cannot have that problem.

Deterministic Pricing Engines in C++ builds one production-grade engine from the floor up: closed-form kernels, trees, finite difference solvers, Monte Carlo, stochastic and local volatility, calibration, and adjoint Greeks. Every layer holds to one standard: the same inputs, method and build give the same bits, on any host and at any degree of parallelism. Then the book shows why that standard is what makes aggressive optimization safe. Caching, vectorization, scenario batching and incremental repricing all become changes you can prove harmless before they merge.

You will learn to:

• Pin the floating-point behaviour that silently changes prices: FMA contraction, fast-math, FTZ/DAZ and libm drift.
• Write branchless, vectorized Black-76 kernels with single-pass analytic Greeks that price full option chains in low single-digit microseconds.
• Build implied volatility solvers that converge in bounded iterations and return typed errors instead of garbage.
• Construct arbitrage-free SVI surfaces, bootstrapped curves and dividend-aware forwards, and swap them lock-free under live updates.
• Run Monte Carlo on counter-based Philox streams and Sobol sequences with Brownian bridges, with results that do not change when you move from 16 cores to 64.
• Apply antithetics, control variates, importance sampling and Longstaff-Schwartz correctly, including the conditions under which each one makes things worse.
• Solve the pricing PDE with Crank-Nicolson, Rannacher smoothing and penalty-method American exercise.
• Price Heston with the COS method, build Dupire local volatility from a live surface, and calibrate with Levenberg-Marquardt in bounded time.
• Compute every bucketed Greek for a small multiple of one price using pathwise estimators and expression-template AAD.
• Serve prices to strategy and risk through seqlocks and lock-free rings, with content-addressed caching and shadow deployment.

What makes this book different:

• Every chapter opens with a real class of production failure, not a definition.
• Equations come first, then the code that implements them, with every place the discrete version departs from the mathematics called out.
• The code is modern C++23 (concepts, std::expected, designated initializers, C++20 atomics) and is written to compile, not as pseudocode.
• Every chapter ends with a Determinism Ledger: a running record of the guarantees the engine has gained so far.
• Appendices include a full formula and Greeks reference, convergence tables, market data conventions, and a release-gate validation checklist you can adopt as is.

Who it’s for: quant developers, trading-systems engineers and engineering leads who own pricing infrastructure in production. It assumes you know what a Greek is and are comfortable with modern C++. It does not teach either from scratch.