book

Mastering Quantitative Finance with Modern C++: Foundations, Derivatives, and Computational Methods

Name: Mastering Quantitative Finance with Modern C++: Foundations, Derivatives, and Computational Methods
Author: Aaron De la Rosa
ISBN: 9798868817939

by Aaron De la Rosa

January 2026

Intermediate to advanced

902 pages

18h 52m

English

Apress

Read now

Unlock full access

Mastering Quantitative Finance with Modern C++
Introduction
What Readers Will LearnWho This Book Is ForUser LevelIntermediate to AdvancedCompiling C++23 Code
Acknowledgments
Table of Contents
About the Author
About the Technical Reviewer
1. Introduction to Modern C++23
The Birth of C++ (1979–1985)C++98 and the Rise of the Standard Template Library (1998)C++11: The Birth of Modern C++ (2011)C++17: Performance and Expressiveness (2017)C++20: A Paradigm Shift (2020)C++23: The Cutting Edge (2023)SummaryAdvantages of C++23Limitations of C++23Final ThoughtsCore Components of C++23 and Procedural ProgrammingObject-Oriented Programming in C++23EncapsulationInheritancePolymorphismAbstraction1.1 Introduction to Generic Programming in C++23Core Concepts of Generic ProgrammingEnhancements in C++23 for Generic ProgrammingThe Standard Template Library in C++23Core Components of the STLEnhancements in C++23 STL1.2 Boost, Eigen/Dense, and QuantLib Libraries in C++23Boost: A Versatile and High-Performance LibraryEigen/Dense: High-Performance Matrix ComputationsQuantLib: A Dedicated Financial Library1.3 C++23 in Quantitative Analysis1.4 Software Requirements and C++23 CompilersCompiler VersionBoost C++ LibrariesEigen/Dense for Matrix ComputationsQuantLib for Derivatives PricingGuide to Install and Set up Boost, Eigen, and QuantLib in Visual Studio 2022 for C++23Install BoostConfigure in Visual StudioInstall Eigen (Eigen/Dense)Install QuantLibConclusion
2. The Components of an Object-Oriented C++ Program
Core Principles of OOP in C++23Object CompositionClasses, Objects, and PointersClasses: The Blueprint for ObjectsDefining a Class in C++23Class Members: Data and FunctionsObjects: Instances of ClassesCreating and Using ObjectsPointers: Managing Object Memory EfficientlyRaw Pointers (Manual Memory Management)Smart Pointers (Automatic Memory Management)Why These Concepts Matter in C++232.1 Constructors and Destructors in C++23?Constructors: Initializing ObjectsDefault ConstructorParameterized ConstructorCopy Constructor (Deep Copying Objects)Move Constructor (Optimizing Performance with R-Values)Destructors: Cleaning Up ResourcesSmart Pointers and Automatic Destruction in C++232.2 Selectors and ModifiersWhat Are Selectors (Getters)?What Are Modifiers (Setters)?Read-Only Objects in C++23 (const Objects and Getters Only)Using std::expected<T, E> in Setters for Safer Error Handling (C++23 Feature)Calling the Setter with std::expected2.3 European Vanilla Option Specification in C++23Why Are the Header and the Source File Separated?Header Files (.h)Source Files (.cpp)2.4 Header Files (hpp or .h): Declarations OnlyKey Features of Header Files2.5 Source Files (.cpp): ImplementationsKey Features of Source Files2.6 The Function of main.cpp in C++23 ProjectsUsing Header, Source, and Main Files in a C++23 ProjectMain.cppSummary: Components of an Object-Oriented C++ ProgramConclusion
3. Option Payoff Hierarchies in C++23
What Are Option Payoff Hierarchies?A Better Approach: Payoff HierarchiesThe Benefits of This Approach3.1. Designing and Implementing a Base Class for Different Option Payoff StructuresDefining the Payoff InterfaceExtending the Base Class to Create Specific Option Payoffs (European Call, Double Digital)Step 1: Define the Abstract Base Class (PayOff)Step 2: Implement the European Call PayoffStep 3: Implement the Double Digital PayoffStep 4: Use the Payoff ClassesVirtual Destructors3.2 Preventing Memory Leaks in Option Pricing ModelsUse Smart Pointers (std::unique_ptr and std::shared_ptr)Why Use Smart Pointers?Use Resource Acquisition Is InitializationWhy Use RAII?Use std::vector Instead of Raw ArraysWhy Use std::vector?Use Move Semantics to Avoid Unnecessary CopiesWhy Use Move Semantics?Avoid Memory Leaks in Monte Carlo SimulationsUse delete Correctly If Using Raw PointersWhy Use Smart Pointers?SummaryConclusion
4. Generic Programming and Template Classes in C++23
How Does Generic Programming Differ from Object-Oriented Programming?Introduction to Template ClassesAnalysis of the CodeAnalysis of the CodeAnalysis of the CodeA Matrix Template Class4.1 Template Syntax and DeclarationNested Templates in C++Default Types in TemplatesSimpleMatrix DeclarationAnalysis of This Header FileSource File: SIMPLEMATRIX_CPPAnalysis of the Source FileExample Usage: main.cppAnalysis of the Main FileConclusion

5. Introduction to the Standard Template Library in C++23
Components of the STL in C++23How STL in C++23 Simplifies Quantitative Finance Applications with Prebuilt Data Structures and AlgorithmsPrebuilt Containers for Efficient Data ManagementGeneric Algorithms for Performance OptimizationParallel Execution for High-Speed ComputationIterators and Ranges for Cleaner, Safer CodeFunction Objects, Lambdas, and Custom Computation ModelsMemory Safety and Resource ManagementContainers in STL C++23Sequence Containers (Ordered Data Storage)std::vector (Dynamic Array, Best for Performance-Critical Applications)std::deque (Double-Ended Queue for Fast Insertions and Removals at Both Ends)std::list (Doubly Linked List for Frequent Insertions/Removals Anywhere)Associative Containers (Key-Value Storage for Fast Lookups)std::map (Balanced BST for Ordered Key-Value Data)std::unordered_map (Hash Table for Ultra-Fast Lookups)std::set (Sorted Unique Elements for Efficient Financial Calculations)Hybrid Containers in C++23 (Optimized for Performance)std::flat_map (Faster Alternative to std::map)5.1 Container Adapters in C++23std::stack (LIFO: Last-In, First-Out)std::queue (FIFO)std::priority_queue (Ordered Processing Based on Priority)Iterators in STL C++23Iterator Categories in C++23Input Iterator (Single-Pass Read-Only)Output Iterator (Single-Pass Write-Only)Forward Iterator (Multi-Pass Read/Write)Bidirectional Iterator (Supports Forward and Backward Navigation)Random Access Iterator (Fastest, Similar to Pointers)Why Iterator Categories Matter in C++23Iterator Adapters in C++23Reverse IteratorsInsertion IteratorsStream IteratorsConst IteratorsIterator Traits5.2 STL Algorithms in C++23Nonmodifying AlgorithmsModifying AlgorithmsRemoval AlgorithmsMutating AlgorithmsSorting AlgorithmsNumeric AlgorithmsConclusion
6. Function Objects
Ways to Model Functions in C++23Function Pointers (Legacy, but Still Useful)Function Objects (Functors): More Flexible than Function PointersLambda Expressions: Modern, Concise, and Flexiblestd::function: General-Purpose Function WrapperSTL Function Objects (Unary and Binary Functors)6.1 Function Pointers in C++23Function Pointer for Arithmetic OperationsFunction Pointers in Higher-Order FunctionsFunction Pointers with ArraysPerformance OverheadLack of StatefulnessThread Safety IssuesPoor Compatibility with TemplatesFixed Parameter Types and Lack of AdaptabilityModern Alternatives to Function Pointers6.2 Function Objects (Functors) in C++23Modern Alternative: Lambdas (C++11 - C++23)Conclusion
7. Matrix Classes
Choosing a Storage Mechanism for the Matrix ClassMatrix RepresentationType Considerations and Compiler BehaviorEncapsulation and Future FlexibilityMatrix Mathematical OperationsOperator OverloadingUnderstanding Operator OverloadingSummaryFull Declaration of the Matrix Header FileAnalysis of the Header FileThe Source FileImplementation of Mathematical OperatorsTypes of Overloaded OperatorsImplementationFull Source Implementation for QSMatrix ClassUsing the Matrix Classmain.cppExternal Matrix LibrariesWhy Avoid Custom Matrix Libraries in Production?Why Choose Eigen?Code BreakdownSummaryFinal InsightsConclusion
8. Numerical Linear Algebra in Quantitative Finance
Why Is NLA Essential in Quantitative Finance?Solving Large Systems of EquationsEigenvalue Problems in Risk Management and Portfolio OptimizationRegression and Least Squares in Financial ModelingCholesky Decomposition in Correlation and Risk ModelsFast Computation for High-Frequency Trading (HFT)Machine Learning and Predictive AnalyticsLU Decomposition: Theory and ApplicationsApplications of LU Decomposition in Quantitative FinanceAdvantages and Limitations of LU DecompositionC++ Basic Implementation (Using the Eigen Library)Manually Download and Add EigenUsing Eigen for LU DecompositionCode OverviewCode AnalysisAnalysis of OutputCholesky Decomposition: Theory and ApplicationsWhy Is Cholesky Decomposition Useful?Cholesky Decomposition and Its Role in Quantitative FinanceCholesky Decomposition AlgorithmCholesky Decomposition: Eigen ImplementationImplementationAnalysis of the CodeOutput AnalysisQR Decomposition in Quantitative FinanceHouseholder Reflection and Its Role in QR DecompositionQR Decomposition: Eigen ImplementationCode AnalysisSummaryOutput AnalysisSummaryLU DecompositionCholesky DecompositionQR DecompositionNumerical ImplementationConclusion
9. Black–Scholes Pricing Formula
Black–Scholes Formula for a European Call Option9.1 Implementation of the Black–Scholes Model for a European Call OptionStep 1: Include Necessary LibrariesStep 2: Implement the Standard Normal CDF N(d)Step 3: Implement the Black–Scholes FormulaStep 4: Implement main() for User Input and TestingThe Complete Code for the Black–Scholes ModelAnalysis of the CodeBlack–Scholes: Full ImplementationAnalysis of the CodeClosed-Form Solution for European OptionsNext Steps: Numerical Approximation with Monte CarloSummary9.2 Risk-Neutral Pricing of a European Vanilla OptionStock Price Evolution: Geometric Brownian MotionSummary9.3 Monte Carlo Simulation for Step-by-Step European Option PricingStep 1: Understanding the Monte Carlo MethodStep 2: Setting up the C++23 ImplementationStep 3: Implementing Monte Carlo PricerStep 4: Explanation of the CodeStep 5: Expected OutputAnalysis of the OutputComparison: Monte Carlo vs. Black–Scholes9.4 Gaussian Box–Muller Algorithm for European Vanilla OptionHow Useful Is the Box–Muller Algorithm for European Vanilla Option Pricing?SummaryGaussian Box–Muller Algorithm: Full ImplementationAnalysis of the CodeAnalysis of the Output9.5 Full Implementation European Vanilla Option in C++23 (Headers and Source Files)VanillaOption.hppVanillaOption.cpp (Source File): Class ImplementationVanillaOption.cppmain.cpp (Entry Point): Runs the ProgramMain.cppAnalysis of the OutputConclusion
10. Calculating the Greeks
Option Pricing10.1 Sensitivity Analysis and the Greeks in Derivatives PricingDelta (Δ)Gamma (Γ)Vega (ν)Theta (Θ)Rho (ρ)10.2 Implementation in C++23 of Header File (Greeks.h)Purpose of the Header FileBreakdown of Each SectionHeader Guards and IncludesStandard Normal Probability FunctionsStandard Normal Probability Density Function (PDF)Standard Normal Cumulative Distribution Function (CDF)Black–Scholes Helper Function (dj)European Call Option Pricing and GreeksCall Option PriceCall Option GreeksEuropean Put Option Pricing and GreeksMonte Carlo Gaussian Random Number GeneratorSummaryHeader File Complete: GREEKS.HAnalysis of the Code10.3 Implementation of main.cpp FileBreakdown of main.cppInclude HeadersDefine Input ParametersCompute Option Prices and GreeksDisplay Results (Using C++23 std::format())Display Call and Put Option PricesImplementing main.cpp (C++23)10.4 Euro Call and Put Pricing and Their Using Only Greeks.cpp in C++23: Full ImplementationAnalysis of the CodeAnalysis of the Output10.5 Implementing a CRR Binomial Tree for Option Pricing and Greeks10.6 CRR Binomial Tree for American Call and Put Options and Their Greeks Using C++23: Full ImplementationAnalysis of the CodeAnalysis of the OutputAmerican Call Option (Values)American Put Option (Values)Greek Sensitivity Charts for American Call and Put Options (Analysis)Chart 1: Delta vs. Stock PriceChart 2: Gamma vs. Stock PriceChart 3: Vega vs. Stock PriceChart 4: Theta vs. Stock PriceChart 5: Rho vs. Stock PriceConclusion
11. European Options with Monte Carlo Simulation
OverviewEstimating the price of European Call and Put Options using Monte Carlo Simulation: Basic Example11.1 Pricing European Options Using Monte Carlo Simulation: Full ImplementationAnalysis of the CodeAnalysis of the OutputSummary11.2 European Call Option Pricing Using Monte Carlo Simulation with Antithetic Variance Reduction and Control Variates Techniques in C++Variance Reduction TechniquesAntithetic VariatesControl VariatesConclusionMonte Carlo Antithetic Variates Method: Full Implementation in C++23Analysis of the CodeAntithetic Variates TechniqueDiscount PayoffPrints ResultsAntithetic VariatesAnalysis of the OutputSummary of Your OutputFinal Observations from the Output11.3 Monte Carlo Using Control VariatesMonte Carlo Standard vs. Monte Carlo Control VariatesMonte Carlo Control VariatesAdvantages and DisadvantagesConclusionAnalysis of the Monte Carlo Control Variates Results11.4 Implementing European Call Option Using Monte Carlo, Antithetic Delta, and Gamma-Based Control Variates in C++How Monte Carlo Works for Option PricingVariance Reduction TechniquesAntithetic VariatesDelta-based Control VariateGamma-based Control VariateCode WalkthroughMonte Carlo Valuation of a European Call Option using Antithetic, Delta, and Gamma-based Control Variates: Full Implementation in C++23 (Three Header Files and Two Source Files)MonteCarloMethod.hOptionGreeks.hAnalysis of the OuputConclusionKey Takeaways
12. Path-Dependent Asian Options
OverviewAsian OptionsArithmetic Asian Option (Payoff)Geometric Asian Option (Payoff)PayOff Class DeclarationAsianOption Base ClassPayOff ClassesPayoff.h (Header File)_PAY_OFF_CPP (Source File)Path Generation Header: Overviewpath_generation.hasian.cppThe Main ProgramExplanation12.1 Arithmetic Fixed Average Asian Option Pricing: Full Implementation (Three Headers and Four Source Files)Implementation (Headers and Source Files)Payoff.hPayoff.cpppath_generation.hConclusionpath_generation.cppSummaryasian_option.hSummaryasian_option.cppSummarymain.cppSummaryAnalysis of the Output12.2 Arithmetic Floating Average Asian Option Pricing: Full ImplementationAsianOption.hWhat Is a Floating Strike Asian Option?SummaryAsian_option.cppSummaryMain.cppClass Definition: AsianOption12.3 Geometric Average Asian Option Pricing (Fixed and Floating) Using Boost LibrariesWhat Are Boost Libraries?Why Use Boost?Implementing Geometric Average Asian Option Pricing with Boost12.4 Geometric Average Asian Option Pricing (Fixed and Floating) Using Boost Libraries: Full Implementation (Three Headers and Three Source Files)ASSIAN_OPTION_HASIAN_OPTION_CPPPATH_GENERATION_HPAY_OFF_HPAY_OFF_CPPMAIN.CPPExplanation of the OutputVisualizationConclusionKey Takeaways
13. Binomial and Trinomial Trees
OverviewRole in Financial ModelingRisk-Neutral Valuation13.1 Calculating the Value of a European Call Option Using Binomial Trees and Risk-Neutral ValuationsBinomial Trees for American Options with Early Exercise and Dividends13.2 Specifying Parameters for a Binomial European Call OptionAnalysis of the CodeAnalysis of the Output13.3 C++23 Implementation That Handles Both American Call and American Put Options Using the Binomial Tree ModelAnalysis of the CodeAnalysis of the Output13.4 Valuing Options on Stocks with Known Dividend Yields and Dollar DividendsParameters for Binomial TreesImplementationStoring the Binomial Tree in an ArrayCalculating Option PricesAnalysis of the CodeExplanation of the Output: Binomial Tree VisualizationStock Price TreeAmerican Call Option Price Tree13.5 Implementing American Spread Call Option Pricing Using Two-Variable Binomial ProcessImplementationHow to Price an American Spread Call OptionTwo Assets with CorrelationAmerican Option: Early Exercise FeatureVersatility and IntuitionImplementation in C+23Analysis of the CodeAnalysis of the OutputWhy the Value Is Around 513.6 CRR Binomial Tree and Greeks for Pricing OptionsImplementation in C++23Analysis of the CodeAnalysis of the Output13.7 Implementing CRR Binomial Tree Model with Dynamic Boundary Truncation for Pricing OptionsHow the CRR_Dyn_Bound_Trun Function WorksImplementation in C++23Analysis of the CodeAnalysis of the Output13.8 Leisen–Reimer Binomial TreeImplementationAnalysis of the CodeAnalysis of the Output13.9 Edgeworth Binomial TreeImplementation in C++23 Using Eigen/Dense LibraryAnalysis of the CodeA Quick Interpretation of the Result13.10 Trinomial TreeImplementationAnalysis of the CodeOutput AnalysisAmerican Option Price TreeFinal Option Price13.11 Adaptive Mesh Method: Advanced Implementation in C++23 (Greeks Included)Analysis of the CodeInterpretationConclusionKey Takeaways
14. Finite Difference Methods
OverviewFinite Difference Methods for Derivative Pricing14.1 Alternative Numerical Methods for Option PricingThe Diffusion Process and Derivative PricingApproximating DerivativesFinite Difference Schemes14.2 Explicit Finite Difference MethodBasic Implementation for the Given ProblemStep 1: Set up the GridStep 2: Finite Difference CoefficientsStep 3: Boundary ConditionsStep 4: Backward IterationStep 5: ResultExplicit Finite Difference Implementation in C++23Code Analysis14.3 Implicit Finite Difference MethodAdvantages over the Explicit MethodTrade-offsImplementing the Implicit Difference Method for an American ATM Put Option in C++23Applications of the Implicit Finite Difference MethodWhy Use the Implicit Method for American Options?Implementing the Implicit Difference Method for an American ATM Put Option in C++23Code AnalysisAnalysis of the OutputComparison with the Explicit Method14.4 Crank–Nicolson Scheme and Implementation for European Call Option PriceCode AnalysisInterpretationCrank–Nicolson Visualization (Modified Code, Including CSV Files for Visualization)Analysis of the Code14.5 Convergence Between Crank–Nicolson and Black–Scholes PricesImplementationCode AnalysisConclusion
15. Exotic Options
Overview15.1 Barrier Options15.2 Trinomial Tree for an American Barrier Up-and-Out Put Option (Basic Implementation in C++23)Code AnalysisFormula for Trinomial Probabilities15.3 Implementing the Up-and-Out Put Barrier Option Price Using Monte Carlo Simulations (Two Header Files and Three Source Files): Full Implementation in C++23Header File: Random1.hSource File. Random.cppHeader File: EuroBarrierOption.hSource file. EuroBarrierOption.cppSource file. Main.cpp15.4 Implementing the Up-and-Out Put Barrier Option Price Using Monte Carlo Simulations (Source File Only): Full Implementation in C++23Code Analysis15.5 Boyle and Lau Method for a European Barrier Option in C++23Pricing Barrier Options Using a Binomial TreeBoyle and Lau Method using Parity Relation, Reflection Principle and a Binomial Tree for European Single-Barrier Options with Optimal Number of Steps in C++Binomial Tree for Option PricingOptimal Number of StepsBarrier Adjustment for Discrete MonitoringParity Relation and Reflection PrincipleConclusionBoyle and Lau Method for EuropeanBarrierOption.cpp: Full Implementation in C++23Code AnalysisInterpretation of the Output15.6 Implementing a Binomial Tree for American Up-and-In Barrier Put Option Using Kwok and Dai Method with Optimal Number of Steps in C++23Option Pricing BackgroundKwok and Dai MethodOptimal Steps by Boyle and LauImplementation in C++23Code Analysis15.7 Implementing Binomial Tree for an American Down-and-In Call Option Using Kwok and Dai Method with Optimal Number of Steps in C++23American Down-and-In Call OptionBinomial Tree MethodKwok and Dai ModelImplementationCode Analysis15.8 Pricing a Call Option, a Put Option, and a Digital Option Using Gaussian Random Number Generator and the Box–Muller Transform (Three Header Files and Four Source Files): Full Implementation in C++23Header File: Payoff.hSource file. Payoff.cppHeader File: Random.hSource file. Random.cppHeader File: SimpleMC.hSource file. SimpleMC.cppMain File: Main.cpp15.9 American Cash-or-Nothing Call OptionWhat Is a Cash-or-Nothing Call Option?Leisen–Reimer Binomial Tree for ValuationImplementationCode Analysis15.10 Binomial Tree for European Fixed Strike Lookback ATM Call OptionImplementationCode Analysis15.11 Exotic Options Pricing Using Monte Carlo Simulation: Full ImplementationSimulates Asset Price MovementsImplementationCode AnalysisAnalysis of Results15.12 Exotic Option Valuation Engine Using the Boost and Eigen/Dense Libraries: Full ImplementationImplementationCode AnalysisAnalysis of the ResultsConclusion
16. Implied Volatility
OverviewInterval Bisection and Newton–Raphson16.1 Interval Bisection MethodApplication to Implied VolatilityFunction Templates in C++23 for Interval BisectionBasic Implementation in C++23Code Analysis16.2 Interval Bisection Method (Three Header Files and Two Source Files): Full ImplementationBlackScholesCall.hCode AnalysisBlackScholesCall.cppCode Analysisbs_prices.hCode AnalysisInterval_bisection.hCode AnalysisMain.cppCode Analysis16.3 Interval Bisection Method Using Boost LibraryPrerequisitesImplementationCode AnalysisOutput AnalysisImplementationCode AnalysisOutput Analysis16.4 Implied Volatility via Newton–RaphsonNewton–Raphson in ActionBasic Implementing Newton–Raphson in C++23Using Member Function Pointers16.5 Implementing Newton–Raphson (Two Header Files and Two Source Files, Including Option Vega): Full ImplementationBlackScholesCall.hBs_prices.hNewton_Raphson.hBlackScholesCall.cppMain.cpp16.6 Implementing Newton–Raphson Using Boost LibraryCode with Boost Newton–RaphsonCode AnalysisOutput Analysis16.7 Estimating Implied Volatility Using Newton–Raphson and Interval Bisection (Combined Method) in C++23Newton–Raphson MethodInterval Bisection MethodCombining Both MethodsInitial Bracketing with BisectionSwitch to Newton–RaphsonStep-by-Step ImplementationImplementationCode AnalysisPractical CaseCode AnalysisAnalysis of the OutputEstimating Implied Volatility for TSLA.cppCode AnalysisCode Structure and FunctionalityAnalysis of the OutputImplied Volatility Surface for TSLA OptionsCode AnalysisConclusion
17. Heston Stochastic Volatility Model
OverviewMonte Carlo AlgorithmC++ ImplementationBlack–Scholes ModelThe Heston ModelKey Differences in Generating Correlated PathsCholesky Decomposition17.1 Heston Model and its Greeks (Basic Implementation in C++23)Analysis of the CodeHeston Price Calculation17.2 Heston Stochastic Volatility Model Using the Euler–Maruyama Discretization Scheme (Five Header Files and Six Source Files): Full Implementation in C++23Statistics.hppAnalysis of the CodeStatistics.cppBreakdown of Each FunctionHeston_MC_hppHestonEuler Classheston_mc.cppPROJECTNAME_CORRELATED_SND_HPPCorrelated_snd.cppOption.hppOption.cppPay_off.hppPay_off.cppMain.cppMode 1: Heston Monte Carlo SimulationMode 2: Generating Normal and Correlated Normal VariablesBreakdown of the OutputImplementing Empirical CorrelationCode Analysis17.3 Implementing the Heston–Nandi Model in C++23Volatility Dynamics (GARCH Process)Option Pricing FrameworkTrapezoidal Rule for Numerical IntegrationBasic ImplementationStep 1: Include Headers and Define ConstantsStep 2: Define Model ParametersStep 3: Characteristic Function Under Risk-Neutral MeasureStep 4: Trapezoidal Rule IntegrationStep 5: Main Function To Tie Everything TogetherHeston–Nandi Model.cpp: Full ImplementationTrapezoidal Integration (TRAPnumint)Heston–Nandi Integrand Function (HNC_f)Heston–Nandi Call Price Calculation (HNC)The Main Function17.4 Implementing GARCH(1,1) in C++23 Using S&P500 Data: Estimating Variance and Standard Deviation (Annual and Daily Volatility)GARCH Models: Understanding Time-Varying Volatility in Financial MarketsThe GARCH FrameworkImplementation Main.cpp for GARCH(1,1) and SP500.txt File (1257 Data Columns or Close Prices: Apr 9, 2020–Apr 9, 2025)Code AnalysisAnalysis of the Output17.5 Implementing LGARCH(1,1) Often Implemented as EGARCH (Exponential GARCH) in C++23 Using S&P500 Data: Estimating Variance and Standard Deviation (Annual and Daily Volatility)Variance and VolatilityFull Implementation in C++23Code AnalysisOutput AnalysisConclusion
18. Geometric Brownian Motion and Jump-Diffusion Models
Overview18.1 Geometric Brownian MotionImplementationCode Analysis18.2 Jump-Diffusion Process and CEVJump-Diffusion ProcessCEV ModelComparison and Applications18.3 Pricing European Options Under a Jump-Diffusion ProcessThe Merton Jump-Diffusion ModelSimulation ComparisonGBMJump-DiffusionBasic ImplementationCode Analysis18.4 Implementing Black–Scholes and Diffusion Process Using Ornstein–Uhlenbeck Process in C++23The Black–Scholes ProcessImplementation in C++23 Using ParametersCode AnalysisOutput Analysis18.5 Estimating Monte Carlo Prices for a European Call Option Under the Merton Jump-Diffusion Process and the Geometric Brownian Motion ModelImplementation in C++23Code AnalysisAnalysis of the Output18.6 Estimating Prices for a European Call Option Under the Jump-Diffusion Monte Carlo Process, Merton Analytical Price, and the Geometric Brownian Motion ModelCore ComponentsImplementationCode AnalysisAnalysis of Results18.7 American Call and Put Option Pricing Using Jump-Diffusion Process and Merton Model Adding Control Variates: Full Implementation in C++23Inputs and ConfigurationMathematical Model: Merton’s Jump-DiffusionBlack–Scholes and Merton Analytical (Control Variates)Monte Carlo SimulationControl Variates LogicParallelization with OpenMPFull ImplementationCode AnalysisAnalysis of the Output18.8 Merton Jump-Diffusion Prices (Example): VisualizationImplementationCode AnalysisConclusion
References
Index

Overview

Learn to build robust, scalable financial models to position yourself as an expert in computational finance. At a time when the financial industry demands an increasingly complex and accurate mode, this book ensures you stay ahead of the curve by leveraging the latest advancements in programming to develop faster, more reliable, and maintainable financial software.

To begin, you’ll explore key features of C++23, object-oriented programming, and template-based design patterns critical for building reusable financial components. From there, dive into a range of numerical methods, including Monte Carlo simulations, binomial and trinomial trees, and finite difference schemes. Special attention is given to practical implementation details. Every chapter is designed to guide you step by step in transforming mathematical models into efficient, production-level C++ code. You will also learn to handle exotic derivatives, stochastic volatility, and jump-diffusion models, bridging the gap between theory and practice.

In the end, you’ll be equipped with the technical foundation and practical tools needed to design, implement, and analyze complex financial products. You will also be well-prepared to tackle the advanced interest rate and credit derivatives covered in further depth in De La Rosa’s Advanced Quantitative Finance with Modern C++.

What You Will Learn:

Master modern C++23 syntax and features, including object-oriented and generic programming.
Design flexible option payoff hierarchies for code reuse.
Apply advanced numerical techniques such as Monte Carlo, binomial/trinomial trees, and finite difference methods.
Calculate and interpret option sensitivities (Greeks).
Model and price exotic options, including stochastic volatility and jump-diffusion models.
Integrate mathematical finance concepts into production-quality C++ code.

Who This Book is for:

Quantitative analysts, financial engineers, researchers, and advanced developers who seek to deepen their knowledge of derivative pricing and computational finance using modern C++. Also suited for graduate students in quantitative finance or applied mathematics who want to complement their theoretical studies with robust coding skills.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Advanced Quantitative Finance with Modern C++: Interest Rate Modeling and Advanced Derivatives

Publisher Resources

ISBN: 9798868817939Purchase Link Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills