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.
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!
The Foundation Edition. The first in the series.
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.
Hi-Res Edition Cover
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.
Advanced Topics Cover
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.
Get Day Trading Edition Today!
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.
Trend Following Cover.
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
