It has been brought to my attention by a very astute reader of the book that the ordering of the buy/sell/longliq/shortliq directives creates a potential error by giving preference to entries. The code in the book and my examples thus far test for a true condition first in the entry logic and then in the exit logic. Let’s say your long exit stop in the Euros is set at 11020, but your reversal is set at 11000. The python back tester will skip the exit at 11020 and reverse at 11000. This only happens if both stops are hit on the same day. If this happens you will incur a 20 point additional loss. You can prevent this by using logic similar to:
if ((mp == 0 or (mp == -1 and stb < stopb)) and myHigh[D0] >= stb) :
Eliminate Reversal Bias
Notice bow I compare the price level of stb and stopb [stb – reversal and stopb – liquidation]. I added this to the long entry logic – the code is only executed if the entry is less than the exit (closer to the current market). I am in the process of restructuring the flow so that all orders will be examined on a bar by bar basis and the ones that should take place (chronologically speaking) will do so and be reflected in the performance metrics. This can cause multiple trades on a single bar. This is what happens in real trading and should be reflected in the PSB. This is where the lack of a GOTOcreates a small headache in Python. The ESB already takes this into consieration. I will post when I finalize the code.
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.
Backtesting with [Trade Station,Python,AmiBroker, Excel]. Intended for informational and educational purposes only!
9237
Get All Four Books in the Easing Into EasyLanguage Series - The Day Trade Edition is now Available!
Announcement – A Day Trade Edition will be added to my Easing Into EasyLanguage Series this year! This edition will be the fourth installment and will utilize concepts discussed in the Hi-Res and Advanced Topics editions. I will show how to develop and program algorithms that will enter after the open of the day and get out before the market closes. Hence, no overnight exposure. Most examples will be carried out on the mini Dow, Nasdaq, S&P500 and Russel. The programming skills that you will learn can be carried to any market that provides enough bang for the buck to day trade. Look for this edition later this year. But get geared up for it by reading the first three editions in the series now. Get your favorite QUANT the books they need!
The Cover of my latest book. The first in the series.
Hello to All! The Easing Into EasyLanguage Series is now complete with the publication of the Advanced Topics Edition. This series includes three educational editions. 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. All source code is available too, and if you have TradeStation, so are the workspaces. Plus you can always email George for any questions. george.p.pruitt@gmail.com.
Hi-Res Edition Cover
This book is for those that have read the Foundation Edition or have some experience working with EasyLanguage and the various functions that help make a trading decision. This book’s audience will be those programmers that want to take an idea, that requires an observation of intraday market movements to make a trading decision, and program it accurately. If you have programmed daily bar systems, and you want to drill down and add some components that require additional market information (like what came first – the high or the low), then you have come to the right place. If you want to buy and sell short in the same day and use trade management principles such as profit targets and stop losses then The Hi-Res Edition is the book you need. There are two paradigms that EasyLanguage covers: daily and intraday bar programming. It’s the same language, but the move from daily to intraday programming can be quite difficult. Learn all the essentials and shortcuts with this edition. 5 HOURS OF VIDEO INSTRUCTION in this Hi-Res edition – one for each tutorial. All source code is available too, and if you have TradeStation, so are the workspaces. Plus you can always email George for any questions. george.p.pruitt@gmail.com.
Advanced Topics Cover
Advanced Topics (AT) could cover a vast amount of ideas and concepts and be the length of “War and Peace” on steroids. Since this book is part of the series, I wanted to cover a handful of concepts that included the follow programming constructs. Arrays and their manipulation. Buffers (fixed length arrays) and the tools to maintain buffer elements with formulas for extraction and sorting. Finite State Machines using the switch-case construct and range based case values. Using original text graphic objects and retrieving and analyzing their properties to determine X and Y coordinate values of text location. Seasonality: The Ruggiero/Barna Universal Seasonal and the Sheldon Knight Seasonal methods. In AT, you will also find an introduction to EasyLanguage’s Project Concept and the steps to create one by adding/deleting component files. TradeStation now provides access to fundamental data such as Commitment of Traders – learn how to convert the Net Change indicator into a strategy utilizing the FundValue functionality. If you wanted to find out how to merge multiple time frames into a single indicator, you are in luck! Create a MTF indicator for yourself.
Get Day Trading Edition Today!
Day Trading (DT) – This is a surprise installment in my Easing into EasyLanguage Series, as I had only intended on three books. However, I think it will fit well with the other books. Daytrading is a very popular approach as overnight risk is eliminated. Don’t worry there is plenty of risk during the day too! However, it can be very difficult to accurately program a trading idea on higher resolution data such as five- or one-minute bars. Like my other books, there is no “Holy Grail” included. And if you are looking for a book that gets in and out of a trade in a few seconds, this is not the one for you. I discourage trading more than a handful of trades per day – this is best left up to the professionals. But, if you want to learn about volatility-based break outs, pyramiding, scaling out, zone-based trading, accurate trade accounting and having a peek at algorithms that once ruled the systematic daytrading industry, then this is the book for you. A beginner might have a little difficulty in following along with the tutorials. If you have read the first two books (Foundation and Hi-Res) in this series, you are good to go. Or if you have some experience working with EasyLanguage and minute data, you will be OK as well.
Pick up your copies today – e-Book or paperback format – at Amazon.com
9237
