Thursday, April 17, 2014

Python and QuantLib - American Equity Options

[The previous post in this series is here]

American options are exactly the same as European options in every respect, except of course, the holder of an American option can exercise his right to buy or sell stock earlier than the expiry date.

On the face of it, this extra freedom in the contract sounds like a big benefit.  Extra choice is always good.

In practice however, the dollar value of the benefit is minimal.

American bankers (North or South?) are great sales people.  They sell some fancy financial products which sound much better value than it really is.  Where have I heard that before?  Ingenious.

The benefit might be near worthless but after the tweak there is no analytical solution to the problem.  I.e. no best 'answer' in all situations.
If the expiry date is finite, the problem is associated with a 2-dimensional free-boundary problem with no known closed-form solution.
Luckily QuantLib provides a couple of dozen pricing engines that numerically approximate solutions; which means if you really care about accuracy you have a lot of ammunition to nail down decent numbers.

On the other hand, if you really don't care too much, I hear you!

It takes two lines of code to change our previous European option into an American option.

First we need to change the exercise rules to allow for early expiry.

Our exercise variable in the European option example
exercise = EuropeanExercise(expiry_date)  
exercise = AmericanExercise(valuation_date, expiry_date)
Now we have to look into which pricing engine to use.

Cox, Ross and Rubinstein is the bog standard method that everyone uses and understands well but unfortunately is also terribly inefficient.

I have found that the finite difference engine generally achieves far better accuracy within a similar time period.

We switch out the European analytical engine
engine = AnalyticEuropeanEngine(process)
with our brand spanking new one
time_steps = 100
grid_points = 100
engine = FDAmericanEngine(process, time_steps, grid_points)
Once we have everything good to go and see results we will notice far fewer analytics available.  We have left the analytical world and almost every sensitivity calculation no longer comes for free.  I.e. now we will have to recalculate by shocking inputs a little in order to see each Greek.

The full source code for the example is here.  Note that I have started to organise the code into methods.

So there you have it.  Bank salesmen in America threw a nice sweetener into the option deal causing headaches for practitioners (and grant money for mathematicians) for decades to come.

Now we will just have to wait for African (?) equity option salesmen to popularise American options that never expire to make our lives easier again.

[Next post]

Wednesday, April 16, 2014

Python and QuantLib - Equity Option Example Source Code

[Read the previous part of this series here]

The command line entries have been rejiggered into one Python file which you can download.

I added some new results also, which give you an idea of the analytical results available out of the box.

[Read the next part here!]

Saturday, April 05, 2014

Quantlib and Python - Putting Fingers to Keyboard

[Read the previous part in this series here]

You want to be an ueber powerful super hero capable of all sorts of impossible feats; then again don't you want to lead a simple life away from all the complexities of having rubbery hands and being able to become invisible?

No wonder super heroes resort to having those Clarke Kent and Bruce Wayne alter egos.

[As an aside, that reminds me of the age old question - would you rather be able to fly or turn invisible?]

Every designer has to ask himself this.  Not whether he wants to fly or not but do we want to do a few things well or be a super duper Swiss Army knife?

Quantlib (most of the time) comes down on the Swiss Army side of the argument; which means it's hard to learn; but also, once mastered, you will have those financial super powers at the touch of your finger tips. That's the hope!

Dates are a good starting point.  Almost everything non trivial in finance involves specific future payoffs.  Actually when I say non trivial I mean in some way tractable; the really hard stuff doesn't have specific future payments is left untouched.

In any case let's drop into Python's interactive interpreter


and create a few date objects

>>> from QuantLib import *
>>> valuationDate = Date(13,1,2014) 
>>> expiryDate = Date(13,1,2015)

Now tell the system what the valuation date is

>>> Settings.instance().evaluationDate = 

Finance is obsessed by time.  And of course money.  The cost of money over time is naturally represented by discount factors and on a day to day basis these prices are quoted as interest rates.

The following code sets an interest rate of 1% and tells the system that the price of money is constant over time.  The actual actual day count convention makes sure every calendar is accounted for when accruing payment IOUs (i.e. no short cut conventions are made in assuming 30 days in a month and 360 days a year).

>>> interestRate = 0.01
>>> riskFreeRate = FlatForward(valuationDate, interestRate, ActualActual() )

We can do the same for dividends.

>>> dividendRate = 0.02
>>> dividendYield = FlatForward(valuationDate, dividendRate, ActualActual() )

By the way if you want decent dividend predictions, check out

Any financial asset with non-linear payoffs (it turns out almost everything) needs to account for volatility.  We will setup our volatility data in a very similar manner.

>>> calendar = UnitedStates()
>>> volRate = 0.03 
>>> volatility = BlackConstantVol(valuationDate, calendar, volRate, ActualActual())

As an aside, QuantLib's calendars are very useful (at the risk of being monotonous - finance is obsessed by time! : )).

I am unsure why volatility requires calendar information whereas flat forwards does not.  Let me know in the comments if you can enlighten me.

The last piece of data to setup is an underlying equity price of 123

>>> underlying = SimpleQuote(123)

As you can see, pretty much everything needed to be an object in QuantLib.  Every.  Single.  Thing.

Hardcore abstraction may well give you super powers, but also means there's a high barrier to entry.

No prizes for what we are going to model next.  We need to specify the payoff conditions for our European equity call option with a strike of 100

>>> exercise = EuropeanExercise(expiryDate)  
>>> strikePrice = 100
>>> payoff = PlainVanillaPayoff(Option.Call, strikePrice)

and roll those terms together into an option object

>>> option = VanillaOption(payoff,  exercise)

Now bundle the market data together

>>> u = QuoteHandle(underlying) 
>>> d = YieldTermStructureHandle(dividendYield)
>>> r = YieldTermStructureHandle(riskFreeRate)
>>> v = BlackVolTermStructureHandle(volatility)  
>>> process = BlackScholesMertonProcess( u,d,r,v)

Things are getting a little convoluted now with the handle objects, eh?

Finally we set the pricing engine.

>>> engine = AnalyticEuropeanEngine(process)
>>> option.setPricingEngine(engine)

Let's price and see a result

>>> option.NPV()

Now we start to tangibly benefit from the object oriented-ness.  We can swap pricing engines in and out to our heart's content.  For example, why stick with bog standard Black Scholes when we could use something which sounds much fancier?

In any case, we will wrap up by calculating some Greeks

>>> option.gamma()
>>> option.vega()
>>> option.theta() 
>>> option.rho()

If you missed it, QuantLib is a pretty verbose convoluted affair.

Rest assured as with intelligent design or creationism everything is done for a reason and after overcoming all of these obstacles you will become a finance quant prophet amongst men.

[Next part is here]

Friday, April 04, 2014

Quantlib and Python - Getting Started

[See part 1 of this series here]

When it comes to open source software Linux is the only way to go.

Why would you use anything other than Photoshop on a Mac or a cutting edge game on Windows? - using Linux is just easier for Python development and all the quant lib packages come ready made for your machine (no messy compiling required!).

In order to install Quantlib for Python on Debian (sure to work on Ubuntu and Mint also) Linux system run:

apt-get install quantlib-python quantlib-swig

which will install everything you need.

Now give your setup a quick test:

cd /usr/share/doc/quantlib-python/examples/

With any luck you will see a bunch of analytical results in your console.

This collection of examples are one of two resources I have found about using Python for Quantlib, which hopefully I can add to a little with these blog posts.

The other reference which you can use are the test units also included in the same folder.

ls /usr/share/doc/quantlib-python/examples/test/

These tests are used as a check by the library developers to ensure everything is good to go and no bugs have been introduced.  With such meagre references the tests are valuable reference for code written in Python.

One of the other places to go to with is the Quantlib C++ library reference itself.  As I said before, C++ is not my forte and in this day and age more of an academic pursuit in finance than anything else.  Nevertheless, example Python code is in short supply - and the python code that you do write is pretty close to what you see written in C++.

The upshot is on the one hand your Python code doesn't feel super Pythonic because you are tied so close to the C++ libraries.  On the other hand the C++ idioms start making more and more sense after days and weeks of banging your head of the wall! (no pain no gain?)

The places to ask questions are Wilmott, Quant Stack Exchange and the mailing list.  None are high traffic when it comes to Quantlib (scared off yet?) so your mileage may vary.

[Continued here]

Quantlib and Python - An Introduction

I am learning how to write Quantlib code with Python in order to create a project of mine called Vol Kills.  What better way to learn than writing down what I have figured out?  And perhaps I can help others out along the way.

First question, why Quantlib? why Python?

Firstly Python is easier to learn than C++ (I admit I never tried, always sounded too daunting).  You can code quick with no need to worry about the cruft that comes with Java and C.

Secondly, we're really just using Python to send messages to Quantlib which is written in C++ compiled down to super fast 1s and 0s.

Best of both worlds!

Third Python does a lot.  You get the stats libraries; web frameworks; heavy lifting"extract transform load" libraries and more right there in the one place (their motto is "batteries included" after all).  No need to mess around with multiple languages and run times.

A quick word about QuantLib.  It's a collection of code which helps people like me model financial investments; understand how investor's portfolios tick and perhaps point out some opportunities and pitfalls ahead.

Quantlib has been developed for over a decade.  It is widely used and battle hardened.  Best of all it is free and open source, which means you can use it without worrying about licensing fees and nasty bugs (the more eyeballs on the code the less chance of errors).

[Continued here]