Advanced C# for Computational Finance and Derivatives' Pricing -

(code CS-CF)

DESCRIPTION

The goal of this hands-on course is to apply the C# object-oriented language and the libraries in the .NET framework to the design and implementation of flexible and robust applications. The focus of the course is on using object-oriented and generic programming models in combination with useful libraries to help the quant developer produce running code for a range of pricing applications for equities and interest rate products. We also discuss how to implement the Gamma (GOF) design patterns in C# and we have seen a many-fold productivity improvement because the .NET libraries support them or can be easily adapted to support them.

Why C#? In our experience we have seen that C# and the .NET libraries are suitable for high-performance desktop applications. First, developer productivity levels are higher in C# when compared with C++, second code performance is excellent and finally the features in the language and the libraries in the .NET framework allow us to develop customizable finance applications.


Overview of Course

This intensive four-day course discusses the object-oriented and generic programming techniques in C#, using the .NET libraries and integrating them with design patterns to create finance applications. Major topics are:

  • Using the .NET framework for finance applications
  • Derivatives modeling for equities and fixed income products
  • Classes, composition and inheritance
  • Interfaces and component programming in C#
  • Design patterns and customizable applications
  • Interfacing with legacy systems
  • Finite difference, PDE and Monte Carlo models in C#

Benefits

  • Advanced object-oriented, generic and functional programming
  • Functionality to support application development A-Z
  • Applications to computational finance
  • Increased developer productivity
  • Next generation design patterns in .NET
  • Monte Carlo, PDE and fixed-income applications


What previous delegates have said

  • "Good presentation and documentation"
  • "The Excel part will help us in future work"
  • "All questions answered by trainer"
  • "Very deep and full scope"

                                                                                 

Course Contents

Part I: Essential C#

Overview of the .NET framework

  • Type Safety and Memory Management
  • Classes and Interfaces
  • Namespaces and their use in .NET
  • Common Language Runtime (CLR)

 

Object-Oriented Programming in C#

  • Classes, fields and methods
  • Pass-by-value and pass-by-reference
  • Constructors and object initializers
  • Structs
  • Properties

 

Advanced Classes

  • Inheritance
  • Polymorphism and casting
  • Virtual function members
  • Abstract classes and abstract methods
  • Boxing and unboxing

 

Interfaces and Components

  • Interfaces and contracts
  • Implementing interfaces; the different scenarios
  • Should we use an abstract class or an interface?
  • Why interfaces are essential for applications

 

Delegates

  • Motivation: function pointers and callbacks
  • Delegate types and delegate instances
  • Writing plug-in methods with delegates
  • Multi-cast delegates
  • Delegates versus interfaces

 

Events

  • Broadcasts and notification patterns
  • Event accessors and modifiers
  • Events and Windows programming
  • Anonymous methods

 

Generics in C#

  • Generic types
  • Generic methods and parameters
  • Generic delegates

 

Advanced Generics

  • Generic constraints
  • Subclassing of generic types
  • Self-referencing generic declarations
  • Generic events

 

Application in .NET, Part 1

  • One-factor Monte Carlo option pricing
  • Scoping the system
  • System and component interfaces
  • System Decomposition

 

Application in .NET, Part 2

  • Choosing between interfaces and delegates
  • Implementing classes
  • Design and system patterns (BuilderMediator)
  • Creating a single-threaded solution
  • Multi-threaded solution


Part II: Core Libraries and their Applications in Finance

Fundamental Data Structures

  • Strings and text handling
  • Dates and Times; time zone
  • Financial dates: day-count convention
  • Formatting and parsing
  • Regular expressions

 

Collections

  • Defining and iterating in containers
  • The Array Class
  • Linked lists
  • Hash tables and sorted dictionaries

 

Creating your own Containers

  • Combining inheritance and generics
  • Composition as an alternative to inheritance
  • Data structures: vectors and numeric matrices
  • Multi-dimensional data structures
  • Applications to finance

 

Streams and I/O

  • Stream architecture
  • Stream class' members
  • File, memory and pipe streams
  • Stream adapters

 

Serialization

  • Serialization engines
  • Data contract serializer
  • Binary serializer
  • XML serializer
  • Creating and applying serializers

 

Design by Contract

  • Background (Eiffel Programming language)
  • Supplier and client: rights and responsibilities
  • What is reliable and correct software?
  • Correctness and Hoare triples
  • Preconditions, postconditions and assertions
  • Imperative and declarative statements

 

Code Contracts in .NET

  • Overview of Code Contract
  • The binary rewriter
  • The Contract class
  • Implementing contract by design
  • Contracts on interfaces and abstract classes
  • Dealing with contract failure

 

Disposal and Garbage Collection(GC) 

  • IDisposable, Dispose and Close
  • Finalisers
  • Automatic garbage collection
  • GC internals
  • Memory leaks


Part III: Design and Integration Techniques

Threads and Parallel Programming

  • A quick introduction to multi-threading concepts
  • Thread class
  • Synchronisation
  • Asynchronous delegates
  • Locking
  • Thread safety

 

Assemblies

  • No more DLL hell!
  • The structure of an assembly
  • Private and shared assemblies
  • Global Assembly Cache (GAC)
  • Assemblies and their importance for component design

 

Reflection and Metadata

  • What is reflection and why is it useful?
  • Reflection applied to types
  • Reflection applied to assemblies
  • Reflection and member invocation
  • Application configuration
  • Dynamic code generation


Part IV: Creating Computational Finance Applications

Threads and Data

  • Implementing the shared data metaphor
  • Passing data to a thread
  • Mutex and Semaphore in C#
  • Thread safety

 

Synchronisation I

  • Blocking methods
  • Sleep and EndInvoke
  • Join
  • Spinning

 

Synchronisation II

  • Locking
  • Mutex and Semaphore, again
  • Nested locking
  • Locking and atomicity

 

Parallel design patterns

  • SPMD pattern
  • Master/Worker pattern
  • Loop parallelism pattern
  • Shared data and shared queues patterns

 

C# and Design Patterns

  • Why design patterns and which ones to use
  • Implementing patterns in C#
  • Ready-made patterns in C#
  • Applications in finance

 

Major Patterns

  • Builder and Factory Method
  • Adapter, Bridge
  • Visitor, Strategy, Template Method
  • Builder

 

Monte Carlo Engine in C#

  • Modular decomposition
  • Design of engine (Produce-consumer)
  • Random number generators
  • Parallel programming


 

Finite Difference Method (FDM)

  • One-factor models
  • Plain and barrier options
  • Early exercise features
  • The Crank Nicolson method
  • Comparing FDM with trinomial method


Alternating Direction Explicit (ADE) Method

  • Background and motivation
  • ADE for one-factor models
  • ADE for nonlinear pricing models
  • Advantages of ADE


Two-Factor Model

  • ADI and Splitting Methods
  • Craig-Sneyd method
  • Mixed derivatives and Janenko method
  • ADE for two-factor problems

 

Fixed Income Application

  • Creating a structured product in C#
  • Class design
  • Bootstrapping and yield curves
  • Linear and cubic spline interpolation
  • Worksheet functions
  • Add-ins

 

Monte Carlo Simulator

  • Class Design
  • Random number generators
  • Stochastic equations and finite difference methods
  • Using multi-threading to improve performance


 

Prerequisites

This is not a beginners course and we assume that the student has a working knowledge of C++ or Java, for example. Alternatively, knowledge of basic C# syntax is necessary. We also assume that you are involved in derivative pricing application development or plan to move into this area.

If you have any queries, please do not hesitate to contact Daniel J. Duffy.

 

Who should attend?

We have created this course for those working with applications for a range of derivatives pricing models, for example quant analysts, developers and model validators. The course is also of interest to VBA, Java and C++ developers who wish to learn C# and apply it in their daily work. 
 

Course Form

The percentage theory/practice is approximately 70/30. 

 

Course dates

Date from Date to Location Price (excl. VAT)
Wednesday 9 May 2018 Friday 11 May 2018 London EUR 1995.00

Advanced C# for Computational Finance and Derivatives' Pricing -

Course date

Fill in your personal details