Welcome back.

In this post, I’ll look at the implementation of market quotes and take a break from the series on the new finite-difference framework. But before that, a couple of announcements.

First, save the date for the next QuantLib User Meetings; it will be in Düsseldorf on the 7th and 8th of December. I’ll give you more details as they come my way.

Second: remember when I told you that Quaternion announced at the QuantLib user meeting in London that they were going to release their risk engine as open-source code? They just did. The project has a web site at www.opensourcerisk.org, the code is on GitHub, and the goal is to create a global standard for risk management. They’re brilliant people, so they might succeed.

Follow me on Twitter if you want to be notified of new posts, or add me to your circles, or subscribe via RSS: the buttons for that are in the footer. Also, make sure to check my Training page.

Market quotes

There are at least two possibilities to model quoted values. One is to model quotes as a sequence of static values, each with an associated timestamp, with the current value being the latest; the other is to model the current value as a quoted value that changes dynamically.

Both views are useful; and in fact, both were implemented in the library. The first model corresponds to the TimeSeries class, which I won’t describe in detail here; it is basically a map between dates and values, with methods to retrieve values at given dates and to iterate on the existing values, and it was never really used in other parts of the library. The second resulted in the Quote class, shown in the following listing.

   class Quote : public virtual Observable {
        virtual ~Quote() {}
        virtual Real value() const = 0;
        virtual bool isValid() const = 0;

Its interface is slim enough. The class inherits from the Observable class, so that it can notify its dependent objects when its value change. It declares the isValid method, that tells whether or not the quote contains a valid value (as opposed to, say, no value, or maybe an expired value) and the value method, which returns the current value.

These two methods are enough to provide the needed behavior. Any other object whose behavior or value depends on market values (for example, the bootstrap helpers in this post) can store handles to the corresponding quotes and register with them as an observer. From that point onwards, it will be able to access the current values at any time.

The library defines a number of quotes—that is, of implementations of the Quote interface. Some of them return values which are derived from others; for instance, ImpliedStdDevQuote turns option prices into implied-volatility values. Others adapt other objects; ForwardValueQuote returns forward index fixings as the underlying term structures change, while LastFixingQuote returns the latest value in a time series.

At this time, only one implementation is an genuine source of external values; that would be the SimpleQuote class, shown in the next listing.

    class SimpleQuote : public Quote {
        SimpleQuote(Real value = Null<Real>())
        : value_(value) {}
        Real value() const {
            QL_REQUIRE(isValid(), "invalid SimpleQuote");
            return value_;
        bool isValid() const {
            return value_!=Null<Real>();
        Real setValue(Real value) {
            Real diff = value-value_;
            if (diff != 0.0) {
                value_ = value;
            return diff;

        Real value_;

It is “simple” in the sense that it doesn’t implement any particular data-feed interface: new values are set manually by calling the appropriate method. The latest value (possibly equal to Null<Real>() to indicate no value) is stored in a data member. The Quote interface is implemented by having the value method return the stored value, and the isValid method checking whether it’s null. The method used to feed new values is setValue; it takes the new value, notifies its observers if it differs from the latest stored one, and returns the increment between the old and new values. (The choice to return the latest increment is kind of unusual; the idiomatic choice in C and C++ would be to return the old value.)

I’ll conclude this post with a few short notes. The first is that the type of the quoted values is constrained to Real. This has not been a limitation so far, and besides, it’s now too late to define Quote as a class template; so it’s unlikely that this will ever change.

The second is that the original idea was that the Quote interface would act as an adapter to actual data feeds, with different implementations calling the different API and allowing QuantLib to use them in a uniform way. So far, however, nobody provided such implementations; the closer we got was to use data feeds in Excel and set their values to instances of SimpleQuote.

The last (and a bit longer) note is that the interface of SimpleQuote might be modified in future to allow more advanced uses. When setting new values to a group of related quotes (say, the quotes interest rates used for bootstrapping a curve) it would be better to only trigger a single notification after all values are set, instead of having each quote send a notification when it’s updated. This behavior would be both faster, since chains of notifications turn out to be quite the time sink, and safer, since no observer would risk to recalculate after only a subset of the quotes are updated. The change (namely, an additional silent parameter to setValue that would mute notifications when equal to true) has already been implemented in a fork of the library, and could be added to QuantLib too.