Quantum blog

Which programming language to choose?

2011-10-14T11:47:00.000-07:00

When I started programming as a kid somewhere in the early nineties, choosing a programming language was easy, as there were not many to choose from.
I first started in Pascal and since then have programmed in Delphi, C, C++, C#,Java , VB, PHP, Matlab, Python, SPIN and even ASM. All this without even being a professional programmer (I am a physicist). I did not learn all these languages for fun, as I have better things to do (like actual work), but I needed to as I had no ‘swiss army knife’ language for all my needs.
Ideally, I would like learn only *one* language that is suited for all kind of stuff: number crunching, application building, web development, interfacing with APIs etc. This language would be easy to learn, the code would be compact and clear, it would run on any platform. It would enable me to work interactively, enabling the code to evolve as I write it and be at least free as in speech. And most importanty, I care much more about my own time than the cpu time of my pc, so performance is less important than productivity.
I also need a language that is capable of handling large arrays of data in a clear way. Luckily, after considering all these wishes, only two contestants remain: Matlab and Python.

Matlab is king of the hill when it comes to technical computing. If your tasks a limited to research only, it is probably the best tool there is. Good IDE, fantastic plotting function, great documentation. It is less well suited for application development or as a general purpose language. Expect to pay ~2k$ for a basic commercial license. Extra toolboxes cost more.

Python is very similar to Matlab and is free! Interactive work in Python is a bit less easy as in Matlab, but what you get is a programming language that can complete almost any task, from data mining to web development.

If I’d have to start all over again, I would choose Python as it would save me the trouble of learning another language for Gui and web development.

After flirting with Python for some time, I’ve fallen in love with it and decided to use it for most of my work from now on.

I'll be running a series of Python posts on my other blog: http://tradingwithpython.blogspot.com/

Why should I learn a programming language?

2011-10-09T05:35:00.000-07:00

People are bad at math. Some are better than others, but who can calculate ln(sqrt(345)*34)^3.4 in less than 1/1000th of a second? Even the simplest computer can calculate at a rate million times faster than a human, in fact this is the main reason computers have been invented. To use the full capacity of a computer the user should learn how to progam it.

People are quickly bored. Imagine you'd have to download around 1500 excel sheets of stock data and then combine them together? Unless you have an autistic disorder you would probably get bored to death. A computer would not mind doing the task, but you'd have to program it.
Another example is reaction speed. It takes ages measured in computer time, for a human to see a price change in a stock and then just press a button.Curious about how fast you can react? Take a test here. Your reaction speed should be around 0.2s, while even a simple microcontroller (the ones you’ll find almost in any electronic gadget) will do the same task in 0.0000001s. Want to compete? If you know what action should be taken in a certain sitiuation, a computer can do the job for you a couple of million times faster, but still you need to tell it what to do by means of programming.
Still, even with all that raw computer power nowadays, measured in gigahertz and terabytes, the 'heart' of computers haven't changed much since their invention: they are still not much more than 'calculators'. Yes, we've come a long way in terms of size factor, power consumption, user friendliness and price, but still, computers are incapable of creative thinking, adaptation to new environments and unpredictable situations. A cockroach is more intelligent measured by these standards than the most advanced computer. By combining the human power of creative thinking with the raw processing power of a computer a trader can become supertrader, achieving a consistent return.
Financial markets are just like nature, the smartest ones with the best skills for the current (and ever changing) environment survive. The ones that do not adapt get extinct at some point.
Using computers for trading today is a fact of life, and a trader has got no choice but to adapt. Who does not use some form of charting tool to find entry and exit points or an excel sheet to keep track of performance? Not much algorithm here, but it is already a form of computer-assisted trading. Another level is to purchase special purpose software, like spread trading tools. Often it includes some form of 'black box' logic, so you can only hope that it works and continues to work in the future. But why not move to the top of the food chain and learn how to process incredible amounts of data, design own algorithms, backtest strategies, automatically place hundreds of orders and analyze trading performance? By writing your own tools and programs, you'll be able to quickly adapt to every new market environment.

Your time invested in learning programming techniques will have a ten-fold return in time saved from doing boring daily trading tasks.

Coming next: which programming language to choose?

Getting started with Matlab & finance

2011-09-25T11:45:00.000-07:00

I am thinking about creating a series of screencasts showing how to use Matlab for financial research. This is the first one, covering the basics and aimed at people not yet familiar with Matlab.
The whole series would include (among others) topics like:

Getting data from the web (yahoo, google, CBOE etc)
Aligning and filtering datasets
Nearest-neighbor classification
Designing & backtesting strategies
Interfacing with Interactive Brokers
Keeping track of strategy performance

Creating quality material takes a lot of time and effort, so I don't think that I will be able to offer whole material for free.
If you are interested in the series please let me know what you think by filling in the poll on the right.

Get source files

XIV is stealing my money!

2011-08-10T14:04:00.000-07:00

With current volatility exceeding 40, it seemed like a good idea to short the VIX. Two very popular ways to do this is either to short VXX or go long XIV. I choose to go long XIV a couple of days ago, after making sure that it tracks the inverse daily return of VXX.
Now a strange thing has happened that both puzzles me and pisses me off: yesterday there was a tracking error of 2% between the two and today another 1%, both in my disadvantage. It seemed like somebody 'stole' 3% of my position! At this moment I am less than happy with this XIV product.
Take a look at this chart:

Here I plotted daily returns of VXX and XIV against each other, where the outliers have been plotted in red. Please note that there are another 2 outliers of similar magnitude, occuring on 4 and 5 January 2011, but these two cancel each other out pretty nicely.
I thought that both etfs were based on the same SPVXSTR index, but while their intraday path relative to each other is very stable (no arbitrage possibilities), the tracking offset was present throughout the whole day.
I understand that XIV could get a positive tracking error because it was banned from short selling on both days (just like VXX), but a negative tracking error is a mystery to me.

Can someone shed a light on what is going on here???

Are we in for a rebound?

2011-08-04T14:38:00.000-07:00

Today we've had a pretty heavy drop in the SPY, that has been preceded by a series of down days. It could be tempting to join the panicking crowd, but the crowd usually gets it wrong.
The put/call ratio and the VIX/VXV ratio tell their own story:

Both of them are pretty high, the situation that is usually accompanied by a pop in the market.
Disclosure: I'm long.

Going Python II

2011-07-28T12:29:00.000-07:00

The trading platform to be now has got a name: Nautilus. It is available on Google code.
I have decided to share the project in an early stage. Because of this it may currently be of interest to a limited group of people willing to write more than a couple of lines of code.
Python is very new to me. That, combined with the fact that I am more of a researcher than a programmer, can lead to a less-than-optimal code. I hope that the open nature of the project will help it to improve in quality and grow.

Going Python

2011-07-18T10:48:00.000-07:00

It was a tough decision to make, but I decided against using Matlab as an intraday trading platform. It is still the best data digging tool out there, but for application development it just doesn't cut it.
Luckily, there are tools that are just perfect for the task, like Python. Unfortunately I'm very new to Python programming so the learning curve will be steep and initial products will be far from optimal.
I am currently building a framework on top of the excellent IbPy, capable of connecting to Interactive Brokers and executing orders.
The goal is to create a simple trading platform, and running strategies as plug-ins.
I'll be keeping this project open-sourced, hosted on Google Code.

Stay tuned....

Implied vs Realized volatility premium

2011-06-15T14:29:00.000-07:00

There is a funny thing that I've come across while trying to build a volatility model. According to my estimations the VIX is usually higher than the actual volatility (RV) realized for that same period. Just take a look at the following chart:

In the top chart I've plotted the VIX (IV) and RV estimate for a 3-year period. The bottom chart is the difference between the IV & RV . To estimate the RV I've used a function from tradingwithmatlab blog. It uses several common estimators for RV (I've used the average value for RV ).
It looks like IV on average is 7% higher than the RV. So one could just sell volatility and get a steady profit, right? Knowing that there is no free lunch in trading, it seems that I'm missing out something. Is my estimation of RV incorrect? Is it unjustified to compare VIX and SP500 volatility? All feedback is very welcome...

Guess what, leveraged etfs don't decay!

2011-05-16T13:30:00.000-07:00

While writing the previous posts and doing the math I still had a feeling that something in my reasoning was not quite right. I could not put a finger on it, but with the help of the author of OnlyVix blog, I seem to have figured it all out.
Let me start with an old problem of 50/50 chance of winning 1% every timestep. Here is a puzzle from E.Chans blog (and book):

"Here is a little puzzle that may stymie many a professional trader. Suppose a certain stock exhibits a true (geometric) random walk, by which I mean there is a 50-50 chance that the stock is going up 1% or down 1% every minute. If you buy this stock, are you most likely, in the long run, to make money, lose money, or be flat? Most traders will blurt out the answer “Flat!”

...And they would be right. To prove this, let's write down a binomial tree for this case. I'll use 10% step to simplify the math:

Here we start with initial 100$. Every branch has 50% probability. Notice that the expected value at each time step is exactly 100$. However, on the third timestep the most probable value is 99$ .

To double-check it, I've run a Monte-Carlo simulation of the above problem. Here is the result:

The average value is 0, while the median is -0.5% for 100 steps or -0.005% for one step.

The case for 5% change per timestep looks like this:

The distribution shifts to the left, bu again, average value is zero, and median is -0.1176.

So the answer to above puzzle is indeed 'flat'.

Now returning to a leveraged pair like FAS&FAZ, here is a Monte-Carlo simulation of a leveraged pair:

Here I've used a normal distribution for returns of the underlying with sigma = 1%. Once again, the average return over 100 periods is zero, while most of the occurrences are negative.

This means that leveraged etfs don't decay over time, they just look like they do, because that is the most likely outcome.
So here we go, contrary to common belief, the leveraged etfs don't decay after all!

The problem with shorting leveraged etfs

2011-05-15T03:53:00.000-07:00

As I've described in my previous post, inverse etfs decay relative to each other. After looking at their charts it is not difficult to imagine earning 'easy mony' by shorting a pair of leveraged etfs. Max Dama has done this and there are more people doing this according to Google, but I think this type of strategy is pretty risky.

Here is an example of 'easy money'. I've simulated a random walk (upper chart in blue) that has 50/50% chance of going up or down every day. And it always moves exactly by 3% (log, so it should be flat over the long run ). From this reference I've created two leveraged trackers, with +2x and -2x leverage, I'll call them 'up' and 'down'.

Suppose we start a 100 day period with a pair consisting of equal amounts of capital in 'up' and 'down', both equal to 100$. So the pair value on day 1 is $200. Pair value is plotted in the lower chart. Without a trend in the reference, the pair value decays at a constant rate exp(0.5log(leverage*(1+daily_delta))+0.5log(leverage*(1-daily_delta))). If we short both 'up' and 'down' the lower chart will flip upside down, producing pretty good looking pnl.
But before you short sell every available leveraged etf out there, take a look at the next chart:

All the parameters here are the same, only the underlying has two brief periods of consecutive wins or losses. This results in two heavy spikes in the pair value. If we would have shorted both 'up' and 'down' the result would be a pretty heavy drawdown. No easy money here...

FAS vs FAZ - inverse etf behavior

2011-05-14T11:25:00.000-07:00

There has been a lot of talk about leveraged etf (under) performance . In general, these etfs seem to underperform their benchmark. A google search for 'leveraged etf decay' will provide a couple of hours worth of reading material, so I will try to limit information redundancy to a minimum. I'll limit myself to a single sentence introduction: 'leveraged and inverse etfs are based on the arithmetic returns of their benchmark, which introduces a negative tracking error'.
If you have little idea about what I'm talking about, take a look here for an explanation of the difference between the arithmetic and geometric returns.
So I'll continue the examination of inverse etf dynamics from what is already known: underperformance.

Let's first take a look at the relation between FAS and FAZ. Both are 3x leveraged versions of the same underlying index, FAZ being the inverse one.

Here can be seen clearly that while the etfs move in the opposite directions, FAS in the long run outperforms FAZ.
Their daily arithmetic returns however are performing exactly as advertised:

However, anybody holding a position for longer than one time period (being a day) should be only interested in geometric returns, or log returns.
When log returns of these two are examined, the picture changes:

Instead of following a straight line, the returns are skewed in favor of FAS. The green line here is a theoretical estimation of inverse relation based on algebraic returns.
For example: FAS gains 10% on a given day and FAZ follows with a 10% decline. In log returns this would translate to FAS: log(1.1) = 0.0953 FAZ: log(0.9)=-0.1054. The log returns are not equal (duh!) but skewed in favor of FAS . When the position is held for a longer time and the pair moves 10% every day (no matter in which direction), we loose approx 0.5% per day of the total position.
Please take a note that this 'skew' is not about leverage, but inverse algebraic relationship. Leverage only provides more daily movement, exaggerating the skew.
A handy chart below shows the under performance of inverse etf as a function of its underlying daily change. One can see that the error is relatively small for <1% moves, but increases rapidly with bigger moves.

The difference between geometric and algebraic returns has been explained by E.Chan on his blog (and in his book) . However, he made a mistake in the calculation of average loss per time period stating it to be -0.5%.
When we have a 50/50 chance of winning or loosing 1% , in fact the expected return per minute is exp(0.5*log(1.01)+0.5*log(0.99)), which translates to -.005 % per minute, which is equivalent to -7% in 24 hours ;-).

There are a couple of very interesting strategies that can be derived from this asymmetry, if one can handle the math and rebalancing logic.

In trading no one should ever be absolutely sure

2011-05-11T13:51:00.000-07:00

...and the one who is will get punished sooner or later. This has happened countless times, to traders of all skill levels. Once you think you've got a trade on your hands that can't possibly go wrong, you're brewing a recipe for disaster. Everybody knows this, me included, however I just barely escaped such a situation by plain luck.

A couple of days ago I ran my spread scanner and the good old GLD-GDX spread caught my eye. It was so streched up, that I decided to trade it. In fact it was at an extreme that has not happened for a very verly long time. This spread is a 'classic' for spread traders and it has been mean reverting for years now. I'm was sure that it would mean revert again, and quickly got on board. The only thing that prevented me from betting big was the shortage of free cash and I did not want to close any other positions. So I ended up with a usual size of a spread bet, that I don't allow to produce more than 2% of portfolio volatility.
What happened next is a short story. The spread moved further against me, knocking 2% off my portfolio. A pity, but not a disaster.
The good part is that I can still handle this situation with calmness and make reasonable decisions about keeping this spread or taking a loss. Things could be different if my position was larger and I lost months worth of work on a single trade.
This reminded me again that trading should not be convinced with gambling or one will end up the as >90% of amateur day traders- with a blown account, but more on this later...

When Sharpe is useless

2011-04-16T09:34:00.000-07:00

During development of an intrady strategy I've come across a case where Sharpe ratio (and Sortino too) is a very bad way to benchmark performance. To illustrate this case, imagine a strategy that enters a position and 'brackets' the exit levels with a limit and a stop-loss order. This results in the pnl distribution as shown in the graph:

The position is either closed at the limit or the stop-loss level, but not in between. Because Sharpe is all about normal distribution, it just does does not work for this case. A better solution here is to use win %, especially in the case of symmetric brackets.

HOWTO: Signal filtering, the better way.

2011-03-03T13:50:00.000-08:00

It is hard to find a trading system that does not employ signal filtering through use of sma, ema, wma and the likes. I'm not going to dive in detail on the inner workings of these filters as this info is widely available.
Filters that prioritize recent data are more suitable taking market dynamics into account but implementing these filters using a for loop in Matlab is anything but efficient. Luckily, Matlab provides the filter function, that can be used to calculate all these types of moving averages and even more.
In the code attached to this post I'm going to show how to filter signals based on an excellent article written by John F.Ehlers. (more articles can be found here) Please read it before playing with the code. I've implemented the different filters mentioned to compare their characteristics.

Looking at the data, I must draw a conclusion that the hybrid filter provides an improvement in terms of lag over the standard ema.
Using this hybrid filter one can create a simple indicator of the current price imbalance, like shown in the next graph. For this I've used the difference between the current price and emaHibrid(price,0.85,0.3).

Source: demoFilter.m, emaHybrid.m data: price.mat

Gaps, part 3

2011-02-28T10:21:00.000-08:00

Recently I've come to realise that I've made quite a mistake calculating the 'fill' ratio for the gaps. It's time to correct it, before somebody will embarrass me in the comments ;-).The problem is that I've used asymmetric boundaries when calculating the statistics. By doing this, the statistics shift in favor of the nearest stop. The closer the stop, the higher the chances of hitting it, but by no means does this mean profit. And previous close is usually not far from the open so chances of hitting it are quite high.
To make statistics fair, I've set the levels symmetric around the open, like this:
gap = open-prevClose
winLevel = open+gap
lossLevel = open-gap

With this calculation* the chances are quite different and closer to my results using the intraday data:
down gap: 52% fill
up gap: 48% fill

*geek note: when both win and loss levels are reached for the same day, it is counted both as win and loss (with daily ohlc data there is no way of knowing which one was reached first) . Data for SPY Feb.2000- Feb-2011.

Code: dumbGaps.m

Looking for cooperation

2011-02-25T11:36:00.000-08:00

Quite a time ago I've written a post about open innovation, the reason I've started this blog. Looking back, this 'loose cooperation' was very fruitful. During past year and a half this blog has given me a lot in return for the efforts of writing it. Next to the obvious personal goal of getting my thoughts straight, I've had many quite inspiring discussions with some of the people from the blogphere.

So far, so good, but my experiences had made me realize that I've still some time to go before I can afford to live from trading. I am confident that I'll get there some day, but I'd like it to happen rather sooner than later.
So what's keeping me back? Here is a little SWOT analysis of my trading venture:

Strengths:

masters degree in Applied Physics, high level of creativity.
Experience with signal processing, artificial intelligence and pattern recognition.
Programming skills in several languages.
Knowledge of IB API.
Strictly quantitative approach.

Weakness:

Little hands-on experience with trading.
Limited knowledge of the financial markets.

Opportunities:

Strategies that are just too boring to do by hand or require automation, like scalping.
Strategies that cannot be traded with conventional software (multiple assets, custom metrics etc.)

Threats:

Blowing my account through inexperience.

I'm sure there are some people around with goals similar to mine, but with strengths where I have weakness and the other way around. Joined effort in this case would be more than just a sum of the parts.

Now the point that I was getting to:
Life is just too short to do everything by yourself. I'm open to cooperation with someone who has hands-on experience with trading and wants to make a step towards automation or quantitative trading. If you are interested, drop me an e-mail.

-Jev

Closing the gap, part 2

2011-02-06T03:24:00.000-08:00

I felt the need to verify the calculations in the previous post, just to be sure no coding error was made, or at least not a serious one. To do this, I've rewritten the strategy using vector operations rather than 'for' loops and I'm happy to say, the result still stands. Sharpe is a little lower at 1.13, but the curves are quite similar.

To make this post a worthy follow up, I've also included the code:
dumbGaps.m , download_hist_yahoo_data.m

The following remarks are still very appropriate:

It is very hard to get a fill at the opening price.
Results are frictionless.
All this is just a basic concept

Your feedback is very much appreciated.

Closing the gap strategy

2011-02-04T05:58:00.000-08:00

Fading the opening gap is a well-known strategy, promising acceptable results with minimal efforts. A great article about trading gaps is written by Scott Andrews. It sounded interesting, so I've decided to spend an hour or so to check if the numbers are right. The basic 'Dumb gap' strategy that I've simulated always trades the opening gap in the direction of the previous days close. In other words, if opening above yesterdays close, go short. Take profit level is set on yesterdays close, if it is not reached, the strategy closes the position on the days close.
As a test set I've chosen past 10 years of the SPY, ignoring transaction costs and slippage. And the results are:

The gaps fully closed on about 75% of occasions
The strategy has a sharpe of 1.3
Using 'BLUD' (below low of an up day) compensation introduces only marginal improvement. These days are quite rare, ~3% of all occurences.

And as a picture speaks a thouthand words, here are the pnl curves.

Disclaimer: this is just an idea that that needs some work before a tradeable stragegy is achieved. I do not recommend anyone trading using the rules described above.

Nearest neighbour classification

2011-01-24T13:59:00.000-08:00

I've been following trading the odds blog for some time now. It surprised me how well Frank was able to predict the short-term movement of the S&P500. At first I was quite sceptical about the predictability of the directional stock movement, but had to admit now that there is some sense to it.
Previously I've been playing around with some techniques from pattern recognition field, especially the 'nearest neigbours' approach. Just as one could get an impression of somebody by meeting his friends, the same can be said about stocks. By finding some 'examples' most related to an 'new' situation, a statistical picture could be made of the things to come.
To provide a simple illustration, I've taken the intraday SPY and TICK data for 2010. Some traders are using the first hour of trading to decide what kind of strategy they need to implement for that situation. But is the first hour of trading representative for the rest of the day? It turns out it is. Take a look at the chart below.

Here I've classified the intraday SPY data based on the first hour of the TICK reading. For this I've used the mean and standard deviation of the 30-sec TICK-NYSE data. Green lines in the chart represent ten days with minimal mean and minimal std of the TICK in the first hour (closest to [0,0]). Blue lines are days with large positive mean of the tick and low std ([max, 0]). It turns out that days with large positive bias int the first hour of trading have a quite strong negative bias for the rest of the day, who would have thought?
Predicting the market regime for the rest of the trading day is not very profitable by itself, but can be very well used for choosing the right strategy.

XVIX performance

2011-01-15T07:07:00.000-08:00

In a reaction to my previous post about the VXX-VXZ combo, a kind reader has pointed me to the newly launched UBS XVIX etn. From the first look it does not seem to be that liquid, so its ability to track the VXZ-0.5VXX is somewhat questionalble.
I've decided to take a quick look at the fist month of its existance to check if it is really performing as advertised.

In the graph I've plotte the cumulative change in VIX (index), VXZ, VXX, XVIX and a synthetic VXZ-0.5VXX pair. It seems that XVIX performing exactly as promised, providing performance very close to the underlying pair, without the cost of rebalancing.

The following plot shows cumulative tracking error:

An interesting observation is that it does have some occasional tracking errors, of about ~0.3%, providing some arbitrage opportunities.

What if S&P 500 lost 50% on a single day?

2011-01-10T14:07:00.000-08:00

Most of us know that there are leveraged ETFs, providing up to 3x daily exposure, in decimal percent. Usually these etfs perform just as advertised, but imagine a situation where the index looses a very large portion (~50%). Such an event unlikely, but is not impossible if you think about the 'fat tails' and ~20% loss on black monday in 1987.
Now imagine you are unfortunate enough to own one of the 3X leveraged etfs on while S&P looses 50% of its value. will 3x exposure result in a 150% loss??? Ok, you probably will face a margin call before that, but I'm having a hard time trying to imagine what would happen to the leveraged etf price on such a day.
What do you think?

Yahoo quote downloader

2011-01-05T12:47:00.000-08:00

Here is a simple function to get current yahoo data for a bunch of symbols : get_yahoo_quote.m
It downloads quotes from yahoo (take a look here at what is possible) and returns them in a struct.

example usage:
quote = get_yahoo_quote({'SPY','IWM'})

result:

symbol: 'SPY'

desc: 'SPDR S&P 500'

lastTrade: [127.5695]

lastTradeTime: '3:30pm'

dividendDate: 'Dec 17'

open: [126.58]

lastClose: [126.98]

symbol: 'IWM'

desc: 'iShares Russell 2'

lastTrade: [79.26]

lastTradeTime: '3:30pm'

dividendDate: 'Dec 22'

open: [78.4]

lastClose: [78.422]

VIX buy & hold strategy

2010-12-07T07:52:00.000-08:00

Here is a simple buy&hold strategy that popped up while I was playing with some VIX based ETNs . The volatility was extremely high through the end 2008- beginning 2009, presenting a good opportunity to go short on the VIX. A good way to go was probably the VXX etn, however one would suffer some substantial losses through the summer of 2010.
Now take a look what happens if the upside risk of the VXX (short term futures) is hedged by the VXZ (long term futures). It turns out that a the summer 2010 dip can be completely 'ironed out' by constructing a pair of short VXZ-long VXX, allocating 2x of the capital to VXX. The graph below shows a portfolio of -22 shares VXX, 46 shares VXZ. Sharpe is just above 2.

Of course past returns are not necessarily representative for the future, but I imagine that during the next crisis this behavior could be repeated.
At this moment this strategy may be turning around, as downwards potential of the VIX seemes limited for now. But I can't wait for the next crisis. ;-).

ActiveX vs Java API what's the difference?

2010-11-25T14:32:00.000-08:00

There has been quite a discussion on Chans blog about ActiveX vs Java API. One of the claims presented by Anonymous is that ActiveX is missing ticks when another function is executing. This alarmed me as I rely heavily on the ActiveX api.
So I've tested this claim: while tws events are handled in the background by the wrapper and listener classes, I start a ~10 second 100% cpu intensive task in the foreground. After this I examine the timestamps of each tick.
The results are in the figure:

On the horizontal axis is the logged tick number and tick timestamp is plotted vertically. The cpu is loaded between the red lines. This graph shows that during cpu load no ticks reach the listener class, however no events are lost as they are all fired up just after the cpu has some available time.
The other claims were quite vague as 'performance', as far as I'm concerned I've never had any performance issues using activeX. And last but not least, if you need 'performance' why do you use Matlab??? I would directly go for some native language and FIX CTCI api.

So I'm sticking with the ActiveX for now.

HOWTO: Wrap Interactive Brokers TWS api in a Matlab class.

2010-11-15T10:52:00.000-08:00

There are many ways of interfacing Matlab with Interactive Brokers API. The main choice is of course whether you are going to buy a commercial product (like quant2ib) or go the DIY route (a-la Max Dama). For me it was the second option. The reason is that not only am I short of $600 for an interface, but in most cases a commercial product will have some limitations compared to your own or open-source code.
I've started with the code from Max that really got me a flying start, but his approach to interfacing is far from optimal. One would need a bunch of global variables and separate functions to get the data back and forth. Synchronization to events also becomes very difficult with this approach. Without object oriented design, one would quickly become bogged down in 'spaghetti' code.
So I went another route: wrapping all of the tws stuff in a single class and using events for synchronization. This was not trivial to do, as passing class methods as a callback function proved quite tricky. With code from leptokurtosis.com (thanks!) this issue was solved and I finally managed to create a descent wrapper.

Here is the base code for the wrapper : ib_matlab_tutorial.zip
It's a basic skeleton that can be extended further. At this moment only market data subscriptions are implemented. To add order placing, historical data etc. you'll need to add some code, but from here on most of the heavy lifting is already done.

How to use:
- install tws ActiveX , enable api connection in tws
- start TWS
- open demoScript.m and step through the code blocks to see what happens.

File description:
CTws - main wrapper class .
CSymbolData - used by CTws as a data container
CListener - basic example of a listener class, listening to tws events.
GenericIbEvent - used for passing symbol data within an event (written by leptokurtosis.com)
demoScript - basic tws/listener demo

Have fun!
Any remaks/improvements are welcome!

Behold the ideal database tooling combination

2010-10-09T12:41:00.000-07:00

As I've mentioned earlier, I've spent most of my time in the last year managing data instead of developing strategies. Its a dirty job... ~~but somebody's gonna do it~~ and with the right tooling somebody has already done it for you.
In my search for the ideal database tooling I've tried native matlab files, excel, MySql, Access and plain csv, before settling for far-from-ideal xml - *.mat combination. Still, a lot of programming is required to manage data this way.
A couple of days ago I finally found the solution: SQLite + mksqlite . Both packages are simply excellent: a serverless database contained in a single file plus a very fast matlab interface. The best thing with this combination is that one does not need a db server or any drivers to take full advantage of an SQL database.
Thanks to the open source community, I can now really start focusing on strategy development instead of data management.

Yahoo historical data downloader

2010-09-26T12:57:00.000-07:00

I've taken a look inside the get_hist_stock_data.m from Luminous Logic , the script that I was using for a looong time. The code seemed like it could use a little bit of cleaning up, but I've ended up rewriting it completely. The resulting code is just several lines long , accepts precise historical period and returns a struct.

Code: download_hist_yahoo_data.m

Where did all the money go???

2010-06-27T13:32:00.000-07:00

We've seen the markets rise and fall all over again. Sometimes I've asked myself a question : ' When the prices fall, where does all the money go?' I could imagine that 'smart money' left first and somebody made a huge profit (just like in any pyramid scheme). Never really got the time to think about it, until today. Today somebody asked me this question and while trying to explain it all suddenly became clear. The 'money' was never really there. A good illustration are the house prices. Imagine you bought a house for $500k a couple of years ago. The prices have risen since then to 550k, so you've made a virtual profit of 10%. Now the prices fall again and you start loosing 'virtual' money. This is the same as unrealized pnl. The good thing with real estate is that they have some real underlying value, while for the stocks the underlying value is often completely unclear.

Strange things that happen at the open

2010-06-07T09:05:00.000-07:00

Each stock has its quoted open price. But how is it formed? I've logged tick data during todays opening and plotted it in the figure below. Each point represents a tick, the color tick type (ask, bid, trade). Take a note that NYSE opens at 15:30 in my time zone. According to Google finance, the stock opened at $37.5.
As you can see, the opening price jumps all over the place in the first minutes of trading. Seems that traders are not sure of what the fair price is, but it does settle after about one minute.
One conclusion is clear, if you want a stock against its opening price, you got to act fast.

Estimating the fair price of ETF components

2010-05-31T03:00:00.000-07:00

The essence of every arbitrage strategy (in any timeframe) is an estimator of a 'fair price'. Once you got that, the rest is easy: just buy the stocks that are too low relative to the fair value and sell the overpriced ones.
Now the hard part: how do we estimate the fair value? Solutions could be countless: linear regression, neural networks, kalman filter, weight in the index, mean value, ... you name it. And of course the ETF tracker itself.
In the example below I've taken a look at the old time favorite group of stocks : the XLE. The data plotted is a cumulative return for 1 week history with 15 minutes sampling rate. Notice the fat lines: the blue one is just the mean return of the group and the red one is the return of XLE itself.

It turns out that the returns of XLE are almost identical to the mean of the group! A quick conclusion from this is that the ETF itself is as good estimator as just the mean value!. Another conclusion could be that one does not need a phd-rocket-science-chaos-theory sophistication to design a descent arbitrage strategy.

Intraday data downloader for TWS

2010-05-29T07:16:00.000-07:00

Having descent historical data is essential for developing a good strategy. But access to (free) intraday data is almost non-existent. However, if you have an account at interactive brokers, they let you download historical data for free.
In the last couple of weeks I've been very busy with implementing an intraday arbitrage strategy. The strategy itself is very simple with zero (!!!) parameters, but the amount of code needed for data and error handling is much more than I've anticipated. Have been coding data handling and conversion for a couple of weeks now with one clear conclusion: I hate programming. So this is how it feels to be the low-level software engineer aka code-monkey ;-).
However, during this process I managed to get Matlab to talk to TWS through their API and written a historic data downloader that could spare some boring work for other people.
The code is based on tutorial written by Max Dama (thanks Max!). You should follow the steps described on his page to install and configure the tws api. After that just fire it up:

hDataIntraday = getHistoryTws(tickers, filename_copy ,period, barsize);

Keep in mind that IB imposes restrictions on data download : Historical Data Limitations
The data is downloaded to a structure:
hDataIntraday :
         stocks: [1x20 struct]
                  ticker: 'AEE'
                 history: [1x1 struct]
                           dates: [253x1 double]
                            open: [253x1 double]
                           close: [253x1 double]
                          volume: [253x1 double]

                  ticker: 'AEP'
                 history: [1x1 struct]
                           dates: [253x1 double]
                            open: [253x1 double]
                           close: [253x1 double]
                          volume: [253x1 double]
         last_update: '29-May-2010 16:07:21'

The code: tws_history_downloader.zip

Forex costs

2010-03-22T16:51:00.000-07:00

Once again I must come to the conclusion that Forex costs are too high for a descent high frequency strategy. By high frequency I mean time windows of less than an hour. Everything I've tried so far gets killed by the spreads, very frustrating. When the arbitrage spread is just 2-3 times larger than the broker spread all the odds shift against my favor.
As the arbitrage combinations are quite limited in Forex, there are probably just too many players with access to much tighter spreads playing this game. No easy money here, moving on...

Transaction costs : forex vs stocks

2010-03-21T05:43:00.000-07:00

I've decided to take a quick look at the transaction costs involved in forex versus stock trading. Most of the forex brokers brag about 'no transaction costs', but the impact of the ask-bid spread is often unclear. The results were as expected: forex has higher transaction costs than the stock market. .
To enable the comparison of the costs I've defined a cost_ratio=spread/(max(bid)-min(bid)); . In other words, the cost ratio is the transaction cost divided by the price range in some given period of time. I am using a week. To calculate the cost ratio for forex I've taken the spreads for 'USD/CAD' 'USD/CHF' 'USD/DKK' 'USD/NOK' 'USD/SEK' pairs relative to their weekly range and then averaged them. (data source: Gain Capital)

The cost ratio for a stock is calculated in a similar way. SPY has a weekly range of about 2% (rough estimate) , one share price is around $115, so the weekly range is 0.02*115 = $2.3. Transaction costs at IB are $0.005 a share, resulting in a cost ratio of 2.2e-3.

The results are in the graph below:

The cost ratio for forex seemst to be around 5 times higher than for stocks. This changes of course if a lower priced stock is traded. For a $20 share with the same weekly range , the price ratios between forex and stock market are roughly equeal.

I guess the difference in cost ratios is the price you pay for liquidity, minimal slippage and real-time data.

Intraday data handling can be easy, when you've got the right tools.

2010-03-18T13:19:00.000-07:00

The title of this post could be just as well 'In praise of Matlab' ( or possibly SciLab or R, but not Excel). Yesterday it took me only a couple of hours to complete a task that otherwise would be almost impossible to achieve without the right tooling. I was so excited about how easy it turned out to be that I decided to share my experience.
For some time now I was going to take a look at Forex intraday data. It tempted me because of the law of 'large numbers'. A model should be allowed to make a couple of hundred of trades before its profitability can be estimated reliably. For a swing-trading system this should mean at least half a year paper trading and I just don't like to wait. In case of an intraday system, one only needs a couple of days! Forex data is freely available (intraday data archive) making it a good candidate to test some intraday strategies.
But once you download some data, a problem becomes obvious: the data is sampled at irregular intervals, making it very difficult to compare one dataset to another. Take a look at the beginning of the data files:
USD/CHF:
lTid,cDealable,CurrencyPair,RateDateTime,RateBid,RateAsk
1051976017,D,USD/CHF,2010-01-31 17:04:45,1.060100,1.060600
1051976080,D,USD/CHF,2010-01-31 17:05:20,1.060200,1.060600
1051976102,D,USD/CHF,2010-01-31 17:05:22,1.060100,1.060600
1051976119,D,USD/CHF,2010-01-31 17:05:22,1.060200,1.060700
------------------------------------------------------------------------
USD/CAD
lTid,cDealable,CurrencyPair,RateDateTime,RateBid,RateAsk
1051975015,D,USD/CAD,2010-01-31 17:01:50,1.070500,1.071000
1051975069,D,USD/CAD,2010-01-31 17:01:56,1.070500,1.071100
1051976049,D,USD/CAD,2010-01-31 17:05:14,1.070500,1.071200
1051976441,D,USD/CAD,2010-01-31 17:06:10,1.070600,1.071200

The sampling time seems to vary between less than a second to more than a minute! Even if you don't want to compare these two datasets, the data is still unusable for a backtest.

Now imagine trying to align these datasets in Excel. If somebody has an idea, please let me know ;-).
However, in a technical software tool (like Matlab ) there should be an interpolation function.
In Matlab it is the wonderful interp1 . It accepts available data along with a new vector of time values for interpolation.
I've used a 10-second interval for interpolation, while synchronizing start times between different datasets. The result is a neat matrix with prices at even time periods. Of course this introduces an error , but looking at the interpolated data (see graph below, deeply zoomed in), less than 1/2 pip, nothing serious.

Again, it gives me a headache just thinking about having to complete this task without the right tooling.

The temptation of overfitting and how to resist it.

2010-03-13T15:55:00.000-08:00

One of the greatest temptations when designing a quantitative system is without a doubt overfitting (or data snooping). Sometimes it is so evident that only a novice can get fooled by it, sometimes really hard to point out. For example, everybody knows that you should not try to predict the future prices by linear extrapolation. The higher the polinome order you are using, the better it will fit the training data and the worse it will fit the test data.
Still, I often come across traders running insane optimizations of a 10+ parameter model. But the truth is, if your data is bad , no amount of optimization will help. Imagine a true random walk process. It can not be predicted by definition, but by pure chance it can produce something that *looks* predictable. These situations can lead to a life-long quest for a 'jesus indicator', which of course can not be found. Speaking of indicators I must say that I do not believe in them. Well, I do use a couple occasionally, but for me it is only tooling. Just like a wrench could be useful from time to time as a tool, but there is really no need to 'believe' in it.
I've spent a lot of time lately developing a robust model and things are going in the right direction. Here is an example of a P&L from one of the better models. It does not account for transaction costs and slippage yet, but the good thing is that the result is not optimized in any way.

My way of avoiding overfitting is

making a hypothesis of a physical phenomenon, and testing it on multiple datasets. If the existence of the phenomenon is proven, only then a robust model can be bult.
avoiding models that produce negative sharpe for any model settings
optimizing the data instead of the model. In other words, if a general model does not work on your data, go find a better one.

Using VIX for volatility correction

2010-02-25T15:35:00.000-08:00

Market neutral strategies often rely on a relative mispricing of two instruments. One of the challenges I've been facing is how to keep this mispricing constant in time, allowing it to stretch much further before initiating a trade in times of high market volatility.
A solution I've come up with is using the VIX index as a correction measure. It seems to work much better than a moving window estimation based on the data itself. The formula I'm using for correction is C = (100-VIX)/100 . The spread is then multiplied by C.

Upper graph: VIX , lower graph : real and corected spreads.

Notice how the corrected spread remains stable through the end of 2008.

P.S. The spread shown is a relative mispricing in time an not an actual X/Y ratio.

Probability mapping (2)

2010-02-17T14:30:00.000-08:00

While building a model based on the probability mapping from the previous post I wasn't quite satisfied with the initial results. So I took a step back to a one dimensional state space and plotted the 5 day forecast of the XLE/XOM vs bollinger %b. Zero on the x-axis corresponds with -3 sigma and 100 with +3 sigma deviation . Y-axis shows the ratio between XLE/XOM 5 days into the future and today .

The figure shows just how difficult it is to forecast the movement of the ratio. Ideally, the data should follow a band from upper left to lower right corner. Instead, it is quite hard to see any trend present. After a linear fit (red line) some trend can be found still. Note that around 50 pct_b it is exactly coin flip between increase and decrease in XLE/XOM.

Probability mapping

2010-02-16T06:40:00.000-08:00

Here is a nice idea I've got during cross-country skiing this weekend. The 'classic' way of trading pairs is defining some measure of divergence from the mean, such as z-score. Outside some threshold a buy or sell signal is triggered. This brought me to thinking about what we are actually doing here. In essence, we are using a linear classifier in a 1-d space. By optimizing the model, the classifier is trained for an optimal value. People familiar with pattern recognition know that the linear classifier is the most basic and limited tool there is.
Having quite a background in Q-learning (my masters thesis), I understand its beautiful ability to map a state space to an expected reward, elegantly and without any models. Doesn't trading in general boil down to state-reward mapping? For sure!
I have tried different implementations of reinforcement learning without much success. But this weekend I managed to combine some ideas from pattern recognition and RL to an implementation that could work.
Some people are probably wondering by now: ' Here we go with the AI bullshit again!'. I'd like to call it probability mapping. Also, probably many of the advanced quantitative traders are already using it. Its all about estimating the chances of a bet at a set of certain conditions.
First, I define the conditions, called 'feature 1' and 'feature 2'. Two features means a two dimensional feature space, nothing keeps us from making it more (or less) dimensional, but since my monitor can best visualize two dimensions I choose that number. In my case, both features are oscillators based on cumulative returns over past x days. Feature 1 uses 3 days averaging and feature 2 20 days. Any other measure could be used (RSI, Stochastics, etc).

In the figure above the ratio between XLE and XOM is plotted along with two oscillators. It is clear that a high oscillator value correlates with the subsequent drop in the ratio.
Normally you could start applying threshold conditions from here based on oscillator levels, but i want to go a couple of steps further.

So now I plot my state map for all values of feature 1 and 2 along with the corresponding future XLE/XOM ratio after 5 days. A green dot represents increase and red dot decrease of the XLE/XOM ratio.
From this map an estimation can be made how likely it is for the ratio to go up or down for each combination of the features. Let's call it 'Sharpe surface'. I define it similar to the sharpe ratio: mean(20 nearest neighbors)/std(20 nearest neighbors).

Scanning the feature space gives me the nice plot as above (note that the vertical axis is flipped over compared to the previous figure).

The interpretation of the sharpe surface is very simple: expect the XLE/XOM ratio to rise in red areas and drop in the blue. This is very much in line with common sense: low values of both features correspondent with anticipated increase of the ratio (see feature 2 <20 or feature 1 < 20).

Again, normally we would use just one of the dimensions and put thresholds somewhere around 20 and 80. But with this probability mapping we can go for cherry picking!

Files: probability_mapping.zip

Any remarks about the code are very welcome.

Which sharpe is good enough?

2010-01-30T04:59:00.000-08:00

I've made some progress designing a market neutral strategy. My test set is XLE (stocks and its component stocks (2001-2009). The strategy trades each stock against the XLE using bollinger bands. A trade is entered when the spread between XLE and a stock exceedes 2. A position is closed after the spread crosses zero. As a safety measure, a stop-loss at 5% is implemented together with a maximum holding period of 60 days. Transaction costs are 0.2% one-way.
Generally I get sharpe ratios around 0.8 without optimization ( z-score and window size are fixed).

Now I'm unsure how far can I push the simple stock-index arbitrage. If I start optimizing for a specific stock, overfitting seems to occur very fast.

I still see some possible improvements to the strategy, but I'm not sure if I'll be able to push it above 1. There should be a limit how much profit you can squeeze from stock-etf arbitrage anyway.

The question I'm asking myself now 'is this good enough?'. Apart from a personal preference about risk I'm very curious about the results achieved by others.

Which Sharpe ratio is 'good enough' for stock-index arbitrage in your opinion?

A note on index tracking

2009-12-29T14:11:00.000-08:00

A couple of years ago, Ernie has started an interesting discussion on his blog. A reader named 'L' was having doubts about ability of a small portfolio to track an index out of sample. And to be honest, he has a point, starting with only one stock in the portfolio you are most likely to get a random walk instead of tracking. On the other hand, having N-1 stocks in the portfolio should result in almost perfect tracking.
I've decided to verify the results and test tracking portfolios for the XLE. The results for 5 'best' portfolios consisting of only 5 stocks are given below.

Blue charts are in-sample training and red is true out-of-sample data (no re-balancing). Look how well three of them survived the 2008 debacles.
I must note that these portfolios have probably not enough variance for profitable trading, but that should be easy to fix.

Overachievers vs underperformers

2009-12-25T13:30:00.000-08:00

This paper got me thinking: market-neutral trading of two stock baskets seems like an elegant strategy. A 'long' basket should mainly consist of favorable stocks, performing above the index. It is then traded against a 'short' basket of underperformers. So each trade should deliver the alpha of the long and -alpha of the short basket. Seems like a great idea, but how to identify the right stocks? How consistent is the over- and underperformance?
Here is my first shot at this.

In the graph above the average 10-day performance of a stock is plotted relative to the XLE index. Some patterns can be clearly seen, but to be honest, I'm not really thrilled.
Maybe I'll try using bollinger next time.

However, the cumulative returns seem much more interesting, through I don't have any particular use for it.

I think a better way to approach stock rating is to look at the stationarity of the tracking error.
But for now, I'll stick with building a cointegrating portfolio and trading it against a benchmark.

Files: stocks_XLE.mat, lag.m, analizeStock.m

What does Dickey-Fuller test tell us (not)?

2009-12-23T08:45:00.000-08:00

I've been trying to build an index-cointegrating portfolio in the last couple of days. One of the crucial questions here is which criterion to use for stock combination ranking. Dickey-Fuller test is the first option that comes to mind. I know it tests for stationarity, but that is just a part of what I'm looking for.
You see, even when you have a stationary time series that has very little variance, it is also of very little use for trading, as you will probably not earn the transaction costs back. (low variance is a sign of market efficiency, in an ideal efficient market variance will be zero, eliminating any arbitrage opportunities). On the other hand, if a series is instationary with a low drift, but has plenty of variance, many good trading opportunities will exist.
To test the DF-test I've simulated a combination of two AR(1) time series I(0.95) and I(1):
y = (1-drift)*s + drift*d

where
s - stationary I(0.95) time series.
d- non-stationary I(1) time series
Both series have variance alpha.

I've varied drift from 0 to 1 and alpha from 0.2 to 5. (0, 5) combination being most profitable. Increasing the drift value effectively means a transition from stationary signal to random walk.
The results are in the figure below:

Just as I've thought, DF can not distinguish between different levels of variance.

I clearly have a need for a better estimator, not looking for stationarity but for variance/drift ratio.

Maybe it's time to blow the dust off the good old Fourier transform, looking for high spectral peaks.
Probably an even better idea is to use wavelets for spectral decomposition and filtering, then estimate spectral density of each frequency band.
Any other ideas?

Files: drift_model.m , semistat.m

Can open innovation give a competitive edge?

2009-12-21T16:40:00.000-08:00

I believe it certainly can! Even more so, I believe a small company must use it to be able to compete against 'big boys'. (if you don't know what open innovation is, take a look at the Wikipedia ). My current full-time job is in the technology sector, working inside an RnD site about 1000 people strong. In my daily work I get to work with small(er) size subcontractors, companies ranging from 10 to 150 employees. My observation in the past couple of years is that 'big' is not always beautiful and 'small' is not much better. But open innovation could change this in favor of smaller sized companies. What are the strengths of a big RnD? Usually it is a decent research budget and a large knowledge pool. Project organization is usually well organized, making it possible to handle very large projects (>50 fte). I've also experienced that these advantages come at a cost: bureaucracy, ill communication, heavy overhead, 'political' decisions etc. This is common to most large RnD's , as illustrated by Dilbert cartoons. Reading them daily I often find them spot-on, equally applicable to European and American companies alike.
Smaller companies have their own disadvantages. While being extremely agile and efficient, they often lack professional organization and broad know-how. If only they could get the knowledge they need....
This is where open innovation provides a competitive edge. I believe that the ways of doing research have been changing for the last couple of years and the rate of change is increasing. Information becomes readily available making it easier to build on ideas of others rather than reinventing the wheel.
I've started this blog with open innovation in mind. Here I'll try to
- share my ideas. Many of them will be incomplete, unpractical or just plain wrong. I really hope to get enough feedback to filter out the better ones.
- share specifics on things that don't work. In my professional work the 'don't do this' advice has proven to be most valuable. Hopefully I'll help somebody spare some time to come up with really great ideas (and then of course share them).
A great example of open innovation in action: today I've come across this post. It really helped me to get a couple of thoughts together that have been floating in my head for weeks. Thinking of these ideas as puzzle pieces, I now know that all the pieces are there. Now I can start the tedious work of putting them in place.

Where is the catch?

2009-12-15T07:52:00.000-08:00

...is a question I usually ask myself when something seems to be going 'too well'. Up till now things were looking much too easy, so now seems the right time to start asking questions.
Here is what I did:
1. got a list of 800+ etfs in to Matlab from Yahoo.
2. run a Dickey-Fuller test to establish potential trading pairs. Cointegration was only tested inside a category to avoid pairs with no 'physical' cointegration. Setting a threshold to 3.9 t-static I've got about 900 pairs. Later I've decided to ditch some categories like 'N/A' and 'Bear Market'.
3. Let the 'Duck' strategy loose on the pool pair, let it figure out the optimal sharpe. (I've decided to use animal names for strategy tracking. Of course starting with 'not so cool' animals as rabbits, ducks is logical as early strategies will be not really great. I'll be moving to panthers and tigers in the later stages of develpment). To elaborate more on the Duck, which I'll post later: this strategy tracks the ratio of a pair. Optimization is done on the moving window and z-level threshold. For example: a trade is entered when z-spread is higher than 1.5 and exited when it reverts back to zero. Duck is plain and simple, no fancy stuff like stop-loss or time limits. I've let some big holes in backtesting, like not using training and test sets, not testing the data-snooping to the finest detail etc. But still, this step should give an *indication* on the returns achievable by the pairs. After this step I'll reduce the 900 pair set to a 'profitable' set on which I'll continue my research.

Good, quick and dirty, but let's take a look at the results.

The results provided by Duck are very encouraging: almost all pairs have positive sharpe, but the top of the list alarmed me. Take a closer look at the figure: sharpe ratios of well above 3 a possible even with a dumb duck strategy. Either I'm going to become rich much faster than expected or I haven't thought about something important. I guess the latter.

Ok, let's look at our runner-up, the MZO.

This is where my bad feeling is justified: MZO has zero trading volume for many days! This would result in slippage (I guess) and all other sorts of trouble, like being unable to short the share.
Now, what really confuses me is the fact that liquidity of an etf should be based on the underlying stock as explained here. And MZO has some really heavy weights behind it.

The same goes for many of the promising etf pairs, they seem to miss liquidity.
So now I'm a little confused: is it better to filter out the non-liquid etfs or start building my own share baskets and trading them against each other or bigger sized etfs?

The most important question

2009-12-13T01:55:00.001-08:00

when starting something is 'What do you want to achieve?'. And it is certainly true in case of quatitative trading. Even more so, this question should be answered in a measurable manner.
It took me a couple of month and a lot of research to come up with a descent answer and here it is:
- I'm looking for a way to start a small independent trading business. This is only possible when a steady income is generated at least monthly, so steady profits are more important than high profits. Translating this to trading strategies puts most directional trades out of the scope due to their unstable nature. Mean-reverting & market neutral is going to be my style.
- On a short term my goal is to find a reliable trading strategy with a sharpe of at least 1.5.

.

and so it started.

2009-12-11T04:19:00.001-08:00

I finally decided to start a blog. The reason for this is that I've been bugging most of my friends for the past two month with my quantitative trading adventures. Usually, if you are passionate about something, you just must share it with everybody around you and you are in great luck if the people around you share the same passion. It is plain ok if they are just agree to listen. And if they don't, you just have to start a blog.