In part 1 of this bootstrap post, we looked at how to apply the method to establish the statistical significance of a single trading rule. In Part 2, we’ll look at how to deal with the data mining bias, the impact of geometric vs. arithmetic mean return. The code implementing the bootstrap test is available for download at the bottom of this post.

Dealing with Data Mining Bias

The approach described in the single rule test is not valid when performing data mining (whether testing different rules or different parameter values of the same rule). As per the data mining bias (explained previously), the (best) rule selected from the data mining process will invariably owe a large part of its over-performance to random (good) luck.

The way the bootstrap test deals with the data mining bias is by implementing a concept introduced in White’s Reality Check. The Reality Check derives the sampling distribution appropriate to test the statistical significance of the best rule found by data mining.

In effect, the concept is fairly simple – and similar to the single-rule bootstrap: assuming N rules have been tested in the data mining process, each resample iteration will perform a resample with replacement for each rule and the best mean return will be kept as this resample iteration’s test statistic:

1. N back-tests are run on detrended data. The mean daily return, based on x observations, is calculated for each back-tested rule.
2. Each rule’s mean daily return is substracted from the rule’s set of daily returns (zero-centering), This gives a set of adjusted returns for each rule.
3. For each “higher-level” resample (to form the sampling distribution of the best-performing rule in a universe of N rules), perform a “lower-level” resample with replacement on every rule. For each rule select x instances of adjusted returns at random and calculate their mean daily return (rule bootstrapped mean). Compare each rule bootstrapped mean and select the highest one: this is the test statistic of this “higher level” resample (bootstrapped best mean).
4. Perform a large number of “higher level” resamples to generate a large number of bootstrapped best means.
5. Form the sampling distribution of the best means generated in the step above.
6. Derive the p-value of the best back-test mean return (non zero-centered) based on the sampling distribution derived above

In effect: for each iteration, resample each rule, take the best return, keep it as this iteration test statistic and move on to the next iteration. The sampling distribution is formed of each iteration’s best return.

White Reality Check Related Papers

I have not yet found searched hard for White’s paper on the Reality Check but I did find the two following papers which seem to be worth a read:
Stepwise Multiple Testing as Formalized Data Snooping – Romano & Wolf

Abstract:

It is common in econometric applications that several hypothesis tests are carried out at the same time. The problem then becomes how to decide which hypotheses to reject, accounting for the multitude of tests. In this paper, we suggest a stepwise multiple testing procedure which asymptotically controls the familywise error rate at a desired level. Compared to related single-step methods, our procedure is more powerful in the sense that it often will reject more false hypotheses.

Unlike some stepwise methods, our method implicitly captures the joint dependence structure of the test statistics, which results in increased ability to detect alternative hypotheses. We prove our method asymptotically controls the familywise error rate under minimal assumptions. Some simulation studies show the improvements of our methods over previous proposals. We also provide an application to a set of real data.

Re-Examining the Profitability of Technical Analysis with White’s Reality Check and Hansen’s SPA Test
Abstract:

In this paper, we re-examine the profitability of technical analysis using White’s Reality Check and Hansen’s SPA test that correct the data snooping bias. Comparing to previous studies, we study a more complete universe of trading techniques, including not only simple rules but also investor’s strategies, and we test the profitability of these rules and strategies with four main indices. It is found that significantly profitable simple rules and investor’s strategies do exist in the data from relatively young markets (NASDAQ Composite and Russell 2000) but not in the data from relatively mature markets (DJIA and S&P 500). Moreover, after taking transaction costs into account, we find that the best rules for NASDAQ Composite and Russell 2000 outperform the buy-and-hold strategy in most in- and out-of-sample periods. Our results thus suggest that the degree of market efficiency may be related to market maturity. It is also found that investor’s strategies are able to improve on the profits of simple rules and may even generate significant profits from unprofitable simple rules.

Geometric or Arithmetic Mean?

In part 1, I introduced the idea that the mean arithmetic return being positive is not equivalent to the strategy being profitable (ie. this is not a sufficient condition). On the other hand, the mean geometric return being positive is a necessary and sufficient condition to the strategy being profitable (ie. both conditions are equivalent).

Therefore bootstrapping using the mean geometric return as the test statistic should provide a better evaluation of the system’s profitability statistical siginificance.

I will not go into detail of how the calculation is done as it is very similar to the arithmetic mean return, but using log of returns instead. Note that the geometric mean will be a stricter test than the arithmetic mean (a rules can have a significantly positive arithmetic return but a negative geometric return).

To illustrate the multiple applications of the bootstrapping methodology, I decided to run the test on one of the Trend Following Wizards track record (set of monthly returns). I picked Chesapeake and ran the monthly returns (from 1988 to 2009) through the bootstrap test.

The p-value calculated using the arithmetic mean is 0.000098 (less than 1 chance in 10,000 that this kind of results are due to random luck). Using the geometric mean, the p-value is 0.00022. The values are extremely low, which is not surprising given Jerry Parker’s 20-year track record with only one losing year and a monthly average return of 1.7%.

Many people would point out that survivorship bias should be considered, and obviously it depends on how you look at it. The main point of this dual test is that the geometric p-value is higher than the arithmetic p-value, verifying that it is a stricter test of statistical significance.

Bootstrap Code

Finally, here is a tool coded to implement the bootstrap test for a single strategy – available for download. Note that this is distributed “as is”, with no guarantee (but that’s the one I have been using so I still think it does the job…). It should run on any Windows machine with the .Net framework installed (XP or higher should do fine).

It simply takes three parameters (separated by space):

1. Returns file path and name
2. Number of resamples
3. Flag for Arithmetic (A) or Geometric (G) mean calculation

It also generates a file in the same directory with all of the resamples test-statistic values (to draw the histogram).

Simply place the bootstrap.exe in your directory of choice and run it from the command prompt as below:

Run the bootstrap.exe from the command line

Download here:
bootstrap.exe

Related posts:

1. The Bootstrap Test: How significant are your back-testing results?
2. Monte Carlo Permutation: Test your Back-Tests
3. Evidence-Based Technical Analysis

CSI Data Extractor: Utility tool to extract CSI data in plain text files

I have mentioned before that I use CSI as my main provider for Futures data. Overall, I judge CSI’s service as good quality – however one drawback is the closed aspect of the data access. And I decided to write a utility to make it more “open”.

To access the historical data, you have to go through their software (Unfair Advantage), which extracts and decrypts it from their proprietary binary format. You can always “build” historical files to disk, but these are usually pre-processed with a special algorithm (ie. back-adjusted, etc.).

What more, if you decide to stop your subscription to CSI’s data services, you will not be able to access any data any more, even historical data downloaded under the subscription contract.

For some of the reasons above, it might be interesting to be able to extract/store CSI’s raw data in plain text files. This would allow for:

• Browsing the data outside of the CSI’s Unfair Advantage software
• Applying back-adjustment or other manipulation algorithms not supported by CSI’s UA (such as calculating the yield curve)
• Keep the historical data independently of your CSI subscription

Note: what I consider CSI raw data is the actual daily information for each contract traded on any day. For example, in the Corn market, there are currently 15 different contracts trading (with different maturities), each with their own Open, High, Low, Close, Volume and Open Interest.

CSI API to the rescue

Now, you could easily go to Unfair Advantage and pick every single historical contract that you want to extract… but this would be a fairly tedious job

Luckily for us, the API allows for programmatic access to CSI’s data to automate the process of extracting all contracts that we want – so I decided to write a little utility to do just that. And now my data is really mine!

Below is a zip file containing the files to copy to “install” the utility:

CSI-DataExtractor.zip

Note that you need to have Unfair Advantage installed on the machine running this exe (which does not come with any guarantee by the way… but I have been using it fine so far).

The operation is very simple: just enter CSI’s number for the market you want to extract and choose which path the files need to be extracted to.

Hope you’re finding this tool useful…

Related posts:

1. Unfair Advantage API Code (C#): Extract Futures Continuous data
2. How-To: CSI Data into TradersStudio
3. Continuous Contract options

CC picture by almccon@flickr

Improved Vortex indicator

As mentioned in the original Vortex indicator post, I thought there were some flaws that needed to be corrected in the original version published by the authors (Etienne Botes & Douglas Siepman). I have since heard from them .

They gave me a detailed explanation regarding the logic of their design. The most important consideration is that they are using their indicator on Forex – which is a 24-hour market and therefore exhibits virtually no gap. Moreover, I believe they favoured a simple moving average (to Wilder’s exponential one) to add extra lag / beneficial noise filtering.

Anyhow, I still thought that the indicator could be improved for non-Forex markets. I also thought that the process could be taken further by creating the AVX: the Average Vortex Index (similarly to Welles Wilder’s ADX, based on the DMI). Well, I coded that up as well.

Trading Blox blocks for all this code can be downloaded at the end of the article (or in the new free code section).

Updated calculation logic

I started prototyping the calculations in Excel for the original Wilder DMI and ADX, the original Vortex indicator and my improved version. Please find the Excel spreadsheet for your perusal.

As mentioned in the initial Vortex indicator post, the original calculation did not handle gap days appropriately (in my opinion) and was not replicating the smoothing implemented in Wilder’s DMI by the use of an exponential Moving Average (Wilder’s to be precise) for the VI/TR calculation.

The logic implemented is as follows:

VM+ = High - Low[1]

(VM+ is today’s High minus yesterdays’ Low, can be negative, in case of down gaps)

VM- = High[1] - Low

(VM- is yesterday’s High minus today’ Low, can be negative, in case of up gaps)

True Range (TR) is calculated as per the standard formula.

These 3 daily indicators are then smoothed using the “Wilder” exponential moving average (alpha = 1 / N ). These give us AVM+, AVM- and ATR.

Normalise AVM+ and AVM- by ATR to obtain the improved VI+ and VI-.

VI+ =AVM+/ATR
VI- =AVM-/ATR

Building upon these calculations, we can just replicate the ADX logic to create the AVX indicator:

Calculate the VX:

VX = (VI+ - VI-) / (VI+ + VI-) x 100

VX is then smoothed (using Wilder moving average) to produce the AVX.

Now we’re talking!

Note that because VM and VI both have higher values than the original DM and DMI, VX and AVX,which express the relative difference of VI+ and VI-) will not register values as high as the ADX. But that’s ok – it just means we work on a different scale (where AVX>15 might be similar to ADX>60).

Vortex to the test

The vortex indicator can be used as an entry signal (go long when VMI+ crosses above VMI- and go short with the opposite cross). In addition, the AVX can be thought of as a measure of the strength of a directional vortex movement. The entry signal could be enhanced by only taking the signals where the AVX breaches a specific strength threshold (note: this is a very similar logic to the ADX system that ships with Trading Blox).

Calculating the e-ratio for the VMI/AVX entry is a great way to measure the edge of that specific entry.

Another great thing is the Blox marketplace where Trading Blox users share their custom code. And guess what? There was a block available for e-ratio calculation. Great! I love it when I can leverage existing code…

With a bit of updating of the system I managed to run the e-ratio calc on 3 different entry signals:

• Simple VMI cross
• VMI cross with AVX threshold filter (threshold = 10)
• VMI cross with AVX threshold filter (threshold = 15)

Below are the charts for each of the entries:

e-ratio plotted for length of 1 to 100 days

Notice how the AVX threshold does not seem to help and is completely counter-productive in the “AVX>15″ case. In a classic example of curve-fitting / data snooping, we could decide to turn around the AVX threshold logic and only take signals for which the AVX is below 15. But we will not do that. Bad practice ;-)

Conclusion

I was not expecting much out of this study. I was mostly using it as material for getting to use Trading Blox. I was not surprised by either: I found Trading Blox easy to get a handle on. Definitely a productivity boost compared to TradersStudio, both in terms of development and simulation running time.

With regards to the vortex indicator, it does seem to provide a (small) edge when used as the authors intended to (albeit in a modified form). The AVX filtering, on the other hand, did not seem to improve anything at all. Maybe the edge would have been better, had I not “messed up” with the indicator…

Code download

Please find below the individual components (blocks) for download:
improved Vortex Indicator & AVX auxiliary block file (tbx)
AVX Entry Exit block (tbx)
AVX System (tbs)
The lot in a zip file

Related posts:

1. Vortex indicator
2. MMDI Portfolio Filter in Trading Blox
3. Unfair Advantage API Code (C#): Extract Futures Continuous data

Vortex is present in chaotic movements such as fluid mechanics - picture courtesy of NASA

The indicator logic is described in the January issue of TASC (Technical Analysis of Stocks and Commodities) and sounds intriguing (link to PDF article). Without rehashing the details of the indicator calculation, it is very similar to Welles Wilder’s Directional Movement Index Calculation (DMI) except that Wilder’s Directional Movement (largest part of today’s range outside of yesterday’s range) is replaced by calculating the differences between today’s High and yesterday’s Low (positive Vortex Movement) and today’s Low and yesterday’s High (negative Vortex Movement).

TASC provides the Vortex indicator implementations in a wide collection of backtesting platforms (here). Unfortunately the Trading Blox implementation is not provided, which provided me a perfect opportunity to test and learn my new “backtesting toy” out.

System Logic Flaw?

The authors of the indicator provide a sample Excel spreadsheet to illustrate their calculation. By replicating the logic in Excel to get a handle on it (link to Excel spreadsheet), I uncovered what I think is a flaw in the logic of the indicator of the calculation.

The VM calculations take the absolute value of the difference of opposite price extremes (High and Low) between today and yesterday. The screenshot of this Excel spreadsheet below clearly illustrates that this is a problem when dealing with gaps.

Additionally, one could argue that the simple summation/averaging of the VMs is different from the original DMI calculations which use Wilder Moving Averages.

I have emailed the authors of the indicator with a suggestion for a fix. I’ll relay their answer here.

Trading Blox implementation

First and foremost, this is a Trading Blox coding exercise so I was not too concerned about these flaws (although I might be tempted to implement my own version addessing both flaws later).

I suggest you follow the calculation logic on the PDF article or the Excel spreadsheet. Here is how I implemented the Vortex Indicator in Trading Blox:

1: Create Auxiliary Block

This will hold all indicators and implement their calculations. Call it Vortex Indicator.

2: Create parameters

There is one parameter: the period for the Vortex indicator (VI) calculation:

3: Create Indicators

These are the first-level calculations: the daily True Range (TR), and VM+ (plusVM) and VM- (minusVM).

VM+ indicator using a calculated formula

The code for each of these indicators is:

plusVM (VM+ is the difference between today’s High and yesterday’s Low):

Abs(instrument.High - instrument.Low[1])

minusVM (VM- is the difference between today’s Low and yesterday’s High):

Abs(instrument.High[1]-instrument.Low)

TR (standard True Range calculation):

Max(instrument.High-instrument.Low,Abs(instrument.High-instrument.Close[1]), Abs(instrument.Low-instrument.Close[1]))

4: Create Instrument Permanent Variables (IPV)

This is for next-level calculations (Sum of TR, Sum of VM+ and VM-, VI+ and VI-). Setting these up as IPV allow for their values to be made available to other blocks (such the Entry block of a system).

Notice how the variable scope has been updated to System

The values for these IPVs are updated in the block Update Indicators script:

plusVMSum=Sum(plusVM,viDays,0)
minusVMSum=Sum(minusVM,viDays,0)
TRSum=Sum(TR,viDays,0)
plusVI=plusVMSum/TRSum
minusVI=minusVMSum/TRSum

Use in Trading Blox

Adding the auxiliary block to any System will enable it to access the values of the vortex indicators.

Here is how it could be done for a simple reversal system switching from Short to Long when VI+ crosses with VI- (and vice-versa).

Create an Entry Exit block

The system will have the Vortex Indicator Auxiliary block and our new Entry Exit block.

Add VI+ and VI- as IPV to the Entry Exit block

This is just a declaration to indicate that the values of these indicators are calculated in another block (our Vortex Indicator Auxiliary block).

The IPV is defined externally in another block (Vortex indicator)

The other parameters and indicators in this block are standard ATR Stop elements.

Code up the entry formula

Simple logic to enter long when VI+ is above VI- and no long position are in and opposite for short entry:

VARIABLES: pvi TYPE: Floating
pvi = plusVI
VARIABLES: nvi TYPE: Floating
nvi = minusVI	
VARIABLES: pos TYPE: String
pos = instrument.position
 
IF 	plusVI > minusVI AND
	instrument.position <> LONG THEN
 
	IF useATRStops THEN
		broker.EnterLongOnOpen( instrument.close - averageTrueRange * atrStop )
	ELSE
		broker.EnterLongOnOpen
	ENDIF
 
ENDIF
 
IF	plusVI < minusVI AND
	instrument.position <> SHORT THEN
 
	IF useATRStops THEN
		broker.EnterShortOnOpen( instrument.close + averageTrueRange * atrStop )
	ELSE
		broker.EnterShortOnOpen
	ENDIF
 
ENDIF

Trading Blox test

Although I would like to do a more complete test to compare the Vortex Indicator to the DMI, all I have time left for today is a simple run of the system described above. I arbitrarily chose 39 for the VI period and here is the result:

Logarithmic Equity curve from Vortex indicator system

And as a side note of caution when dealing with backtest results, I’ll show you a quick trick that will allow me to nearly double the CAGR (Compounded Annual Growth Rate) by not touching the system at all:

Logarithmic Equity curve from Vortex indicator system (truncated period)

Notice what happened there: I just dropped years 1996 to 1999 from the backtests. Et voila! Surely a trick employed by more than one dubious trading systems salesmen…

Conclusion

The authors claim that the Vortex indicator improve on the DMI invented by Welles Wilder Update: the authors have sent me an email to clarify that they have not made such claim (I was merely interpolating, given the ressemblance of the Vortex indicator with the DMI). It would be interesting to test this as the idea of mixing chaos/fluid mechanics concepts to price movements is appealing. Fixing the indicator flaws would be good too. More to come… (update: on the next post, I also explain the authors response to my claim of the indicator having flaws).

Code download

Please find below the individual components (blocks) for download:
link to Vortex indicator block file (tbx)
link to VI sample Entry Exit block (tbx)

Related posts:

1. New: Free Code section – and improved Vortex
2. MMDI Portfolio Filter in Trading Blox
3. e-ratio calculation in TradersStudio and Excel

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

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

Getting started with the API

Fire up your favourite IDE/language that supports COM Interoperability (I am using Visual C# 2008 Express Edition), start Console Application project and add a reference to the Unfair Advantage API. For this you just need to “Add reference” and browse to the Unfair Advantage installation folder and select the main EXE (uad.exe). This gives access to the CSI UA API.

Add UA into your project and "Bob's your Uncle!"

Simple extraction code

The rest is fairly simple as long as you understand the RetrieveBackAdjustedContract2 parameters.
The code below takes 2 parameters: an input file name containing the list of markets to extract and a folder name to extract each continuous contract to. It sets specific UA session parameters and calls the RetrieveBackAdjustedContract2 with specific variables to obtain the concatenation desired. Each continuous contract is output to a folder in a .txt file.
The file containing the list of markets is of the following format (CSI number, Symbol, Market name):
…
8,CT,Cotton
…

The code

Please find the code there (very nicely formatted thanks to this great tool by manoli). You can also download the Program.cs file:

Related posts:

1. I just got myself an Unfair Advantage…
2. Continuous Contract options
3. Unfair Advantage API: Retrieve Back-Adjusted Contracts function