Beginning C++ for Financial Analysts

1. Auflage 2016
ISBN: 978-1-4842-0488-7
Verlag: Apress

Buch, Englisch, 400 Seiten, Book, Format (B × H): 178 mm x 254 mm

Beginning C++ for Financial Analysts is a primer for financial analysts and quantitative finance students who know finance but lack programming. Because most computational finance programs are written in C++, acquiring a pertinent subset of C++ programming skills is essential to success in the lucrative and burgeoning labor market for quants.

Beginning C++ for Financial Analysts teaches financial practitioners and students precisely what they need to know to use C++ to do routine financial computations such as valuing complex exotic options by Monte Carlo simulation. As opposed to being a book for programmers who want to tailor their skills to work in the finance industry, this book is for those with financial backgrounds who are novice programmers. Its coverage of the C++ language but is limited to what quants need in their daily work, and its approach is hands-on tutorial. Lessons start from the presumption of zero knowledge and progress step by step through familiar examples from computational finance.

Readers with a financial background will learn how to use modern C++11 to perform standard financial computations, including the following:

Zielgruppe

Popular/general

Autoren/Hrsg.

Brough, Tyler

Fachgebiete

• Mathematik | Informatik EDV | Informatik Programmierung | Softwareentwicklung Programmier- und Skriptsprachen
• Mathematik | Informatik Mathematik Mathematik Interdisziplinär Finanz- und Versicherungsmathematik

Inhaltsverzeichnis

Chapter 1. Introduction to C++ in the Finance Industry

• Why quantitative finance software is written in C++

• The C++11 language standard

• Toolchains for C++ programmers: compilers, editors, IDEs

Chapter 2. Variables, Data Types, and Standard Input/Output: The Simple Net Present Value Program

• The simple net present value program

• Declaring variables

• Fundamental data types

• Floating-point arithmetic in computational finance

• Initializing variables

• Type deduction in C++11

– The auto keyword

– The decltype keyword

• Variable scopes

• std:string

• Interacting with your program through standard input/output

• Arithmetic operators

• Constants

• Enumerations

Chapter 3. Control Structures and Loops: The Geometric Brownian Motion Simulation Program
[How to adapt the simple net present program to handle multiple cash flows. How to use pseudo-random number generators. First example of Monte Carlo simulation.]

• Introduction to flow control and branching concepts

• The if statement

– The else clause

• The switch statement

• while loops

– do while loops

– break and continue statements

• for loops

• Exception handling with try and catch blocks

• Logical operators

• The random header from the standard library for generating pseudo-random numbers

• The Geometric Brownian motion simulation program

Chapter 4. Creating User-Defined Functions: The Binomial and Black-Scholes European Option Pricing Engines

• How to write and call new user-defined functions

• How to pass data into our functions through the parameter list

• How to create default values for parameters in the parameter list

• How to overload a function definition

• How to inline functions

• The Binomial European option pricing engine
• The Black-Scholes European option pricing engine

Chapter 5. Arrays and Strings: The Binomial American Option Pricing Engine

• Simple static arrays: Introducing the Binomial American option pricing

engine program

– Creating arrays

– Indexing arrays

• Multidimensional arrays

– Creating multidimensional arrays

– Indexing multidimensional arrays

• Using std:string objects: Introducing the Portfolio Tracker program

– Objects

– The C-style strings

– Creating string objects

– Using std:string member functions

Chapter 6. The Standard Template Library: The Path-Dependent Exotic Option Pricing Engine

• Introduction to the Standard Template Library (STL)

– Containers

– Iterators

– Algorithms

– Templates
• Using std:vector in the path-dependent exotic pricing engine program

– Declaring vectors

– Using the push_back member method

– Indexing vectors

– Understanding vector performance

– List initialization

– Other member methods

• The other STL containers

• valarray

• Using std:array from C++11 instead of traditional arrays

• Using STL algorithms

– find

– sort

Chapter 7. References and Pointers: Improving Pricing Engine Efficiency

• Using references to improving pricing engine efficiency

– Creating references

– Assessing referenced values

– Changing referenced values

• Passing by reference to functions

• Returning references from functions

• Using pointers

– Declaring pointers

– Pointer arithmetic

– Dereferencing pointers

• Pointers to objects

• Passing pointers to functions

• Returning pointers from functions

• Function pointers

• The relationship between pointers and references

• Smart pointers from C++11

– The shared_ptr

– The unique_ptr

• The Monte Carlo pricing engine 2.0

Chapter 8. Creating User-Defined Types with Classes: The Option-Payoff Class

• User-defined types with classes: The option payoff class

– Structures

– Unions

– Classes

* Member variables

* Member functions

• Constructor functions

• Class access levels

– Private

– Public

• Using static data members and methods

• Destructor functions
• The Monte Carlo option pricing engine 3.0

Chapter 9. Advanced Classes: The Option Classes

• Aggregation: The VanillaOption and ExoticOption

classes

– Using object data members

– Using STL container members

• Operator functions and operator overloading

• Dynamically allocating memory

– Using the new operator

– Using the delete operator

– Avoiding memory leaks

– Smart programmers and smart pointers

• The this pointer

• The Monte Carlo option pricing engine 4.0

Chapter 10. Polymorphism and Inheritance: The Pricing Engines Revisited

• Class inheritance: The payoff class

– Deriving from a base class

– Using inherited members and methods

• Access control under inheritance

• Calling and overriding base class member methods

– Calling base class constructor functions

– Declaring virtual base class member methods

– Overriding virtual base class member methods

– Calling base class member methods

• Abstract base classes

• Polymorphism: The Monte Carlo and Binomial pricing engines revisited

Chapter 11. Advanced Topics: Solvers, Implied and Stochastic Volatility

• Generic programming and templates: the implied volatility solver

– Function templates

– Generic classes

• The Heston stochastic volatility model and implied volatility

• Design patterns

• Tools for large projects

• API design for libraries

• Third party libraries used in computational finance

• Advanced topics: Where to go from here

Über Autor(innen)

Tyler J. Brough is Assistant Professor of Finance in the Jon M. Huntsman School of Business at Utah State University. He holds a PhD in Finance from the University of Arizona, an MS in Finance from the University of Illinois at Urbana-Champaign, and a BS in Economics from Brigham Young University. He has published research in empirical finance in Financial Management, the Journal of Banking and Finance, the Journal of Trading, and other highly regarded academic journals. He programs in C++ for his research in financial economics and econometrics. In addition, for the last three years he has developed and taught a course in computational finance, in which he teaches the C++ programming language to students who typically have little prior programming experience. As a researcher in financial economics, he has extensive experience programming in C++ for the processing of massive data sets and for intense numerical programming for econometric analysis and Monte Carlo simulation. As an end user of the C++ programming language, he has learned what matters for financial computation and how to use real examples from finance to motivate the learning of C++.