One-day Special Seminars on Computational Finance - (code SEM-CF)

The goal of these special one-day seminars is to introduce a number of topics of interest to quantitative analysts and designers who design and implement financial derivatives products. Each seminar is an intensive introduction to, and overview of the essential features of a specific design technique as applied to computational finance. We discuss the most important and critical techniques that we apply to a number of applications such as the Monte Carlo method and PDE/Finite Difference Methods for option pricing and interest-date modelling, for example.

Course Structure

The three courses are all independent of each other and can be taken separately. The ideal trajectory is to attend all three courses because then you can see how to design, implement and optimize applications in computational finance. In particular, we concentrate on proven and standard tools such as Design Pattern (Gamma, GOF), the boost library and the de-facto standard OpenMP library for parallel and multi-threading programming.

We structure these courses in such a way that you get maximum benefit from them during the allotted time. In the morning sessions we shall introduce the essentials of the course and its applications. After the lunch break attendees can experiment with software that is provided in the course and we discuss more examples and applications from computational finance. There is ample opportunity for questions and an interactive session is stimulated.

We have shown the steps in the figure below. Each course delivers a certain product as it were based on given input. For example, Day 1 creates a design using GOF/POSA patterns using the description of some finance problem; Day 2 implements the design in boost using the design from Day 1 while in Day 3 we port the code from Day 2 to parallel code. The topics are independent, however, thus allowing you to attend each one independently of the others.

What do you learn?

Using the most appropriate software techniques for computational finance Modern and proven design patterns and software libraries Developing Monte Carlo and PDE/FDM applications Bringing C++ to the next level

The Examples and test Cases in this Course

We take a number of specially chosen examples and applications at different levels of complexity and applicability in order to ensure that the attendees understand the topics as soon as possible:

• '101' examples to show the essential syntax
• Small building block-type examples that use combined syntax
• Mini-applications for computational finance

After lunch, the students have the opportunity to experiment with the code so that they can consolidate the morning session's theory and before we continue with advanced topics and applications.

What do you receive?

Slides, sheets and C++ source code for all examples and test cases. The course also includes tea, coffee, lunch and refreshments.

Course Contents

Day 1: Design Patterns in Computational Finance

The goal of this course is to introduce and motivate the use of POSA system patterns and GOF design patterns. We discuss how they can be used, combined and applied to finance applications. A design pattern is a template or set of activities to implement any kind of problem. The advantage of patterns is that they add to the flexibility and reusability of your applications and they also improve developer productivity.

Contents

What is POSA?

• Architectural patterns in POSA
• Design patterns in POSA
• Relationship with GOF patterns
• Structural Decomposition

Whole-Part pattern

• Examples from application areas
• Comparing Whole-Part with Composite
• Combinations

Overview of Design Patterns

• What is a design pattern?
• A brief history of patterns
• Describing and documenting patterns

Creational Patterns

• Factory Method pattern
• Abstract Factory pattern
• Builder pattern
• Structural Patterns

Bridge pattern

• Decorator pattern
• Façade pattern
• Proxy pattern
• Behavioural Patterns

State pattern

• Visitor pattern
• Observer pattern
• Mediator pattern
• Observer problems and solution

Template Classes and Design Patterns

• Using C++ templates with patterns
• Generic design patterns
• Advantages of the template approach
• Templates for Creational, Structural and Behavioural patterns

Applications, Demos and Discussion

• Monte Carlo simulation
• Matrix algebra
• Finite Difference method

Day 2: The Boost Library in Computational Finance

The goal of this course is to introduce the C++ boost template library, what kind of functionality it offers and how to use and apply it to application development in computational finance. This library contains for many kinds of functionality that you need in applications for computational finance. A number of the libraries have been accepted of part of the standard C++ language and more will follow in due time.

Contents

Overview of Functionality

• Mathematics
• Containers and Data Structures
• Function Objects and Higher-Order Programming
• System libraries (threads, statecharts,…)
• String and Text Processing
• Input/Output
• Miscellaneous (many more) libraries

Memory

• Dynamic object lifecycle
• Improvement over raw pointers
• Scoped and shared pointers
• Single objects and arrays

uBLAS (Basic Linear Algebra System)

• Vectors, matrices and their operations
• Patterned matrices (sparse, triangular, ..)
• Expression templates to improve performance
• Applications of uBLAS classes

Tuple

• Modelling n-tuples (pair is a 2-tuple)
• Using tuples as function arguments and return types
• Accessing the elements of a tuple
• Advantages and applications of tuples

Variant

• Creating discriminated unions with heterogeneous types
• Manipulating several distinct types in a uniform manner
• Type-safe visitation
• Avoiding type-switching for variant data

Random Library

• Functionality for random number generators
• Mersenne Twister, lagged Fibonacci
• Useful in a number of applications

Interval

• Interval arithmetic
• Model round-off errors explicitly
• Applications to numerical analysis
• Quantify the propagation of rounding errors

Applications, Demos and Discussion

• Monte Carlo simulation
• Matrix algebra
• Finite Difference method

Day 3: The OpenMP Multi-Threading Library in Computational Finance

Most C++ applications are written for single-core processors but with the emergence of affordable and powerful multi-core processors we can create applications that use the full power of these processors using parallel programming techniques. Present-day commodity computers already contain dual-core and quad-core processors and this opens up new possibilities to create even faster applications that would have been unthinkable even a few years ago.

This course is an essential introduction to the design and implementation of multi-threaded C++ applications using the OpenMP library. OpenMP is a collection of compiler directives, library routines and environment variables that developers use to specify shared-memory parallelism in C and C++. It is a de-facto industry standard and it has been accepted by several major software and hardware vendors.

Contents

Memory Systems

• Shared memory parallel computers (SMPs)
• Shared and cache memory

Threads

• What is a thread?
• Data Access in Threads
• Fork-join (master/slave) model
• Shared and private data
• Thread synchronization

Synchronisation in Detail

• Mutual exclusion (mutex) and condition variables
• Critical sections
• Memory synchronization and fences
• Barriers
• Overview

Compiler directives

• Library routines
• Environment variables
• My First OpenMP Program

Writing the serial program

• Determining parallel code
• Adding OpenMP directives
• Debugging and performance measurement
• Data Clauses in OpenMP

Shared and private Data

• Lastprivate, firstprivate
• Default and nowait clause
• OpenMP Synchronisation Constructs

Barrier

• Ordered
• Critical and Atomic
• Locks, Master construct

Troubleshooting in OpenMP

• Common problems
• Race, shared and private variables
• Work scheduling assumptions
• Side-effects; the need for thread safety

Applications, Demos and Discussion

• Monte Carlo simulation
• Matrix algebra and solving linear systems
• Sorting
• Finite Difference method

Prerequisites

Who should attend?

Duration, price, date, locations