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!”

To Rollover or not to Rollover – that is the Question!

In actuality that is only a portion of what we need to ask ourselves when dealing with rollovers and data.  As you probably already know, continuous futures contracts are created by adjusting historic data in an attempt to eliminate the gap between the new and old contract.  If you don’t adjust your data, then the gap causes erroneous disruptions in your historic back testing.  A trade that bridges a rollover does not accurately reflect what really happened.  So, we must use adjusted data.  Two problems arise from using back adjusted data:

1. The date of the rollover can have a large impact on algorithm performance.
2.  In real time trading, rollovers must take place, and this increases execution costs.  If you trade a longer-term strategy, you may need to execute 12 additional spreads (exit old – enter new) in crude oil annually.  If you levy a \$50 charge (slip and commission) for each turn, then that is \$600 in additional costs annually.

Several options can be used to trigger when to rollout of the expiring contract and roll into the new one.  Some traders use consecutive days of higher volume and open interest in the new contract in relation to the expiring one to begin the process.  This mechanism is also popular in creating continuous contract data.  Other traders, and I was one of them, chose a particular trading day of the month based on the expiring date of the contract.  Many futures contracts expire after a certain number of days have passed in the expiring month or the prior month of expiration.  This mechanism, n-days into the expiring month, can also be used when creating continuous contracts.

Using Wilder’s Parabolic SAR Algorithm

Using Pinnacle Data’s Adjusted Data for CL

The two equity curves are similar.  However, TradeStation’s data produced nearly \$60K in profit, whereas Pinnacle only produced north of \$20K.  I discovered in the early part of TradeStation’s @CL data, the values were derived strictly from the electronic markets.  Up until about 2008 or so, I think the pits were still more active.  Take a look at this graphic.

Pinnacle Data knits the pit session data with the purely electronic data during the transition period.  However, this only accounts for the early trades in the back test.  The parabolic indicator uses its prior output to calculate the next value.  Any disruption in the differences in the relationships of historic highs and lows of the data will perpetuate through the output of subsequent parabolic calculations.  Things start to work themselves out later in the back test.  Indicators like the Parabolic are more sensitive to data differences.

What if you wanted to trade the Parabolic SAR real time?

This can be done, but results may look different than your back test.  In trading crude oil, you should trade all 12 contracts.   And you will need to execute roll spreads once a month, if you are in a position.  This doesn’t answer the question on how to calculate the Parabolic once a rollover takes place.  You have two options, 1.) you can use what Futures Truth coined as overlap data to calculate the new indicator reading.  Basically, we would load the new contract data going back as far as we could and derive the indicator values off of the new data.  This would work just fine with crude data, but many futures do not have a sufficient amount of overlap.  In other words, the new contract would have very little history.  And this data wasn’t sufficient to calculate accurate indicator values.  2.) Roll into the new contract and adjust the historical data of the old contracts by the discount between the two contracts that were rolled out of and into.  This would alleviate the problems with the futures contract with very little history.

I like the second option best, because it works for all markets and even in crude oil you may not have overlap data to do the calculation.  Even if you have enough data, it might not be all that good.  If you can go back 100 days in the new contract, the data may deteriorate before you get those 100 days.

Wouldn’t it be great if we could test with this type of data?  You know rollover and then adjust all the historic data that we need for our indicators using good data from the old contracts, but adjusted in terms of our new data?  Well, we are in luck, I spent several hours doing this with my Python TS-18 software.  I used Pinnacle Data‘s actual contract data – you get this when you buy their CLC database and derived the discount between the contracts.  Pinnacle rolls at the same time each month in crude – it’s not a calendar date but a number of days into the prior expiration month.    Take a look at this trade-by-trade listing.

This shows rolling out of the old contract and into the new contract, and then backing up 100 days of old contract data and adjusting the data by the discounts as they occur.  This could involve more than three adjustments historically.  This rollover inspired data was then fed into the parabolic indicator.  The indicator was restarted on each rollover going back N days.  In other words, when a rollover was observed, the indicator was reset with the new rollover adjusted historic data by using a loop.  The rollover mechanism called the parabolic calculation N times going back N days into our dynamically adjusted data.  Once the loop finished, the new contract data was then fed into the calculation on day at a time.  This occurred until another rollover was observed.

I would show the results of this testing but…

I got very diverse results when I recalculated the parabolic on each rollover with different loop counts.  On the rollover, if I looped back 40 days to bring the parabolic up to speed, I got very similar results to TradeStation’s results using Pinnacle data.  What the heck I will show that to you.

The results are similar but the draw down of late concerns me.  However, if I only go back 30 days to synchronize the parabolic on each rollover, the results are much better.  This tells me that the parabolic is very sensitive to the data that is used for its calculations.

This post may have raised more questions than it answered.  But I will try to get down to the differences between the different look back lengths on rollover and report any findings back here.  However, you must keep rollovers in mind when dealing with trading futures, period.

Daily Bar Daytrade to 5 Minute Bars — Not So Easy!

Like in the previous post, I designed a simple optimization framework trying to determine the best day of the week to apply a long only volatility based open range break out algorithm on natural gas.  You might first ask why natural gas?  Its a good market that has seasonal tendencies that can actually be day-traded – there is enough volatility and volume.  Anyway, by simply slapping setExitOnClose at the end of your code turns your algorithm into one that exits every day at the settlement (fictional value that is derived via formula) price.  You can always use LIB (look inside bar) to help determine the magnitude of intraday swings and there respective chronological order.  But you are still getting out at the settlement price – which isn’t accurate.  However, if you are trying to get a set of parameters that gets you into the ballpark, then this is a very acceptable approach.  But you will always want to turn you daily bar strategy with LIB intro an intraday version for automation and accuracy purposes.

Day of Week Analysis On Intraday Data

When you optimize the day of week on daily bars, the first bar of the week is usually Monday.  When testing with intraday bars on futures, the trading actually starts on Sunday evening.  If your daily bar analysis reveals the best day of week is Wedneday, then you must inform TradeStation to take the trade from the opening on Tuesday night through the close on Wenesday.  If you are executing a market order, then you just need to tell TradeStation to execute at Tuesday night’s open (1800 eastern standard time).  The TRICK to allow trading throughout the 24 hour session (1800 to 1700) on just a particular day of the week is to capture the day of the week on the first bar of the trading session.  Here is some bookkeeping you can take care of on the first bar of the trading session.

``if t = sessionstartTime(0,1) + barInterval ThenBegin		todaysOpen = o;	openDOW = dayOfWeek(d);	canBuy = False;	if openDOW = daysOfWeekToTrade then canBuy = True;	if canBuy and d[1] <> date of data2 then 	begin		canBuy = False;		print(d," turning off canBuy");	end;			if mp = 1 then curTradeDays = curTradeDays + 1;	if mp = 0 then curTradeDays = 0;	barsToday = 1;end;``
Bookkeeping on the first bar of trading session

Here, I check to see if the first bar’s time stamp is equal to the sessionStarttime + barInterval.  Remember TradeStation shows the close time of each bar as the time stamp.  If adding a barInterval to the opening time results in a non-time, then use the calcTime function ( 1800 + 60 = 1860 – a non-time.)   I first store the open of the session in my variable todaysOpen.  Why not just use openD(0).  Well openD(0) is great for sessions that don’t span midnight.  If they span midnight then the openD returns the open of the12:00 am bar.  Here is the output from August 9th with the open on August 8th at 1800.  The two other values are midnight on August 8th and August 7th.  So the openD, highD, lowD, and closeD functions involve the 24 hour clock and not the session.

```print(todaysOpen:5:5," ",openD(0):5:5," ",openD(1):5:5);

18:00  midnite[0]   midnite[1]
--------------------------------------
1230808 2.797        2.712      2.588

```

On the first bar of the trading session I also capture the day of the week.  The days of the week, using intraday data on a 24 hour session, range from Sunday to Thursday, instead of Monday thru Friday.  CanBuy is turned on if the day of week equals the input provided by the user.  When using daily bars and you optimize the day of the week, remember if you chose 2 or Tuesday you really mean Wednesday.  If today is Tuesday, then buy next bar at…  This will generate trades only on Wednesdays.  When testing on intraday data you do not need to make a modification for the day of week.  If the first bar of the trading session is Tuesday, then you will actually trade what is considered the Wednesday session that starts on Tuesday evening at 18:00.

Here is a quick trick to not trade on Holidays.  The daily bar does not include preempted sessions in its database, whereas intraday data does.  So, if at 18:00 the date of the prior bar does not match the date of the daily bar located in the Data2 slot, then you know that the prior day was preempted and you should not trade today.  In other words, Data2 is missing.  Remember, you only want to trade on days that are included in the daily bar database in your attempt to replicate the daily bar strategy.

```date             close   moving average
1230703.00 data2         2.57382 2.70300
1230704.00 missing data2 2.57382 2.70300 <-- no trade
1230705.00 data2         2.57485 2.65100 <-- matches```

How to count the daily bars since entry.

Here again you need to do some bookkeeping.  If you are long on the first bar of the day, then you have been in the trade for at least a day.  If you are long on two first bars of the trading session, then you have been long for two days.  I use the variable, curTradeDays, to count the number of days we have been in the trade.  If on the first bar of the trading session we are flat, then I reset curTradeDays to zero.  Otherwise, I increment the variable and this only occurs once a day.  You can optimize the daysInTrade input, but for this post we are just interested in getting out at the close on the day of entry.

Controlling one entry per day.

We only want one long entry per day in an attempt to replicate the daily bar system.  There are several ways to do this, but comparing the current bar’s marketPosition to the prior bar’s value will inform you if a position has been transitioned from flat to long.  If the prior bar’s position if flat and the current bar is now long, then we can turn our canBuy off or to false.  If we get stopped out later and the market rallies again to our break out level, we will not execute at that level, because the trade directive will not be issued.  Why not use the entriesToday function?  Again midnight cause this function to reset.  Say you go long at 22:00 and you do not want to enter another position until the tomorrow at 18:00.  EntriesToday will forget you entered the long position at 22:00.

```1220726.00 2350.00 entries today 1.00
1220726.00 2355.00 entries today 1.00
1220727.00 0.00 entries today 0.00 < not true!```

Cannot execute on the first bar of the day – does it matter?

``	if canBuy and h > todaysOpen + volAmt *volMult then 	Begin 		print(d," first bar penetration ",value67," ",value68," ",(c - (todaysOpen + volAmt *volMult))*bigPointValue );		value67 = value67 + 1;		value68 = value68 + (c - (todaysOpen + volAmt *volMult))*bigPointValue;	end;``
Testing for penetration on first 5 minute bar of the day

By the end of the first bar of the day we know the open, high, low and close of the day thus far.  We can test to see if the high would have penetrated the break out level and also calculate the profit or loss of the trade.  In a back-test you will not miss this trade if the next bar’s open is still above the break out level.  If the next bar’s open is below the break out level, then you may have missed a fake out break out.   Again this is a rare event.

The rest of the code in its entirety

``inputs: daysOfWeekToTrade(1),mavLen(20),volLen(10),volMult(0.25),volComp(.5),stopLoss(500),profitTarget(1000),daysInTrade(0),llLookBack(2);vars: todaysOpen(0),curTradeDays(0),mp(0),barsToday(0),openDOW(0),canBuy(False),volAmt(0),movAvg(0);mp = marketPosition;if t = sessionstartTime(0,1) + barInterval ThenBegin		todaysOpen = o;	openDOW = dayOfWeek(d);	canBuy = False;	if openDOW = daysOfWeekToTrade then canBuy = True;		if canBuy and d[1] <> date of data2 then 	begin		canBuy = False;	end;			if mp = 1 then curTradeDays =curTradeDays + 1;	if mp = 0 then curTradeDays = 0;	barsToday = 1; 		volAmt = average(range of data2,volLen);	movAvg = average(c,mavLen) of data2;	if canBuy and h > todaysOpen + volAmt *volMult then 	Begin 		print(d," first bar penetration ",value67," ",value68," ",(c - (todaysOpen + volAmt *volMult))*bigPointValue );		value67 = value67 + 1;		value68 = value68 + (c - (todaysOpen + volAmt *volMult))*bigPointValue;	end;end;if mp[1] = 0 and mp = 1 and canBuy then canBuy = False;if canBuy and t <> sessionEndTime(0,1) ThenBegin	if barsToday > 1 and 	close of data2 > movAvg and 	range of data2 > volAmt * volComp then 		 buy("DMIntraBuy") next bar at todaysOpen + volAmt *volMult stop;end;barsToday = barsToday + 1;if daysInTrade = 0 then 	setExitOnClose;	sell("LLxit") next bar at lowest(l of data2,llLookBack) stop;if mp = 1 and daysInTrade > 0 thenbegin	if curTradeDays = daysInTrade then sell("DaysXit") next bar at open;end;setStopLoss(stopLoss);setProfitTarget(profitTarget);``
Intrday system that replicates a daily bar day trader

We are using the setStopLoss and setProfitTarget functions in this code.  But remember, if your continuous contract goes negative, then these functions will not work properly.

This type of programming is tricky, because you must use tricks to get EasyLanguage to do what you want it to do.  You must experiment, debug, and program ideas to test the limitations of EasyLanguage to hone your craft.

On the Subject of Data Mining with EasyLanguage

When Mining for Data, Make Sure You Have Accurate Data

Take a look at these results with no execution costs.

These results were derived by applying a simple algorithm to the natural gas futures for the past 15 or so years.  I wanted to see if there was a day of the week that produced the best results with the following entry and exit techniques:

• Long entries only
• Open range break out using a fraction of the N-day average range.
• Buy in the direction of the moving average.
• Yesterdays close must be above the X-day moving average of closing prices.
•  Yesterday must have a wider range than a fractional multiple of the average range.
• A fixed \$stop and \$profit used to exit trades.
• Other exits
• Exit at low of prior day.
• Exit at the close of today – so a day trade.

Here is a list of the parameters that can be optimized:

• daysOfWeekToTrade(1) : 1 – Monday, 2 – Tuesday…
• mavLen(20): moving average calculation length.
• volLen(10):  moving average calculation length for range.
• volMult(0.25): average range multiplier to determine break out/
• volComp(.5):  yesterday’s range must be greater than this percentage.
• stopLoss(500): stop loss in \$
• profitTarget(1000): profit objective in \$
• daysInTrade(0): 0 get out at end of day.
• llLookBack(2): pattern derived stop value – use the lowest low of N-days or the stop loss in \$, whichever is closer.

Here is the code:

``inputs: daysOfWeekToTrade(1),mavLen(20),volLen(10),volMult(0.25),volComp(.5),stopLoss(500),profitTarget(1000),daysInTrade(0),llLookBack(2);if dayOfWeek(d) = daysOfWeekToTrade ThenBegin	if close > average(c,mavLen) and range > average(range,volLen)*volComp then 		buy("DMDailyBuy") next bar at open of tomorrow + average(range,volLen)*volMult stop;end;if daysInTrade = 0 then setExitOnClose;sell("LLxit") next bar at lowest(l,llLookBack) stop;if marketPosition = 1 thenbegin	if barsSinceEntry = daysInTrade then sell("DaysXit") next bar at open;end;setStopLoss(stopLoss);setProfitTarget(profitTarget);``

Why Is This Algorithm Wrong?  It’s Not It’s the Data!

The algorithm, speaking in terms of logic, is accurate. The data is wrong.  You cannot test the exit technology of this algorithm with just four data points per day – open, high, low, and close.  If this simple algorithm cannot be tested, then what can you test on a daily bar basis accurately?

• Long or short entry, but not both.
• If the algorithm can enter both long and short, you need to know what occurred first.  Doesn’t matter if you enter via stop or limit orders.  Using a stop order for both, then you need to know if the high occurred first and got you long, and then later the low and got you short.  Or just the opposite.  You can test, with the benefit of hindsight, if only one of the orders would have been elected.  If only one is elected, then you can proceed.  If both then no-go.  You must be able to use future leak to determine if only one of the orders were fillable.  TS-18 allows future leak BTW.  I say that like it’s a good thing!
• L or S position from either a market or stop, and a profit objective.
• If a long position is entered above the open, via a stop, and then the market moves even higher, you can get out on a sell limit for a profit.
• Same goes for the short side, but you need to know the magnitude of the low price in relation to the open.
• L or S position from either a market or limit and a protective stop.
• If short position is entered above the open, via a limit order, and the market moves even higher, you can exit the short position at a loss via a buy stop order.
• Same goes for the long side, but you need to know the magnitude of the high in relation to the open.
• Long pyramid on multiple higher stop or lower limit orders, but not both.
• The market opens and then sells off. You can go long on a limit order below the open, then you go long another unit below the original limit price and so on…
• The market opens and rallies.  You can go long on a stop order above the open, then you can go long another unit above the original stop price and so on…
• Short pyramid on multiple lower stop or higher limit orders.
• Same as long entries but in opposite direction.

Can’t you look at the relationships of the open to low and open to high and close to high and close to low and determine which occurred first, the high or the low of the day.  You can, but there is no guarantee.  And you can’t determine the magnitude of intraday day swings.  Assume the market opens and immediately moves down and gets you short via a stop order.  And from looking at a daily chart, it looks like the market never turned around, so you would assume you had a profit going into the close.  But in fact, after the market opened and moved down, it rallied back to the open enough to trigger a protective stop you had working.

The entry technique of this strategy is perfectly fine.  It is only buying in the direction of a breakout.  The problems arise when you apply a profit objective and a stop loss and a pattern-based stop and a market on close order.    After buying did the market pull back to get you stopped out before moving up to get you out at profit objective?  Did the market move up and then down to the prior lowest low of N days and then back up to get you long?  Or just the opposite? In futures, the settlement price is calculated with a formula.  You are always exiting at the settlement price with an MOC or setExitOnClose directive (daily bar basis.)

No Biggie – I Will Just Test with LIB (Look Inside Bar.  That should fix it, right?

It definitely will increase accuracy, because you can see the intraday movements that make up the daily bar.  So, your entries and exits should be executed more accurately.  But you are still getting out at the settlement price which does not exist.  Here are the results from using LIB with 5-minute bar resolution.

We Know the Weakness, But What Can We Do?

Test on a 5-minute bar as Data1 and daily as Data2.  This concept is what my Hi-Res Edition of Easing Into EasyLanguage is all about.  Here the results of using a higher resolution data and exiting on the last tick of the trading day – a known quantity.

These results validate the LIB results, right?  Not 100%, but very close.  Perhaps this run makes more money because the settlement price on the particular days that the system entered a trade was perhaps lower than the last tick.  In other words, when exiting at the end of the day, the last tick was more often higher than the settlement price.

In my next post, I will go over the details of developing an intraday system to replicate (as close as possible) a simple daily bar-based day trading system.  Like the one we have here.

Extend Data Mining to Actual Trading System

Data Mining May or May Not Link Causality

A study between ice cream sales and crime rate demonstrated a high level of correlation.  However, it would be illogical to assume that buying more ice cream leads to more crime.  There are just too many other factors and variables involved to draw a conclusion.  So, data mining with EasyLanguage may or may not lead to anything beneficial.  One thing is you cannot hang your hat completely on this type of research.  A reader of my books asked if there was evidence that pointed to the best time to enter and exit a day trade.  Is it better to enter in the morning or in the afternoon or are there multiple trading windows throughout the day?  I thought I would try to answer the question using TradeStation’s optimization capabilities.

If You Like the Theory and its EasyLanguage Code of this Blog Post – Check Out my New Book at Amazon.com

Create a Search Space of Different Window Opening Times and Open Duration

My approach is just one of a few that can be used to help answer this question.  To cut down on time and the size of this blog we will only look at day trading the @ES.D from the long side.  The search space boundaries can be defined by when we open the trading window and how long we leave it open.  These two variables will be defined by inputs so we can access the optimization engine.  Here is how I did it with EasyLanguage code.

``inputs: openWindowTime(930),openWindowOffset(5),windowDuration(60);inputs: canBuy(True),canShort(True);if t >= calcTime(openWindowTime,openWindowOffset) and t < calcTime(openWindowTime,openWindowOffset+windowDuration) ThenBegin	if entriesToday(d) = 0 and canBuy Then		buy next bar at market;	if entriesToday(d) = 0 and canShort Then		sellshort next bar at market ;end;if t = calcTime(openWindowTime,openWindowOffset+windowDuration) ThenBegin	if marketPosition = 1 then sell next bar at open;	if marketPosition =-1 then buyToCover next bar at open;end;setExitOnClose;``
Optimize when to open and how long to leave open

The openWindowTime input is the basis from where we open the trading window.  We are working with the @ES.D with an open time of 9:30 AM eastern.  The openWindowOffset will be incremented in minutes equivalent to the data resolution of the chart, five minutes.  We will start by opening the window at 9:35 and leave it open for 60 minutes.  The next iteration in the optimization loop will open the window at 9:40 and keep it open for 60 minutes as well.  Here are the boundaries that I used to define our search space.

• window opening times offset: 5 to 240 by 5 minutes
• window opening duration: 60 to 240 by 5 minutes

A total of 1739 iterations will span our search space.   The results state that waiting for twenty minutes before buying and then exiting 190 minutes later, worked best.  But also entering 90 minutes after the open and exiting 4 hours later produced good results as well (no trade execution fee were utilized.)  Initially I was going to limit entry to once per day, but then I thought it might be worthwhile to enter a fresh position, if the first one is stopped out, or pyramid if it hasn’t.  I also thought, each entry should have its own protective stop amount.  Would entering later require a small stop – isn’t most of the volatility, on average, expressed during the early part of the day.

Build a Strategy that Takes on a Secondary Trade as a New Position or One that is Pyramided.

This is not a simple strategy.  It sounds simple and it requires just a few lines of code.  But there is a trick in assigning each entry with its own exit.  As you can see there is a potential for trade overlap.  You can get long 20 minutes after the open and then add on 70 minutes  (90 from the open) later.  If the first position hasn’t been stopped out, then you will pyramid at the second trade entry.  You have to tell TradeStation to allow this to happen.

System Rules

1. Enter long 20 minutes after open
2. Enter long 90 minutes after open
3. Exit 1st entry 190 minutes later or at a fixed \$ stop loss
4. Exit 2nd entry 240 minutes later or at a fixed \$ stop loss
5. Make sure you are out at the end of the day

Sounds pretty simple, but if you want to use different stop values for each entry, then the water gets very muddy.

AvgEntryPrice versus EntryPrice

Assume you enter long and then you add on another long position.  If you examine EntryPrice you will discover that it reflects the initial entry price only.   The built-in variable AvgEntryPrice will be updated with the average price between the two entries.  If you want to key off of the second entry price, then you will need to do a little math.

avgEntryPrice = (entry price 1 + entry price 2) / 2

or ap = (ep1 + ep2) /2

Using this formula and simple algebra we can arrive at ep2 using this formula:  ep2 = 2*ap – ep1.  Since we already know ep1 and ap, ep2 is easy to get to.  We will need this information and also the functionality of from entry.  You tie entries and exits together with the keywords from entry.  Here are the entry and exit trade directives.

``if time = calcTime(openTime,entryTime1Offset) then 	buy("1st buy") next bar at open;	if time = calcTime(openTime,entryTime2Offset) then 	buy("2nd buy") next bar at open;if time = calcTime(openTime,entryTime1Offset + exitTime1Offset) then 	sell("1st exit") from entry("1st buy") next bar at open;if time = calcTime(openTime,entryTime2Offset + exitTime2Offset) then 	sell("2nd exit") from entry("2nd buy") next bar at open;if mp = 1 ThenBegin	value1 = avgEntryPrice;	if currentShares = 2 then value1 = avgEntryPrice*2 - entryPrice;	sell("1st loss") from entry("1st buy") next bar at entryPrice - stopLoss1/bigPointValue stop;	sell("2nd loss") from entry("2nd buy") next bar at value1 - stopLoss2/bigPointValue stop;end;if mp = 1 and t = openTime + barInterval then sell("oops") next bar at open;``
Entry and Exit Directives Code

The trade entry directives are rather simple, but you must use the calcTime function to arrive at the correct entry and exit times.  Here we are using the benchmark, openTime and the offsets of entryTime1Offset and entryTime2Offset.  This function adds (or subtracts if the offset is negative) the offset to the benchmark.  This takes care of when the trading windows open, but you must add the entry1TimeOffset to exit1TimeOffset to calculate the duration the trading window is to remain open.  This goes for the second entry window as well.

Now let’s look at the exit directives.  Notice how I exit the 1st buy entry with the code from entry (“1st buy”).  This ties the entry and exit directives together.  This is pretty much straightforward as well.  The tricky part arrives when we try to apply different money management stops to each entry.  Exiting from the 1st buy requires us to simply subtract the \$ in terms of points from entryPrice.  We must use our new equation to derive the 2nd entry price when two contracts are concurrent.   But what if we get stopped out of the first position prior to entering the second position?  Should we continue using the formula.  No.  We need to fall back to entryPrice or avgEntryPrice:  when only one contract or unit is in play, these two variables are equal.  We initially assign the variable value1 to the avgEntryPrice and only use our formula when currentShares = 2.  This code will work a majority of the time.  But take a look at this trade:

This is an anomaly, but anomalies can add up.  What happened is we added the second position and the market moved down very quickly – too quickly for the correct entry price to be updated.  The stop out (2nd loss) was elected by using the 1st entry price, not the second.  You can fix this with the following two solutions:

1. Increase data resolution and hope for an intervening bar
2. Force the second loss to occur on the subsequent trading bar after entry.  This means you will not be stopped out on the bar of entry but will have to wait five minutes or whatever bar interval you are working with.

OK – Now How Do We Make this a Viable Trading System

If you refer back to the optimization results you will notice that the average trade (before execution costs) was around \$31.  Keep in mind we were trading every day.  This is just the beginning of your research – did we find a technical advantage?  No.  We just found out that you can enter and exit at different times of the trading day, and you can expect a positive outcome.  Are there better times to enter and exit?  YES.  You can’t trade this approach without adding some technical analysis – a reason to enter based on observable patterns.  This process is called FILTERING.   Maybe you should only enter after range compression.  Or after the market closed up on the prior day, or if the market was an NR4 (narrow range 4.)  I have added all these filters so you can iterate across them all using the optimization engine.  Take a look:

``filter1 = True;filter2 = True;if filtNum1 = 1 then	filter1 = close of data2 > close[1] of data2;if filtNum1 = 2 Then	filter1 = close of data2 < close[1] of data2;if filtNum1 = 3 Then	filter1 = close of data2 > open of data2;if filtNum1 = 4 Then	filter1 = close of data2 < open of data2;if filtNum1 = 5 Then	filter1 = close of data2 > (h data2 + l data2 + c data2)/3;if filtNum1 = 6 Then	filter1 = close of data2 < (h data2 + l data2 + c data2)/3;if filtNum1 = 7 Then	filter1 = openD(0) > close data2;if filtNum1 = 8 Then	filter1 = openD(0) < close data2;	if filtNum2 = 1 Then	filter2 = trueRange data2 < avgTrueRange(10) data2;if filtNum2 = 2 Then	filter2 = trueRange data2 > avgTrueRange(10) data2;if filtNum2 = 3 Then	filter2 = range data2 = lowest(range data2,4);if filtNum2 = 4 Then	filter2 = range data2 = highest(range data2,4);``
Filter1 and Filter2 - filter1 looks for a pattern and filter2 seeks range compression/expansion.

Let’s Search – And Away We Go

I will optimize across the different patterns and range analysis and different \$ stops for each entry (1st and 2nd.)

Best Total Profit

Trade when today’s open is greater than yesterday’s close and don’t worry about the volatility.  Use \$550 for the first entry and \$600 for the second.

Best W:L Ratio and Respectable Avg. Trade

This curve was created  by waiting for yesterday’s close to be below the prior day’s and yesterday being an NR4 (narrow range 4).  And using a \$500 protective stop for both the 1st and 2nd entries.

Did We Find the Holy Grail?  Gosh No!

This post served two purposes.  One, how to set up a framework for data mining and two, create code that can handle things that aren’t apparently obvious – entryPrice versus avgEntryPrice!

``if filter1 and filter2 Thenbegin	if time = calcTime(openTime,entryTime1Offset) then 	buy("1st buy") next bar at open;		if time = calcTime(openTime,entryTime2Offset) then 	buy("2nd buy") next bar at open;end;``
Incorporating Filter1 and Filter2 in the Entry Logic

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;                           ``

Week Of Month

I could be wrong, but I couldn’t find this functionality in EasyLanguage.  I was testing a strategy that didn’t want to trade a specific week of the month.   If it’s not built-in, then it must be created.   I coded this functionality in Sheldon Knight’s Seasonality indicator but wanted to create a simplified universal version.  I may have run into one little snag.  Before discussing the snag, here is a Series function that returns my theoretical week of the month.

``vars: weekCnt(0),cnt(0);vars: newMonth(False),functionSeed(False);if month(d) <> month(d[1]) ThenBegin	weekCnt = 1;end;if dayOfWeek(d)<dayOfWeek(d[1]) and month(d) = month(d[1]) Thenbegin	weekCnt = weekCnt + 1;end;if weekCnt = 1 and dayofMonth(d) = 2 and dayOfWeek(D) = Sunday Then	print("Saturday was first day of month"," ",d);WeekOfMonth = weekCnt;``
Series Function to Return Week Rank

This function is of type Series because it has to remember the prior output of the function call – weekCnt.  This function is simple as it will not provide the week count accurately (at the very beginning of a test) until a new month is encountered in your data.  It needs a ramp up (at least 30 days of daily or intraday data) to get to that new month.  I could have used a while loop the first time the function was called and worked my way back in time to the beginning of the month and along the way calculate the week of the month.  I decided against that, because if you are using tick data then that would be a bunch of loops and TradeStation can get caught in an infinite loop very easily.

This code is rather straightforward.  If the today’s month is not equal to yesterday’s month, then weekCnt is set to one.  Makes sense, right.  The first day of the month should be the first week of the month.  I then compare the day of week of today against the day of week of yesterday.  If today’s day of week is less than the prior day’s day of week, then it must be a Sunday (futures markets open Sunday night to start the week) or Monday (Sunday = 0 and Monday = 1 and Friday = 5.)  If this occurs and today’s month is the same as yesterday’s month, weekCnt is incremented.  Why did I check for the month?  What if the first trading day was a Sunday or Monday?  Without the month comparison I would immediately increment weekCnt and that would be wrong.  That is all there is to it?  Or is it?  Notice I put some debug code in the function code.

Is There a Snag?

April 2023 started the month on Saturday which is the last day of the week, but it falls in the first week of the month.  The sun rises on Sunday and it falls in the second week of the month.  If you think about my code, this is the first trading day of the month for futures:

month(April 2nd) = April or 4

month(March 31st) = March or 3

They do not equal so weekCnt is set to 1.  The first trading day of the month is Sunday or DOW=0 and the prior trading day is Friday or DOW=5.  WeekCnt is NOT incremented because month(D) doesn’t equal month(D[1]).  Should WeekCnt be incremented?  On a calendar basis it should, but on a trading calendar maybe not.  If you are searching for the first occurrence of a certain day of week, then my code will work for you.  On April 2nd, 2023, it is the second week of the month, but it is the first Sunday of April.

Thoughts???  Here are a couple of screenshots of interest.

This function is an example of where we let the data tell us what to do.  I am sure there is calendar functions, in other languages, that can extract information from just the date.  However, I like to extract from what is actually going to be traded.

Email me if you have any questions, concerns, criticism, or a better mouse trap.

Reentry of Long at better price

How to reenter at a better price after a stop loss

A reader of this blog wanted to know how he could reenter a position at a better price if the first attempt turned out to be a loser.  Here I am working with 5 minute bars, but the concepts work for daily bars too.  The daily bar is quite a bit easier to program.

ES.D Day Trade using 30 minute Break Out

Here we are going to wait for the first 30 minutes to develop a channel at the highest high and the lowest low of the first 30 minutes.  After the first 30 minutes and before 12:00 pm eastern, we will place a buy stop at the upper channel.  The initial stop for this initial entry will be the lower channel.  If we get stopped out, then we will reenter long at the midpoint between the upper and lower channel.  The exit for this second entry will be the lower channel minus the width of the upper and lower channel.

Here are some pix.  It kinda, sorta worked here – well the code worked perfectly.   The initial thrust blew through the top channel and then immediately consolidated, distributed and crashed through the bottom channel.  The bulls wanted another go at it, so they pushed it halfway to the midpoint and then immediately the bears came in and played tug of war.  In the end the bulls won out.

Here the bulls had initial control and then the bears, and then the bulls and finally the bears tipped the canoe over.

This type of logic can be applied to any daytrade or swing trade algorithm.  Here is the code for the strategy.

``//working with 5 minute bars here//should work with any time frameinput:startTradeTime(0930),numOfBarsHHLL(6),stopTradeTime(1200),maxLongEntriesToday(2);vars: startTime(0),endTime(0),barCountToday(0),totTrades(0),mp(0),longEntriesToday(0),periodHigh(-99999999),periodLow(99999999);startTime = sessionStartTime(0,1); endTime = sessionStartTime(0,1); if t = calcTime(startTime,barInterval) Thenbegin	periodHigh = -99999999;	periodLow = 99999999;	barCountToday = 1;	totTrades = totalTrades;end;if barCountToday <= numOfBarsHHLL ThenBegin	periodHigh = maxList(periodHigh,h);	periodLow = minList(periodLow,l);end;barCountToday = barCountToday + 1;longEntriesToday = totalTrades - totTrades;mp = marketPosition;if t <= stopTradeTime and barCountToday > numOfBarsHHLL ThenBegin	if longEntriesToday = 0 then 		buy("InitBreakOut") next bar at periodHigh + minMove/priceScale stop;	if longEntriesToday = 1 Then		buy("BetterBuy") next bar at (periodHigh+periodLow)/2 stop;end;if mp = 1 then	if longEntriesToday = 0 then sell("InitXit") next bar at periodLow stop;	if longEntriesToday = 1 then sell("2ndXit") next bar at periodLow - (periodHigh - periodLow) stop;SetExitOnClose;	``

The key concepts here are the time constraints and how I count bars to calculate the first 30 – minute channel.  I have had problems with EasyLanguages’s entriesToday function, so I like how I did it here much better.  On the first bar of the day, I set my variable totTrades to EasyLanguages built-in totalTrades (notice the difference in the spelling!)  The keyword TotalTrades is immediately updated when a trade is closed out.  So, I simply subtract my totTrades (the total number of trades at the beginning of the day) from totalTrades.  If totalTrades  is incremented (a trade is closed out) then the difference between the two variables is 1.  I assign the difference of these two values to longEntriesToday.  If longEntriesToday = 1, then I know I have entered long and have been stopped out.  I then say, OK let’s get back long at a better price – the midpoint.  I use the longEntriesToday variable again to determine which exit to use.  With any luck the initial momentum that got us long initially will work its way back into the market for another shot.

It’s Easy to Create  a Strategy Based Indicator

Once you develop a strategy, the indicator that plots entry and exit levels is very easy to derive.  You have already done the math – just plot the values.  Check this out.

``//working with 5 minute bars here//should work with any time frameinput:startTradeTime(0930),numOfBarsHHLL(6);vars: startTime(0),endTime(0),barCountToday(0),periodHigh(-99999999),periodLow(99999999);startTime = sessionStartTime(0,1); endTime = sessionStartTime(0,1); if t = calcTime(startTime,barInterval) Thenbegin	periodHigh = -99999999;	periodLow = 99999999;	barCountToday = 1;end;if barCountToday <= numOfBarsHHLL ThenBegin	periodHigh = maxList(periodHigh,h);	periodLow = minList(periodLow,l);end;if barCountToday < numOfBarsHHLL Thenbegin	noPlot(1);	noPlot(2);	noPlot(3);	noPlot(4);EndElsebegin	plot1(periodHigh,"top");	plot2((periodHigh+periodLow)/2,"mid");	plot3(periodLow,"bot");	plot4(periodLow - (periodHigh - periodLow),"2bot");end;barCountToday = barCountToday + 1;``

So, that’s how you do it.  You can use this code as a foundation for any system that wants to try and reenter at a better price.  You can also use this code to develop your own time based break out strategy.  In my new book, Easing Into EasyLanguage – the Daytrade Edition I will discuss topics very similar to this post.