for iCnt = 0 to 3
begin
if lastTradeLoser then
begin
if mp <> -1 and currentContracts = iCnt * lotSize then
begin
buyPrice = hh20 + iCnt * N/2;
end;
if mp <> 1 and currentContracts = iCnt * lotSize then
begin
sellPrice = ll20 - iCnt * N/2;
end;
virTmp = 0;
end;
if lastTradeLoser = false then
begin
if mp <> -1 and currentContracts = iCnt * lotSize then
begin
buyPrice = hh55 + iCnt * N/2;
end;
if mp <> 1 and currentContracts = iCnt * lotSize then
begin
sellPrice = ll55 - iCnt * N/2;
end;
virTmp = 0;
end;
end;
MultiCharts is a very powerful program that can be purchased outright and seems to be very compatible with EasyLanguage. Their software requires a third-party data feed or ASCII data.
This just happened recently in the bond market. The LastTradeLoser filter prevented the Turtle 20 bar low entry from occurring. As you can see from the prior trade – it was a winner.
The following code uses our new functions to synthetically keep track of our trading to determine when to enter a new trade. The Turtle System only took trades after a losing trade took place. Even with the Virtual Trade functions you still need to keep track of whether the entries/exits generated a profitable trade. It simple enough to track the real trades – compare the entries/exits when a the market position changes.
inputs: absEntryChanLen(55),entryChanlen(20),exitChanLen(10),lastTradeLoserFilter(false);
vars:lastTradeLoser(true),mp(0),virtmp(0),tradeProfit(0),virtBuyPrice(0),virtSellPrice(0),
myFillPrice(0);
mp = marketPosition;
If mp <> 1 and mp[1] = 1 then
Begin
tradeProfit = ExitPrice(1) - EntryPrice(1);
If tradeProfit > 0 then lastTradeLoser = false;
print(date," Long Trader ",tradeProfit);
end;
If mp <> -1 and mp[1] = -1 then
Begin
tradeProfit = EntryPrice(1) - ExitPrice(1);
If tradeProfit > 0 then lastTradeLoser = false;
print(date," Short Trader ",tradeProfit," ",lastTradeLoser);
end;
If lastTradeLoserFilter = False then lastTradeLoser = True;
If lastTradeLoser = False then
Begin
print(date," In Virtual Section And VirtTmp = ",virTmp);
If(virtmp = 1) then
Begin
if(virtualLongExit(lowest(low[1],exitChanLen),1,myFillPrice) =1) then
Begin
tradeProfit = myFillPrice - virtBuyPrice;
If tradeProfit < 0 then lastTradeLoser = true;
virtmp = 0;
end;
end;
If(virtmp = -1) then
Begin
if(virtualShortExit(highest(high[1],exitChanLen),1,myFillPrice) =1) then
Begin
tradeProfit = virtSellPrice - myFillPrice;
If tradeProfit < 0 then lastTradeLoser = true;
virtmp = 0;
end;
end;
if(virtualBuy(highest(high[1],entryChanLen),1,myFillPrice) = 1) then
Begin
if virtmp <> 1 then
begin
virtBuyPrice = myFillPrice;
virtmp = 1;
tradeProfit = 0;
If virtmp[1] = -1 then tradeProfit = virtSellPrice - virtBuyPrice;
If tradeProfit < 0 then lastTradeLoser = true;
end;
end;
if(virtualSell(lowest(low[1],entryChanLen),1,myFillPrice) = 1) then
Begin
if virtmp <> -1 then
begin
virtsellPrice = myFillPrice;
virtmp = -1;
tradeProfit = 0;
If virtmp[1] = 1 then tradeProfit = virtBuyPrice - virtSellPrice;
If tradeProfit < 0 then lastTradeLoser = true;
end;
end;
print("End of Virtual Module : virTmp = ",virTmp);
end;
My next little project is to create an EasyLanguage extender by creating a virtual trading function. The Turtle System always waits until a losing trade prior to taking a new trade. In EasyLanguage this doesn’t exist. This is similar to my Ghost Trader in Building Winning Trading Systems with TradeStation (1st and 2nd edition.)
In order to virtualize theoretical positions you must have the ability to enter/exit long/short positions. To carry this out we will create four functions:
Information will need to be passed back and forth between the call program and the functions. Here is the template of the virtualBuy:
Inputs: price(numericSimple),orderType(numericSimple),fillPrice(numericRef);
{Function to see if a virtual buy order was filled - we are passing the entry price, orderType
[stop,limit,market] and we will reply with with true or false and the fill price.
orderType:
1 - Stop
2 - Limit
3 - Market}
VirtualBuy = 0;
Switch(orderType)
Begin
Case 1:
If high >= price then
Begin
fillPrice = maxList(open,price); {check for gap open}
VirtualBuy = 1;
end;
Case 2:
If low < price then
Begin
fillPrice = minList(open,price); {check for gap open}
VirtualBuy = 1;
end;
Case 3:
Begin
fillPrice = open;
VirtualBuy = 1;
end;
Default:
fillPrice = 999999;
VirtualBuy = 0;
End;
Here is a nice little function that helps determine market choppiness. This function measures the actual distance the market moves against the total distance traveled. If the market starts in the lower left of your chart and moves, without much gyrations, to the upper right then the CMI will reflect a higher value. However if the market moves frantically around the chart and doesn’t achieve a great distance from the initial to the end points then the CMI will reflect a lower number.
Inputs: periodLength(NumericSimple);
Vars: num(0),denom(1);
if(periodLength<>0)then
begin
denom = Highest(High,periodLength) - Lowest(Low,periodLength);
num =Close[periodLength - 1]- Close;
num = AbsValue(num);
if (denom <> 0) then ChoppyMarketIndex = num/denom * 100;
end;
You can use the CMI function to help determine when you should follow a Turtle style break out. If the market has been trading in a range and you get a break out it might just carry a little more validity. Buying/Selling at really high/low prices may lead to false break outs.
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