Bojan's Blog

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.

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.

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.

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.

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?

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:

Pricing options using the Heston model using QuantLib

2009-09-23T09:44:55Z

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:

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.

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.

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:

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.

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.

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.

Relinking Handles

2010-05-25T20:51:39Z

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

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.

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:

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.

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.

Fitting a Curve in QuantLib

2009-09-23T09:44:55Z

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 Emacs

2009-09-23T09:44:55Z

Tips on running python from Emacs.

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.

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:

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.

Setting up Python on Win32 platform

2009-09-23T09:44:55Z

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

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.

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.

Computing Blog -- Complete Index and permanent links

2010-08-20T01:00:09Z

This blog is linked on technorati.

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.

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.

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:

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:

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++.

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.

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.

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.

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.

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:

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:

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.

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.