Learning Modern C++ for Finance Daniel Hanson

Spis treści książki

• Preface
  • Navigating This Book
  • Conventions Used in This Book
  • Using Code Examples
  • OReilly Online Learning
  • How to Contact Us
  • Acknowledgments
• 1. An Overview of C++
  • C++ and Quantitative Finance
    • C++11: The Modern Era Is Born
    • Open Source Mathematical Libraries
    • Some Myths about C++
    • Compiled Versus Interpreted Code
  • The Components of C++
    • C++ Language Features
    • The C++ Standard Library
  • Some New Language Features Since C++11
    • The auto Keyword
    • Range-Based for Loops
    • The using Keyword
    • Uniform Initialization
    • Formatting Output
    • Class Template Argument Deduction
    • Enumerated Constants and Scoped Enumerations
      • Enumerated constants
      • Potential conflicts with enums
      • Scoped enumerations with enum classes
    • Lambda Expressions
  • Mathematical Operators, Functions, and Constants in C++
    • Standard Arithmetic Operators
    • Mathematical Functions in the Standard Library
    • Mathematical Special Functions
    • Standard Library Mathematical Constants
  • Naming Conventions
  • Summary
  • Further Resources
• 2. Writing User-Defined Classes with Modern C++ Features
  • A Black-Scholes Class
    • Representing the Payoff
    • Writing the Class Declaration
    • Writing the Class Implementation
    • Using a Functor for Root Finding: Implied Volatility
  • Move Semantics and Special Member Functions
    • Data Members and Performance Considerations
    • An Introduction to Move Semantics
    • Initialization of Constructor Arguments with std::move(.)
    • Anonymous Temporary Objects and Move Semantics
    • Return Value Optimization
    • Default Constructor
  • Three-Way Comparison Operator (Spaceship Operator)
  • Lambda Expressions and User-Defined Class Members
  • Summary
  • Additional References
• 3. Inheritance, Polymorphism, and Smart Pointers
  • Polymorphism
  • Resource Ownership with Raw Pointers
    • Using Clone Methods
    • Creating an Instance of OptionInfo
    • Preventing Shallow Copy
    • Implementing the OptionInfo Destructor
    • Pricing an Option
    • Implementing Copy Operations
    • The (Old) Rule of Three
  • Introducing Smart Pointers
    • Unique Pointers
    • Shared Pointers
  • Managing Resources with Unique Pointers
    • Just Move It
    • Using the Result in a Pricing Model
    • If Copy Operations Are Required
      • Clone methods, revisited
      • Implementation of the updated copy operations
      • The rule of zero/the rule of five
  • Summary
  • Further Resources
• 4. The Standard Template Library Part I: Containers and Iterators
  • Templates
    • Using Function Templates
    • Using Class Templates
    • Compiling Template Code
  • STL Containers
    • Sequential Containers
      • The vector sequential container
        • Storage of objects in a vector
        • Polymorphic objects
        • Allocation and contiguous memory
        • The clear() method
        • The front(), back(), and pop_back() methods
        • Random access in a vector: at(.) versus [.]
        • A potential pitfall with the meaning of () and {} with a vector
        • C-arrays and the data() member function
      • The std::deque sequential container
      • The std::list sequential container
      • Fixed-length std::array
      • When in doubt, use a vector
    • Associative Containers
      • std::map as a model data container
  • STL Iterators
    • Using auto to Reduce Verbosity
    • Using Constant Iterators
    • Iterators or Indices?
    • Iterators on Associative Containers
  • Summary
  • Further Resources
• 5. The Standard Template Library Part II: Algorithms and Ranges
  • STL Algorithms
    • A First STL Algorithm Example
    • A First Example with Ranges
    • Some Commonly Used Algorithms
      • The for_each algorithm
      • The transform algorithm
        • Modify and replace elements in the same container
        • Modify elements and place in a separate container
    • Function Objects as Auxiliary Functions
    • Class Member Functions as Auxiliary Functions
    • Locating, Sorting, Searching, Copying, and Moving Elements
      • Maximum and minimum elements
      • Sorting values
      • Searching for elements in containers
      • Copying and moving elements
    • Numeric Algorithms
      • Generating incremented values with std::iota
      • Using std::accumulate for sums and generalized accumulations
      • Computing dot products and generalizations with std::inner_product
      • Pairwise differences and generalizations with std::adjacent_difference
      • Computing partial sums of finite series with std::partial_sum
      • Considering financial applications of numeric STL algorithms
  • Range Views, Range Adaptors, and Functional Programming
    • Range Views
    • Chaining for Functional Composition
    • Views, Containers, and Range-Based for Loops
  • Summary
  • Additional References
• 6. Random Number Generation and Concurrency
  • Distributional Random Number Generation
    • Introducing Engines and Distributions
    • Generating Random Normal Draws
    • Using Other Distributions
  • Shuffling
  • Monte Carlo Option Pricing
    • A Review of Monte Carlo Option Pricing
    • Generating Random Equity Price Scenarios
    • Calculating the Option Price
    • Pricing Path-Dependent Options
  • Concurrency and Parallelism
    • Parallel Algorithms from the Standard Library
      • Descriptive statistics
      • Inner product
      • Performance and guidance
      • Execution policies: in general
    • Task-Based Concurrency
      • Creating and managing a task
      • Revisiting Monte Carlo option pricing
      • Considering caveats and performance
    • Concluding Remarks on async and future
  • Summary
  • Further Resources
• 7. Dates and Fixed Income Securities
  • Representation of a Date
  • Serial Representation
  • Accessor Functions for Year, Month, and Day
    • Checking the Validity of a Date
    • Checking Leap Years and Last Day of the Month
    • Identifying Weekdays and Weekends
    • Adding Years, Months, and Days
      • Adding years
      • Adding months and handling end-of-month cases
      • Adding days
  • A Date Class Wrapper
    • Class Declaration
      • Constructors
      • Public member functions and operators
      • Private members and member functions
      • The ChronoDate class declaration, in full
    • Class Implementation
      • Constructors
      • Member functions and operators
        • Accessors
        • Date properties
        • Operators
        • Addition of years, months, and days
        • Business-day roll rule
        • Stream operator
  • Day Count Basis
  • Yield Curves
    • Deriving a Yield Curve from Market Data
    • Discount Factors
    • Calculating Forward Discount Factors
    • Implementing a Yield-Curve Class
    • Implementing a Linearly Interpolated Yield Curve Class
  • A Bond Class
    • Bond Payments and Valuation
      • Determining the payment schedule
      • Valuing a bond
    • Designing a Bond Class
    • Implementing the Bond Class
  • A Bond Valuation Example
  • Summary
  • Additional Reference
• 8. Linear Algebra
  • Lazy Evaluation and Expression Templates
    • Lazy Evaluation
    • Expression Templates
  • The Eigen Linear Algebra Library
    • Eigen Matrices and Vectors
    • Matrix and Vector Math Operations
    • STL Compatibility
      • STL and VectorXd
      • Applying STL algorithms to a matrix
      • STL-like variants and mathematical functions in Eigen
  • Matrix Decompositions and Applications
    • Fund Tracking with Multiple Regression
    • Correlated Random Equity Paths and the Cholesky Decomposition
    • Yield-Curve Dynamics and Principal Component Analysis
  • Future Directions: Linear Algebra in the Standard Library
    • mdspan
    • BLAS Interface
  • Summary
  • Further Resources
• 9. The Boost Libraries
  • Mathematical Constants
  • Statistical Distributions
    • Probability Functions
    • Drawdown Example, Revisited
    • Random Number Generation with Boost Distributions
  • MultiArray
    • A Simple Two-Dimensional MultiArray
    • Binomial Lattice Option Pricing
      • American options
      • Implementation with Boost MultiArray
      • Convergence
      • Extensions
    • Accumulators
    • Max and Min Example
    • Mean and Variance
    • Rolling Mean and Variance
  • Trading Indicator Examples
  • Summary
  • Further Reading
• 10. Modules and Concepts
  • Modules
    • Standard Library Header Units
    • Templates in Modules
    • import Versus #include
    • Declarations in Module Interfaces
    • Separating Declarations from Implementation
    • Namespaces
    • Partitions
  • Concepts
    • Defining Concepts
    • Defining Concepts with Multiple Conditions
    • Standard Library Concepts
  • Summary
• A. Virtual Default Destructor
• B. Object Slicing
• C. Implementation of Move Special Member Functions
• D. Resolving Conflicts in the Initialization of a vector
• E. valarray and Matrix Operations
  • Arithmetic Operators and Math Functions
  • valarray as a Matrix Proxy
• Index

pokaż cały spis treści

ukryj recenzje