Log in / Register
Home arrow Computer Science arrow Learn BlackBerry 10 App Development
< Prev   CONTENTS   Next >

C++ Inheritance

So far so good; the Instrument class provides us with a convenient abstraction for managing financial instruments. However, for the pricing library to be useful, you need to extend it by building a hierarchy of concrete types. In finance you can literarily synthesize any instrument with a desired payoff (that's what quants do). However, the basic building blocks are bonds, stocks, and money accounts. You can use these instruments to create more or less complex derivatives such as options and swaps (that's why they are called derivatives, because their price derives from an underlying instrument). Let's extend the hierarchy to include stocks (see Listing 3-4).

Listing 3-4. Stock.h

#define STOCK_H_

#include "Instrument.h"

class Stock: public Instrument { Q_OBJECT

Q_PROPERTY(double spot READ spot WRITE setSpot NOTIFY spotChanged) public:

Stock(QObject* parent = 0); virtual ~Stock();

double spot();

void setSpot(double spot); double price() const;


void spotChanged(); private:

double m_spot;


#endif /* STOCK_H_ */

As illustrated in the previous code, Stock inherits from the Instrument class and adds a new spot property, which corresponds to the stock's market price. The member function definitions are given by Stock.cpp (see Listing 3-5).

Listing 3-5. Stock.cpp

#include "Stock.h"

Stock::Stock(QObject* parent) : Instrument(parent), m_spot(0) {


Stock::~Stock() {

// for illustration purposes only. Show that the destructor is called std::cout << "~Stock()" << std::endl;


double Stock::price() const{ return spot();


double Stock::spot() const{ return m_spot;


voidStock::setSpot(double spot){ if(m_spot == spot) return; m_spot = spot;

emit spotChanged();


The Stock constructor calls the Instrument base class constructor in order to initialize the base class object correctly (and once again, a constructor initialization list is used in order to initialize

the Stock object's member variables). The Stock.cpp file also includes a concrete implementation of

the Instrument::price() method, which simply returns the current spot or market price of the stock.

An option is a slightly more complex beast. A vanilla equity option gives you the right, but not the obligation, to buy (in the case of a call option) or sell (in the case of a put option) the underlying stock for a specific agreed-upon price sometime in the future. The parameters defining the current price of the option (i.e., the right to buy or sell the underlying stock in the future according to the terms of the option contract) are given by the following:

n The current spot price of the stock.

n The future agreed-upon strike price of the stock.

n The stock's volatility, which is a measure of its riskiness.

n The time to maturity of the contract expressed in years.

n The risk-free rate, which usually represents the interest rate on a three month US Treasury bill.

Using the previous input parameters, a neat little thing called the Black-Scholes formula gives you the option's fair value. Putting all of this together, our Option class definition is given in Listing 3-6.

Listing 3-6. Option.h

#ifndef OPTION_H_

#define OPTION_H_

#include "Instrument.h"

class Option: public Instrument { Q_OBJECT


Q_PROPERTY(OptionType type READ optionType WRITE setOptionType NOTIFY typeChanged)

Q_PROPERTY(double riskfreeRate READ riskfreeRate WRITE setRiskfreeRate NOTIFY riskfreeRateChanged)

Q_PROPERTY(double spot READ spot WRITE setSpot NOTIFY spotChanged) Q_PROPERTY(double strike READ strike WRITE setStrike NOTIFY strikeChanged) Q_PROPERTY(double maturity READ timeToMaturity WRITE setTimeToMaturity

NOTIFY maturityChanged)

Q_PROPERTY(double volatility READ volatility WRITE setVolatility NOTIFY volatilityChanged)


enumOptionType { CALL, PUT


Option(QObject* parent = 0); virtual ~Option();

double price() const;

double riskfreeRate() const;

void setRiskfreeRate(double riskfreeRate);

double spot() const;

void setSpot(double spot);

double strike() const;

void setStrike(double strike); double timeToMaturity() const;

void setTimeToMaturity(double timeToMaturity);

OptionType optionType() const;

void setOptionType(OptionType type);

double volatility() const;

void setVolatility(double volatility);


void priceChanged(); void typeChanged(); void spotChanged();

void volatilityChanged(); void strikeChanged();

void riskfreeRateChanged(); void maturityChanged();


OptionType m_type; double m_strike; double m_spot; double m_volatility;

double m_riskfreeRate; double m_timeToMaturity;


#endif /* OPTION_H_ */

Here again, the Option class adds its own set of properties and notification signals. An option type is also defined using the OptionType enumeration, which is used to differentiate between put and call options (depending on the option type, the Black-Scholes price is different). Also note how the Q_ENUMS macro is used to export the enumeration to QML. Here again, the virtual price method is overridden to provide the option's Black-Scholes fair value (see Listing 3-7). You can simply skim over the implementation, which is only provided to illustrate how the different option parameters are used in the pricing. (Note that the CND function, which is an implementation of the cumulative distribution function, is not shown here.)

Listing 3-7. Option::price( )

double Option::price() const { double d1, d2;

d1 = (log(m_spot / m_strike)

+ (m_riskfreeRate + m_volatility * m_volatility / 2)

* m_timeToMaturity)

/ (m_volatility * sqrt(m_timeToMaturity)); d2 = d1 m_volatility * sqrt(m_timeToMaturity);

switch (m_type) { case CALL:

return m_spot * CND(d1)

- m_strike * exp(-m_riskfreeRate * m_timeToMaturity) * CND(d2);

case PUT:

return m_strike * exp(-m_riskfreeRate * m_timeToMaturity) * CND(-d2)

- m_spot * CND(-d1);



return 0;



The methods used for updating the option's properties are straightforward. For example, Listing 3-8 illustrates how the spot property is updated:

Listing 3-8. Spot Property

double Option::spot() const { return m_spot;


voidOption::setSpot(double spot) { if(m_spot == spot) return; m_spot = spot;

emit spotChanged(); emit priceChanged();


Also note that when a property is updated, besides emitting the corresponding property change signal, the priceChanged() signal is also emitted. This will play an important role when you will use the Option instance in QML bindings.

At this point, we have defined three abstractions in our class hierarchy: Instrument, Stock, and

Option. Let's try to use them in practice. A small test program is given in Listing 3-9.

Listing 3-9. main.cpp

#include <iostream>

#include "Stock.h"

#include "Option.h"

int main()


Stock stock; stock.setSymbol("orcl"); stock.setSpot(50);

Option option;

option.setSymbol("myOption"); option.setSpot(50); option.setStrike(55); option.setMaturity(0.5); option.setVolatility(0.2); option.setRiskfreeRate(.05);

std::cout << "Stock price is: " << stock.price() << std::endl; std::cout << "Option price is: " << option.price() << std::endl;


To display the program's output, I am using the standard C++ library by including the iostream header (std::cout is the standard output stream, which displays characters in a text console by default). The program's output is given as follows:

Stock price is: 50 Option price is: 1.45324

Found a mistake? Please highlight the word and press Shift + Enter  
< Prev   CONTENTS   Next >
Business & Finance
Computer Science
Language & Literature
Political science