Advanced C++ Design and Implementation in Quantitative Finance by Nick Webber

Advanced C++ Design and Implementation in Quantitative Finance by Nick Webber

Start Date: Week Commencing 26th January 2015

Early Bird: 20% Discount before 19th December 2014

Location: Globally online

This course can be taken as part of the Annual Subscription Service

Introduction:

The aim of the programme is to teach delegates the principles and concepts of OOP C++,  enabling them to understand the fundamentals of application design in OOP C++

The course uses concepts of application design to structure the presentation of C++ and numerical material.  As new ideas are introduced their realizations in C++ are presented in the context of applications of simulation and lattice methods to models of option pricing. The simulation method is developed from a naive monolithic single procedure main to a powerful fully polymorphic application. The final application, employing a variety of important design patterns including a polymorphic factory,  uses most of the syntactical elements of C++ in standard design paradigms. During this development a lattice method is implemented,  enabling further features to be introduced.

A basic knowledge of C++ is assumed.  A knowledge of classes is not assumed, nor a knowledge of object oriented programming styles. Implementations are in DevCpp, a freeware IDE wrapping the C++ 03 standard compliant GCC 3.4.2 compiler. C++ 11 extensions to C++ 03 are not required.

Quants Hub Programming School 14 Week Format:

Week 1, Lecture 1. A  simple procedural Monte Carlo

This module takes as its starting point the construction a simple monolithic procedural implementation of a basic time-stepping Monte Carlo method of option valuation.

Topics:  file layout and coding standards;  encapsulation into functions;  separation in translation units;  the (mis)use of static variables;  syntactic speed-ups and pre-computing;  the cost of exp().

Week 2, Lecture 2. Introducing objects:  basic syntax and design

The procedural application of module 1 is converted into an application with functionality split between objects.  Constructs option,  process and accumulator objects.

Topics:  Class declaration and definition;  constructors/destructors; public and private functions and data;  forward declarations and decoupling; initializer lists;  identifying objects in the Monte Carlo application; encapsulation and decoupling in the MC application;  telepathy and avoiding it;  pointers to objects;  memory handling.

 Week 3, Lecture 3. Developing the basic structure

The basic objects in the module 2 are refined and developed by introducing I/O objects,  a stopwatch, an application wrapper object,  and a valuation object.  A path,  coded as a std∷vector,  is introduced.

Topics:  std∷vector;  object interaction (dispatching);  exception handling.

Week 4, Lecture 4. Introducing polymorphism:  basic syntax

In the application developed in module 2 it is awkward to value different options.  Module 3 introduces and implements polymorphism.  It constructs polymorphic option,  process and application objects.  The concept of a pseudo-factory,  encapsulating object creation,  is introduced and implemented.

Topics: polymorphism and base classes;  pure virtual functions,  inheritance,  and interfaces;  the this pointer;  double dispatching;  output registration with std∷map;  the decorator pattern with Monte Carlo.

Week 5, Webinar Week: This will cover the first 4 weeks of the course. 

Week 6, Lecture 5. A lattice application

A basic procedural lattice method is constructed.  The objects that support it are identified and integrated into the application developed in module 4.  The module 5 application can value American and Bermudan style options,  with the lattice,  and European style options,  with simulation.

Topics:  slices and extending the design of the option,  process and valuation objects;  whether to use composition or inheritance;  the pimple pattern.

Week 7, Lecture 6. Advanced topics in class design

Motivated by the inconvenience of zero-based arrays and vectors in the lattice application this module develops a vector class that illustrates a number of advanced features of C++ object design.  In the module 6 application std∷vector is replaced by the new vector class.

Topics: deep and shallow copy;  the copy constructor and copy-assignment;  the  rule of three;  exception safety;  clone() and swap(); operator overloading;  friend methods.

Week 8, Lecture 7. Polymorphic I/O

So far I/O has been comparatively crude.  Module 7 now addresses polymorphic I/O including I/O to and from file.  Objects request input using parameter classes.  A singleton IO object is introduced.  An environment object is created to manage I/O choice.

Topics:  streams;  opening modes;  methods and manipulators;  I/O to file;  random access files;  designing polymorphic input and output;   the singleton pattern.

Week 9, Lecture 8. Generic programming and templates

This module provides background material required for the template factory described in module 10.  Template inputter functions are added to the model 7 application.

Topics:  templates,  declaration and definition;  the typename keyword; the inclusion model;  template member functions;  class templates;  non-member function templates;  full and partial specialization.

Week 10, Webinar Week: This will covers weeks 6 - 9 of the course. 

Week 11, Lecture 9. Design patterns with objects

This module develops a non-template polymorphic application factory,  a precursor to the template factory developed in module 10.

Topics:  registration and call-back;  the factory pattern.

 Week 12, Lecture 10. A template factory

The non-template application factory of module 9 is converted in a full template factory.  Separate IO and environment factories are added.  The progress made since module 1 is assessed.

Topics:  mix-in classes;  traits;  printable objects;  the configuration object

Week 13, Revision week.

Week 14, Final Practical Project week.

The final project will be marked with feedback and a pass or fail will given. One retake is allowed if you fail. 

About the Presenter

Nick Webber learnt to programme with Algol 60 and has been programming ever since. Currently he lectures in Finance at De Montfort University where,  amongst other things,  he develops computational methods for the numerical valuation of financial derivatives.  He has authored books on interest rate modelling and on implementing derivatives valuation systems.  His research interests lie in computational methods for financial models,  including lattice and simulation methods.

Before his academic incarnation Nick worked in system design and implementation in industry,  both in IT groups and as a consultant.  He has  taught computational finance in C++ and VBA for  many years,  in Universities and to practitioners.  He combines a research and theory oriented perspective with experience with real applications.  He advocates sensible design precepts at all times. 

PRMIA Certification:

The Professional Risk Managers' International Association (PRMIA) is a non-profit professional association, governed by a Board of Directors directly elected by its global membership, of nearly 90,000 members worldwide. PRMIA is represented globally by over 65 chapters in major cities around the world, led by Regional Directors appointed by PRMIA's Board.

The Programming School will be fully certified by PRMIA, available from October 2014. 

Other courses: 
Matlab – An Introduction for Financial Applications with Jörg Kienitz
Python for Finance with Yves J. Hilpisch: The Python Quants
F# and Functional Programming in Finance with Tomas Petricek
Mathematica / UnRisk distance learning Module with Michael Aichinger
R in Finance by Joris Meys