So I decided to give the “legendary fast” Amibroker a test to see if it could better TradersStudio’s performance. After some “playing and learning”, I have finalised the code to compute the e-ratio. My big thanks go to the ASX gorilla whose own version forms a large part of my code.

Below is the code explanation and downloadable afl file.

Directly from the ASX Gorilla’s website as a prelude to the code:

My implementation of the Edge Ratio involves two profound Amibroker fudges. The first is the use of the AddToComposite function to create a composite ticker symbol in which to hold the ATR array of a given stock for later retrieval within the Custom Back Tester via the Foreign function.

The second fudge is the use of the VarSet/VarGet function to create a quasi array. This was necessary to overcome the limitation where array elements cannot exceed in number the value of barcount-1.

The first part is to actually code up your Buy signal (in our case a Donchian Channel Breakout). The Sell signals are tested separately:

//BUY RULES: implemented with Buy Stop on Upper Donchian Channel(17)
BuyStop = Ref(HHV(High, 17),-1);
Buy = Cross( High, BuyStop );
BuyPrice = Max( BuyStop, Low ); // make sure buy price >= Low

Exiting positions is done on a fixed duration basis:

//Never Sell so that the position is stopped out after N bar instead
Sell = 3 > 5;
//Stop the positon and close it after N bars
//(eratio = N that we step from 1 to 100 in optimisation)
ApplyStop( stopTypeNBar, stopModeBars, eratio );

The first fudge mentioned above to store the ATR:

Normaliser = ATR(17);
AddToComposite(Normaliser, "~atr_"+Name(), "C", 1+2+8);

And the “meat” of the code: the chunk that implements the custom back-testing to:

1. Loop through the signals and store the Entry ATR value.
2. Loop through all trades and retrieve MFE, MAE and ATR.
3. Compute the e-ratio based on values from all trades.

SetCustomBacktestProc(""); //activate the custom backtester
if(Status("action") == actionPortfolio) //called when backtesting/optimising
{
	bo = GetBacktesterObject();
	bo.PreProcess(); // run default backtest procedure
	TradeATR = NumTrades = ATRArr = 0; //init variables
	for( bar=0; bar < BarCount-1; bar++)
	{
		bo.ProcessTradeSignals(bar);
 
		for ( sig=bo.GetFirstSignal(bar); sig; sig=bo.GetNextSignal(bar) )
		{
			if (sig.isEntry())
			{
				NumTrades++;
				ATRArr = Foreign("~atr_"+sig.Symbol, "C");
				VarSet("TradeATR" + NumTrades, ATRArr[bar]);
 
				_TRACE("Symbol " + sig.Symbol + " ATR: " + VarGet("TradeATR" + NumTrades));
			}
		}
	}
 
	AvgMAE = AccumMAE = AvgMFE = AccumMFE = NumTrades = 0;
 
	// iterate through closed trades
	for( trade = bo.GetFirstTrade(); trade; trade = bo.GetNextTrade() )
	{
		NumTrades++;
		EntryATR = VarGet ("TradeATR" + NumTrades);
		if ( EntryATR != 0 )
		{
			_TRACE("EntryATR: " + WriteVal(EntryATR));
			_TRACE("AccumMAE : " + WriteVal(AccumMAE));
			AccumMAE = AccumMAE + (trade.GetMAE()*trade.EntryPrice/(100*EntryATR));
			AccumMFE = AccumMFE + (trade.GetMFE()*trade.EntryPrice/(100*EntryATR));
		}
 
		trade.AddCustomMetric("My MAE", trade.GetMAE()*trade.EntryPrice/100);
		trade.AddCustomMetric("My MFE", trade.GetMFE()*trade.EntryPrice/100);
		trade.AddCustomMetric("Entry ATR", EntryATR*10000);
	}
 
	AvgMAE = AccumMAE / NumTrades;
	AvgMFE = AccumMFE / NumTrades;
 
	_TRACE(WriteVal(AccumMAE ));
	_TRACE(WriteVal(NumTrades));
	_TRACE(WriteVal(AvgMAE));
 
	Eratio = abs(AvgMFE/AvgMAE);
 
	_TRACE(WriteVal(Eratio));
 
	bo.AddCustomMetric( "Avg MAE", AvgMAE );
	bo.AddCustomMetric( "Avg MFE", AvgMFE );
	bo.AddCustomMetric( "Eratio", Eratio);
 
	bo.PostProcess();
}

If you want to run this code, you can download the e-ratio “gorilla” afl file and simply update the BUY signals to whatever you fancy testing.

The next post will be a direct speed comparison between TradersStudio and Amibroker for computing the e-ratio on the same underlying data and with the same signal. I expect Amibroker to win the fight hands-down as it appeared “way” faster!

Related posts:

1. Amibroker V. TradersStudio: Speed comparison Fight
2. Amibroker vs TradersStudio: comparison
3. e-ratio calculation in TradersStudio and Excel

I will show you how I calculated the e-ratio for a 17-day Donchian Channel breakout coupled with a 108-day moving average filter (the red curve on this chart). All the code referenced is provided at the end of this post.

As we saw in the last post about the e-ratio, you need to run the same signal over multiple fixed trade durations and record trade data. For this the TradersStudio optimisation and custom reports functionalities fit the bill.

System Code

Step 1: code up the system to test in TraderStudio

As you can not have simultaneous open Buy and Sell positions, there are actually 2 systems (long-only and short-only). The below will be based on the Buy-only system.
The entry signal is a breakout of the Donchian channel if the MA filter conditions are met (price > MA and MA rising).
In TradersStudio this translates to:

MA = ScriptAve(Close, MALength,0)
If MA > MA[1] And Close > MA Then 
    Buy(EntryName,1,donchianHigh+MinMove ,Stop,Day)
End If

The exit is simple: close the trade after n days (tradeLength):

If BarsSinceEntry=tradeLength And MarketPosition=1 Then 
    ExitLong("ExitLong",EntryName,1,0,CloseExit,Day)
End If

Step 2: retrieve trade data in custom report

As discussed in the e-ratio post we need to get MAE, MFE and ATR for each trade. For this we use a TradersStudio custom report. The report code is executed at the end of the system test and retrieve trade info with the following command:

GetInfoAboutTrades(Info, i + 1)

we are interested in the MAE and MFE which can be derived off the Maximum Profit and Maximum Loss of each trade:

SetCell(row, 13, 2, 10, Info[16]) 'Max Pos Profit
SetCell(row, 14, 2, 10, Info[17]) 'Max Pos Loss

For the ATR value, we need to use a little trick as it is not directly available. We record it as part of the entry name which can be output to the report.
In the system code we have:

EntryName = "DonchianBreakoutBuy" + "|" + indLength + "|" + tradeLength  + "|" + avgtruerange(indLength)

which concatenates the entry name with the ATR value as well as the length of the indicator (Donchian Channel) and trade duration – this will come in handy when we do the e-ratio calculation.

Step 3: run the system through the optimizer

The system is called DonchianChanBrkoutFiltBuy and has 3 parameters:

Sub DonchianChanBrkoutFiltBuy(indLength, tradeLength, MALength)

In the optimization process, step through all values of trade duration required (e.g from 1 to 100 in increments of 1) – warning TradersStudio will take a few hours to do this (sic!).
This will generate a custom trade report for all trades containing all the data required.

Step 4: paste data in Excel

Once you run the long-only and short-only systems, we are done with TradersStudio. We need to move the data over to Excel for analysis and the e-ratio computation.
Copy the custom trade report from the short-only system run to one sheet and from the long-only run to another sheet (watch out for the number of rows: if you have more than 65,536 and a version of Excel earlier than 2007 you will need to do that in several chunks).

Step 5: Run e-ratio macro

Copy the macro code from the text file, create a new VBA module in Excel and paste the code in it.
Go back to both sheets and run the macro. This should manipulate the data and create an aggregation pivot table on a separate sheet.

Step 6: Compute the e-ratio

On a brand new sheet, copy both pivot tables (I recommend a paste/special – values only) side by side so that each trade length values corespond with each other. Sum each Total value (column D and J) together for the same Buy and Sell parameters (in column N in example file). Divide each Sum of MFE by Sum of MAE: this gives you the e-ratio for the given trade length.

THE CODE

Please find below code files to support the example below (all txt files except the Excel workbook). This should be easily portable to any system (i.e. just change entry criteria in the system).
Donchian Channel Indicator
Custom trade Report
Buy System
Sell System
Excel e-ratio macro (text file)
Excel example workbook (does not contain underlying raw data as it is 60MB!)

Or if you prefer a zipped version of all files – here it is.

Any questions, clarifications, etc. please let me know how I can help.

Related posts:

1. Amibroker e-ratio code
2. Amibroker V. TradersStudio: Speed comparison Fight
3. e-ratio: How to measure your trading edge in 4 easy steps

Why I chose TradersStudio

I did consider a few options before buying TradersStudio (Amibroker, TradeStation, Trading Blox, WealthLab, NinjaTrader) and based on feature analysis, recommendations and actual testing, I settled on TradersStudio.
My requirements were for a standalone platform that would allow me to test any system, with money management and multiple system interaction.
I did hesitate with Trading Blox, which I enjoyed testing (demo version), but in the end the price sorted the argument (Trading Blox is $3,000 for similar functionality).
For more info on what each product offers, I would definitely recommend heading to EliteTrader where many platform comparison posts can be found. Please also feel free to ask me questions in the Comments section below.

First impressions

Not so good… There is no demo available on the website, you can not download the app from the website once purchased and the manuals you receive after waiting a few days seem quite unprofessional (despite being over 300 pages).
However, the install is quite easy and you can be up and running following examples from the manual in a few minutes.

Main Features

The app offers some interesting features which help me take the decision:

Integrated Systems testing

TradersStudio uses different hierarchical levels: Instrument, System, Session, Trade Plan. This allows you to test a complete system (i.e. more than simple entry and exit testing). A Trade Plan can contain several sessions, which in turn can contain several systems and instruments with possible interaction between them. Additionally, Money Management options can be tested as part of the Trading Plan. This makes it much more realistic than a collection of independent strategy tests.
There is also to the concept of virtual systems that allow you to run a system in “monitor” mode and only use it for decision making on other “live” systems (i.e. enter a trade in real system only after virtual system posts 3 losing trades).

Customisation

TradersStudio implements its own Macro language, which appears to be a cross between TradeStation EasyLanguage and Visual Basic. Theoritically you can implement whatever extra functionality you require (indicator, software add-in, etc.). Moreover there is an import tool that automatically converts TradeStation EasyLanguage code, which should allow to reuse available code.

Data-independent

You can basically load data from whatever source you wish in any supported format (any standard text file format will do). I personally use Unfair Advantage from CSI and getting it loaded to TradersStudio was a breeze (see Unfair Advantage posts for more information on CSI UA -> TradersStudio)

Walk Forward

Walk forward is a useful concept to use in back-testing to avoid over-optimization and curve-fitting. TradersStudio implements this functionality and runs it automatically which means less manual workaround for you to deal with.

Documentation issues

My main grudge is about the manuals. Despite being over 300 pages it is still missing an essential reference guide for programming using their language (there are a few examples but they do not cover the whole range of functionality and much is left to be guessed by the user). It is a “Learning by Example” type of manual which can sound a bit patronising at times.
For that reason I have found it hard to seriously get into TradersStudio… but I have just signed up for the yahoo group dedicated to it and will be spending many hours in front of it very soon!

I will explore TradersStudio in more details as I start using it and share in a later post if you are interested.

Related posts:

1. Amibroker vs TradersStudio: comparison
2. Amibroker V. TradersStudio: Speed comparison Fight
3. How to decide on a Backtesting and Trading Platform

This is the list of my real-life library dedicated to building automated trading systems. This is not the exhaustive list: I have more specialised books which I will add at a later stage (some I have not read yet…). But the collection below is a decent starting list:

Please feel free to suggest your book recommendations or any additional info using the comments section below.

Please find below the Library organised in several sections:

• TRADING SYSTEMS
• MONEY MANAGEMENT
• TREND FOLLOWING
• TRADERS INSIGHTS
• MARKETS, RISK AND CHANCE
• OTHER

– TRADING SYSTEMS –
	New Trading Systems and Methods – Perry Kaufman An encyclopedic (1,000+ pages) review of Systems Ideas and Methods –No review/summary yet– Look up on Amazon US | CA | UK
	Quality Money Management – Benjamin Van Vliet & Andrew Kumiega Best practices in Systematic Trading Technology. Build it with Quality! –No review/summary yet– Look up on Amazon US | CA | UK
	Trading Systems and Money Management – Thomas Stridsman Presents a strong approach to developing Trading Systems integrating Money Management concepts –No review/summary yet– Look up on Amazon US | CA | UK
– MONEY MANAGEMENT –
	Money Management Strategies for Futures Traders – Nauzer Balsara Complete introduction to the essential concept of Money Management. Check my review/summary Look up on Amazon US | CA | UK
	The Handbook of Portfolio Mathematics – Ralph Vince Essential reading for Optimal Allocations and Leverage! –No review/summary yet– Look up on Amazon US | CA | UK
– TREND FOLLOWING –
	Trend Following – Michael Covel See Why and How Trend Following works. Over a dozen of top CTAs covered. –No review/summary yet– Look up on Amazon US | CA | UK
	The Complete Turtle Trader – Michael Covel The Turtle story and their complete rules –No review/summary yet– Look up on Amazon US | CA | UK
	Way of the Turtle – Curtis Faith The Turtle experiment from the inside – told by a Turtle! –No review/summary yet– Look up on Amazon US | CA | UK
– TRADERS INSIGHTS –
	Market Wizards – Jack Schwager Legendary interviews of top traders. Inspirational and “motivation-kicker”! –No review/summary yet– Look up on Amazon US | CA | UK
	The New Market Wizards – Jack Schwager Schwager strikes back! You’ll re-read him often. –No review/summary yet– Look up on Amazon US | CA | UK
– MARKETS, RISK AND CHANCE –
	The (mis)behavior of Markets – Benoit Mandelbrot A fractal view of Risk, Ruin and Reward –No review/summary yet– Look up on Amazon US | CA | UK
	The Black Swan – Nasim Taleb Taleb re-writes the rules of risk. An excellent perspective on conventionally accepted concepts –No review/summary yet– Look up on Amazon US | CA | UK
	Fooled by Randomness – Nasim Taleb The hidden role of Chance in Life and the Markets –No review/summary yet– Look up on Amazon US | CA | UK
	The Drunkard’s Walk – Leonard Mlodinow The hidden role of Chance in Life and the Markets –No review/summary yet– Look up on Amazon US | CA | UK
	A Random Walk Down Wall Street – Burton Malkiel The original classic claiming Efficiency in the Markets –No review/summary yet– Look up on Amazon US | CA | UK
	A Non-Random Walk Down Wall Street – Andrew lo & Craig MacKinlay Collection of academic papers on Efficiency Market Theory –No review/summary yet– Look up on Amazon US | CA | UK
	When Genius Failed – Roger Lowenstein How mis-understanding of Risk and Money Management drove LTCM to their graves. Fascinating! –No review/summary yet– Look up on Amazon US | CA | UK
– OTHER –
	Schwager on Futures Managed Trading – Jack Schwager In-depth investigation into the Managed Futures/CTA industry –No review/summary yet– Look up on Amazon US | CA | UK
	Starting Out in Futures Trading – Mark Powers Learn the ropes of Futures Trading: a Beginner’s reference. –No review/summary yet– Look up on Amazon US | CA | UK
	DeMark Indicators Jason Perl The clearest presentation of all TD indicators –No review/summary yet– Look up on Amazon US | CA | UK

Related posts:

1. Weekend reading
2. A practical Guide to ETF Trading Systems

CSI main API document (word doc) is accessible publicly online from their document page along with other docs including the full 300 page manual (great for getting a feel of the app).

Pivotal API function

This post will focus on is the API function to retrieve Back-Adjusted Contracts from the Unfair Advantage database.
As the last post on Continuous Contract options showed, there are multiple choices available and these all translate to parameters to the API function: RetrieveBackAdjustedContract2. This is what I consider to be the meat of the API: it queries the proprietary UA database and applies the concatenation algorithms to produce a continuous contract.

27 Parameters!

Yes… that function’s behaviour is driven by the value of 27 properties or variables. There are actually 14 “Session” properties and another 13 variables passed to the function. The aim of these parameters is to reproduce exactly all the options covered in the previous post… and then some.

My own doc

Because I found the CSI doc not ideal (you have to keep flipping back and forth for a description of all 27 parameters) I decided to re-write my own “cheat-sheet” documentation for the RetrieveBackAdjustedContract2 API function.
The rest of this post is that document – formatted into HTML by M$ Word (so please excuse any formatting mishaps). The document contains 2 parts: the UA session properties and the function variables. Hope this helps.
You can also download the document in the RTF format.

Stay tuned for the next episode, where I will share a sample code using the function above to extract a list of Futures contracts. This should illustrate how to use all these parameters.

The document:

FUNCTION: RetrieveBackAdjustedContract2

–>

CONVERSION FACTOR        CONVERSION ACTION REQUIRED

        +6             Move decimal point 6 places left

        +5             Move decimal point 5 places left

        +4             Move decimal point 4 places left

        +3             Move decimal point 3 places left

        +2             Move decimal point 2 places left

        +1             Move decimal point 1 place left

         0             Leave number as it is

        -1             Terminal digit is in eighths

        -2             Terminal 2 digits are in 16ths

        -3             Terminal 2 digits are in 32nds

        -4             Terminal 2 digits are in 64ths

        -5             Terminal 3 digits are in 128ths

        -6             Terminal 3 digits are in 256ths

        -7             Terminal 3 digits are in 32nds & 1/2 32nds.

Related posts:

1. Unfair Advantage API Code (C#): Extract Futures Continuous data
2. Continuous Contract options
3. I just got myself an Unfair Advantage…