I have just wrapped up the latest version of the Python System Back-tester (PSB).
I have added some more portfolio performance metrics and you will see these in the performance reports. The most useful addition is the concept of the .POR file when you run a system. Instead of having to select your data files each time you run a system, you can build a .POR file with a list of files/markets you want to batch run.
Here is an example of a Portfolio file:
TY.CSV
CU.CSV
SB.CSV
S2.CSV
QG.CSV
QM.CSV
C2.CSV
Just make sure you put the .POR file inside the same folder that contains your testing data. I have included a TestPortfolio.por file in version 2.0. I would treat the different versions as completely separate applications. Your existing .py algorithm files will need to be slightly modified to work with version 2.0.
This line is near the bottom of the overall loop. I added the initCapital variable so you could do position sizing and the performance metrics would reflect this initial value.
And set initCapital to a pertinent value. I put it right below the sysName variable:
sysName = ‘BollingerBandSys’ #System Name here
initCapital = 100000 #starting account balance
Also I corrected a small bug in the main loop. You should change this:
for i in range(len(myDate) – numBarsToGoBack,len(myDate)):
to
for i in range(len(myDate) – (numBarsToGoBack-rampUp),len(myDate)):
In another post I will show how the portfolio performance metrics have changed. I hope you like the new version. I will be adding a library of trading systems utilizing this new version in a few days.
If you want to download Version 2.0 – just go the the following link
All the unnecessary lines of the Python System Back-Testing Module have been hidden. Only the lines that you need to develop the next great algorithm are included. Reads sort of like English. This snippet introduces you to the use of functions and lists – two major components of the Python language. If you buy my latest book – “The Ultimate Algorithmic Trading System Toolbox” then simply email me or sign up through the contact form and you will get version 2.0 for free!
It was recently brought to my attention that the Excel System Back-Tester(ESB) did not function properly on the MAC OS X. In other words it bombed when trying to open a comma delimited data file and also when one tried to run an algorithm. Thanks to a purchaser of the UATSTB I was able to fix the bugs without removing any functionality. I will post the Macintosh version here as well as have WILEY put it on the book’s website. Sorry for any inconvenience this may have caused. Here is the the link:
The Turtle N or Volatility is basically a 20-day Average True Range in terms of Dollars. This amount is considered the market volatility. In other words the market, based on the average, can either move up or down by this amount. It can move much less or much further; this is just an estimate. If the market moves 2 N against a position, then as a Turtle you were to liquidate your stake in that commodity. The logic indicates that if the market has a break out and then moves 2 N in the opposite direction, then the break out has failed. First the code must be defined to represent the market volatility. This is simple enough by using the sAverage function call and passing it the trueRanges and 20 days. There’s no use in converting this to dollars because what we want is a price offset. Once a position is entered the turtleN is either added to the price [short position] or subtracted from the price [long position] to determine the respective stop levels. Look at lines 2, 8 and 17 to see how this is handled. An additional trade code block must be added to facilitate this stop. Lines 17 to 28 takes care of exiting a long position when the market moves 2 N in the opposite direction. This new stop is in addition to the highest/lowest high/low stops for the past 10 -20 days.
How many of you believe if the last trade was a winner, the probability of the next trade being a loser is higher? The Turtles believed this and in this post I introduce the concept of filtering trades based on the prior trade’s success.
Check for yourself – you will notice that a trade after a winner is skipped. Trades are not picked back up until a loser is reported. Trading like this is quite easy but backtesting is quite a bit more difficult. I talk about this in the book where you have to switch between actual trading and simulated trading. The beauty of the Python BackTester is that it is somewhat easy to incorporate this into the testing logic. All you have to do is determine if the prior real or simulated trade is a loser. If it isn’t then you still must keep track of all trades, but don’t book the trades that follow the winner. I have created a testing module that does just that. Here is a snippet of the code:
# Short Logic
if (mp == 0 or mp == 1) and barsSinceEntry > 1 and myLow[i] <= ll20: profit = 0 price = min(myOpen[i],ll20) numShares = max(1,int(dollarRiskPerTrade/(atrVal*myBPV))) if mp >= 1:
profit,trades,curShares=exitPos(price,myDate[i],"RevLongLiq",curShares,lastTradeLoser)
if lastTradeLoser < 1 : listOfTrades.append(trades) todaysCTE = profit if profit > 0 :
if lastTradeLoser < 0 : lastTradeLoser = 0 if lastTradeLoser > 0 : lastTradeLoser +=1
else:
lastTradeLoser = -1
mp = 0
mp -= 1
tradeName = "Turt20Shrt"
marketPosition[i] = mp
entryPrice.append(price)
entryQuant.append(numShares)
curShares = curShares + numShares
trades = tradeInfo('sell',myDate[i],tradeName,entryPrice[-1],numShares,1)
barsSinceEntry = 1
if lastTradeLoser < 1:
listOfTrades.append(trades) <strong># book the trade if lastTradeLoser < 1 else don't</strong>
totProfit += profit <strong># book the profit from the trade</strong>
Turtle Part 1
I will include this in an update to the Python backtester for registered users of this site.
I include the Python Backtester in my latest book “The Ultimate Algorithmic Trading System Toolbox” book. A good tutorial on how to use it would be to program the Turtle Algorithm in three different parts. Here is part 1:
Entry Description: Buy on stop at highest high of last twenty days. Short on lowest low of last twenty days.
Exit Description: Exit long on stop at lowest low of last ten days. Exit short on highest high of past ten days.
Position Sizing: Risk 2% of simulated 100K account on each trade. Calculate market risk by utilizing the ten day ATR. Size(shares or contracts) = $2,000/ATR in dollars.
#Long Entry Logic
if (mp==0 or mp==-1) and barsSinceEntry>1 and myHigh[i]>=hh20:
profit = 0
price = max(myOpen[i],hh20)
numShares = max(1,int(dollarRiskPerTrade/(atrVal*myBPV)))
tradeName = "Turt20Buy"
#Short Logic
if (mp==0 or mp==1) and barsSinceEntry>1 and myLow[i] <= ll20:
profit = 0
price = min(myOpen[i],ll20)
numShares = max(1,int(dollarRiskPerTrade/(atrVal*myBPV)))
tradeName = "Turt20Shrt"
#Long Exit Loss
if mp >= 1 and myLow[i] <= ll10 and barsSinceEntry > 1:
price = min(myOpen[i],ll10)
tradeName = "Long10-Liq"
#Short Exit Loss
if mp <= -1 and myHigh[i] >= hh10 and barsSinceEntry > 1:
price = max(myOpen[i],hh10)
tradeName = "Shrt10-Liq"
Turtle Part 1
This snippet only contains the necessary code to use in the Python Backtester – it is not in its entirety.
This algorithm utilizes a fixed fractional approach to position sizing. Two percent or $2000 is allocated on each trade and perceived market risk is calculated by the ten-day average true range (ATR.) So if we risk $2000 and market risk is $1000 then 2 contracts are traded. In Part 2, I will introduce the N risk stop and the LAST TRADE LOSER Filter.
If you haven’t come across the great data resource Quandl.com I highly suggest in doing so. A portion of the data that I used in writing my latest book came from Quandl, specifically the wiki futures or CHRIS database. Here is the link:
There is a ton of free futures data. The different contracts are concatenated into large files. However, the rollover discount is not taken into consideration so the data “as-is” is somewhat un – testable. I am in the process of scrubbing the data as well as creating a “Panama” adjustment to the contracts in the large files. As soon as I complete this task I will provide the data on this website. Purchasers of my latest book will find 10+ plus years of history of continuous futures data that I pieced together from several different sources, including Quandl.
Here is a quick video that shows how to create a custom symbol list in TradeStation’s Portfolio Maestro. I describe this in my new book, “The Ultimate Algorithmic Trading System Toolbox.” The books should be released in May.
[follow_me]I was speaking with Mike Chalek on the phone this weekend concerning Data Aliasing and he felt this post was a little confusing. After re-reading it I can see where he is coming from. Using the same example let me see if I can clarify: assume the trading day is Wednesday and you want to keep track of the slope of a 19-day weighted moving average of data2 (weekly bars) by using a variable. The following code will give an erroneous result:
wAvg = wAverage(c of data2,19);
mySlope = wAvg – wAvg[1];
If you interrogate mySlope intra-week then it will always be equal to zero. The wAvg is by default tied to data1 which in this case is daily bars. So the value of wAvg is carried over from one day to the next. It only changes when the average of the weekly bar changes and that only occurs on Friday.
There are two possible solutions:
Without the use of data aliasing – inLine function calls
mySlope = wAverage(c of data2,19) – wAverage(c[1] of data2,19) ;
With the use of data aliasing –
vars: wAvg(close of data2,0);
wAvg = wAverage(c of data2,19);
mySlop = wAvg – wAvg[1];
Either examples will work, but if you have several variables tied to a different data stream, then the code will be much cleaner looking using data aliasing – plus it cuts down on multiple function calls.
I have been working on a project where the strategy combined daily and weekly bars. Keeping track of the two time frames was, at one time, not that easy. However, with TradeStation’s Data Aliasing it is no problem at all. We all know that Data 1 is the highest resolution time frame and is the one used for trade execution. Data 2 can be a different market or a different time from of the same market. TradeStation allows for multiple data streams. Take a look at the following output in table 1. Wavg is a nine period moving average of weekly crude data. Wavg[1] is the prior value of the moving average. If you wanted to make a trading decision on a daily bar basis by looking at the slope of the Wavg you couldn’t. The Wavg and Wavg[1] only changes at the beginning of the next week. Most traders want to be able to make a trading decision intra-week by examining the current values of the Davg1, Davg2 and the slope of Wavg. During the week the slope of Wavg is ZERO.
Now look at table 2. The Wavg is not being updated on a daily basis but on a weekly basis. The current Wavg doesn’t become the prior Wavg on each daily bar. Wavg[1] stays the same until a new weekly bar occurs. You can now make a trading decision intra-week by examining the slope of the Wavg. Each time frame update should only occur when a new bar of that same time frame is generated. This feature is really cool and is easy to implement.
Here is the code that utilizes Data Aliasing. All I did was declare the weekly avg variable and tied it to data2.
vars: mavShortDaily(0),mavLongDaily(0);
vars: mavWeekly(0,data2);
mavShortDaily = average(c,19);
mavLongDaily = average(c,39);
mavWeekly = average(C of data2, 9);
If mavShortDaily > mavLongDaily and mavWeekly > mavWeekly[1] then buy this bar on close;
If mavShortDaily < mavLongDaily and mavWeekly < mavWeekly[1] then sellshort this bar on close;
print(date," ",mavShortDaily," ",mavLongDaily," ",mavWeekly," ",mavWeekly[1]);
Notice how the variable mavWeekly was tied to data2. When you delcare a variable that is tied to another data other than data1 you can put the data stream right in the variable delcaration : mavWeekly(0,data2).
Backtesting with [Trade Station,Python,AmiBroker, Excel]. Intended for informational and educational purposes only!
Get All Five Books in the Easing Into EasyLanguage Series - The Trend Following Edition is now Available!
Announcement – A Trend Following edition has been added to my Easing into EasyLanguage Series! This edition will be the fifth and final installment and will utilize concepts discussed in the Foundation editions. I will pay respect to the legends of Trend Following by replicating the essence of their algorithms. Learn about the most prominent form of algorithmic trading. But get geared up for it by reading the first four editions in the series now. Get your favorite QUANT the books they need!
This series includes five editions that covers the full spectrum of the EasyLanguage programming language. Fully compliant with TradeStation and mostly compliant with MultiCharts. Start out with the Foundation Edition. It is designed for the new user of EasyLanguage or for those you would like to have a refresher course. There are 13 tutorials ranging from creating Strategies to PaintBars. Learn how to create your own functions or apply stops and profit objectives. Ever wanted to know how to find an inside day that is also a Narrow Range 7 (NR7?) Now you can, and the best part is you get over 4 HOURS OF VIDEO INSTRUCTION – one for each tutorial.
This book is ideal for those who have completed the Foundation Edition or have some experience with EasyLanguage, especially if you’re ready to take your programming skills to the next level. The Hi-Res Edition is designed for programmers who want to build intraday trading systems, incorporating trade management techniques like profit targets and stop losses. This edition bridges the gap between daily and intraday bar programming, making it easier to handle challenges like tracking the sequence of high and low prices within the trading day. Plus, enjoy 5 hours of video instruction to guide you through each tutorial.
The Advanced Topics Edition delves into essential programming concepts within EasyLanguage, offering a focused approach to complex topics. This book covers arrays and fixed-length buffers, including methods for element management, extraction, and sorting. Explore finite state machines using the switch-case construct, text graphic manipulation to retrieve precise X and Y coordinates, and gain insights into seasonality with the Ruggiero/Barna Universal Seasonal and Sheldon Knight Seasonal methods. Additionally, learn to build EasyLanguage projects, integrate fundamental data like Commitment of Traders, and create multi-timeframe indicators for comprehensive analysis.
The Day Trading Edition complements the other books in the series, diving into the popular approach of day trading, where overnight risk is avoided (though daytime risk still applies!). Programming on high-resolution data, such as five- or one-minute bars, can be challenging, and this book provides guidance without claiming to be a “Holy Grail.” It’s not for ultra-high-frequency trading but rather for those interested in techniques like volatility-based breakouts, pyramiding, scaling out, and zone-based trading. Ideal for readers of the Foundation and Hi-Res editions or those with EasyLanguage experience, this book offers insights into algorithms that shaped the day trading industry.
For thirty-one years as the Director of Research at Futures Truth Magazine, I had the privilege of collaborating with renowned experts in technical analysis, including Fitschen, Stuckey, Ruggiero, Fox, and Waite. I gained invaluable insights as I watched their trend-following methods reach impressive peaks, face sharp declines, and ultimately rebound. From late 2014 to early 2020, I witnessed a dramatic downturn across the trend-following industry. Iconic systems like Aberration, CatScan, Andromeda, and Super Turtle—once thriving on robust trends of the 1990s through early 2010s—began to falter long before the pandemic. Since 2020 we have seen the familiar trends return. Get six hours of video instruction with this edition.
Pick up your copies today – e-Book or paperback format – at Amazon.com