I didn’t say a very good Free System! This code is really cool so I thought I would share with you. Take a look at this rather cool picture.
Six Bar Break Out with Volatility Buffer and Volatility Trailing Stop
Thanks to a reader of this blog (AG), I got this idea and programmed a very simple day trading system that incorporated a volatility trailing stop. I wanted to make sure that I had it programmed correctly and always wanted to draw a box on the chart – thanks to (TJ) from MC forums for getting me going on the graphic aspect of the project.
Since I have run out of time for today – need to get a haircut. I will have to wait till tomorrow to explain the code. But real quickly the system.
Buy x% above first y bar high and then set up a trailing stop z% of y bar average range – move to break-even when profits exceed $w. Opposite goes for the short side. One long and one short only allowed during the day and exit all at the close.
if barCount >= startTradeBars then begin volAmt = average(range,startTradeBars); if barCount = startTradeBars then begin longStop = highToday + breakOutVolPer * volAmt; shortStop = lowToday - breakOutVolPer * volAmt; end; if t < endTradeTime then begin if longsToday = 0 then buy("volOrboL") next bar at longStop stop; if shortsToday = 0 then sellShort("volOrboS") next bar shortStop stop; end;
trailVolAmt = volAmt * trailVolPer; if mp = 1 then begin longsToday +=1; if c > entryPrice + breakEven$/bigPointValue then longTrail = maxList(entryPrice,longTrail); longTrail = maxList(c - trailVolAmt,longTrail); sell("L-TrlX") next bar at longTrail stop; end; if mp = -1 then begin shortsToday +=1; if c < entryPrice - breakEven$/bigPointValue then shortTrail = minList(entryPrice,shortTrail); shortTrail = minList(c + trailVolAmt,shortTrail); buyToCover("S-TrlX") next bar at shortTrail stop; end; end; setExitOnClose;
if barCount >= startTradeBars then begin volAmt = average(range,startTradeBars); if barCount = startTradeBars then begin longStop = highToday + breakOutVolPer * volAmt; shortStop = lowToday - breakOutVolPer * volAmt; for iCnt = 0 to startTradeBars-1 begin plot1[iCnt](longStop,"BuyBO",default,default,default); plot2[iCnt](shortStop,"ShrtBo",default,default,default); end;
end; if t < endTradeTime then begin if longsToday = 0 and h >= longStop then begin mp = 1; mEntryPrice = maxList(o,longStop); longsToday += 1; end; if shortsToday = 0 and l <= shortStop then begin mp = -1; mEntryPrice = minList(o,shortStop); shortsToday +=1; end; plot3(longStop,"BuyBOXTND",default,default,default); plot4(shortStop,"ShrtBOXTND",default,default,default); end;
trailVolAmt = volAmt * trailVolPer;
if mp = 1 then begin if c > mEntryPrice + breakEven$/bigPointValue then longTrail = maxList(mEntryPrice,longTrail);
longTrail = maxList(c - trailVolAmt,longTrail); plot5(longTrail,"LongTrail",default,default,default); end; if mp = -1 then begin if c < mEntryPrice - breakEven$/bigPointValue then shortTrail = minList(mEntryPrice,shortTrail); shortTrail = minList(c + trailVolAmt,shortTrail); plot6(shortTrail,"ShortTrail",default,default,default); end; end;
Cool code for the indicator
Very Important To Set Indicator Defaults Like This
For the BO Box use these settings – its the first 4 plots:
Use these colors and bar high and bar low and set opacity
The box is created by drawing thick semi-transparent lines from the BuyBo and BuyBOXTND down to ShrtBo and ShrtBOXTND. So the Buy components of the 4 first plots should be Bar High and the Shrt components should be Bar Low. I didn’t specify this the first time I posted. Thanks to one of my readers for point this out!
Use bar low for ShrtBo and ShrtBOXTND plots
Also I used different colors for the BuyBo/ShrtBo and the BuyBOXTND/ShrtBOXTND. Here is that setting:
The darker colored line on the last bar of the break out is caused by the overlap of the two sets of plots.
Here is how you set up the trailing stop plots:
Make Dots and Make Then Large – I have Red and Blue Set
Since this is part 1 we are just going to go over a very simple system: SAR (stop and reverse) at highest/lowest high/low for past 20 days.
A 2D Array in EasyLanguage is Immutable
Meaning that once you create an array all of the data types must be the same. In a Python list you can have integers, strings, objects whatever. In C and its derivatives you also have a a data structure (a thing that stores related data) know as a Structure or Struct. We can mimic a structure in EL by using a 2 dimensional array. An array is just a list of values that can be referenced by an index.
array[1] = 3.14
array[2] = 42
array[3] = 2.71828
A 2 day array is similar but it looks like a table
array[1,1], array[1,2], array[1,3]
array[2,1], array[2,2], array[2,3]
The first number in the pair is the row and the second is the column. So a 2D array can be very large table with many rows and columns. The column can also be referred to as a field in the table. To help use a table you can actually give your fields names. Here is a table structure that I created to store trade information.
trdEntryPrice (0) – column zero – yes we can have a 0 col. and row
trdEntryDate(1)
trdExitPrice (2)
trdExitDate(3)
trdID(4)
trdPos(5)
trdProfit(6)
trdCumuProfit(7)
So when I refer to tradeStruct[0, trdEntryPrice] I am referring to the first column in the first row.
This how you define a 2D array and its associate fields.
In EasyLanguage You are Poised at the Close of a Yesterday’s Bar
This paradigm allows you to sneak a peek at tomorrow’s open tick but that is it. You can’t really cheat, but it also limits your creativity and makes things more difficult to program when all you want is an accurate backtest. I will go into detail, if I haven’t already in an earlier post, the difference of sitting on Yesterday’s close verus sitting on Today’s close with retroactive trading powers. Since we are only storing trade information when can use hindsight to gather the information we need.
Buy tomorrow at highest(h,20) stop;
SellShort tomorrow at lowest(l,20) stop;
These are the order directives that we will be using to execute our strategy. We can also run a Shadow System, with the benefit of hindsight, to see where we entered long/short and at what prices. I call it a Shadow because its all the trades reflected back one bar. All we need to do is offset the highest and lowest calculations by 1 and compare the values to today’s highs and lows to determine trade entry. We must also test the open if a gap occurred and we would have been filled at the open. Now this code gets a bit hairy, but stick with it.
if mPos <> 1 then begin if h >= stb1 then begin if mPos < 0 then // close existing short position begin mEntryPrice = tradeStruct[numTrades,trdEntryPrice]; mExitPrice = maxList(o,stb1); tradeStruct[numTrades,trdExitPrice] = mExitPrice; tradeStruct[numTrades,trdExitDate] = date; mProfit = (mEntryPrice - mExitPrice) * bigPointValue - mCommSlipp; cumuProfit += mProfit; tradeStruct[numTrades,trdCumuProfit] = cumuProfit; tradeStruct[numTrades,trdProfit] = mProfit; print(d+19000000:8:0," shrtExit ",mEntryPrice:4:5," ",mExitPrice:4:5," ",mProfit:6:0," ",cumuProfit:7:0); print("-------------------------------------------------------------------------"); end; numTrades +=1; mEntryPrice = maxList(o,stb1); tradeStruct[numTrades,trdID] = 1; tradeStruct[numTrades,trdPOS] = 1; tradeStruct[numTrades,trdEntryPrice] = mEntryPrice; tradeStruct[numTrades,trdEntryDate] = date; mPos = 1; print(d+19000000:8:0," longEntry ",mEntryPrice:4:5); end; end; if mPos <>-1 then begin if l <= sts1 then begin if mPos > 0 then // close existing long position begin mEntryPrice = tradeStruct[numTrades,trdEntryPrice]; mExitPrice = minList(o,sts1); tradeStruct[numTrades,trdExitPrice] = mExitPrice; tradeStruct[numTrades,trdExitDate] = date; mProfit = (mExitPrice - mEntryPrice ) * bigPointValue - mCommSlipp; cumuProfit += mProfit; tradeStruct[numTrades,trdCumuProfit] = cumuProfit; tradeStruct[numTrades,trdProfit] = mProfit; print(d+19000000:8:0," longExit ",mEntryPrice:4:5," ",mExitPrice:4:5," ",mProfit:6:0," ",cumuProfit:7:0); print("---------------------------------------------------------------------"); end; numTrades +=1; mEntryPrice =minList(o,sts1); tradeStruct[numTrades,trdID] = 2; tradeStruct[numTrades,trdPOS] =-1; tradeStruct[numTrades,trdEntryPrice] = mEntryPrice; tradeStruct[numTrades,trdEntryDate] = date; mPos = -1; print(d+19000000:8:0," ShortEntry ",mEntryPrice:4:5); end; end;
Shadow System - Generic forany SAR System
Notice I have stb and stb1. The only difference between the two calculations is one is displaced a day. I use the stb and sts in the EL trade directives. I use stb1 and sts1 in the Shadow System code. I guarantee this snippet of code is in every backtesting platform out there.
All the variables that start with the letter m, such as mEntryPrice, mExitPrice deal with the Shadow System. Theyare not derived from TradeStation’s back testing engine only our logic. Lets look at the first part of just one side of the Shadow System:
if mPos <> 1 then begin if h >= stb1 then begin if mPos < 0 then // close existing short position begin mEntryPrice = tradeStruct[numTrades,trdEntryPrice]; mExitPrice = maxList(o,stb1); tradeStruct[numTrades,trdExitPrice] = mExitPrice; tradeStruct[numTrades,trdExitDate] = date; mProfit = (mEntryPrice - mExitPrice) * bigPointValue - mCommSlipp; cumuProfit += mProfit; tradeStruct[numTrades,trdCumuProfit] = cumuProfit; tradeStruct[numTrades,trdProfit] = mProfit; print(d+19000000:8:0," shrtExit ",mEntryPrice:4:5," ",mExitPrice:4:5," ",mProfit:6:0," ",cumuProfit:7:0); print("-------------------------------------------------------------------------"); end;
mPos and mEntryPrice and mExitPrice belong to the Shadow System
if mPos <> 1 then the Shadow Systems [SS] is not long. So we test today’s high against stb1 and if its greater then we know a long position was put on. But what if mPos = -1 [short], then we need to calculate the exit and the trade profit and the cumulative trade profit. If mPos = -1 then we know a short position is on and we can access its particulars from the tradeStruct 2D array. mEntryPrice = tradeStruct[numTrades,trdEntryPrice]. We can gather the other necessary information from the tradeStruct [remember this is just a table with fields spelled out for us.] Once we get the information we need we then need to stuff our calculations back into the Structure or table so we can regurgitate later. We stuff date in to the following fields trdExitPrice, trdExitDate, trdProfit and trdCumuProfit in the table.
Formatted Print: mEntryPrice:4:5
Notice in the code how I follow the print out of variables with :8:0 or :4:5? I am telling TradeStation to use either 0 or 5 decimal places. The date doesn’t need decimals but prices do. So I format that so that they will line up really pretty like.
Now that I take care of liquidating an existing position all I need to do is increment the number of trades and stuff the new trade information into the Structure.
The same goes for the short entry and long exit side of things. Just review the code. I print out the trades as we go along through the history of crude. All the while stuffing the table.
If LastBarOnChart -> Regurgitate
On the last bar of the chart we know exactly how many trades have been executed because we were keeping track of them in the Shadow System. So it is very easy to loop from 0 to numTrades.
if lastBarOnChart then begin print("Trade History"); for arrIndx = 1 to numTrades begin value20 = tradeStruct[arrIndx,trdEntryDate]; value21 = tradeStruct[arrIndx,trdEntryPrice]; value22 = tradeStruct[arrIndx,trdExitDate]; value23 = tradeStruct[arrIndx,trdExitPrice]; value24 = tradeStruct[arrIndx,trdID]; value25 = tradeStruct[arrIndx,trdProfit]; value26 = tradeStruct[arrIndx,trdCumuProfit];
print("---------------------------------------------------------------------"); if value24 = 1 then begin string1 = buyStr; string2 = sellStr; end; if value24 = 2 then begin string1 = shortStr; string2 = coverStr; end; print(value20+19000000:8:0,string1,value21:4:5," ",value22+19000000:8:0,string2, value23:4:5," ",value25:6:0," ",value26:7:0); end; end;
Add 19000000 to Dates for easy Translation
Since all trade information is stored in the Structure or Table then pulling the information out using our Field Descriptors is very easy. Notice I used EL built-in valueXX to store table information. I did this to make the print statements a lot shorter. I could have just used tradeStruct[arrIndx, trdEntry] or whatever was needed to provide the right information, but the lines would be hard to read. To translate EL date to a normal looking data just add 19,000,000 [without commas].
If you format your PrintLog to a monospaced font your out put should look like this.
PrintLog OutPut
Why Would We Want to Save Trade Information?
The answer to this question will be answered in Part 2. Email me with any other questions…..
A reader of this blog wanted a conversion from my Ratchet Trailing Stop indicator into a Strategy. You will notice a very close similarity with the indicator code as the code for this strategy. This is a simple N-Bar [Hi/Lo] break out with inputs for the RatchetAmt and TrailAmt. Remember RatchetAmt is how far the market must move in your favor before the stop is pulldown the TrailAmt. So if the RatchetAmt is 12 and the TrailAmt is 6, the market would need to move 12 handles in your favor and the Trail Stop would move to break even. If it moves another 12 handles then the stop would be moved up/down by 6 handles. Let me know if you have any questions – this system is similar to the one I just posted.
Notice how the RED line Ratchets Up by the Fixed Amount [8/6]
If d <> d[1] then Begin longMult = 0; shortMult = 0; myBarCount = 0; mp = 0; lep = 0; sep = 0; buysToday = 0; shortsToday = 0; end;
myBarCount = myBarCount + 1;
If myBarCount = 6 then // six 5 min bars = 30 minutes Begin stb = highD(0); //get the high of the day sts = lowD(0); //get low of the day end;
If myBarCount >=6 and t < calcTime(sess1Endtime,-3*barInterval) then Begin if buysToday = 0 then buy("NBar-Range-B") next bar stb stop; if shortsToday = 0 then sellShort("NBar-Range-S") next bar sts stop; end;
mp = marketPosition; If mp = 1 then begin lep = entryPrice; buysToday = 1; end; If mp =-1 then begin sep = entryPrice; shortsToday = 1; end;
// Okay initially you want a X point stop and then pull the stop up // or down once price exceeds a multiple of Y points // longMult keeps track of the number of Y point multipes of profit // always key off of lep(LONG ENTRY POINT) // notice how I used + 1 to determine profit // and - 1 to determine stop level
If mp = 1 then Begin If h >= lep + (longMult + 1) * ratchetAmt then longMult = longMult + 1; Sell("LongTrail") next bar at (lep + (longMult - 1) * trailAmt) stop; end;
If mp = -1 then Begin If l <= sep - (shortMult + 1) * ratchetAmt then shortMult = shortMult + 1; buyToCover("ShortTrail") next bar (sep - (shortMult - 1) * trailAmt) stop; end;
setExitOnClose;
I Used my Ratchet Indicator for the Basis of this Strategy
I have seen a plethora of posts on the Turtle trading strategies where the rules and code are provided. The codes range from a mere Donchian breakout to a fairly close representation. Without dynamic portfolio feedback its rather impossible to program the portfolio constraints as explained by Curtis Faith in his well received “Way Of The Turtle.” But the other components can be programmed rather closely to Curtis’ descriptions. I wanted to provide this code in a concise manner to illustrate some of EasyLanguage’s esoteric constructs and some neat shortcuts. First of all let’s take a look at how the system has performed on Crude for the past 15 years.
Turtle Performance on Crude past 15 years
If a market trends, the Turtle will catch it. Look how the market rallied in 2007 and immediately snapped back in 2008, and look at how the Turtle caught the moves – impressive. But see how the system stops working in congestion. It did take a small portion of the 2014 move down and has done a great job of catching the pandemic collapse and bounce. In my last post, I programmed the LTL (Last Trader Loser) function to determine the success/failure of the Turtle System 1 entry. I modified it slightly for this post and used it in concert with Turtle System 2 Entry and the 1/2N AddOn pyramid trade to get as close as possible to the core of the Turtle Entry/Exit logic.
Can Your Program This – sure you CAN!
Can You Program This?
I will provide the ELD so you can review at your leisure, but here are the important pieces of the code that you might not be able to derive without a lot of programming experience.
If mp[1] <> mp and mp <> 0 then begin if mp = 1 then begin origEntry = entryPrice; origEntryName = "Sys1Long"; If ltl = False and h >= lep1[1] then origEntryName = "Sys2Long"; end; if mp =-1 then begin origEntry = entryPrice; origEntryName = "Sys1Short"; If ltl = False and l <= sep1[1] then origEntryName = "Sys2Short"; end; end;
Keeping Track Of Last Entry Signal Price and Name
This code determines if the current market position is not flat and is different than the prior bar’s market position. If this is the case then a new trade has been executed. This information is needed so that you know which exit to apply without having to forcibly tie them together using EasyLanguage’s from Entry keywords. Here I just need to know the name of the entry. The entryPrice is the entryPrice. Here I know if the LTL is false, and the entryPrice is equal to or greater/less than (based on current market position) than System 2 entry levels, then I know that System 2 got us into the trade.
If mp = 1 and origEntryName = "Sys1Long" then Sell currentShares shares next bar at lxp stop; If mp =-1 and origEntryName = "Sys1Short" then buyToCover currentShares shares next bar at sxp stop;
//55 bar component - no contingency here If mp = 0 and ltl = False then buy("55BBO") next bar at lep1 stop; If mp = 1 and origEntryName = "Sys2Long" then sell("55BBO-Lx") currentShares shares next bar at lxp1 stop;
If mp = 0 and ltl = False then sellShort("55SBO") next bar at sep1 stop; If mp =-1 and origEntryName = "Sys2Short" then buyToCover("55SBO-Sx") currentShares shares next bar at sxp1 stop;
Entries and Exits
The key to this logic is the keywords currentShares shares. This code tells TradeStation to liquidate all the current shares or contracts at the stop levels. You could use currentContractscontracts if you are more comfortable with futures vernacular.
AddOn Pyramiding Signal Logic
Before you can pyramid you must turn it on in the Strategy Properties.
Turn Pyramiding ON
If mp = 1 and currentShares < 4 then buy("AddonBuy") next bar at entryPrice + (currentShares * .5*NValue) stop; If mp =-1 and currentShares < 4 then sellShort("AddonShort") next bar at entryPrice - (currentShares * .5*NValue) stop;
This logic adds positions on from the original entryPrice in increments of 1/2N. The description for this logic is a little fuzzy. Is the N value the ATR reading when the first contract was put on or is it dynamically recalculated? I erred on the side of caution and used the N when the first contract was put on. So to calculate the AddOn long entries you simply take the original entryPrice and add the currentShares * .5N. So if currentShares is 1, then the next pyramid level would be entryPrice + 1* .5N. If currentShares is 2 ,then entryPrice + 2* .5N and so on an so forth. The 2N stop trails from the latest entryPrice. So if you put on 4 contracts (specified in Curtis’ book), then the trailing exit would be 2N from where you added the 4th contract. Here is the code for that.
Liquidate All Contracts at Last Entry – 2N
vars: lastEntryPrice(0); If cs <= 1 then lastEntryPrice = entryPrice; If cs > 1 and cs > cs[1] and mp = 1 then lastEntryPrice = entryPrice + ((currentShares-1) * .5*NValue); If cs > 1 and cs > cs[1] and mp =-1 then lastEntryPrice = entryPrice - ((currentShares-1) * .5*NValue);
//If mp = -1 then print(d," ",lastEntryPrice," ",NValue);
If mp = 1 then sell("2NLongLoss") currentShares shares next bar at lastEntryPrice-2*NValue stop; If mp =-1 then buyToCover("2NShrtLoss") currentShares shares next bar at lastEntryPrice+2*NValue Stop;
Calculate Last EntryPrice and Go From There
I introduce a new variable here: cs. CS stands for currentShares and I keep track of it from bar to bar. If currentShares or cs is less than or equal to1 I know that the last entryPrice was the original entryPrice. Things get a little more complicated when you start adding positions – initially I couldn’t remember if EasyLanguage’s entryPrice contained the last entryPrice or the original – turns out it is the original – good to know. So, if currentShares is greater than one and the current bar’s currentShares is greater than the prior bar’s currentShares, then I know I added on another contract and therefore must update lastEntryPrice. LastEntryPrice is calculated by taking the original entryPrice and adding (currentShares-1) * .5N. Now this is the theoretical entryPrice, because I don’t take into consideration slippage on entry. You could make this adjustment. So, once I know the lastEntryPrice I can determine 2N from that price.
Getting Out At 2N Trailing Stop
If mp = 1 then sell("2NLongLoss") currentShares shares next bar at lastEntryPrice-2*NValue stop; If mp =-1 then buyToCover("2NShrtLoss") currentShares shares next bar at lastEntryPrice+2*NValue Stop;
Get Out At LastEntryPrice +/-2N
That’s all of the nifty code. Below is the function and ELD for my implementation of the Turtle dual entry system. You will see some rather sophisticated code when it comes to System 1 Entry and this is because of these scenarios:
What if you are theoretically short and are theoretically stopped out for a true loser and you can enter on the same bar into a long trade.
What if you are theoretically short and the reversal point would result in a losing trade. You wouldn’t record the loser in time to enter the long position at the reversal point.
What if you are really short and the reversal point would results in a true loser, then you would want to allow the reversal at that point
There are probably some other scenarios, but I think I covered all bases. Just let me know if that’s not the case. What I did to validate the entries was I programmed a 20/10 day breakout/failure with a 2N stop and then went through the list and deleted the trades that followed a non 2N loss (10 bar exit for a loss or a win.) Then I made sure those trades were not in the output of the complete system. There was quite a bit of trial and error. If you see a mistake, like I said, just let me know.
Remember I published the results of different permutations of this strategy incorporating dynamic portfolio feedback at my other site www.trendfollowingsystems.com. These results reflect the a fairly close portfolio that Curtis suggests in his book.
Last Trade Was a Loser Filter – To Use or Not To Use
Premise
A major component of the Turtle algorithm was to skip the subsequent 20-day break out if the prior was a winner. I guess Dennis believed the success/failure of a trade had an impact on the outcome of the subsequent trade. I have written on how you can implement this in EasyLanguage in prior posts, but I have been getting some questions on implementing FSM in trading and thought this post could kill two birds with one stone: 1) provide a template that can be adapted to any LTL mechanism and 2) provide the code/structure of setting up a FSM using EasyLanguage’s Switch/Case structure.
Turtle Specific LTL Logic
The Turtle LTL logic states that a trade is a loser if a 2N loss occurs after entry. N is basically an exponential-like moving average of TrueRange. So if the market moves 2N against a long or short position and stops you out, you have a losing trade. What makes the Turtle algorithm a little more difficult is that you can also exit on a new 10-day low/high depending on your position. The 10-day trailing exit does not signify a loss. Well at least in this post it doesn’t. I have code that says any loss is a loss, but for this explanation let’s just stick to a 2N loss to determine a trade’s failure.
How To Monitor Trades When Skipping Some Of Them
This is another added layer of complexity. You have to do your own trade accounting behind the scenes to determine if a losing trade occurs. Because if you have a winning trade you skip the next trade and if you skip it how do you know if it would have been a winner or a loser. You have to run a theoretical system in parallel with the actual system code.
Okay let’s start out assuming the last trade was a winner. So we turn real trading off. As the bars go by we look for a 20-Day high or low penetration. Assume a new 20-Day high is put in and a long position is established at the prior 20-Day high. At this point you calculate a 2N amount and subtract if from the theoretical entry price to obtain the theoretical exit price. So you have a theoMP (marketPosition) and a theoEX (exit price.) This task seems pretty simple, so you mov on and start looking for a day that either puts in a new 10-Day low or crosses below your theoEX price. If a new 10-Day low is put in then you continue on looking for a new entry and a subsequent 2N loss. If a 2N loss occurs, then you turn trading back on and continue monitoring the trades – turning trading off and then back on when necessary. In the following code I use these variables:
state – 0: looking for an entry or 1: looking for an exit
lep – long entry price
sep– short entry price
seekLong – I am seeking a long position
seekShort – I am seeking a short position
theoMP – theoretical market position
theoEX – theoretical exit price
lxp – long exit price
sxp – short exit price
Let’s jump into the Switch/Case structure when state = 0:
Switch(state) Begin Case 0: lep = highest(h[1],20) + minMove/priceScale; sep = lowest(l[1],20) - minMove/priceScale; If seekLong and h >= lep then begin theoMP = 1; theoEX = maxList(lep,o) - 2 * atr; // print(d," entered long >> exit at ",theoEX," ",atr); end; If seekShort and l <= sep then begin theoMP = -1; theoEX = minList(sep,o) + 2 * atr; end; If theoMP <> 0 then begin state = 1; cantExitToday = True; end;
State 0 (Finite State Set Up)
The Switch/Case is a must have structure in any programming language. What really blows my mind is that Python doesn’t have it. They claim its redundant to an if-then structure and it is but its so much easier to read and implement. Basically you use the Switch statement and a variable name and based on the value of the variable it will flow to whatever case the variable equates to. Here we are looking at state 0. In the CASE: 0 structure the computer calculates the lep and sep values – long and short entry levels. If you are flat then you are seeking a long or a short position. If the high or low of the bar penetrates it respective trigger levels then theoMP is set to 1 for long or -1 for short. TheoEX is then calculated based on the atr value on the day of entry. If theoMP is set to either a 1 or -1, then we know a trade has just been triggered. The Finite State Machine then switches gears to State 1. Since State = 1 the next Case statement is immediately evaluated. I don’t want to exit on the same bar as I entered (wide bars can enter and exit during volatile times) I use a variable cantExitToday. This variable delays the Case 1: evaluation by one bar.
State = 1 code:
Case 1: If not(cantExitToday) then begin lxp = maxList(theoEX,lowest(l[1],10)-minMove/priceScale); sxp = minList(theoEX,highest(h[1],10)+minMove/priceScale); If theoMP = 1 and l <= lxp then begin theoMP = 0; seekLong = False; if lxp <= theoEX then ltl = True Else ltl = False; end; If theoMP =-1 and h >= sxp then begin theoMP = 0; seekShort = False; if sxp >= theoEX then ltl = True else ltl = False; end; If theoMP = 0 then state = 0; end; cantExitToday = False; end;
State = 1 (Switching Gears)
Once we have a theoretical position, then we only examine the code in the Case 1: module. On the subsequent bar after entry, the lxp and sxp (long exit and short exit prices) are calculated. Notice these values use maxList or minList to determine whichever is closer to the current market action – the 2N stop or the lowest/highest low/high for the past 10-days. Lxp and sxp are assigned whichever is closer. Each bar’s high or low is compared to these values. If theoMP = 1 then the low is compared to lxp. If the low crosses below lxp, then things are set into motion. The theoMP is immediately set to 0 and seekLong is turned to False. If lxp <= a 2N loss then ltl (last trade loser) is set to true. If not, then ltl is set to False. If theoMP = 0 then we assume a flat position and switch the FSM back to State 0 and start looking for a new trade. The ltl variable is then used in the code to allow a real trade to occur.
Strategy Incorporates Our FSM Output
vars:N(0),mp(0),NLossAmt(0); If barNumber = 1 then n = avgTrueRange(20); if barNumber > 1 then n = (n*19 + trueRange)/20;
If useLTLFilter then Begin if ltl then buy next bar at highest(h,20) + minMove/priceScale stop; if ltl then sellShort next bar at lowest(l,20) -minMove/priceScale stop; end Else Begin buy next bar at highest(h,20) + minMove/priceScale stop; sellShort next bar at lowest(l,20) -minMove/priceScale stop; end;
mp = marketPosition;
If mp <> 0 and mp[1] <> mp then NLossAmt = 2 * n;
If mp = 1 then Begin Sell("LL10-LX") next bar at lowest(l,10) - minMove/priceScale stop; Sell("2NLS-LX") next bar at entryPrice - NLossAmt stop; end; If mp =-1 then Begin buyToCover("HH10-SX") next bar at highest(h,10) + minMove/priceScale stop; buyToCover("2NLS-SX") next bar at entryPrice + NLossAmt stop; end;
Strategy Code Using ltl filter
This code basically replicates what we did in the FSM, but places real orders based on the fact that the Last Trade Was A Loser (ltl.)
Does It Work – Only Trade After a 2N-Loss
Last Trade Loser In Action
Without Filter on the last 10-years in Crude Oil
With Filter on the last 10-years in Crude Oil
I have programmed this into my TradingSimula-18 software and will show a portfolio performance with this filter a little later at www.trendfollowingsystems.com.
I had to do some fancy footwork with some of the code due to the fact you can exit and then re-enter on the same bar. In the next post on this blog I will so you those machinations . With this template you should be able to recreate any last trade was a loser mechanism and see if it can help out with your own trading algorithms. Shoot me an email with any questions.
If you have some time on your hands and you want to build your own Frankenstein monster from a parts bin, here is your chance. The Super Combo Day Trading System was originally published in my “Building Winning Trading Systems” book back in 2001. I designed it to be more of a tutorial than a pure trading system. You should be able to get the spare parts you need to create your own day trading system. Back in 2001, I wanted to show how to control and monitor different entry and exit techniques in one complete algorithm. The system was designed to day-trade the big SP and the results at the time looked promising. Since the transition to the ES and the higher levels of volatility that we have seen over the years and the adoption of overnight trading, the system hasn’t fared that well, but the concepts are still viable as an instructional tool today as they were 20 years ago. EasyLanguage has been improved over this time period so the coding for the Super Combo can definitely take advantage of the new enhancements.
Here are the main premises of the logic:
take advantage of a buyEasier and shortEasier pattern setup
incorporate daily and 5-minute time frames in one chart
include a breakOut, failedBreakOut and reverseOnLiquidation trade entry techniques
monitor which signal is currently online and apply the correct exit signal
monitor profit and incorporate a break even stop
monitor time and incorporate a trailing stop
provide an interface into the logic via inputs
Okay here we go – there is quite a bit of code here so let’s divide an conquer by examining just one module at a time. This first module includes the inputs and variables section plus once per day calculations.
[LegacyColorValue = true];
{Super Combo by George Pruitt - redo 2020 This intra-day trading system will illustrate the multiple data handling capabilities of TradeStation. All pertinent buy and sell calculations will be based on daily bars and actual trades will be executed on 5-min bars. I have made most of the parameters input variables}
{Just like we did in the psuedo code -- let's start out with the daily bar calculations. If Date <> Date[1] -- first bar of day} if(Date <> Date[1]) then {save time by doing these calculations once per day} begin averageRange = Average(Range,10) of Data2; {Data 2 points to daily bars}
canTrade = 0; if range of data2 < averageRange then canTrade = 1;
{use close of data2 - seems to be more accurate than CloseD(1) buyEasierDay =Close of Data2 >= Close[1] of Data2; sellEasierDay = Close of Data2 < Close[1] of Data2;
buyBOPoint = Open + thrustPrcnt1*averageRange; sellBOPoint= Open - thrustPrcnt2*averageRange;
if(sellEasierDay) then begin sellBOPoint= Open - thrustPrcnt1*averageRange; buyBOPoint = Open + thrustPrcnt2*averageRange; end;
{Go ahead and initialize any variables that we may need later on in the day}
barCount = 0; buysToday = 0;sellsToday = 0;{You can put multiple statements on one line} end;
First Modules of SuperCombo 2020
Here I am just setting up the inputs and variables that I will need to execute the algorithm. If you are using .D data then the code
if date <> date[1] then
is a valid test for the first bar of the day. A new date will represent the beginning of the next day. The code controlled by this if-then construct is only executed one time per day. So if you can put the lion’s share of daily calculations here, then it should speed stuff up. The first thing I do is calculate the average range of the last 10 daily bars. I access this date from data2. Can you build a loop and accumulate the difference between the HighD and LowD function calls?
for i = 1 to 10 begin
sum = sum + (HighD(i) – LowD(i));
end;
The HighD() and LowD() functions are EasyLanguage enhancements that can help eliminate the need for a multi-data chart. However, if you do this, you will get an warning message that its not a good idea. I have done this and it seems to work, but to be safe just use Data2. Next I determine if there has been a narrow range or range compression by comparing yesterday’s range to the averageRange. If so, then I allow trading. This is an old filter that looks for range expansion after compression. The concept of a buyDay and sellDay was originated in the 1930s by George W. Cole (correct me if I am wrong here). I use this idea by comparing the prior two bars closing relationships. If there has been an up close, then I consider the next day to be a buyEasier day. If the opposite is true, then its a sellEasier day. This system isn’t unidirectional and does allow buying and shorting in the same session – hence the word easier. Continuing I calculate the levels that if the market reaches will hopefully trigger a short term trend in that direction. This is the once highly respected open range break out or ORBO. This methodology has lost its luster over the last 10 years or so due to overnight trading and allowing pent up buying and selling to be expressed in the overnight sessions. Twenty years ago it was still viable. The next bit of code creates the break out levels based on the buyEasier or sellEasier days. The thrust is calculated by multiplying the range by thrustPrcnt1 and thrustPrcnt2.
So that is method 1 – break out. Hope the market breaks out and continues to the close. I wish it were this easy. Since its not, the second methodolgy, FailedBreakOut, is calculated. This is also known as the “ClearOut” trade. The market is pushed to take out all the buy stops and then pulled back for the professionals to feast on the amateurs. SuperCombo tries to take advantage of this by calculating the two points to determine a failed break out. On the long side, it is the two points the market rises up to and then falls back to. If the market breaches the longBreakPt, then look to sellShort at the shortFBOPoint. Here is the next module
{Now lets trade and manage on 5-min bars}
barCount = barCount + 1; {count the number of bars of intraday data} if(barCount >= waitPeriodMins/BarInterval and canTrade = 1) then {have we waited long enough} begin if(MarketPosition = 1) then buysToday = 1; if(MarketPosition =-1) then sellsToday= 1;
if(buysToday = 0 and Time < initTradesEndTime) then Buy("LBreakOut") next bar at buyBOPoint stop;
if(sellsToday= 0 and Time < initTradesEndTime) then SellShort("SBreakout") next bar at sellBOPoint stop;
if(highD(0) > longBreakPt and sellsToday = 0 and Time < initTradesEndTime) then SellShort("SfailedBO") next bar at shortFBOPoint stop; if(lowD(0) < shortBreakPt and buysToday = 0 and Time < initTradesEndTime) then Buy("BfailedBO") next bar at longFBOPoint stop;
Monitor Market Action and Place Trades Accordingly
if(barCount>= waitPeriodMins/BarInterval and canTrade = 1) then
Forces the logic to flow only if canTrade is 1 and we have waited for amateur hour to be completed – well 30 minutes to be accurate. Is the first hour really amateur hour? I don’t think this applies, but if you think it does this is how you control trading prior to the completion of this period. By dividing by BarInterval and counting each bar you can generalize this code for any time resolution. If MarketPosition is 1 then you know you entered a long position and the opposite is true for short positions. Only place the break out orders if time is less than initTradesEndTime. If the market penetrates the long and shortBreakPts, then prepare to take advantage of a failed breakout. Only go short if a short position has not already been entered – same for longs. So, this logic places the breakOut and failedBreakOut orders. Now for the last module.
{The next module keeps track of positions and places protective stops}
mp = marketPosition; if(MarketPosition = 1) then begin longLiqPoint = EntryPrice-protStopPrcnt1*averageRange; longLiqPoint = MinList(longLiqPoint,EntryPrice - protStopAmt); longLiqPoint1 = EntryPrice - protStopPrcnt2*averageRange; longLiqPoint1 = MinList(longLiqPoint1,EntryPrice - protStopAmt); if Maxpositionprofit >= breakEvenPrcnt*averageRange*bigPointValue then begin longLiqPoint = EntryPrice; {Breakeven trade} longLiqPoint1 = EntryPrice; {Breakeven trade} end; if(Time >= initTradesEndTime) then begin longLiqPoint = MaxList(longLiqPoint,Lowest(Low,3)); {Trailing stop} longLiqPoint1 = MaxList(longLiqPoint1,Lowest(Low,3)); {Trailing stop} end; if(Time < liqRevEndTime and sellsToday = 0 and longLiqPoint <> EntryPrice and BarsSinceEntry >= 4) then SellShort("LongLiqRev") next bar at longLiqPoint stop;
Sell("LongLiq-BO") from entry("LBreakOut") next bar at longLiqPoint stop; Sell("LongLiq-FBO") from entry("BFailedBO") next bar at longLiqPoint stop; Sell("LongLiq-RLoss") from entry("ShortLiqRev") next bar at longLiqPoint1 stop; end; if(MarketPosition =-1) then begin shortLiqPoint = EntryPrice+protStopPrcnt1*averageRange; shortLiqPoint = MaxList(shortLiqPoint,EntryPrice + protStopAmt); shortLiqPoint1 = EntryPrice + protStopPrcnt2*averageRange; shortLiqPoint1 = MaxList(shortLiqPoint1,EntryPrice + protStopAmt); if maxPositionProfit >= breakEvenPrcnt*averageRange*bigPointValue then begin shortLiqPoint = EntryPrice; {Breakeven trade} shortLiqPoint1 = EntryPrice; end; if(Time >= initTradesEndTime) then begin shortLiqPoint = MinList(shortLiqPoint,Highest(High,3)); {Trailing stop} shortLiqPoint1 = MinList(shortLiqPoint1,Highest(High,3)); {Trailing stop} end; if(Time < liqRevEndTime and buysToday = 0 and shortLiqPoint <> EntryPrice and BarsSinceEntry >= 4) then Buy("ShortLiqRev") next bar at shortLiqPoint stop;
BuyToCover("ShortLiq-BO") from entry("SBreakOut") next bar at shortLiqPoint stop; BuyToCover("ShortLiq-FBO") from entry("SFailedBO") next bar at shortLiqPoint stop; BuyToCover("ShortLiq-RLoss") from entry("LongLiqRev") next bar at shortLiqPoint1 stop; end; end; SetExitOnClose;
TradeManagement (Enter on Stop Loss or Not?)
This code looks a little hairy, but its not. Let’s just look at the long side logic to save time here. First let’s calculate the LongLiqPoints (1 and 2.) Twenty years ago I thought it would be better to have a smaller stop for entries that occurred on a LiquidationReversal. Oh yeah that code is in here to. Back in the day I wanted to make sure the stop was at least 3 handles – ha, ha, ha – no really I am serious. Really. Stop laughing!! That code could be eliminated. After calculating these two points I start to monitor profit and if it reaches a predetermined level I pull the the longLiqPoints toa BreakEven stop. If you are fortunate to still be in a trade after initTradesEndTime, then I start trailing the stop by the lowest low of the last 3 five minute bars – I don’t want to turn a small winner into a loser. Now this is the fun stuff.
if(Time < liqRevEndTime and sellsToday = 0 and longLiqPoint <> EntryPrice and BarsSinceEntry >= 4) then
SellShort(“LongLiqRev”) next bar at longLiqPoint stop;
If time is less than liqRevEndTime and BarsSinceEntry, then reverse and go short at the longLiqPoint stop. Do this instead of liquidating. I thought if the market reversed course quickly, then I wanted to take advantage of this counter trend move. Eliminating this to see if it has any impact would be where I would start to play around with the template. Okay now the liquidations based on from Entry take place next. If I am long from a “ShortLiqRev“, then I use longLiqPoint1 instead of longLiqPoint. Okay that last part was the kitchen sink. Now you have enough code to make your own day trading system – really too much code, but you should be able to hobble something together from these parts. Let me know if you can create your own Frankenstein monster. I will update the parameters to see if there is any hope to the system as a whole. Keep checking back for updated performance metrics. Best to all and be safe!
Many Times It Takes Multiple Tools to Get the Job Done
Just like a mechanic, a Quant needs tools to accomplish many programming tasks. In this post, I use a toolbox to construct an EasyLanguage function that will test a date and determine if it is considered a Holiday in the eyes of the NYSE.
Why a Holiday Function?
TradeStation will pump holiday data into a chart and then later go back and take it out of the database. Many times the data will only be removed from the daily database, but still persist in the intraday database. Many mechanical day traders don’t want to trade on a shortened holiday session or use the data for indicator/signal calculations. Here is an example of a gold chart reflecting President’s Day data in the intra-day data and not in the daily.
Holiday Data Throws A Monkey Wrench Into the Works
This affects many stock index day traders. Especially if automation is turned on. At the end of this post I provide a link to my youTube channel for a complete tutorial on the use of these tools to accomplish this task. It goes along with this post.
First Get The Data
I searched the web for a list of historical holiday dates and came across this:
Historic List of Holidays and Their Dates
You might be able to find this in a easier to use format, but this was perfect for this post.
Extract Data with Beautiful Soup
Here is where Python and the plethora of its libraries come in handy. I used pip to install the requests and the bs4 libraries. If this sounds like Latin to you drop me an email and I will shoot you some instructions on how to install these libraries. If you have Python, then you have the download/install tool known as pip.
Here is the Python code. Don’t worry it is quite short.
url = 'http://www.market-holidays.com/' page = requests.get(url) soup = BeautifulSoup(page.text,'html.parser') print(soup.title.text) all_tables = soup.findAll('table') #print (all_tables) print (len(all_tables)) #print (all_tables[0]) print("***") a = list() b = list() c = list() #print(all_tables[0].find_all('tr')[0].text) for numTables in range(len(all_tables)-1): for rows in all_tables[numTables].find_all('tr'): a.append(rows.find_all('td')[0].text) b.append(rows.find_all('td')[1].text)
for j in range(len(a)-1): print(a[j],"-",b[j])
Using Beautiful Soup to Extract Table Data
As you can see this is very simple code. First I set the variable url to the website where the holidays are located. I Googled on how to do this – another cool thing about Python – tons of users. I pulled the data from the website and stuffed it into the page object. The page object has several attributes (properties) and one of them is a text representation of the entire page. I pass this text to the BeautifulSoup library and inform it to parse it with the html.parser. In other words, prepare to extract certain values based on html tags. All_tables contains all of the tables that were parsed from the text file using Soup. Don’t worry how this works, as its not important, just use it as a tool. In my younger days as a programmer I would have delved into how this works, but it wouldn’t be worth the time because I just need the data to carry out my objective; this is one of the reasons classically trained programmers never pick up the object concept. Now that I have all the tables in a list I can loop through each row in each table. It looked liker there were 9 rows and 2 columns in the different sections of the website, but I didn’t know for sure so I just let the library figure this out for me. So I played around with the code and found out that the first two columns of the table contained the name of the holiday and the date of the holiday. So, I simply stuffed the text values of these columns in two lists: a and b. Finally I print out the contents of the two lists, separated by a hyphen, into the Interpreter window. At this point I could simply carry on with Python and create the EasyLanguage statements and fill in the data I need. But I wanted to play around with Excel in case readers didn’t want to go the Python route. I could have used a powerful editor such as NotePad++ to extract the data from the website in place of Python. GREP could have done this. GREP is an editor tool to find and replace expressions in a text file.
Use Excel to Create Actual EasyLanguage – Really!
I created a new spreadsheet. I used Excel, but you could use any spreadsheet software. I first created a prototype of the code I would need to encapsulate the data into array structures. Here is what I want the code to look like:
Arrays: holidayName[300](""),holidayDate[300](0);
holidayName[1]="New Year's Day "; holidayDate[1]=19900101;
Code Prototype
This is just the first few lines of the function prototype. But you can notice a repetitive pattern. The array names stay the same – the only values that change are the array elements and the array indices. Computers love repetitiveness. I can use this information a build a spreadsheet – take a look.
Type EasyLanguage Into the Columns and Fill Down!
I haven’t copied the data that I got out of Python just yet. That will be step 2. Column A has the first array name holidayName (notice I put the left square [ bracket in the column as well). Column B will contain the array index and this is a formula. Column C contains ]=”. Column D will contain the actual holiday name and Column E contains the ; These columns will build the holidayName array. Columns G throuh K will build the holidayDates array. Notice column H equals column B. So whatever we do to column B (Index) will be reflected in Column H (Index). So we have basically put all the parts of the EasyLanguage into Columns A thru K.
Excel provides tools for manipulating strings and text. I will use the Concat function to build my EasyLanguage. But before I can use Concat all the stuff I want to string together must be in a string or text format. The only column in the first five that is not a string is Column B. So the first thing I have to do is convert it to text. First copy the column and paste special as values. Then go to your Data Tab and select Text To Columns.
Text To Columns
It will ask if fixed width or delimited – I don’t think it matters which you pick. On step 3 select text.
Text To Columns – A Powerful Tool
The Text To Columns button will solve 90% of your formatting issues in Excel. Once you do this you will notice the numbers will be left justified – this signifies a text format. Now lets select another sheet in the workbook and past the holiday data.
Copy Holiday Data Into Another Spreadsheet
New Year's Day - January 1, 2021 Martin Luther King, Jr. Day - January 18, 2021 Washington's Birthday (Presidents' Day) - February 15, 2021 Good Friday - April 2, 2021 Memorial Day - May 31, 2021 Independence Day - July 5, 2021 Labor Day - September 6, 2021 Thanksgiving - November 25, 2021 Christmas - December 24, 2021 New Year's Day - January 1, 2020 Martin Luther King, Jr. Day - January 20, 2020 Washington's Birthday (Presidents' Day) - February 17, 2020 Good Friday - April 10, 2020 Memorial Day - May 25, 2020
Holiday Output
Data Is In Column A
Text To Columns to the rescue. Here I will separate the data with the “-” as delimiter and tell Excel to import the second column in Date format as MDY.
Text To Columns with “-” as the delimiter and MDY as Column B Format
Now once the data is split accordingly into two columns with the correct format – we need to convert the date column into a string.
Convert Date to a String
Now the last couple of steps are really easy. Once you have converted the date to a string, copy Column A and past into Column D from the first spreadsheet. Since this is text, you can simply copy and then paste. Now go back to Sheet 2 and copy Column C and paste special [values] in Column J on Sheet 1. All we need to do now is concatenate the strings in Columns A thru E for the EasyLanguage for the holidayName array. Columns G thru K will be concatenated for the holidayDate array. Take a look.
Concatenate all the strings to create the EasyLanguage
Now create a function in the EasyLanguage editor and name it IsHoliday and have it return a boolean value. Then all you need to do is copy/paste Columns F and L and the data from the website will now be available for you use. Here is a portion of the function code. Notice I declare the holidayNameStr as a stringRef? I did this so I could change the variable in the function and pass it back to the calling routine.
holidayName[1]="New Year's Day "; holidayDate[1]=19900101; holidayName[2]="Martin Luther King, Jr. Day "; holidayDate[2]=19900115; holidayName[3]="Washington's Birthday (Presidents' Day) "; holidayDate[3]=19900219; holidayName[4]="Good Friday "; holidayDate[4]=19900413; holidayName[5]="Memorial Day "; holidayDate[5]=19900528; holidayName[6]="Independence Day "; holidayDate[6]=19900704; holidayName[7]="Labor Day "; holidayDate[7]=19900903; holidayName[8]="Thanksgiving "; holidayDate[8]=19901122; holidayName[9]="New Year's Day "; holidayDate[9]=19910101; holidayName[10]="Martin Luther King, Jr. Day "; holidayDate[10]=19910121; holidayName[11]="Washington's Birthday (Presidents' Day) "; holidayDate[11]=19910218;
// There are 287 holiays in the database. // Here is the looping mechanism to compare the data that is passed // to the database
vars: j(0); IsHoliday = False; For j=1 to 287 Begin If testDate = holidayDate[j] - 19000000 then Begin holidayNameStr = holidayName[j] + " " + numToStr(holidayDate[j],0); IsHoliday = True; end; end;
A Snippet Of The Function - Including Header and Looping Mechanism
This was a pretty long tutorial and might be difficult to follow along. If you want to watch my video, then go to this link.
I created this post to demonstrate the need to have several tools at your disposal if you really want to become a Quant programmer. How you use those tools is up to you. Also you will be able to take bits and pieces out of this post and use in other ways to get the data you really need. I could have skipped the entire Excel portion of the post and just did everything in Python. But I know a lot of Quants that just love spreadsheets. You have to continually hone your craft in this business. And you can’t let one software application limit your creativity. If you have a problem always be on the lookout for alternative platforms and/or languages to help you solve it.
Thanks to MJ for planting the seed for this post. If you were one of the lucky ones to get Keith’s “Building Reliable Trading Systems – Tradable Strategies that Perform as They Backtest and Meet Your Risk-Reward Goals” book by John Wiley 2013 at the list price of $75 count yourself lucky. The book sells for a multiple of that on Amazon.com. Is there anything earth shattering in the book you might ask? I wouldn’t necessarily say that, but there are some very well thought out and researched topics that most traders would find of interest.
Bar Scoring
In his book Keith discusses the concept of bar-scoring. In Keith’s words, “Bar-scoring is an objective way to classify an instrument’s movement potential every bar. The two parts of the bar-scoring are the criterion and the resultant profit X days hence.” Keith provides several bar scoring techniques, but I highlight just one.
Keith broke these patterns down into the relationship of the close to the open, and close in the upper half of the range; close greater than the open and close in the lower half of the range. He extended the total number of types to 8 by adding the relationship of the close of the bar to yesterdays bar.
The PatternSmasher code can run through a binary representation
for each pattern and test holding the position for an optimizable number of days. It can also check for long and short positions. The original Pattern Smasher code used a for-loop to create patterns that were then compared to the real life facsimile. In this code it was easier to just manually define the patterns and assign them the binary string.
if c[0]> c[1] and c[0] > o[0] and c[0] > (h[0] + l[0])/2 then patternString = "----"; if c[0]> c[1] and c[0] > o[0] and c[0] < (h[0] + l[0])/2 then patternString = "---+"; if c[0]> c[1] and c[0] < o[0] and c[0] > (h[0] + l[0])/2 then patternString = "--+-"; if c[0]> c[1] and c[0] < o[0] and c[0] < (h[0] + l[0])/2 then patternString = "--++"; if c[0]< c[1] and c[0] > o[0] and c[0] > (h[0] + l[0])/2 then patternString = "-+--"; if c[0]< c[1] and c[0] > o[0] and c[0] < (h[0] + l[0])/2 then patternString = "-+-+"; if c[0]< c[1] and c[0] < o[0] and c[0] > (h[0] + l[0])/2 then patternString = "-++-"; if c[0]< c[1] and c[0] < o[0] and c[0] < (h[0] + l[0])/2 then patternString = "-+++";
Manual Pattern Designations
Please check my code for any errors. Here I go through the 8 different relationships and assign them to a Patter String. “-+++” represents pattern number (7 ) or type (7 + 1 = 8 – my strings start out at 0). You can then optimize the test pattern and if the test pattern matches the actual pattern, then the Pattern Smasher takes the trade on the opening of the next bar and holds it for the number of days you specify. You an also designate long and short positions in the code. Here I optimized the 8 patterns going long and short and holding from 1-4 days.
Here is the equity curve! Remember these are Hypothetical Results with $0 commission/slippage and historic performance is not necessarily indicative of future results. Educational purposes only! This is tested on ES.D
Play around with the code and let me know if you find any errors or any improvements.
{written by George Pruitt -- copyright 2019 by George Pruitt This will test a 4 day pattern based on the open to close relationship. A plus represents a close greater than its open, whereas a minus represents a close less than its open. The default pattern is set to pattern 14 +++- (1110 binary). You can optimize the different patterns by optimizing the patternTests input from 1 to 16 and the orbAmount from .01 to whatever you like. Same goes for the hold days, but in this case you optimize start at zero. The LorS input can be optimized from 1 to 2 with 1 being buy and 2 being sellshort.}
if(mod(value1,2) = 1) or value1 = 1 then patternBitChanger[0] = 1; value2 = value1 - patternBitChanger[0] * 1;
if(value2 >= 7) then begin patternBitChanger[3] = 1; value2 = value2 - 8; end;
if(value2 >= 4) then begin patternBitChanger[2] = 1; value2 = value2 - 4; end; if(value2 = 2) then patternBitChanger[1] = 1; end;
for iCnt = 3 downto 0 begin if(patternBitChanger[iCnt] = 1) then begin patternTest = patternTest + "+"; end else begin patternTest = patternTest + "-"; end; end;
patternString = "";
if c[0]> c[1] and c[0] > o[0] and c[0] > (h[0] + l[0])/2 then patternString = "----"; if c[0]> c[1] and c[0] > o[0] and c[0] < (h[0] + l[0])/2 then patternString = "---+"; if c[0]> c[1] and c[0] < o[0] and c[0] > (h[0] + l[0])/2 then patternString = "--+-"; if c[0]> c[1] and c[0] < o[0] and c[0] < (h[0] + l[0])/2 then patternString = "--++"; if c[0]< c[1] and c[0] > o[0] and c[0] > (h[0] + l[0])/2 then patternString = "-+--"; if c[0]< c[1] and c[0] > o[0] and c[0] < (h[0] + l[0])/2 then patternString = "-+-+"; if c[0]< c[1] and c[0] < o[0] and c[0] > (h[0] + l[0])/2 then patternString = "-++-"; if c[0]< c[1] and c[0] < o[0] and c[0] < (h[0] + l[0])/2 then patternString = "-+++";
if(barNumber = 1) then print(elDateToString(date)," pattern ",patternTest," ",patternTests-1); if(patternString = patternTest) then begin
// print(date," ",patternString," ",patternTest); //uncomment this and you can print out the pattern if (enterNextBarAtOpen) then begin if(LorS = 2) then SellShort("PatternSell") next bar on open; if(LorS = 1) then buy("PatternBuy") next bar at open; end else begin if(LorS = 2) then SellShort("PatternSellBO") next bar at open of tomorrow - avgTrueRange(atrAvgLen) * orbAmount stop; if(LorS = 1) then buy("PatternBuyBO") next bar at open of tomorrow + avgTrueRange(atrAvgLen) * orbAmount stop; end;
end;
if(holdDays = 0 ) then setExitonClose; if(holdDays > 0) then begin if(barsSinceEntry = holdDays and LorS = 2) then BuyToCover("xbarLExit") next bar at open; if(barsSinceEntry = holdDays and LorS = 1) then Sell("xbarSExit") next bar at open; end;
Have you ever wondered how many bars have transpired since a certain condition was met? Some platforms provide this capability:
If ExitFlag and (c crosses above average within 3 bars) then
TradeStation provides the MRO (Most Recent Occurrence) function that provides a very similar capability. The only problem with this function is that it returns a -1 if the criteria are not met within the user provided lookback window. If you say:
And c hasn’t crossed the 200-day moving average within the past twenty days the condition is still set to true because the function returns a -1.
I have created a function named BarsSince and you can set the false value to any value you wish. In the aforementioned example, you would want the function to return a large number so the function would provide the correct solution. Here’s how I did it:
inputs: Test( truefalseseries ), Length( numericsimple ), Instance( numericsimple ) , { 0 < Instance <= Length} FalseReturnValue(numericsimple); {Return value if not found in length window}
The condition that is being tested [e.g. rsi > crosses above 30]
The lookback window [rsiLen – 14 bars in this case]
Which occurrence [1 – most recent; 2- next most recent; etc…]
False return value [999 in this case; if condition is not met in time]
A Simple Mean Reversion Using the Function:
Here are the results of this simple system utilizing the function.
Optimization Results:
I came up with this curve through a Genetic Optimization:
The BarsSince function adds flexibility or fuzziness when you want to test a condition but want to allow it to have a day (bar) or two tolerance. In a more in-depth analysis, the best results very rarely occurred on the day the RSI crossed a boundary. Email me with questions of course.
In the Pascal programming language you have Procedures and Functions. Procedures are used when you want to modify multiple variables within a sub-program. A function is a sub-program that returns a single value after it has been modified by say a formula. EasyLanguage combines procedures and functions into one sub-program called a function. Functions and procedures both have a formal parameter definition – a list that describes the type of parameters that are being received by the calling program. In Pascal procedures, you pass the address of the value that you want changed. By modifying the contents of the address you can pass the value back and forth or in and out of the procedure. In functions you pass by value. Remember the parameter in a normal function call is used to instruct something within the body of the function and is not altered (e.g. the number 19 in value1 = average(c,19)). This value doesn’t need to be modified it’s just used. Look at the following code:
Here I am modifying mav1, mav2 and mav3 within the function and then passing the values back to the calling strategy/indicator/paintbar. All functions must return a value so I simply assign the value 1 to the function name. The key here is the keyword numericRef, once I change the values located in the addresses of mav1, mav2 and mav3 (address are provided by the keyword numericRef), they will be made available to the calling program. This code allows the function to return more than just one value.
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
