Bojan's Blog

A simple FX-Option Example in QuantLib

2009-09-23T09:44:55Z

Here is a simple, bare-bones example of pricing an American FX vanilla option in QuantLib:

Comments now available on this blog

2012-03-05T20:48:50Z

I have added a commenting capability on this blog, using the disqus system. Initially the comments will be un-moderated. Hopefully they will be useful and there won't be too much spam. I look forward to hearing from the readers!

Constrained fitting in QuantLib

2011-10-23T19:01:05Z

Below is a short example illustrating fitting of a function to observables, demonstrating also how to put some constraints on the parameters. Placing such constraints is useful when, for example, a model is well defined for certain values of the parameters.

Accessing Internet in Greece using Linux, Nokia E61, and a Vodafone data plan contract

2009-09-23T09:44:55Z

The aim is to be able to connect my laptop to the Internet over the cellular/wireless networks in Greece at a reasonable price and speed.

Lazy Code Generation (LzCG) and C++ Expression Templates

2011-02-05T22:16:52Z

I've been thinking recently about strategies for writing fast numerical codes based on C++. One of the ideas I have been pursuing is generating the code for the some of the performance critical sections after the compilation of the main body of the code. The summary of the idea is:

Managing QuantLib source using Bazaar

2009-09-23T09:44:55Z

QuantLib is an open source project providing a comprehensive software framework for quantitative finance. It is developed in an open way by discussion on mailing lists and the source code is manged in a centralised QuantLib SVN repository. In this article I discuss how to efficiently manage non-public modifications to the source code tree of this project. These modifications could, for example, be patches that are not yet ready for a public review and integration in the central source code tree; or they could be modifications intended as permanently private extensions of the QuantLib functionality.

BoostCon 2011 Report

2011-05-23T11:36:55Z

I've just got back from the BoostCon 2011 meeting at Aspen, CO. It was my first time at this conference and I was very impressed by the high quality of presentations and discussions at the conference.

Making use of std::map<> ordered property: interpolation

2011-02-04T05:00:24Z

The Map container of the C++ Standard template library is an ordered associative container. Often it is used simply for associative property, i.e., to look up a value based on a key. However, the ordered property can often be useful to and the classic example is in one-dimensional interpolation.

Generating Normally Distributed Random Numbers Using Boost

2009-09-23T09:44:55Z

One of my previous posts describes a very minimal program that generates a normally distributed random number using Boost. However, I've realised from the number of people visiting that this example may indeed be a bit too short and simple, and lead people to not exactly the best practises. So here is a longer post with more pointers.

A Simple, Minimal, Example of C++ Expression Templates

2011-04-20T17:15:20Z

I am preparing a lecture on efficient numerical computation in C++ and this obviously touches upon the technique expression template. I came up with the following, very stripped-down, example which still manages to illustrate expression templates are in general far more efficient than normal C++ value semantics.

Python: To Switch or not to Switch

2009-09-23T09:44:55Z

It is easy to fall into the trap of writing switch like statements in any programing language. (switch is a construct in C and C++; in python it can be replicated by a string of elif statements.) Often, for example, this occurs at the interface between applications and libraries. In Python these look something like the following frivolous example:

Setting up Python on Win32 platform

2009-09-23T09:44:55Z

Here are just the links... this is work in progress:

From BoostCon 2011 -- Bulk Synchronous Parallelism using Hybrid MPI+OpenMP

2011-05-17T16:56:49Z

An interesting approach to implementing structured parallel algorithms in C++ presented today by Joel Falcou. The performance appears to be close to hand-coded algorithms and it should be reasonably easy to use. However, it currently needs at an external analysis stage based on a plug-in to clang.

Runtime compilation in InMin of functions to be minimised

2012-04-05T14:28:36Z

With help from the tinycc compiler project, the InMin library can now compile, at-runtime, a function to minimise from its string representation in a C-like language.

RR: About the Random Review Series

2009-09-23T09:44:55Z

The aim of the random review series articles is to do a sort of public code-review of C++ code, generally in the field of numerical algorithms. I do not publish the names of original codes to which review articles relate because the hope is that they will be applicable much more widely than the original codes.

From BoostCon 2011 -- The Geneva Optimisation library

2011-05-17T16:50:33Z

The library was presented here at the conference -- it allows parametric optimisation using evolutionary and particle swarm algorithms using efficient parallel execution across many cores and nodes. The only external dependency is Boost!

Derived classes still have a default assignment operator

2009-09-23T09:44:55Z

If a class does not declare an explicit assignment operator (operator=()), a default operator will be created by the C++ compiler which will copy over each of the data members of the class. A class can (and often they do) override this behaviour by declaring the assignment operator. If a class derives from a base class with a non-default assignment operator, but does not have an assignment operator itself, the C++ compiler will still create a default operator which copies the members of the derived (but not the base) class.

Using QuantLib from Clojure

2012-03-15T18:24:30Z

We've recently begun developing applications in the Clojure language that make use of the QuantLib libraries through the Java bindings (see for example here). Using Clojure has substantial advantages about which I hope to write more about later, but in the mean time here is how to overcome an initial problem.

Implementation of the Heston model in QuantLib

2010-08-20T00:52:47Z

The QuantLib derivatives pricing library provides an algorithm for "analytic" pricing of European-style options under the Heston model. The description "analytic" is conventional but not very precise as the algorithm in fact involves numerical evaluation of an integral. There is however no stepping in time in this algorithm, and so it is certainly distinct from the finite-difference methods that are used to price path-dependent options.

Simple input parsing using Boost

2009-09-23T09:44:55Z

Inexperienced programmers often get stuck getting data into their C++ program and with output out of their program. Somewhat more experienced programmers often use clunky routines from the Standard C library such as strtok, atof and friends. I think pretty much everybody agrees that plain C++ does not provide for elegant parsing of simple input data. Fortunately the Boost libraries provide lots of tools to tackle this, and here is a very simple example.

Using QuantLib to generate a Brownian Bridge

2009-09-23T09:44:55Z

This is a very short article illustrating how to use the QuantLib library Brownian bridge code. The reason there can be some confusion is that the code takes a sequence of random variates as input for the bridge construction code. The first variate in this sequence is taken to represent the global step of the bridge, i.e., how much the value of the underlying changes over the entire period (for bridge of length of unit time only). If the first variate is set to zero, then the standard Brownian bridge that begins and ends at zero will be created.

RR: std::vector<> instead of new[]

2009-09-23T09:44:55Z

One of the trickiest concepts for beginners in C++ (and other languages with low-level capability) is memory management, i.e., correct allocation and de-allocation of memory. I already discussed that in some cases memory management can be avoided, but of course at some point in the program memory allocation does need to be made. Here I discuss using the standard library std::vector<> container instead of the plain new[] and the advantages this approach gives.

Opportunities for (remote-working) internships with BN Algorithms

2011-11-06T18:59:16Z

We are currently looking to take on one or two interns to work with us for a period ranging from six weeks to six months. We are looking for people with following skills:

Version 0.1 of InMin library

2011-09-15T16:03:58Z

Version 0.1 of the InMin library has just been released.

C++ & SWIG: using data pointed to by a pointer

2011-07-05T16:24:35Z

SWIG is an excellent, widely used, tool for wrapping C and C++ libraries for use in higher level languages. Learning how to best use SWIG is, as is true with all programming languages, not trivial.

Version 0.2 of InMin library

2012-01-06T20:23:43Z

I am happy to announce version 0.2 of the InMin library (see).

Bumping Interest Rate Curves in QuantLib

2011-07-26T09:00:12Z

The QuantLib library implements the Observer pattern in many of its data structures and functions. This means that a link to data used to build objects such as interest curves is retained and if this input data is changed after the construction of the curve the curve itself is automatically updated. This means that bumping the curve is easy since it is not necessary to explicitly rebuild the curves.

A potential pitfall when using boost::uniform_01

2009-09-23T09:44:55Z

The Boost library collection has a highly useful random number library (Boost.Random). One of the classes in this library, boost::uniform_01, does however present a potential pitfall which I will briefly describe in this post. This pitfall is mentioned briefly in the library documentation but this post expands on this substantially.

Numerical and Quantitative methods in C++ project

2009-10-25T18:42:54Z

I've started on a new long-term project which not only by its nature can not be finished, but it is likely to progress quite slowly: a web-book which gives solutions to some popular numerical/quantitative problems in C++.

Generating Atom feeds using Python and KID

2009-09-23T09:44:55Z

The Atom syndication format is the standard way of making others aware of changes to your web-site, in particular to new content on the website. Atom is based on XML and Atom feeds can be produced very simply and conveniently using Kid and of course Python. Here is on outline on how to do it.

Generating Random in Parallel

2009-09-23T09:44:55Z

The classic requirement for this a large Monte-Carlo simulation which you'd like to be able to run across many threads in production, but at the same time would always like to get exactly the same answer regardless of the number of threads that are used. In other words, the exact numerical answer should be exactly the same across multiple runs and independently of the number of threads.

Creating simple websites

2009-09-23T09:44:55Z

This website is written primarily in re-structured text, a simple text markup language. It is produced to final html form using the following tools:

Simple examples of Date input/output in QuantLib

2010-05-13T15:02:26Z

Following a discussion on the QuantLib users mailing list, here is a quick and very short program illustrating input and output of Date objects in QuantLib:

Pricing options using the Heston model using QuantLib

2011-07-17T20:15:16Z

Bellow is a simple command line program which uses the Heston model implementation in QuantLib to price equity options. The various parameters of the Heston model can be adjusted through the command line. For a list of these, run the program with the ''--help'' option:

Feature inheritance in SWIG -- doesn't apply to classes...

2012-03-07T16:20:38Z

The excellent SWIG package has a number of mechanisms for modifying the interfaces which are generated by initial parse of the original C/C++. One of these mechanism are features (see here for basic explanation). Various output language modules know about different features that the user can specify and they interpret them in a particular way that is appropriate for that language.

Errors like "is not a class, struct, or union type" when using

2009-09-23T09:44:55Z

Decoding compile-time errors when using complex template libraries (like Boost) can be a bit involved with the current generation of c++ compilers. Hopefully this will improve as the compilers are improved but in the meantime it is useful to keep track of the type of errors that you get and why. Here is an example of one of those non-obvious errors.

RR: Small numerical values in C++

2009-09-23T09:44:55Z

In numerical programs, financial codes included, there is often a requirement to use very small numerical values in the algorithm, perhaps for ensuring all operations are in a valid domain. In a code published as an accompaniment to a book there is a line:

Heston Model Calibration

2009-09-23T09:44:55Z

Here are some quick graphs from recent experiments in calibration of a Heston model to observed option prices (in this case options on the DAX index). They are offered with only the briefest of explanations below for the time being, but there should be more coming soon; or if you wish, get in touch with me at webs@bnikolic.co.uk.

Relinking Handles

2010-05-25T20:51:39Z

Very simple example showing how to relink a Handle object in QuantLib:

Fitting a Curve in QuantLib

2011-08-10T21:32:07Z

Here is a simple example of fitting a curve in QuantLib, reworked from the original CurveFitting.cpp file and adjusted to compile with the current versions of QuantLib:

Running Python Programs from the Command-line

2009-09-23T09:44:55Z

Typical ways of running python programs are discussed on the Running Python page, including introduction to running from the command line. Here are some tips on more efficiently running python from the command line.

Constrained Levenberg-Marquardt using the InMin library

2012-01-21T22:42:18Z

This is the equivalent program to the own shown in this old blog post, but implemented using the new InMin library. The program demonstrates Levenberg-Marquardt fitting of a function with a box constraint on the parameters.

RR: Avoiding Memory Allocation

2009-09-23T09:44:55Z

The C++ language has a range of excellent tools for managing allocation and de-allocation of memory. They are an essential part of writing effective and efficient programs. The first strategy, however, for dealing with memory allocation should be to avoid it. If that is not possible, you should try to separate the logic of what you are trying to achieve from the memory allocation routines.

Python/Microsoft Excel Integration

2010-12-16T15:10:22Z

There are several ways of doing this, such as communicating via a (XML-)RPC-like protocol or using COM. However, the traditional way of integrating outside code into Excel has been through the Add-in mechanism.

Converting a Directory of ReSTructured files to Atom feed

2009-09-23T09:44:55Z

In one of the previous posts I sketched out how to generate an Atom feed using Python and Kid. Here I show a complete script that can convert a directory of restructured text files into an Atom feed -- great for writing blogs using restructured text.

Opportunities for (remote-working) internships with BN Algorithms in 2012

2012-04-20T12:35:46Z

We are currently looking to take on one or two interns to work with us for a period ranging from six weeks to six months. We are looking for people with following skills:

C++ implementation of Khachiyan algorithm for the minimum enclosing (or covering) ellipsoid

2010-05-24T17:20:34Z

The problem in this case consists of computing the hyper-ellipsoid (potentially in a space of high-dimensionality) such that it has the minimum volume but still encloses all of the points in a supplied set. The ellipsoid is specified by it's centre and a matrix describing it's axes.

Simple normally distributed random number generation

2009-09-23T09:44:55Z

Here is a very simple program that illustrates how to generate normally distributed random numbers using boost.

Example of Pricing an American Option on a Dividend Paying Stock in QuantLib

2009-09-23T09:44:55Z

Here is a quick, bare-bones, example on how to price an option on a stock that pays dividend on arbitrary but known dates:

The LD_DEBUG environment variable

2012-04-23T09:28:20Z

Development of large systems using many shared (dynamically) loaded libraries can sometimes lead to some frustrating bugs that are difficult to diagnose. These bugs often arise because there a few different versions of libraries on the system and the "wrong" version gets loaded instead of the one the developer used wanted.

RR: Basic random number generation

2009-09-23T09:44:55Z

Many, many codes and books use the standard C function rand() to generate uniformly distributed random numbers. What are the potential pitfalls of using this function? What are the alternatives?

Using the Lourakis constrained Levenberg-Marquardt library

2009-09-23T09:44:55Z

Here is a very quickly prepared example of how to use the Lourakis library to do constrained minimisation in n-dimensions. This shows simple fitting of a second degree polynomial to a handful of observed points. The box constraint is used and it is set so that it does not contain the maximum likelihood point -- this shows off the constraint feature.

Running Python Programs from Emacs

2009-09-23T09:44:55Z

Tips on running python from Emacs.

The new "--as-needed" option to the GNU linker

2012-01-19T19:05:01Z

Recently I upgraded one of my machines to a version of the GNU linker which by default uses the "--as-needed" option.

"Pointer Conflict" Errors in the Boost Serialization Library

2010-12-03T10:09:33Z

The Boost Serialization library offers facilities for saving and restoring C++ data structures to/from sequential representations (e.g., for saving and loading to files). It is generally easy to use and handles most structures correctly, including pointers, circular lists, etc.

SWIG %insert directive

2012-04-05T11:13:09Z

It is often convenient to insert some verbatim code into SWIG generated wrappers to go along with all of the automatically generated code. For this purpose SWIG has the %insert directive, which takes a parameter which is the section to insert the code into, e.g.:

Template constructor in a non-template class

2009-11-16T07:47:28Z

Sometimes it is required to derive a new class from a base class with constructors that can take many types and perform internal conversion. An easy way to avoid errors due to by-hand writing forwarding constructors for each of the types is to use a constructor in the derived class with a template parameter. This works fine even in a non-template class, i.e., non of the data members of the class are dependent on template parameters. This is an example:

SWIG wrappers in Java and the C++ RAII pattern

2012-03-20T17:44:19Z

There was recently some discussion on the QuantLib mailing list about problems arising in SWIG-generated Java wrappers for C++ classes (thread on the mailing list, blog post). The immediate problem in these discussions was that the Java garbage collector runs in a thread which is separate to the main thread of execution of the native C++ code. Therefore, the C++ destructors are called at non-deterministic intervals and if they are not completely thread-safe the program will eventually fail.

Computing Blog -- Complete Index and permanent links

2012-04-23T09:28:37Z

This blog is linked on technorati.

Numba

2012-03-15T15:28:12Z

I came across the Numba project recently (H/T @mza), which looks interesting indeed. From the front page:

A minor rework of the Equity Option example in QuantLib

2009-09-23T09:44:55Z

To enable some experiments with QuantLib I've reorganised the EquityOption example so that each of the pricing methods sits in a separate function. It is a pretty trivial change but I think it makes the example a bit more readable. Feel free to use in accordance with the QuantLib licence.

Private implementation using smart pointers and deletion trouble

2009-09-23T09:44:55Z

It is often desirable to hide excess implementation detail from users of libraries by using forward declarations and private pointers. There is a lot written on the Internet on this idiom. If you are using it you may very well want to use the boost::scoped_ptr<> smart pointer. There is however one simple trap you can fall into doing this and then you may get error messages related to incomplete type such as this:

Python cx_Freeze package

2012-03-15T15:17:26Z

I've recently started using the cx_Freeze Python package. This package makes it possible to more easily distribute Python-based programs by packaging together all of the libraries, python modules and supporting files that are needed to run the program in a single, stand-alone, directory. The Python script itself is turned into an executable which can be run directly from the command line. And, unlike some alternative, this package works on Linux!

Running Python Programs

2009-09-23T09:44:55Z

Answering the question "How do I run Python programs?" is the obvious first step in learning how to use and program python, but often people do not spend enough time thinking about this.

Setting environment variables from within Emacs

2009-09-23T09:44:55Z

If you have a long-running emacs session it is sometimes convenient to change or set the values of the UNIX "environment" variables of the emacs process. This is easy to do using the "setenv" function.

Byte Order Marks and Emacs

2012-03-19T11:59:34Z

Some programs write byte order marks into their output files, even when they are encoded in UTF-8. When opening such file in Emacs in the ordinary way these byte order marks are correctly interpreted and removed from the contents that are displayed to the user.

RR: Avoiding Artificial Class Hierarchies

2009-09-23T09:44:55Z

Polymorphism is a cornerstone of object oriented programing. It allows run-time resolution of the class function (method) to be called, depending on concrete type of the object. This is of course extremely useful, but requirement for run-time resolution of function called should not be by itself the reason for deciding on a deep and complex class hierarchy. If run-time resolution is all that is required, then much simpler solutions based on function pointers, or boost::function object are much better suited.