# Pyramania Levels with 24-Hour Session – Free Code

## Easing Into EasyLanguage-DayTrade Edition [On SALE Now thru November]

EZ-DT Pyramania is a strategy I introduced in the Day Trade Edition.  The logic is rather simple – pyramid as the market moves through multiple levels during the trading day. – buy, buy, buy, dump or buy, dump, short, short, short, dump.  The distance between the levels is constant.  In the book, I showed an algorithm with a total of 6 levels with 7 edges.

Here the market opens @ 9:30 and the levels are instantly plotted and trades are executed as the market moves through the levels located above the open tick.  Over the weekend, I had a reader ask how he could modify the code to plot the levels on the 24-hour @ES session.  In the day session, I used the change in the date as the trigger for the calculation and plotting of the levels.  Here is the day session version.

``inputs:numSegments(6),numPlots(6);arrays: segmentBounds[](0);variables: j(0),loopCnt(0),segmentSize(0),avgRng(0);onceBegin	Array_SetMaxIndex(segmentBounds, numSegments);end;if d <> d[1] Then  // only works on the @ES.D or any .D sessionbegin	avgRng = average(range of data2,20);	segmentSize = avgRng/numSegments;	loopCnt = -1*numSegments/2;	for j = 0 to numSegments	begin		segmentBounds[j] = openD(0) + loopCnt * segmentSize;		loopCnt = loopCnt + 1;	end;end;//The following time constraint only works when all time stamps//are less than the end of day time stamp//This will not work when time = 1800 and endTime = 1700if t < calcTime(sessionEndTime(0,1),-barInterval) Thenbegin	if numPlots >= 1 then plot1(segmentBounds[0],"Level 0");	if numPlots >= 2 then plot2(segmentBounds[1],"Level 1");	if numPlots >= 3 then plot3(segmentBounds[2],"Level 2");	if numPlots >= 4 then plot4(segmentBounds[3],"Level 3");	if numPlots >= 5 then plot5(segmentBounds[4],"Level 4");	if numPlots >= 6 then plot6(segmentBounds[5],"Level 5");	if numPlots >= 7 then plot7(segmentBounds[6],"Level 6");//	plot8(segmentBounds[7],"Level 7");//	plot9(segmentBounds[8],"Level 8");end;``
Works great with @ES.D or any @**.D

I like this code because it exposes you to arrays, loops, and plotting multiple values.  You can fix this by modifying and adding some code.  I used the Trading Around Midnight blog post to get the code I needed to enable plotting around 0:00 hours.  Here is the updated code:

``inputs:numSegments(6),numPlots(6);arrays: segmentBounds[](0);variables: j(0),loopCnt(0),segmentSize(0),avgRng(0),startTime(0),endTime(0),endTimeOffset(0);onceBegin	Array_SetMaxIndex(segmentBounds, numSegments);end;startTime = sessionStartTime(0,1); endTime = sessionEndTime(0,1);//let TS tell you when the market opens - remember the//first time stamp is the open time + bar intervalif t = calcTime(sessionStartTime(0,1),barInterval) Thenbegin	avgRng = average(range of data2,20);	segmentSize = avgRng/numSegments;	loopCnt = -1*numSegments/2;	for j = 0 to numSegments	begin		segmentBounds[j] = open + loopCnt * segmentSize;		loopCnt = loopCnt + 1;	end;end;// if startTime > endTime then you know you are dealing with// timees that more than likely bridges midnight// if time is greater then 1700 (end time) then you must// subtract an offset so it makes sense - endTimeOffset// play with the math and it will come to youif startTime > endTime then begin 	endTimeOffset = 0; 	if t >= startTime+barInterval and t<= 2359 then		endTimeOffSet = 2400-endTime; end;if t-endTimeOffSet < endTime Thenbegin	if numPlots >= 1 then plot1(segmentBounds[0],"Level 0");	if numPlots >= 2 then plot2(segmentBounds[1],"Level 1");	if numPlots >= 3 then plot3(segmentBounds[2],"Level 2");	if numPlots >= 4 then plot4(segmentBounds[3],"Level 3");	if numPlots >= 5 then plot5(segmentBounds[4],"Level 4");	if numPlots >= 6 then plot6(segmentBounds[5],"Level 5");	if numPlots >= 7 then plot7(segmentBounds[6],"Level 6");//	plot8(segmentBounds[7],"Level 7");//	plot9(segmentBounds[8],"Level 8");end;``
Modification to plot data around midnight

Here I let TS tell me with the market opens and then use some simple math to make sure I can plot with the time is greater than and less than the end of day time.

Email me if you have the book and want to companion code to the strategy – georgeppruitt@gmail.com

# Can You Turn Failure into Success?

## Have You Ever Wondered If You Just Reversed the Logic?

You have been there before. What you thought was a great trading idea turns out to be a big flop. We have all developed these types of algorithms. Then it hits you, just flip the logic and in turn the equity curve. Hold your horses! First off you have to make sure it’s not just the execution costs that is hammering the equity curve into oblivion. When testing a fresh trading idea, it is best to keep execution costs to zero. This way if your idea is a good one, but is simply backward, then you have a chance of creating something good out of something bad. I was playing around with a mean reversion day trading algorithm (on the @ES.D – day session of the mini S&P 500) that created the following equity curve.  Remember to read the disclaimer concerning hypothetical performance before proceeding reading the rest of this blog.  It is located under the DISCLAIMER – REAMDE! tab.  By reading the rest of this blog post it implies that you understand the limitations of hypothetical back testing and simulated analysis.

The pandemic created a strong mean reversion environment. In the initial stage of this research, I did not set the executions costs – they defaulted to zero. My idea was to buy below the open after the market moved down from the high of the day a certain percentage of price. Since I was going to be buying as the market was moving down, I was willing to use a wide stop to see if I could hold on to the falling knife. Short entries were just the opposite -sell short above the open after the market rallied a certain percentage of price. I wanted to enter on a hiccup. Once the market moved down a certain range from the high of the day, I wanted to enter on a stop at the high of the prior bar. I figured if the price penetrated the high of the prior five-minute bar in a down move, then it would signal an eventual rotation in the market. Again, I was just throwing pasta against the wall to see what would stick. I even came up with a really neat name for the algorithm the Rubber Band system – stretch just far enough and the market is bound to slam back. Well, there wasn’t any pasta sticking. Or was there? If I flipped the equity curve 180 degrees, then I would have a darned good strategy. All it would take is to reverse the signals, sell short when I was buying and buy when I was selling short. Instead of a mean reversion scheme, this would turn into a momentum-based strategy.

Here are the original rules.

``maxCloseMinusOpen = maxList(close - todaysOpen,maxCloseMinusOpen);maxOpenMinusClose = maxList(todaysOpen - close,maxOpenMinusClose);if c < todaysOpen and todaysOpen-c = maxOpenMinusClose and (maxCloseMinusOpen + maxOpenMinusClose)/c >= stretchPercent Then	canBuy = True;if c > todaysOpen and c- todaysOpen = maxCloseMinusOpen and 	(maxCloseMinusOpen + maxOpenMinusClose)/c >= stretchPercent Then	canShort = True;``
Guts of the complete failure.

Here I measure the maximum distance from the highest close above the open and the lowest close below the open.  The distance between the two points is the range between the highest and lowest closing price of the current day.  If the close is less than today’s open, and the range between the extremes of the highest close and lowest close of the trading day is greater than stretchPercent, then an order directive to buy the next bar at the current bar’s high is issued.  The order is alive until it is filled, or the day expires.  Selling short uses the same calculations but requires the close of the current bar to be above the open.   The stretchPercent was set to 1 percent and the protective stop was set to a wide \$2,000.  As you can see from the equity curve, this plan did not work except for the time span of the pandemic.  Could you optimize the strategy and make it a winning system.  Definitely.  But the 1 percent and \$2000 stop seemed very logical to me.  Since we are comparing the range of the data to a fixed price of the data, then we don’t need to worry about the continuous contract distortion.  Maybe we would have to, if the market price was straddling zero.  Anyways, here is a strategy using the same entry technique, but reversed, with some intelligent trade filtering.  I figured a profit objective might be beneficial, because the stop was hit several times during the original test.

If you like the following code, make sure you check out my books at Amazon.com.  This type of code is used the Hi-Res and Day-Trading editions of the Easing_Into_Easylanguage series.

``input: stretchPercent(0.01),stopLoss(1000),takeProfit(1000),dontTradeBefore(930),dontTradeBeforeOffset(5),dontTradeAfter(1500),dontTradeAfterOffset(5),rangeCompressionPercent(0.75);vars: buysToday(0),shortsToday(0),mp(0),atr(0),canBuy(False),canShort(False),canTrade(False);vars: todaysOpen(0),maxCloseMinusOpen(0),maxOpenMinusClose(0);if t = sessionStartTime(0,1)+barInterval ThenBegin	todaysOpen = open;	maxCloseMinusOpen = 0;	maxOpenMinusClose = 0;	buysToday = 0;	shortsToday = 0;	canTrade = False;	atr = avgTrueRange(20) of data2;	if trueRange of data2 < atr * rangeCompressionPercent Then		canTrade = True;	canBuy = False;	canShort = False;	end;mp = marketPosition;if mp = 1 and mp <> mp[1] then buysToday +=1;if mp =-1 and mp <> mp[1] then shortsToday +=1;maxCloseMinusOpen = maxList(close - todaysOpen,maxCloseMinusOpen);maxOpenMinusClose = maxList(todaysOpen - close,maxOpenMinusClose);if c < todaysOpen and todaysOpen-c = maxOpenMinusClose and (maxCloseMinusOpen + maxOpenMinusClose)/c >= stretchPercent Then	canShort = True;if c > todaysOpen and c- todaysOpen = maxCloseMinusOpen and (maxCloseMinusOpen + maxOpenMinusClose)/c >= stretchPercent	Then	canBuy = True;if canTrade and t >= calcTime(dontTradeBefore,dontTradeBeforeOffset) and t < calcTime(dontTradeAfter,dontTradeAfterOffset) and t < sessionEndTime(0,1) Thenbegin	if shortsToday = 0 and canShort = True Then		sellshort next bar at l stop;	if buysToday = 0 and canBuy = True Then		buy next bar at h stop;end;	setExitOnClose;setStopLoss(stopLoss);setProfitTarget(takeProfit);``
The anti Rubber Band Strategy

Trade filtering was obtained by limiting the duration during the trading day that a trade could take place.  It’s usually wise to wait a few minutes after the open and a few minutes prior to the close to issue trade directives.  Also, range compression of the prior day seems to help in many cases.  Or at least not range expansion.   I only allow one long entry or one short or both during the trading day – two entries only!  Read the code and let me know if you have any questions.  This is a good framework for other areas of research.  Limiting entries using the mp variable is a neat technique that you can use elsewhere.

And as always let me know if you see any bugs in the code.  Like Donnie Knuth says, “Beware of bugs in the above code; I have only proved it correct, not tried it!”

# Learn Pyramiding, Scaling In or Out, Camarilla, Break Out and Clear Out techniques in day trading environment.

• Chapter 1 – Open Range Break Out and other Sundries
• Chapter 2 – Improving Our ORBO with Pattern Recognition
• Chapter 3 – Time based Breakout
• Chapter 4 – Trading After the Lunch Break
• Chapter 5 – Extending Our Break Out Technology With Pyramiding and Scaling Out
• Chapter 6 – Scaling Out of Pyramided and multiple Positions
• Chapter 7 – Pyramania
• Chapter 8 – Introduction to Zone Trading with the Camarilla
• Chapter 9 – Day Trading Templates Appendix

## Take a look at this function that spans the entire search space of all the combinations of the days of the week.

``inputs: optimizeNumber(numericSimple);arrays: dowArr[31]("");vars: currDOWStr(""),daysOfWeek("MTWRF");//Once//begin	print(d," ",t," assigning list ");	dowArr[1]="MTWRF";dowArr[2]="MTWR";	dowArr[3]="MTWF";dowArr[4]="MTRF";	dowArr[5]="MWRF";dowArr[6]="TWRF";	dowArr[7]="MTW";dowArr[8]="MTR";	dowArr[9]="MTF";dowArr[10]="MWR";	dowArr[11]="MWF";dowArr[12]="MRF";	dowArr[13]="TWR";dowArr[14]="TWF";	dowArr[15]="TRF";dowArr[16]="WRF";	dowArr[17]="MT";dowArr[18]="MW";	dowArr[19]="MR";dowArr[20]="MF";	dowArr[21]="TW";dowArr[22]="TR";	dowArr[23]="TF";dowArr[24]="WR";	dowArr[25]="WF";dowArr[26]="RF";	dowArr[27]="M";dowArr[28]="T";	dowArr[29]="W";dowArr[30]="R";	dowArr[31]="F";//end;OptimizeDaysOfWeek = False;if optimizeNumber > 0 and optimizeNumber < 32 ThenBegin	currDOWStr = midStr(daysOfWeek,dayOfWeek(d),1);	if inStr(dowArr[optimizeNumber],currDOWStr) <> 0 Then		OptimizeDaysOfWeek = True;end;``
All The Permutations of the Days of the Week

# Williams Awesome Oscillator Indicator and Strategy

## Awesome Oscillator

This is a very simple yet telling analysis.  Here is the EasyLanguage:

``[LegacyColorValue = true];                     Vars:oscVal(0),mavDiff(0);                    mavDiff= Average((h+l)/2,5)-Average((h+l)/2,34);oscVal = mavDiff - average(mavDiff,5);Plot3( 0, "ZeroLine" ) ;if currentbar>=1 then	if oscVal>oscVal[1] then plot1(mavDiff,"+AO")	else plot2(mavDiff,"-AO")``
Williams Awesome Oscillator Source Code

And here is what it looks like:

The code reveals a value that oscillates around 0.  First calculate the difference between the 5-day moving average of the daily midPoint (H+ L)/2 and the 34-day moving average of the midPoint.    A positive value informs us that the market is in a bullish stance whereas a negative represents a bearish tone.  Basically, the positive value is simply stating the shorter-term moving average is above the longer term and vice versa. The second step in the indicator calculation is to subtract the 5-day moving average of the differences from the current difference.  If the second calculation is greater than the prior day’s calculation, then plot the original calculation value as green (AO+).  If it is less (A0-), then paint the first calculation red.  The color signifies the momentum between the current and the five-day smoothed value.

## Awesome Indicator Strategy

``mavDiff= Average((h+l)/2,5)-Average((h+l)/2,34);oscVal = mavDiff - average(mavDiff,5);                                     mp = marketPosition;mavUp = countIf(mavDiff > 0,30);mavDn = countIf(mavDiff < 0,30);value1 = countIf(oscVal > oscVal[1],10);oscRatio = value1/10*100;``
The beginning of an AO based Strategy

Here I am using the very handy countIf function.  This function will tell you how many times a Boolean comparison is true out of the last N days.  Her I use the function twice, but I could have replaced the second function call with mavDn = 30 – mavUp.  So, I am counting the number of occurrences of when the mavDiff is positive and negative over the past 30-days.  I also count the number of times the oscVal is greater than the prior oscVal.  In other words, I am counting the number of green bars.  I create a ratio between green bars and 10.  If there are six green bars, then the ratio equals 60% This indicates that the ratio of red bars would be 40%.  Based on these readings you can create trade entry directives.

``if canShort and mavUp > numBarsAbove and mavDiff > minDiffAmt and oscRatio >= obRatio thensellShort next bar at open;if canBuy and mavDn > numBarsBelow and mavDiff < -1*minDiffAmt and oscRatio <= osRatio Thenbuy next bar at open;       ``

If the number of readings out of the last 30 days is greater than numBarsAbove and mavDiff is of a certain magnitude and the oscillator ratio is greater than buyOSCRatio, then you can go short on the next open.  Here we are looking for the market to converge.  When these conditions are met then I think the market is overbought.  You can see how I set up the long entries.  As you can see from the chart it does a pretty good job.  Optimizing the parameters on the crude oil futures yielded this equity curve.

Not bad, but not statistically significant either.  One way to generate more trades is to install some trade management such as protective stop and profit objective.

Using a wide protective stop and large profit objective tripled the number of trades.  Don’t know if it is any better, but total performance was not derived from just a couple of trades.  When you are working with a strategy like this and overlay trade management you will often run into this situation.

Here we either get stopped out or take a profit and immediately reenter the market.  This occurs when the conditions are still met to short when we exit a trade.  The fix for this is to determine when an exit has occurred and force the entry trigger to toggle off.  But you have to figure out how to turn the trigger back on.  I reset the triggers based on the number of days since the triggers were turned off – a simple fix for this post.  If you want to play with this strategy, you will probably need a better trigger reset.

I am using the setStopLoss and setProfitTarget functionality via their own strategies – Stop Loss and Profit Target.  These functions allow exit on the same as entry, which can be useful.  Since we are executing on the open of the bar, the market could definitely move either in the direction of the stop or the profit.  Since we are using wide values, the probability of both would be minimal.  So how do you determine when you have exited a trade.  You could look the current bar’s marketPosition and compare it with the prior bar’s value, but this doesn’t work 100% of the time.  We could be flat at yesterday’s close, enter long on today’s open and get stopped out during the day and yesterday’s marketPosition would be flat and today’s marketPosition would be flat as well.  It would be as if nothing occurred when in fact it did.

Take a look at this code and see if it makes sense to you.

``if mp[1] = 1 and totalTrades > totTrades then	canBuy = False;		if mp[1] = -1 and totalTrades > totTrades then 	canShort = False;if mp[1] = 0 and totalTrades > totTrades thenBegin	if mavDiff[1] < 0 then canBuy = False;		if mavDiff[1] > 0 then canShort = False;end;totTrades = totalTrades;``
Watch for a change in totalTrades.

``if  not(canBuy) Then	if barsSince(canBuy=True,100,1,0) = 6 then		canBuy = True;if  not(canShort) Then	if barsSince(canShort=True,100,1,0) = 6 then		canShort = True;``

Complete strategy code:

``inputs:numBarsAbove(10),numBarsBelow(10),buyOSCRatio(60),shortOSRatio(40),minDiffAmt(2),numBarsTrigReset(6);Vars:canBuy(True),canShort(True),mp(0),totTrades(0),oscVal(0),mavDiff(0),oscRatio(0),mavUp(0),mavDn(0),stopLoss\$(1000);	                    mavDiff= Average((h+l)/2,5)-Average((h+l)/2,34);oscVal = mavDiff - average(mavDiff,5);                                     mp = marketPosition;mavUp = countIf(mavDiff > 0,30);mavDn = countIf(mavDiff < 0,30);value1 = countIf(oscVal > oscVal[1],10);oscRatio = value1/10*100; if  not(canBuy) Then	if barsSince(canBuy=True,100,1,0) = numBarsTrigReset then		canBuy = True;if  not(canShort) Then	if barsSince(canShort=True,100,1,0) = numBarsTrigReset then		canShort = True;if mp[1] = 1 and totalTrades > totTrades then	canBuy = False;		if mp[1] = -1 and totalTrades > totTrades then 	canShort = False;if mp[1] = 0 and totalTrades > totTrades thenBegin	if mavDiff[1] < 0 then canBuy = False;		if mavDiff[1] > 0 then canShort = False;end;if canShort and mavUp > numBarsAbove and mavDiff > minDiffAmt and oscRatio >= buyOSCRatio thensellShort next bar at open;if canBuy and mavDn > numBarsBelow and mavDiff < -1*minDiffAmt and oscRatio <= shortOSRatio Thenbuy next bar at open;       		totTrades = totalTrades;                           ``

# The EasyLanguage Function: A Thing of Beauty

The concept of Scope when it comes to a programming language can get very confusing very quickly. If you are new to programming and you think Scope is a mouthwash, no worries here. I will give a full explanation of Scope in terms of programming with the help of ChatGPT. Its response is italicized.

I recently chatted with ChatGPT about Scope in terms of the Python programing language.

In Python, the scope of a variable refers to the region of the program where that variable can be accessed or referenced. There are two types of scopes in Python: global scope and local scope.

Here’s an example that demonstrates the concept of scope in Python:

``# global variablex = 10def my_func():    # local variable    y = 5    print("x inside my_func:", x)  # x is accessed from the global scope    print("y inside my_func:", y)  # y is accessed from the local scopemy_func()print("x outside my_func:", x)  # x is accessed from the global scopeprint("y outside my_func:")  # y is not defined in the global scope, so this will raise a NameError``
Example of Scope as demonstrated by Chat-GPT

In this example, we define a global variable `x` with a value of `10`.

We then define a function `my_func` that has a local variable `y` with a value of `5`. Inside the function, we print the values of `x` and `y`. The variable `x` is accessed from the global scope, which means it can be referenced from anywhere in the program.

The variable `y`, on the other hand, is only accessible within the function, which is the local scope. Outside the function, we print the value of `x` again, which is still accessible from the global scope. However, when we try to print the value of `y`, we get a NameError because `y` is not defined in the global scope.

Okay that was pretty formal. In simpler terms, a variable declared inside a function can only be seen inside that function, unless it is declared globally. Another thing about Scope, is that the variables have amnesia. Once you step out of the function the variable forgets what it was, and you can’t refer to its prior value upon return to the function.

Unless you are an EasyLanguage function. Scope is still constrained by an EasyLanguage function, because it is a separate piece of code held within the library of Analysis Techniques. Most of the time you can’t see what’s in the function unless you open it with the ELEditor. However, the variables that are defined inside the function do not suffer from amnesia. If you need to refer to a prior value of a locally declared variable, you can. This type of function is what EasyLanguage calls a Serial function. The only downside to this function is it slows processing down quite a bit.

Okay. To make a long story short I wanted to show the magic of EasyLanguage function that I have been working with on a project. This project includes some of Ehlers’ cycle analysis functions. The one I am going to discuss today is the HighRoof function – don’t worry I am not going to go into detail of what this function does. If you want to know just GOOGLE it or ask ChatGPT. I developed a strategy that used the function on the last 25 days of closing price data. I then turned around and fed the output of the first pass of the HighRoof function right back into the HighRoof function. Something similar to embedding functions.

doubleSmooth = average(average(c,20),20);

Sort of like a double smoothed moving average. After I did this, I started thinking does the function remember the data from its respective call? The first pass used closing price data, so its variables and their history should be in terms of price data. The second pass used the cyclical movements data that was output by the initial call to the HighRoof function. Everything turned out fine, the function remembered the correct data. Or seemed like it did. This is how you learn about any programming language – pull out your SandBox and do some testing. First off, here is my conversion of Ehlers’ HighRoof function in EasyLanguage.

``//Ehlers HiRoof Inputs: dataSeries(numericseries),cutPeriod(Numeric);  Vars:   a1(0), b1(0), c1(0), c2(0), c3(0), Filt(0), Filt2(0),         alpha1(0),oneMinusAlpha1(0), highPass(0),myhp(0),degrees(0); Vars: numTimesCalled(0);   //Highpass filter cyclic components whose periods are shorter than 48 barsnumTimesCalled = numTimesCalled + 1;print(d," numTimesCalled ",numTimesCalled," highPass[1] ",highPass[1]," highPass[2] ",highPass[2]," highPass[3] ",highPass[3]);degrees = .707*360 / CutPeriod;alpha1 = (Cosine(degrees) + Sine(degrees) - 1) / Cosine(degrees);oneMinusAlpha1 = 1-alpha1; highPass = square(oneMinusAlpha1/2)*(dataSeries-2*dataSeries[1]+dataSeries[2]) +  2*(oneMinusAlpha1)*highPass[1]-square(oneMinusAlpha1)*highPass[2];   EhlersHighRoof=highPass;``
Ehlers High Roof Function

This function requires just two inputs – the data (with a history) and a simple length or cut period. The first input is of type numericSeries and the second input is of type numericSimple. You will see the following line of code

`` print(d," numTimesCalled ",numTimesCalled," highPass[1] ",highPass[1]," highPass[2] ",highPass[2]," highPass[3] ",highPass[3]);``

This code prints out the last three historic values of the HighPass variable for each function call. I am calling the function twice for each bar of data in the Crude Oil futures continuous contract.

``1230206.00 numTimesCalled  494.00 highPass[1]   -0.78 highPass[2]   -0.51 highPass[3]   -0.601230206.00 numTimesCalled  494.00 highPass[1]   -0.05 highPass[2]   -0.02 highPass[3]   -0.061230207.00 numTimesCalled  495.00 highPass[1]   -0.38 highPass[2]   -0.78 highPass[3]   -0.511230207.00 numTimesCalled  495.00 highPass[1]    0.04 highPass[2]   -0.05 highPass[3]   -0.021230208.00 numTimesCalled  496.00 highPass[1]    0.31 highPass[2]   -0.38 highPass[3]   -0.781230208.00 numTimesCalled  496.00 highPass[1]    0.16 highPass[2]    0.04 highPass[3]   -0.051230209.00 numTimesCalled  497.00 highPass[1]    0.49 highPass[2]    0.31 highPass[3]   -0.381230209.00 numTimesCalled  497.00 highPass[1]    0.15 highPass[2]    0.16 highPass[3]    0.041230210.00 numTimesCalled  498.00 highPass[1]    0.30 highPass[2]    0.49 highPass[3]    0.311230210.00 numTimesCalled  498.00 highPass[1]    0.07 highPass[2]    0.15 highPass[3]    0.161230213.00 numTimesCalled  499.00 highPass[1]    0.52 highPass[2]    0.30 highPass[3]    0.491230213.00 numTimesCalled  499.00 highPass[1]    0.08 highPass[2]    0.07 highPass[3]    0.151230214.00 numTimesCalled  500.00 highPass[1]    0.44 highPass[2]    0.52 highPass[3]    0.301230214.00 numTimesCalled  500.00 highPass[1]    0.04 highPass[2]    0.08 highPass[3]    0.07``
Output of calling HighRoof twice per bar

Starting at the top of the output you will see that on 1230206 the function was called twice with two different sets of data. As you can see the output of the first two lines is of a different magnitude. The first line is approximately an order or magnitude of 10 of the second line. If you go to lines 3 and 4 you will see the highPass[1] of lines 1 and 2 moves to highPass[2] and then onto highPass[3]. I think what happens internally is for every call on per bar basis, the variables for each function call are pushed into a queue in memory. The queue continues to grow for whatever length is necessary and then either maintained or truncated at some later time.

## Why Is This So Cool?

In many languages the encapsulation of data with the function requires additional programming. The EasyLanguage function could be seen as an “object” like in object-oriented programming. You just don’t know you are doing it. EasyLanguage takes care of a lot of the behind-the-scenes data management. To do the same thing in Python you would need to create a class of Ehlers Roof that maintain historic data in class members and the calculations would be accomplished by a class method. In the case of calling the function twice, you would instantiate two classes from the template and each class would act independent of each other.

## Here is my SandBox for Indicator

``Value1 = EhlersHighRoof(close,25);plot1(Value1,"EhlersHiRoof");Value2 = EhlersHighRoof(value1,25);plot2(Value2,"EhlersHiRoof2");``
Sandbox Playground for Ehlers Function

One last nugget of information. If you are going to be working with trigonometric functions such as Cosine, Sine or Tangent, make sure your arguments are in degrees not radians. In Python, you must use radians.

# Have you discovered a seasonal tendency but can’t figure out how to test it?

Are there certain times of the year when a commodity increases in price and then recedes?  In many markets this is the case.  Crude oil seems to go up during the summer months and then chills out in the fall.  It will rise once again when winter hits.  Early spring might show another price decline.  Have you done your homework and recorded certain dates of the year to buy/sell and short/buyToCover.  Have you tried to apply these dates to a historical back test and just couldn’t figure it out?  In this post I am going to show how you can use arrays and loops to cycle through the days in your seasonal database (database might be too strong of a term here) and apply long and short entries at the appropriate times during the past twenty years of daily bar data.

## Build the Quasi-Database with Arrays

If you are new to EasyLanguage  you may not yet know what arrays are or you might just simply be scared of them.  Now worries here!  Most people bypass arrays because they don’t know how to declare them, and if they get passed that, how to manipulate them to squeeze out the data they need. You may not be aware of it, but if you have programmed in EasyLanguage the least bit, then you have already used arrays.  Check this out:

``if high > high[1] and low > low[1] andaverage(c,30) > average(c,30)[1] thenbuy next bar at open``

In reality the keywords high and low are really arrays.  They are lists that contain the entire history of the high and low prices of the data that is plotted on the chart.  And just like with declared arrays, you index these keywords to get historic data.  the HIGH[1] means the high of yesterday and the HIGH[2] means the high of the prior day.   EasyLanguage handles the management of these array-like structures.  In other words, you don’t need to keep track of the indexing – you know the [1] or [2] stuff.  The declaration of an array is ultra-simple once you do it a few times.  In our code we are going to use four arrays:

2. SellShort array
3. Sell array

Each of these arrays will contain the month and day of month when a trade is to be entered or exited.  Why not the year?  We want to keep things simple and buy/short the same time every year to see if there is truly a seasonal tendency.  The first thing we need to do is declare the four arrays and then fill them up.

``// use the keyword arrays and : semicolon// next give each array a name and specify the// max number of elements that each array can hold// the [100] part.  Each array needs to be initialized // and we do this by placing a zero (0) in parenthesesarrays: buyDates[100](0),sellDates[100](0),      shortDates[100](0),buyToCoverDates[100](0);// next you want the arrays that go together to have the same// index value - take a look at thisbuyDates[1] = 0415;sellDates[1] = 0515;buyDates[2] = 0605;sellDates[2] = 0830;shortDates[1] = 0915;buyToCoverDates[1] = 1130;shortDates[2] = 0215;buyToCoverDates[2] = 0330;// note the buyDates[1] has a matching sellDates[1]//          buyDates[2] has a matching sellDates[2]// -- and --// shortDates[1] has a matching buyToCoverDates[1]// shortDates[2] has a matching buyToCoverDates[2]``

Our simple database has been declared, initialized and populated.  This seasonal strategy will buy on:

• April 15th and Exit on May 15th
• June 5th and Exit on August 30th

It will sellShort on:

• September 15th and Cover on November 30th
• February 15th and Cover on March 30th

You could use this template and follow the pattern to add more dates to your database.  Just make sure nothing overlaps.

Now, each chart has N dates of history plotted from the left to right.  TradeStation starts out the test from the earliest date to the last date.  It does this by looping one day at a time.  The first thing we need to do is convert the bar date (TradeStation represents dates in a weird format – YYYMMDD – Jan 30, 2022 is represented by the number 1220130 – don’t ask why!!) to a format like the data that is stored in our arrays.   Fortunately, we don’t have to deal with the year and EasyLanguage provides two functions to help us out.

• Month(Date) = the month (1-12) of the current bar
• DayOfMonth(Date) = the day of the month of the current bar

All we need to do is use these functions to convert the current bar’s date into terms of our database, and then test that converted date against our database.  Take a look:

``//convert the date into our own terms//say the date is December 12//the month function returns 12 and the day of month returns 12// 12*100 + 12 = 1212 --> MMDD - just waht we need//notice I look at the date of tomorrow because I want to take//action on the open of tomorrow.currentMMDD = month(d of tomorrow)*100 + dayOfMonth(d of tomorrow);//You might need to study this a little bit - but I am looping through each//array to determine if a trade needs to be entered.//Long Seasonal Entries togglebuyNow = False;for n = 1 to numBuyDatesBegin	if currentMMDD[1] < buyDates[n]  and currentMMDD >= buyDates[n]   Then	Begin		buyNow = True;	end;end;//Short Seasonal Entries toggleshortNow = False;for n = 1 to numshortDatesBegin	if currentMMDD[1] < shortDates[n] and currentMMDD >= shortDates[n] Then	Begin		shortNow = True;	end;end;``
Date conversion and looping thru Database

This code might look a little daunting, but it really isn’t.  The first for-loop starts at 1 and goes through the number of buyDates.  The index variable is the letter n. The loop starts at 1 and goes to 2 in increments of 1.  Study the structure of the for-loop and let me know if you have any questions.  What do you think this code is doing.

``if currentMMDD[1] < buyDates[n] andcurrentMMDD >= buyDates[n] Then``

As you know the 15th of any month may fall on a weekend.  This code basically says, ” Okay if today is less than the buyDate and tomorrow is equal to or greater than buyDate, then tommorrow is either going to be the exact day of the month or the first day of the subsequent week (the day of month fell on a weekend.)  If tomorrow is a trade date, then a conditional buyNow is set to True.  Further down in the logic the trade directive is issued if buyNow is set to True.

### Total of 4 loops – 2 for each long/short entry and 2 for each long/short exit.

Here is the rest of the code:

``inputs: dollarProfit(5000),dollarLoss(3000);arrays: buyDates[100](0),sellDates[100](0),      shortDates[100](0),buyToCoverDates[100](0);       vars: n(0),mp(0),currentMMDD(0), 	   numBuyDates(0),numshortDates(0), 	   numSellDates(0),numBuyToCoverDates(0); 	    vars: buyNow(False),shortNow(False),       sellNow(False),buyToCoverNow(False);      // fill the arrays with dates - remember we are not pyramiding here//  use mmdd formatbuyDates[1] = 0415;sellDates[1] = 0515;buyDates[2] = 0605;sellDates[2] = 0830;numBuyDates = 2;numSellDates = 2;shortDates[1] = 0915;buyToCoverDates[1] = 1130;shortDates[2] = 0215;buyToCoverDates[2] = 0330;numshortDates = 2;numbuyToCoverDates = 2;mp = marketPosition;currentMMDD = month(d of tomorrow)*100 + dayOfMonth(d of tomorrow);//Long Seasonal Entries togglebuyNow = False;for n = 1 to numBuyDatesBegin	if currentMMDD[1] < buyDates[n]  and currentMMDD >= buyDates[n]   Then	Begin		buyNow = True;	end;end;//Short Seasonal Entries toggleshortNow = False;for n = 1 to numshortDatesBegin	if currentMMDD[1] < shortDates[n] and currentMMDD >= shortDates[n] Then	Begin		shortNow = True;	end;end;//Long Seasonal Exits togglesellNow = False;if mp = 1 ThenBegin	for n = 1 to numSellDates	Begin		if currentMMDD[1] < sellDates[n] and currentMMDD >= sellDates[n] Then		Begin			sellNow = True;		end;	end;end;//Short Seasonal Exits togglebuyToCoverNow = False;if mp = -1 ThenBegin	for n = 1 to numBuyToCoverDates	Begin		if currentMMDD[1] < buyToCoverDates[n] and currentMMDD >= buyToCoverDates[n] Then		Begin			buyToCoverNow = True;		end;	end;end;// Long entry executionif buyNow = True thenbegin	buy("Seas-Buy") next bar at open;end;// Long exit executionif mp = 1 thenbegin	if sellNow then	begin		sell("Long Exit") next bar at open;	end;end;// Short entry executionif shortNow thenbegin	sellShort("Seas-Short") next bar at open;end;// short exit executionif mp = -1 thenbegin	if buyToCoverNow then	begin		buyToCover("short Exit") next bar at open;	end;end; 	setStopLoss(dollarLoss);setProfitTarget(dollarProfit);``
Complete Seasonal Template EasyLanguage Code

Does it work?  It does – please take my word for it.  IYou can email me with any questions.  However, TS 10 just crashed on me and is wanting to update, but I need to kill all the processes before it can do a successful update.  Remember to always export your new code to an external location.  I will post an example on Monday Jan 30th.

# The Clear Out Pattern

This pattern has been around for many years, and is still useful today in a day trading scheme.  The pattern is quite simple:  if today’s high exceeds yesterday’s high by a certain amount, then sell short as the market moves back through yesterday’s high.  There are certain components of yesterday’s daily bar that are significant to day traders – the high, the low, the close and the day traders’ pivot.  Yesterday’s high is considered a level of resistance and is often tested.  Many times the market has just enough momentum to carry through this resistance level, but eventually peters out and then the bears will jump in and push the market down even more.  The opposite is true when the bulls take over near the support level of yesterday’s low.  Here is an example of Clear Out short and buy.

## How Do You Program this Simple Pattern?

The programming of this strategy is rather simple, if you are day trading.  The key components are toggles that track the high and low of the day as the market penetrate the prior day’s high and low.  Once the toggles are flipped on, then order directives can be placed.  A max. trade stop loss can easily be installed via the SetStopLoss(500) function.  You will also want to limit the number of entries, because in a congestive phase, this pattern could fire off multiple times.   Once you intuitively program this,  you will almost certainly run into an issue where a simple “trick” will bail you out.   Remember the code does exactly what you tell it to do. Take a look at these trades.

### Okay – Can you rely on a 5 minute bar then?

Five minute bar data has been the staple of day trading systems for many years.  However, if you want to test “bang-bang” algorithms you are probably better off dropping down to a N-seconds bar.  However, this strategy as a whole is not “bang-bang” so with a little trick you can get more accurate entries and exits.

### How Does the Trick Affect Performance?

Here are the results over the past four months on different time frame resolutions.

10 seconds bar would be the most accurate if slippage is acceptable.  And that is a big assumption on “bang-bang” days.

The one minute bar is close but September is substantially off.  Probably some “bang-bang” action.

This is close to the 10-second bar result.  Fast market or “bang-bang” trades were reduced or eliminated with the “trick”.

Surprisingly, the 5 minute bar without the “Trick” resembles the 10 seconds results.  But we know this is not accurate as trades are fired off in a manner that goes against reality.

The two following table shows the impact of a \$15 RT comm./slipp. per trade charge.

## Okay, Now That We Have That Figured Out How Do You Limit Trading After a Daily Max. Loss

Another concept I wanted to cover was limiting trades after a certain loss level was suffered on a daily basis.  In the code, I only wanted to enter trades as long as the max. daily loss was less than or equal to \$1,000   A fixed stop of \$500 on a per trade basis was utilized as well.  So, if you suffered two max. stop losses right off the bat (\$1,000), you could still take one more trade.  Now if you had a \$500 winner and two \$500 losses you could still take another trade.

If you are going to trade a system, you better trade it systematically!

## Now Onto the Code

``//Illustrate trade stoppage after a certain loss has been//experienced and creating realistic stop orders.inputs: maxDailyLoss(1000),startTime(0935);inputs: clrOutBuyPer(.10),clrOutShortPer(.10);vars: coBuy(False),coShort(False),canTrade(0);vars: beginOfDayProfit(0),beginOfDayTotTrades(0),mp(0);if t = startTime thenbegin	coBuy = False;	coShort = False;	beginOfDayProfit = netProfit;	beginOfDayTotTrades = totalTrades;end;canTrade = iff(t >=startTime and t < sess1EndTime,1,0);if  t >= startTime and h > highD(1) + clrOutBuyPer*(highD(1)-lowD(1)) thenbegin	coShort = True;end;if  t >= startTime and l < lowD(1) - clrOutShortPer*(highD(1)-lowD(1)) thenbegin	coBuy = True;end;mp = marketPosition;if canTrade = 1 and coShort and netProfit >= beginOfDayProfit - maxDailyLoss andc > highD(1) - minMove/priceScale then	 sellShort next bar at highD(1) - minMove/priceScale stop;	 if mp = -1 then // toggle to turn off coShort - must wait for set upbegin	coShort = False;end;if canTrade = 1 and coBuy and netProfit >= beginOfDayProfit - maxDailyLoss andc <  lowD(1) + minMove/priceScale then	buy next bar at lowD(1) + minMove/priceScale stop;	if mp = 1 thenbegin	coBuy = False;end;setStopLoss(500);setExitOnClose;``
Strategy in its Entirety

You need to capture the NetProfit sometime during the day before trading commences.  This block does just that.

``if t = startTime thenbegin	coBuy = False;	coShort = False;	beginOfDayProfit = netProfit;	beginOfDayTotTrades = totalTrades;end;``
Snippet that captures NetProfit at start of day

Now all you need to do is compare the current netProfit (EL keyword) to the beginOfDayProfit (user variable)If the current netProfit >= beginOfDayProfit – maxDailyLoss (notice I programmed greater than or equal to), then proceed with the next trade.  The rest of the logic is pretty self explanatory, but to drive the point home, here is how I make sure a proper stop order is placed.

``if canTrade = 1 and coShort and netProfit >= beginOfDayProfit - maxDailyLoss andc > highD(1) - minMove/priceScale then	 sellShort next bar at highD(1) - minMove/priceScale stop;	 if mp = -1 then // toggle to turn off coShort - must wait for set upbegin	coShort = False;end;``
Notice how I use the current bars Close - C and How I toggle coShort to False

## If You Like This – Make Sure You Get My Hi-Res Edition of Easing Into EasyLanguage

This is a typical project I discuss in the second book in the Easing Into EasyLanguage Trilogy.  I have held over the BLACK FRIDAY special, and it will stay in effect through December 31st.  Hurry, and take advantage of the savings.  If you see any mistakes, or just want to ask me a question, or have a comment, just shoot me an email.

# Complete Strategy based on Sheldon Knight and William Brower Research

In my Easing Into EasyLanguage:  Hi-Res Edition, I discuss the famous statistician and trader Sheldon Knight and his  K-DATA Time Line.  This time line enumerated each day of the year using the following nomenclature:

First Monday in December = 1stMonDec

Second Friday in April = 2ndFriApr

Third Wednesday in March = 3rdWedMar

This enumeration or encoding was used to determine if a certain week of the month and the day of week held any seasonality tendencies.  If you trade index futures you are probably familiar with Triple Witching Days.

Four times a year, contracts for stock options, stock index options, and stock index futures all expire on the same day, resulting in much higher volumes and price volatility. While the stock market may seem foreign and complicated to many people, it is definitely not “witchy”, however, it does have what is known as “triple witching days.”

Triple witching, typically, occurs on the third Friday of the last month in the quarter. That means the third Friday in March, June, September, and December. In 2022, triple witching Friday are March 18, June 17, September 16, and December 16

Other days of certain months also carry significance.  Some days, such as the first Friday of every month (employment situation), carry even more significance.   In 1996, Bill Brower wrote an excellent article in Technical Analysis of Stocks and Commodities.  The title of the article was The S&P 500 Seasonal Day Trade.  In this article, Bill devised 8 very simple day trade patterns and then filtered them with the Day of Week in Month.  Here are the eight patterns as he laid them out in the article.

1. Pattern 1:  If tomorrow’s open minus 30 points is greater than today’s close, then buy at market.
2. Pattern 2:  If tomorrow’s open plus 30 points is less than today’s close, then buy at market.
3. Pattern 3:  If tomorrow’s open minus 30 points is greater than today’s close, then sell short at market.
4. Pattern 4:  If tomorrow’s open plus 30 points is less than today’s close, then sell short at market.
5. Pattern 5:  If tomorrow’s open plus 10 points is less than today’s low, then buy at market.
6. Pattern 6:  If tomorrow’s open minus 20 points is greater than today’s high, then sell short at today’s close stop.
7. Pattern 7:  If tomorrow’s open minus 40 points is greater than today’s close, then buy at today’s low limit.
8. Pattern 8:  If tomorrow’s open plus 70 points is less than today’s close, then sell short at today’s high limit.

This article was written nearly 27 years ago when 30 points meant something in the S&P futures contract.   The S&P was trading around the 600.00 level.  Today the  e-mini S&P 500 (big S&P replacement) is trading near 4000.00 and has been higher.  So 30, 40 or 70 points doesn’t make sense.  To bring the patterns up to date, I decided to use a percentage of ATR in place of a single point.  If today’s range equals 112.00 handles or in terms of points 11200 and we use 5%, then the basis would equate to 11200 = 560 points or 5.6 handles.  In the day of the article the range was around 6 handles or 600 points.  So. I think using 1% or 5% of ATR could replace Bill’s point values.  Bill’s syntax was a little different than the way I would have described the patterns.  I would have used this language to describe Pattern1 – If tomorrow’s open is greater than today’s close plus 30 points, then buy at market – its easy to see we are looking for a gap open greater than 30 points here.  Remember there is more than one way to program an idea.  Let’s stick with Bills syntax.

• 10 points = 1 X (Mult)  X ATR
• 20 points = 2 X (Mult)  X ATR
• 30 points = 3 X (Mult)  X ATR
• 40 points = 4 X (Mult)  X ATR
• 50 points = 5 X (Mult)  X ATR
• 70 points =7 X (Mult)  X ATR

We can play around with the Mult to see if we can simulate similar levels back in 1996.

``// atrMult will be a small percentage like 0.01 or 0.05atrVal = avgTrueRange(atrLen) * atrMult;//original patterns//use IFF function to either returne a 1 or a 0//1 pattern is true or 0 it is falsepatt1 = iff(open of tomorrow - 3 * atrVal > c,1,0);patt2 = iff(open of tomorrow + 3 * atrVal < c,1,0);patt3 = iff(open of tomorrow - 3 * atrVal > c,1,0);patt4 = iff(open of tomorrow + 3 * atrVal < c,1,0);patt5 = iff(open of tomorrow + 1 * atrVal < l,1,0);patt6 = iff(open of tomorrow - 2 * atrVal > h,1,0);patt7 = iff(open of tomorrow - 4 * atrVal > c,1,0);patt8 = iff(open of tomorrow + 7 * atrVal < c,1,0);``

## William Brower’s DoWInMonth Enumeration

The Day of Week In A Month is represented by a two digit number.  The first digit is the week rank and the second number is day of the week.  I thought this to be very clever, so I decided to program it.    I approached it from a couple of different angles and I actually coded an encoding method that included the week rank, day of week, and month (1stWedJan) in my Hi-Res Edition.   Bill’s version didn’t need to be as sophisticated and since I decided to use TradeStation’s optimization capabilities I didn’t need to create a data structure to store any data.  Take a look at the code and see if it makes a little bit of sense.

``newMonth = False;newMonth = dayOfMonth(d of tomorrow) < dayOfMonth(d of today);atrVal = avgTrueRange(atrLen) * atrMult;if newMonth thenbegin	startTrading = True;	monCnt = 0;	tueCnt = 0;	wedCnt = 0;	thuCnt = 0;	friCnt = 0;	weekCnt = 1;end;if not(newMonth) and dayOfWeek(d of tomorrow) < dayOfWeek(d of today) then	weekCnt +=1;dayOfWeekInMonth = weekCnt * 10 + dayOfWeek(d of tomorrow);	``
Simple formula to week rank and DOW

NewMonth is set to false on every bar.  If tomorrow’s day of month is less than today’s day of month, then we know we have a new month and newMonth is set to true.  If we have a new month, then several things take place: reinitialize the code that counts the number Mondays, Tuesdays, Wednesdays, Thursdays and Fridays to 0 (not used for this application but can be used later,) and set the week count weekCnt to 1.  If its not a new month and the day of week of tomorrow is less than the day of the week today (Monday = 1 and Friday = 5, if tomorrow is less than today (1 < 5)) then we must have a new week on tomorrow’s bar.  To encode the day of week in month as a two digit number is quite easy – just multiply the week rank (or count) by 10 and add the day of week (1-Monday, 2-Tuesday,…)  So the third Wednesday would be equal to 3X10+3 or 33.

## Use Optimization to Step Through 8 Patterns and 25 Day of Week in Month Enumerations

Stepping through the 8 patterns is a no brainer.  However, stepping through the 25 possible DowInAMonth codes or enumerations is another story.  Many times you can use an equation based on the iterative process of going from 1 to 25.  I played around with this using the modulus function, but decided to use the Switch-Case construct instead.  This is a perfect example of replacing math with computer code.  Check this out.

``switch(dowInMonthInc)begin	case 1 to 5:		value2 =  mod(dowInMonthInc,6);		value3 = 10;	case 6 to 10:		value2 = mod(dowInMonthInc-5,6);		value3 = 20;	case 11 to 15:		value2 = mod(dowInMonthInc-10,6);		value3 = 30;	case 16 to 20:		value2 = mod(dowInMonthInc-15,6);		value3 = 40;	case 21 to 25:		value2 = mod(dowInMonthInc-20,6);		value3 = 50;end;``
Switch-Case to Step across 25 Enumerations

Here we are switching on the input (dowInMonthInc).  Remember this value will go from 1 to 25 in increments of 1. What is really neat about EasyLanguage’s implementation of the Switch-Case is that it can handle ranges.  If the dowInMonthInc turns out to be 4 it will fall within the first case block (case 1 to 5).  Here we know that if this value is less than 6, then we are in the first week so I set the first number in the two digit dayOfWeekInMonth representation to 1.  This is accomplished by setting value3 to 10.  Now you need to extract the day of the week from the 1 to 25 loop.  If the dowInMonthInc is less than 6, then all you need to do is use the modulus function and the value 6.

• mod(1,6)  = 1
• mod(2,6) = 2
• mod(3,6) = 3

This works great when the increment value is less than 6.  Remember:

• 1 –> 11 (first Monday)
• 2 –> 12 (first Tuesday)
• 3 –> 13 (first Wednesday)
• 6 –> 21 (second Monday)
• 7 –> 22 (second Tuesday).

So, you have to get a little creative with your code.  Assume the iterative value is 8.  We need to get 8 to equal 23 (second Wednesday).  This value falls into the second case, so Value3 = 20 the second week of the month.  That is easy enough.  Now we need to extract the day of week – remember this is just one solution, I guarantee there are are many.

mod(dowInMonthInc – 5, 6) – does it work?

value2 = mod(8-5,6) = 3 -> value3 = value1  +  value2 -> value3 = 23.  It worked.   Do you see the pattern below.

• case   6 to 10 – mod(dowInMonthInc –  5, 6)
• case 11 to 15 – mod(dowInMonthInc – 10, 6)
• case 16 to 20- mod(dowInMonthInc – 15, 6)
• case 21 to25 – mod(dowInMonthInc – 20, 6)

Save Optimization Report as Text and Open with Excel

Here are the settings that I used to create the following report.  If you do the math that is a total of 200 iterations.

I opened the Optimization Report and saved as text.  Excel had no problem opening it.

I created the third column by translating the second column into our week of month and day of week vernacular.  These results were applied to 20 years of ES.D (day session data.)  The best result was Pattern #3 applied to the third Friday of the month (35.)  Remember the 15th DowInMonthInc  equals the third (3) Friday (5).  The top patterns predominately occurred on a Thursday or Friday.

Here is the complete code for you to play with.

``inputs: atrLen(10),atrMult(.05),patternNum(1),dowInMonthInc(1);vars: patt1(0),patt2(0),patt3(0),patt4(0),patt5(0),patt6(0),patt7(0),patt8(0);vars: atrVal(0),dayOfWeekInMonth(0),startTrading(false),newMonth(False);;vars: monCnt(0),tueCnt(0),wedCnt(0),thuCnt(0),friCnt(0),weekCnt(0);newMonth = False;newMonth = dayOfMonth(d of tomorrow) < dayOfMonth(d of today);atrVal = avgTrueRange(atrLen) * atrMult;if newMonth thenbegin	startTrading = True;	monCnt = 0;	tueCnt = 0;	wedCnt = 0;	thuCnt = 0;	friCnt = 0;	weekCnt = 1;end;if not(newMonth) and dayOfWeek(d of tomorrow) < dayOfWeek(d of today) then	weekCnt +=1;dayOfWeekInMonth = weekCnt * 10 + dayOfWeek(d of tomorrow);	//print(date," ", dayOfMonth(d)," " ,dayOfWeek(d)," ",weekCnt," ",monCnt," ",dayOfWeekInMonth);//original patternspatt1 = iff(open of tomorrow - 3 * atrVal > c,1,0);patt2 = iff(open of tomorrow + 3 * atrVal < c,1,0);patt3 = iff(open of tomorrow - 3 * atrVal > c,1,0);patt4 = iff(open of tomorrow + 3 * atrVal < c,1,0);patt5 = iff(open of tomorrow + 1 * atrVal < l,1,0);patt6 = iff(open of tomorrow - 2 * atrVal > h,1,0);patt7 = iff(open of tomorrow - 4 * atrVal > c,1,0);patt8 = iff(open of tomorrow + 7 * atrVal < c,1,0);switch(dowInMonthInc)begin	case 1 to 5:		value2 =  mod(dowInMonthInc,6);		value3 = 10;	case 6 to 10:		value2 = mod(dowInMonthInc-5,6);		value3 = 20;	case 11 to 15:		value2 = mod(dowInMonthInc-10,6);		value3 = 30;	case 16 to 20:		value2 = mod(dowInMonthInc-15,6);		value3 = 40;	case 21 to 25:		value2 = mod(dowInMonthInc-20,6);		value3 = 50;end;value1 = value3 + value2 ;//print(d," ",dowInMonthInc," ",dayOfWeekInMonth," ",value1," ",value2," ",value3," ",mod(dowInMonthInc,value2));if value1 = dayOfWeekInMonth thenbegin	if patternNum = 1 and patt1 = 1 then buy("Patt1") next bar at open;	if patternNum = 2 and patt2 = 1 then buy("Patt2") next bar at open;	if patternNum = 3 and patt3 = 1 then sellShort("Patt3") next bar at open;	if patternNum = 4 and patt4 = 1 then sellShort("Patt4") next bar at open;	if patternNum = 5 and patt5 = 1 then buy("Patt5") next bar at low limit;	if patternNum = 6 and patt6 = 1 then sellShort("Patt6") next bar at close stop;	if patternNum = 7 and patt7 = 1 then buy("Patt7") next bar at low limit;	if patternNum = 8 and patt8 = 1 then sellShort("Patt8") next bar at high stop;end;setExitOnClose;``
The Full Monty of the ES-Seasonal-Day Trade

I think this could provide a means to much more in-depth analysis.  I think the Patterns could be changed up.  I would like to thank William (Bill) Brower for his excellent article, The S&P Seasonal Day Trade in Stocks and Commodities, August 1996 Issue, V.14:7 (333-337).  The article is copyright by Technical Analysis Inc.  For those not familiar with Stocks and Commodities check them out at https://store.traders.com/

Please email me with any questions or anything I just got plain wrong.  George

# Can Futures Traders Trust Continuous Contracts? [Part – 2]

## Recap from Part -1

I had to wrap up Part -1 rather quickly and probably didn’t get my ideas across, completely.  Here is what we did in Part – 1.

1. used my function to locate the First Notice Date in crude
2. used the same function to print out exact EasyLanguage syntax
3. chose to roll eight days before FND and had the function print out pure EasyLanguage
4. the output created array assignments and loaded the calculated roll points in YYYMMDD format into the array
5.  visually inspected non-adjusted continuous contracts that were spliced eight days before FND
6. appended dates in the array to match roll points, as illustrated by the dip in open interest

Step 6 from above is very important, because you want to make sure you are out of a position on the correct rollover date.  If you are not, then you will absorb the discount between the contracts into your profit/loss when you exit the trade.

## Step 2 – Create the code that executes the rollover trades

Here is the code that handles the rollover trades.

``............rollArr[118]=20220314;rollArr[119]=20220411;rollArr[120]=20220512;rollArr[121]=20220613;rollArr[122]=20220712;rollArr[123]=20220812;//  If in a position and date + 1900000 (convert TS date format to YYYYMMDD),//  then exit long or short on the current bar's close and then re-enter//  on the next bar's openif d+19000000 = rollArr[arrCnt] thenbegin	condition1 = true; 	arrCnt = arrCnt + 1;	if marketPosition = 1 then	begin		sell("LongRollExit") this bar on close;		buy("LongRollEntry") next bar at open;	end;	if marketPosition = -1 then	begin		buyToCover("ShrtRollExit") this bar on close;		sellShort("ShrtRollEntry") next bar at open;	end;	end;``
Code to rollover open position

This code gets us out of an open position during the transition from the old contract to the new contract.  Remember our function created and loaded the rollArr for us with the appropriate dates.  This simulation is the best we can do – in reality we would exit/enter at the same time in the two different contracts.  Waiting until the open of the next bar introduces slippage.  However, in the long run this slippage cost may wash out.

## Step 3 – Create a trading system with entries and exits

The system will be a simple Donchian where you enter on the close when the bar’s high/low penetrates the highest/lowest low of the past 40 bars.  If you are long, then you will exit on the close of the bar whose low is less than the lowest low of the past 20 bars.  If short, get out on the close of the bar that is greater than the highest high of the past twenty bars.  The first test will show the result of using an adjusted continuous contract rolling 8 days prior to FND

This test will use the exact same data to generate the signals, but execution will take place on a non-adjusted continuous contract with rollovers.  Here data2 is the adjusted continuous contract and data1 is the non-adjusted.

Still a very nice trade, but in reality you would have to endure six rollover trades and the associated execution costs.

## Conclusion

Here is the mechanism of the rollover trade.

And now the performance results using \$30 for round turn execution costs.

### Now with rollovers

The results are very close, if you take into consideration the additional execution costs.  Since TradeStation is not built around the concept of rollovers, many of the trade metrics are not accurate.  Metrics such as average trade, percent wins, average win/loss and max Trade Drawdown will not reflect the pure algorithm based entries and exits.  These metrics take into consideration the entries and exits promulgated by the rollovers.  The first trade graphic where the short was held for several months should be considered 1 entry and 1 exit.  The rollovers should be executed in real time, but the performance metrics should ignore these intermediary trades.

I will test these rollovers with different algorithms, and see if we still get similar results, and will post them later.  As you can see, testing on non-adjusted data with rollovers is no simple task.  Email me if you would like to see some of the code I used in this post.

# Can Futures Traders Trust Continuous Contracts? [Part – 1]

## Well You Have To, Don’t You?

When I worked at Futures Truth, we tested everything with our Excalibur software.  This software used individual contract data and loaded the entire history (well, the part we maintained) of each contract into memory and executed rollovers at a certain time of the month.  Excalibur had its limitations as certain futures contracts had very short histories and rollover dates had to be predetermined – in other words, they were undynamic.  Over the years, we fixed the short history problem by creating a dynamic continuous contract going back in time for the number of days required for a calculation.  We also fixed the database with more appropriate rollover frequency and dates.  So in the end, the software simulated what I had expected from trading real futures contracts.  This software was originally written in Fortran and for the Macintosh.  It also had limitations on portfolio analysis as it worked its way across the portfolio, one complete market at a time.   Even with all these limitations, I truly thought that the returns more closely mirrored what a trader might see in real time.  Today, there aren’t many, if any, simulation platforms that test on individual contracts.  The main reasons for this are the complexity of the software, and the database management.  However, if you are willing to do the work, you can get close to testing on individual contract data with EasyLanguage.

## Step 1 – Get the rollover dates

This is critical as the dates will be used to roll out of one contract and into another.  In this post, I will test a simple strategy on the crude futures.  I picked crude because it rolls every month.   Some data vendors use a specific date to roll contracts, such as Pinnacle data.  In real time trading, I did this as well.  We had a calendar for each month, and we would mark the rollover dates for all markets traded at the beginning of each month.  Crude was rolled on the 11th or 12th of the prior month to expiration.  So, if we were trading the September 2022 contract, we would roll on August 11th.  A single order (rollover spread) was placed to sell (if long) the September contract and buy the October contract at the market simultaneously.  Sometimes we would leg into the rollover by executing two separate orders – in hopes of getting better execution.  I have never been able to find a historic database of when TradeStation performs its rollovers.  When you use the default @CL symbol, you allow TradeStation to use a formula to determine the best time to perform a rollover.  This was probably based on volume and open interest.  TradeStation does allow you to pick several different rollover triggers when using their continuous data.

Trading terminates 3 business day before the 25th calendar day of the month prior to the contract month. If the 25th calendar day is not a business day, trading terminates 4 business days before the 25th calendar day of the month prior to the contract month.

You can look this up on your favorite broker’s website or the handy calendars they send out at Christmas.  Based on this description, the Sept. 2022 Crude contract would expire on August 20th and here’s why

• August 25 is Tuesday
• August 24 is Monday- DAY1
• August 21 is Friday – DAY2
• August 20 is Thursday – DAY3

This is the beauty of a well oiled machine or exchange.  The FND will occur exactly as described.  All you need to do is get all the calendars for the past ten years and find the 25th of the month and count back three business days.  Or if the 25 falls on a weekend count back four business days.  Boy that would be chore, would it not?  Luckily, we can have the data and an  EasyLanguage script do this for us.  Take a look at this code and see if it makes any sense to you.

``Case "@CL":	If dayOfMonth(date) = 25 and firstMonthPrint = false then	begin		print(date[3]+19000000:8:0);		firstMonthPrint = true;	end;	If(dayOfMonth(date[1]) < 25 and dayOfMonth(date) > 25 ) and firstMonthPrint = false then	begin		print(date[4]+19000000:8:0);		firstMonthPrint = true;	end;``
Code to printout all the FND of crude oil.

I have created a tool to print out the FND or LTD of any commodity futures by examining the date.  In this example, I am using a Switch-Case to determine what logic is applied to the chart symbol.  If the chart symbol is @CL, I look to see if the 25th of the month exists and if it does, I print the date 3 days prior out.  If today’s day of month is greater than 25 and the prior day’s day of month is less than 25, I know the 25th occurred on a weekend and I must print out the date four bars prior.  These dates are FN dates and cannot be used as is to simulate a rollover. You had best be out before the FND to prevent the delivery process.   Pinnacle Date rolls the crude on the 11th day of the prior month for its crude continuous contracts.  I aimed for this day of the month with my logic.  If the FND normally fell on the 22nd of the month, then I should back up either 9 or 10 business days to get near the 11th of the month.   Also I wanted to use the output directly in an EasyLanguage strategy so I modified my output to be exact EasyLanguage.

``Case "@CL":	If dayOfMonth(date) = 25 and firstMonthPrint = false then 	begin	value1 = value1 + 1;		print("rollArr[",value1:1:0,"]=",date[9]+19000000:8:0,";");		firstMonthPrint = true;	end;	If(dayOfMonth(date[1]) < 25 and dayOfMonth(date) > 25 ) and firstMonthPrint = false then	begin		value1 = value1 + 1;		print("rollArr[",value1:1:0,"]=",date[10]+19000000:8:0,";");//		print(date[4]+19000000:8:0);		firstMonthPrint = true;	end;// example of outputrollArr[103]=20210312;rollArr[104]=20210412;rollArr[105]=20210512;rollArr[106]=20210614;rollArr[107]=20210712;rollArr[108]=20210812;rollArr[109]=20210913;rollArr[110]=20211012;rollArr[111]=20211111;rollArr[112]=20211210;rollArr[113]=20220111;rollArr[114]=20220211;rollArr[115]=20220314;rollArr[116]=20220411;rollArr[117]=20220512;rollArr[118]=20220610;rollArr[119]=20220712;rollArr[120]=20220812;``
Code to print our 9 or 10 bars prior to FND in actual EasyLanguage

Now. that I had the theoretical rollover dates for my analysis I had to make sure the data that I was going to use matched up exactly.  As you saw before, you can pick the rollover date for your chart data.   And you can also determine the discount to add or subtract to all prior data points based on the difference between the closing prices at the rollover point.  I played around with the number of days prior to FND and selected non adjusted for the smoothing of prior data.

How did I determine 8 days Prior to First Notice Date?  I plotted different data using a different number of days prior and determined 8 provided a sweet spot between the old and new contract data’s open interest.  Can you see the rollover points in the following chart?  Ignore the trades – these were a beta test.

The dates where the open interest creates a valley aligned very closely with the dates I printed out using my FND date finder function.  To be safe, I compared the dates and fixed my array data to match the chart exactly.  Here are two rollover trades – now these are correct.

This post turned out to be a little longer than I thought, so I will post the results of using an adjusted continuous contract with no rollovers, and the results using non-adjusted concatenated contracts with rollovers.  The strategy will be a simple 40/20 bar Donchian entry/exit.  You maybe surprised by the results – stay tuned.