Regular readers might think that I suffer from backtesting-software-indecision-itis. Having first settled for TradersStudio, I then evaluated (and purchased) AmiBroker and found that it was 25 times faster than TradersStudio (at least for the calculation of the e-ratio). However, AmiBroker is not really geared towards true portfolio allocation testing with Futures and could not just replace TradersStudio – so I purchased it as a (cheap: $199) complement to it.

Why TradersStudio in the first place?

During my first round of evaluation, I did hesitate between TradersStudio and Trading Blox. At the time, it appeared that there was not a huge difference in functionality but a substantial price difference ($499 for TradersStudio, $3,000 for the full version of Trading Blox Builder). And this is how the choice was made.

However, I never really got past my TraderStudio’s first (not so good) impressions. Ultimately, I find the platform awkward to work with, documentation rather poor and the user community is very small.

So I decided to give Trading Blox another go and test their latest trial version (v3.3), and give you a teaser review of it.

Trading Blox: friendly, efficient, fast, professional

Trading Blox is vastly superior in terms of user interface “friendliness” and efficiency (love that script management/edit screen!). This makes the documentation lookup less necessary (and in any case, it is rather better).

The simulation runs are also very fast (300 stepped parameter tests under 7 minutes) and the software comes pre-packed with about a dozen ready-coded systems including the famous Turtle Trading system.

Finally, the numerous backtest options (slippage, commission, rollover slippage, volume, interest, etc.) should simulate trading reality much more closely.

Overall, it feels that the difference between Trading Blox and TradersStudio can be summed up by Pro vs. Amateur: both good at what they do, but playing in different leagues.

User community

Trading Blox forum is very good, with top-notch contributors. I joined it a few months ago and the discussion there is top-level, be it on all aspects of trading in general, backtesting, Data problems, Trading Blox questions, etc. It also has a marketplace where users can exchange code/systems, etc. This forum played a big part in my decision to re-consider Trading Blox (TradersStudio’s own forum and yahoo user group are barely ticking…).

In closing: screenshots

I feel I am about to give in and “cut my losses short” with TradersStudio and redeploy my resources towards Trading Blox. In the end, it is a “time vs dollar trade” and I feel that the initial outlay will give a great payback (in time savings and progress made). After all, automated trading is a business and one should not shy away from the essential investments.

Tomorrow, I should post a detailed system test using Trading Blox; but for now please find below some screenshots of the software (click to zoom in):

Result Reports

rich choice in general options

System Editor

Blox Editor

Heat map for stepped parameter

I wanted to start this year with an idea I left off last year, when investigating robustness: Using the median as a more robust tool than the ubiquitous mean (or average). This will be covered in the next post via a TradersStudio simulation results. To do that, I had to re-import some data from CSI Unfair Advantage to TradersStudio. I thought a “how-to” post on this would be useful – if only as an aide-memoire for next time (note-taking and documentation are important after all…)

Extract CSI Data

The first step is to extract the data from the CSI database into text files
(by the way, CSI have a 20% discount running until the end of January – just check their homepage).
This can be done with code using the Unfair Advantage API.

Pick all the instruments to be extracted and create a “contracts.param” file containing the CSI number for those instruments in the first column (comma-separated file with other columns being ignored). The CSI numbers can be found on their website (like here for the CME Futures) or in their Unfair Advantage software UI. Running the EXE code will generate one file for each instrument (proportionally back-adjusted contract) in the following format:

19900403,199006,0,240,110,918,503,2,0,1.59,1.655,1.58,1.635,1.635,1.635,1.635
19900404,199006,0,84,127,656,721,3,0,1.6,1.65,1.599,1.62,1.62,1.62,1.62
19900405,199006,0,57,112,554,885,4,0,1.615,1.635,1.61,1.615,1.615,1.615,1.615
19900406,199006,0,62,136,436,1092,5,0,1.615,1.635,1.61,1.625,1.625,1.625,1.625

Load in TradersStudio

The second step is to load the files in TradersStudio. Copy all generated text files in a dedicated data directory (you might have to rename them as TradersStudio allowed filename length is fairly short, i.e. 10-15 characters).
Create the relevant mapping file (txtinfo.txt) in the data directory. The mapping file should read:

delimit=,
skip=0
dt=1
ti=0
op=10
hi=11
lo=12
cl=13
vol=6
oi=7
dtformat=CCYYMMDD
tiformat=

In TradersStudio, menu Data Manager/Add Data Links, point to the relevant data directory with the following options:

If all goes well, this will load the data in the system (errors I encountered were due to file names being too long).

Data Universe: Contract meta-data

The third step is to populate the meta-data (margin, min tick move, etc.) for each instrument in TradersStudio. This is done via the menu Data Manager/Data Universe.

Once done, the instruments can be used just by adding them to any session.

As mentioned earlier the next post will be a test comparing moving average and moving median indicators.

Note: You can receive a 10% discount on CSI data subscriptions (use coupon code LIBERTY)

• Broker Account – The starting point to trade in the markets
• Live Market Data – To feed to your trading robot so that it can generate trading signals. Most brokers provide market data with proprietary or third-party technology- although market data can also be obtained from an independent vendor (e.g. eSignal).
• Order Routing – To transmit your orders to the exchange. These can be proprietary to the executing broker or third-party based (e.g. Zen Fire).
• Broker Trading Platform – To access your account information, place orders, etc.
• Charting Platform – Sometimes the broker platform charting capabilities are mediocre and an independent charting platform is required (e.g. eSignal)
• Signal Generation Platform – The actual trading robot: it analyses market data, account and positions information and implements the automated trading strategies to generate trade management signals (i.e. Buy / Sell / Exit, etc.).
• Excecution Platform – Receives trade signals and forwards them to the order routing.
• Platform Hosting – You can host the trading robot on your local machine, host it in a dedicated rented server or entrust a specialised broker to host and run your trading robot.
• Historical Market Data – Used as source for back-testing trading strategies
• Strategy Development Application – Allows for coding, optimisation, back-test and result analysis of trading strategies.
• Statistical Analysis package – for in-depth statistical analysis of back-testing results.

Some of these distinctions are physical, some are logical. For example, TradeStation packs many of the points above into one system: a broker account and a trading platform that allows you to:
Access live market data + Visualise price charts + Automate trading strategies that generate signals + Route the trading signals as orders on the exchange + Access account information + Store historical data + Back-test strategies

Sounds like it fits the bill perfectly, doesn’t it?
Well let’s look at the areas you need to consider when deciding on your automated platform.

Type of broker

Different issues to consider: is the broker a clearing broker, a non-clearing FCM or an introducing broker? If the latter is it an independent introducing broker or a guaranteed introducing broker (backed by a clearer)? It would seem that the closer to the exchange you broker is (in terms of relationship), the better/safer it is. See Anatomy of a Futures transaction for more detail on the different types of brokers.

Markets supported

Every broker offers access to different products and different markets. For example Interactive Brokers offers one of most complete coverage (worldwide Futures, Options, Equites and Forex) all “housed” under the same Universal Account. Other brokers only offer access to specific products/markets.

Latency/Speed

For some type of trading strategy, this can have a large impact and various platforms/feeds offer different levels of performance. This has led to specialist companies such as Zen Fire or Trading Technologies – which locate their servers very close to the exchange – achieving speed and reliability for data feed and order routing. They offer their services to brokers who can in turn offer it to their clients.

Development Language

This is mostly a matter of personal preference, experience and expertise. TradeStation has been around for longer and a big collection of Easy Language scripts are available for re-use while NinjaTrader, for example, uses C# and CQG Trader their own language.

Strategy Complexity vs. Platform Functionality

Most of the automated trading platforms that offer back-testing functionality lack sophistication of dedicated applications such as Mechanica, TraderStudio or Trading Blox. For example portfolio testing is usually not available in the live trading platforms. This might work for some simple strategies but not for more complex Money Management ones.

Hosting

You can run the trading robot on your machine, which makes you subject to power and connection failures or you can choose to rent a server to host your robot. Some brokers also offer trading strategy hosting and execution on their own servers.

Charting

Some specialised platforms offer better charting capabilities than the standard trading platforms and can be used as a standalone charting application. Some, such as eSignal, also offer a data feed.

Costs

An obvious one but between platform costs, execution costs, hardware, etc. there exists a wide range between bottom-end and top-end offerings.

What/how to choose?

While researching for this article I have come across many different packages offering different solutions. One of the best ways to help you decide on a solution that makes sense to you is to list your goals and cross-check each platform against them in this fashion (PDF doc).

There are endless possibilities for combining all the differenty packages. Just for fun I tried to “virtually build” the opposite of an all-in-one package such as TradeStation (which will probably not address most automated trader goals) – here is one “wacky” implementation.

A trader decides to use TradeStation as a signal generating platform. However she does not want to use TradeStation data feed and instead decides to go for the eSignal package integrating the broker Dorman Trading and the Zen-Fire connection for market data and a charting platform. In order to route the market data to TradeStation, she needs a bridge application - OwnData from TS Support for example. The backup feed solution would be TradeStation data feed. For the execution side of things, our trader decides to send the trading signals generated by TradeStation to NinjaTrader, which can route the orders to the exchange through a broker. The primary route is through Velocity Futures broker using Trading Technologies order routing, while the secondary route is through Interactive Brokers via their TWS trading platform and API! Additionally, the strategy research and testing is performed with Mechanica using CQG tick data while the results are analysed using R.

Conclusion

Sorry to end up on a cliche but there are no silver bullet to making the choice. If you take away one point is that you need to list your own requirements clearly and make the choice for yourself based on them.

Check that 60-page thread at EliteTrader if you want an endless discussion as to which is the best platform/architecture…

Software and manuals

You can download a fully-functioning Amibroker demo (you cannot with TraderStudio and even when you buy it you have to wait for CDs by post!) which contains some limitations (i.e no more than 5 markets back-tested at a time, etc.).
The manuals are all online and very thorough, complemented with additional articles, presentations and other materials. This makes it very handy (again compared to TradersStudio printed 300 page manual – yet incomplete) as you can search them electronically to look for exactly what you need.

Large Community

The Amibroker community seems much wider and as a result there is loads of available scripts for re-use. There is actually a whole library hosted on amibroker website.
There is also much, much more information available on the internet. As a sample test I googled “Amibroker Donchian” vs. “TradersStudio Donchian”: 23,200 results vs. 17 (including this blog!).
Finally the yahoo group is much more active. There are about 10 times more daily messages (although the TradersStudio one can go days without getting a single message). As an example I posted a question related to the custom backtester and got a useful answer the next day.

The platform

It takes a bit of time to get used to the concept and principles of Amibroker. It is quite different from TradersStudio. For example, all afl files are self-contained and might implement indicator, system, back-test procedure, scan and exploration code all at once (although only one part really runs at once – alightly confusing at first). In TradersStudio you can also define functions to be called in other code files; this does not appear possible in Amibroker (you would have to copy/paste the code over and over again). Both platforms allow you to build COM dlls to code up your functions.

The GUI is different but I would not say better or worse than TradersStudio.The charting forms a more central part of the Amibroker platform and just firing up a chart with several indicators is pretty quick. At first glance the money management/portfolio allocation does not appear very rich in Amibroker (in terms of functionality) but I would have to do more testing to confirm this.

AmiBroker screenshot

The language to create your own indicators, systems, etc. (AFL: Amibroker Formula Language) is based on C and not very hard to pick up especially with the very useful in-line help – it does help to read the tutorials first (!) to get a grasp of the main keywords/built-in functions.

Data loading

Loading the data extracted from CSI Unfair Advantage was fairly straight-forward and there seems to be a bunch of ready-made interfaces with other data vendors in addition to the Amiquote utility – which allows you import quotes in Amibroker. It seems that there is more flexibility in the type of data fields that can be loaded.

Conclusion

Overall I was pretty pleased at what I was able to achieve in a short amount of time. For some reason I found it very hard to get into TradersStudio whereas Amibroker was easier to tackle (once you understand its working concept).
Obviously I have not explored all the functionalities of either software and this is definitely not an exhaustive review. As a result of all this I will be buying a copy of Amibroker to complement (or replace?) TradersStudio. I am sure both platforms each have their pros and cons so having both is probably a good idea (and not a very costly one since Amibroker costs only $200!).

In the last few posts I have been exploring the e-ratio and wrote the code in TradersStudio. I also tried to implement it in AmiBroker AFL language mostly to check how it performed speed-wise – as I found TradersStudio quite slow.

While testing AmiBorker, it actually felt so fast that I decided to perform a more formal speed comparison test.

Conditions of the test

I exported the CSI data via the API for a proportionally back-adjusted Corn contract going back to 1949. The data was imported in both AmiBroker and TradersStudio via their ASCII Import.

The system tested is a simple 20-day Donchian Channel Breakout (Buy-only) and the ATR used to normalise the MAE/MFE is 20-day also.
The optimiser in both systems were used to generate the e-ratio for 50 51 different trade durations (from 10 to 50 days).

One of the condition to validate the results of the test was that the trades generated by both systems are similar (to double-check I did not make a coding mistake resulting in simpler/faster process for one of the platforms).

The computer I was running the test on is a quad-core CPU (2.4 GHz) with 3.25 GB of addressable RAM. Only one platform was running at the time it was tested.

Results are in!

And they look astoninglishly good for AmiBroker:

• The TradersStudio test was run first and took 4 mins 15 sec to complete and produce the custom report (which needs to be manipulated in Excel to calculate the e-ratio). Furthermore, it appeared that every incremental run in the optimisation process took slightly longer than the previous one.
• The AmiBroker test ran in (…drumrolls…) 10 sec! And the e-ratio was readily available from the results grid:
  
  

  AmiBroker optimisation results showing the e-ratio. Click to expand

Both apps maxed out their allocated CPU (i.e. overall CPU usage of 25% = a quarter of the quad-core CPU available).

I then decided to run the AmiBroker code over 5 markets to get a feel of how long it would take. I added Crude Oil (going back to 1985), Cotton (1968), Gold (1975) and Yen (1972).
AmiBroker ran the same code + optimisation in 2 mins 20 sec, twice as fast as one market in TradersStudio!

Applying a simple proportional calculation to derive the time it would take in TradersStudio for the same dataset would give us a completion time of 1 hour (59 min 30 sec exactly…). Since the performance seems to degrade over the course of the optimisation in TradersStudio (i.e. the first back-test is quicker than the last one of the optimisation run) we could assume that it would actually take longer, which is what I experienced when I was testing on similar data in the last few weeks.

So here you have it: AmiBroker is 25 times faster than TradersStudio and it gives you the results in a much more friendly format.

Trade Reconciliation

As mentioned earlier, to ensure that the test was valid, the set of trades generated by both systems should be compared. I ran one back-test of the system over the Corn data for a single optimisation step (e-ratio for 20 days duration) in both systems.

I could find that 296 trades out of 340 presented a very good match (some matches had one day difference on the Entry date and rounding differences on the prices). But overall the trade comparison was good enough to give assurance that the same systems and results were being tested.

I’ll keep investigating for myself where these errors are coming from (and post a further code update if warranted) but we can assume that the differences are trivial with regards to performance comparison.

Did I mention that AmiBroker is 3 times as cheap with a much wider following (many more code samples, better docs, more forums, etc.)?…

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!

The way it works is fairly simple. It is a combination of multiple cycles of “in-sample optimisation” with “out-of-sample verification”.

Background on optimisation and out-of-sample testing

The reason for performing out-of sample verification tests is to check whether the in-sample data optimisation resulted in curve-fitting (over-optimisation) or in a robust system parameters selection.

If the parameters derived from optimisation perform much worse in the out-of-sample verification test, it most likely means that the parameter values were (over-) optimised for the specific in-sample dataset (curve-fitted). If the system performs similarly, it should mean that the system parameters are robust and validate the approach taken for optimisation.

Walk-Forward Process: how it works

Walk-Forward testing is an on-going and dynamic process to determine whether parameters optimisation just curve fits the price and noise or produces statistically valid out-of-sample results. Here is how it works:

Let’s say we have 10 years of data from 1999 to 2009. Optimisation period is three years (in-sample data) and Verification period is one year (out-of-sample data). To begin, you start by optimising your system using only the first three years of data – in this example, 1999-2001. When the system is optimised, record the optimal parameter values and use them in the test with new data (out-of-sample) starting with 2002.

Walk Forward from 1999 to 2009

Slide the three-year window of data forward (2000-2002) and perform the same process. Once you have processed all the data available, you can collate the performance of all out-of-sample tests and compare those to in-sample optimisation runs. If the comparison shows that the system is sufficiently robust to be traded live, you simply continue the walk-forward process in real time by re-optimising every year.

In Closing

Walk-Forward is an adaptive process which re-optimises the system on a continuous basis to adapt its parameters to the most recent market conditions.

The premise of performing several optimisation/verification steps over time is that the recent past is a better environment for selecting system parameters than the distant past. This is an assumption you need to consider when choosing whether to use Walk-Forward testing or not but this is a useful tool in your Systems development arsenal.

As discussed earlier changing system parameters based on recent market conditions could result in a system chasing its tail. The next post on this topic will be an actual comparison of a basic system’s performance when optimised in a “standard way” and when optimised using “Walk-Forward”.

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.

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.