-   Forums
     -   Articles and Whitepapers
     -   Downloads
     -   Courses and Events
     -   Course Registration
     -   Distance learning
     -   Courses for Universities
     -   Books
     -   Audios and Demos
     -   Testimonials

Follow datasim on Twitter
Share this page: 


Advanced C# for Computational Finance and Derivatives' Pricing - (code CS-CF)

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 updated May 2015


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 (Builder, Mediator)
  • 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.

Duration, price, date, locations and registration

Course duration: 3 days.
Dates and location: (click on dates to print registration form)


Date(s) Location Price Language
Nov 01 - Nov 03 2017 Amsterdam
(The Netherlands)
€ 1995.-- ex. VAT
€ 2413.95 inc. 21% VAT
English
Feb 07 - Feb 09 2018 Amsterdam
(The Netherlands)
€ 1995.-- ex. VAT
€ 2413.95 inc. 21% VAT
English
May 09 - May 11 2018 London
(United Kingdom)
€ 1995.-- ex. VAT
€ 2413.95 inc. 21% VAT
English

Click on one of the dates above to register.
This course can also be organised at your company's premises. Call Datasim (+31-72-2204802) or e-mail for more information about the possibilities.




Share this page: