Updated Code That Works With Midnight Time Stamp

Updated Code for the Midnight Hour

I was working with some code for my latest book – Easing Into EasyLanguage – The Hi-Res Edition and streamlined some code from an old post.

startTime = sessionStartTime(0,1); 
endTime = sessionStartTime(0,1); 
if startTime > endTime then 
begin 
	endTimeOffset = 0; 
	if t >= startTime+barInterval and t<= 2359 then endTimeOffSet = 2400-endTime; 
end;

if t-endTimeOffSet < endTime then 
begin
	...
	...
	...
	...
end.
Updated Code That Works with 0000 Time Stamp
24 Hour Session

Now you can carve out times to trade that bridge the midnight hour.  You just need to use the above code for when the your StartTime is greater than your EndTime.

So if you want to trade from 20:00 to 05:00 (8 PM to 5 AM) then just use this code and it will work every time.

I wanted to make sure I did a post for November to keep my record alive and to let you know I am wrapping up the Hi-Res edition and will be on the bookshelves before Christmas – I hope.

 

 

EasyLanguage Code for Day of Week Analysis with Day Trading Algo

D of W Analysis

How important is a day of week analysis?  Many pundits would of course state that it is very important, especially when dealing with a day trading algorithm.   Others would disagree.  With the increase in market efficiency maybe this study is not as important as it once was, but it is another peformance metric that can be used with others.

I am currently working on the second book in the Easing into EasyLanguage trilogy (Hi-Res Edition) and I am including this in one of the tutorials on developing a day trading template.  The book, like this post, will focus on intraday data such as 5 or less minute bars.  I hope to have the book finalized in late November.  If you haven’t purchased the Foundation Edition and like this presentation, I would suggest picking a copy up – especially if you are new to EasyLanguage.  The code for this analysis is quite simple, but it is pretty cool and can be re-used.

Day Trading Algorithms Make Things Much More Simple

When you enter and exit on the same day and you don’t need to wrap around a 00:00 (midnight) time stamp, things such as this simple snippet of code are very easy to create.  The EasyLanguage built-in functions work as you would expect as well.  And obtaining the first bar of the day is ultra simple.  The idea here is to have five variables, one for each day of the week, and accumulate the profit that is made on each day, and at the end of the run print out the results.  Three things must be known on the first bar of the new trading day to accomplish this task:

  1. were trades taken yesterday?
  2. how much profit was made or lost?
  3. what was yesterday – M, T, W, R, or F?

Two Reserved Words and One Function  Are Used:  Total Trades, NetProfit and the DayOfWeek function.

The reserved word TotalTrades keeps track of when a trade is closed out.  The second reserved word, NetProfit keeps track of total profit everytime a trade is closed out.  Along with the DayOfWeek(D[1]) function you can capture all the information you need for this analysis.  Here is the code.  I will show it first and then explain it afterwards.

	if date <> date[1] then
	begin 
		myBarCount = 0;
		buysToday = 0;sellsToday = 0;
		zatr = avgTrueRange(atrLen) of data2;
		if totalTrades > totTrades then
		begin
			Print(d," ",t," trade out ",dayOfWeek(d[1])," ",netProfit);
			switch(dayOfWeek(date[1]))
			begin
				Case 1: MProf = MProf + (netProfit - begDayEquity);
				Case 2: TProf = TProf + (netProfit - begDayEquity);
				Case 3: WProf = WProf + (netProfit - begDayEquity);
				Case 4: RProf = RProf + (netProfit - begDayEquity);
				Case 5: FProf = FProf + (netProfit - begDayEquity);
				Default: Value1 = Value1 + 1;
			end;
			begDayEquity = netProfit;
			totTrades = totalTrades;
		end;
	end;
Snippet To Handle DofW Analysis on DayTrading Algorithm

 Code Explanation – Switch and Case

I have used the Switch –  Case construct in some of my prior posts and I can’t emphasize enough how awesome it is, and how you can cut down on the use of if – thens.  This snippet only takes place on the first bar of the trading day.  Since we are using day sessions we can simply compare today’s date to the prior bar’s date, and if they are different then you know you are sitting on the first  intraday bar of the day.    After some initial housekeeping, the first if – then checks to see if trade(s) were closed out yesterday.  If totalTrades is greater than my user defined totTrades, then something happened yesterday.  My totTrades is updated to totalTrades after I am done with my calculations.  The switch keys off of the DayOfWeek function.  Remember you should account for every possible outcome of the variable inside the switch expression.  In the case of the DayOfWeek function when know:

  1. Monday
  2. Tuesday
  3. Wednesday
  4. Thursday
  5. Friday

Notice I am passing Date[1] into the function, because I want to know the day of the week of yesterday.  After the Switch and its associated expression you have a Begin statement.  Each outcome of the expression is preceded withthe keyword Case followed by a colon (:).  Any code associated with each distinct result of the expression is sandwiched between Case keywords.  So if the day of week of yesterday is 1 or Monday then MProf accumulates the change in the current NetProfit and the begDayEquity (beginning of the yesterday’s NetProfit) variable.  So, if the equity at the beginning of yesterday was $10,000 and there was a closed out trade and the current NetProfit is $10,500 then $500 was made by the end of the day yesterday.  This exact calculation is used for each day of the week and stored in the appropriate day of the week variable:

  • MProf – Monday
  • TProf – Tuesday
  • WProf – Wednesday
  • RProf – Thursday
  • FProf – Friday

You might ask why RProf for Thursday?  Well, we have already used TProf for Tuesday and Thursday contains an “R”.  This is just my way of doing it, but you will find this often in code dealing with days of the week.  Every Switch should account for every possible outcome of the expression its keying off of.  Many times you can’t always know ahead of time all the possible outcomes, so a Default case should be used as an exception.  It is not necessary and it will not kick an error message if its not there.  However, its just good programming to account for everything.    Once the Switch is concluded begDayEquity and totTrades are updated for use the following day.

Here is the code that prints out the results of the DayOfWeek Analysis

if d = 1211027 and t = 1100 then
begin
	print(d," DOW Analysis ");
	print("Monday    : ",MProf);
	print("Tuesday   : ",TProf);
	print("Wednesday : ",WProf);
	print("Thursday  : ",RProf);
	print("Friday    : ",FProf);
	
end;
Printing The Results of DofW Analysis

The  printout occurs on October 27, 2021 at 11 AM.  Here is my analysis of a day trading algorithm I am working  on, tested over the last two years on 5 minute bars of the @ES.D

Monday    : 9225.00
Tuesday   : 7375.00
Wednesday : 5175.00
Thursday  : -1150.00
Friday    : 9862.50
Resuts of around $30,000

Does This Agree with Strategy Performance Report?

This System Will Be Published in the Hi-Res Edition of Easing into EasyLanguage Trilogy

Looks like it does.  These results were derived from one of the Tutorials in The Hi-Res edition of EZ-NG-N2-EZ-LANG trilogy.  I should have it availabe at Amazon some time in late November.    Of course if you have any questions just email me @ george.p.pruitt@gmail.com.

 

Passing and Accessing Multidimensional Array in a Function

Before the days of OOEL and more advanced data structures, such as vectors, you had to work with multidimensional arrays.

The problem with arrays is you have to do all the housekeeping whereas with vectors the housekeeping is handled internally.  Yes, vectors in many cases would be the most efficient approach, but if you are already using Multi-D arrays, then mixing the two could become confusing.  So stick with the arrays for now and progress into vectors at your leisure.

Recreate the CCI indicator with Multi-D Array

This exercise is for demonstration purposes only as the existing CCI function works just fine.  However, when you are trying out something new  or in this case an application of a different data structure (array) its always great to check your results against a known entity.  If your program replicates the known entity, then you know that you are close to a solution.  The CCI function accesses data via the global High, Low and Close data streams and then applies a mathematical formula to derive a result. <

Derive Your Function First

Create the function first by prototyping what the function will need in the formal parameter list (funciton header).   The first thing the function will need is the data – here is what it will look like.

  • OHLCArray[1,1] =  1210903.00 // DATE
  • OHLCArray[1,2] =    4420.25 // OPEN
  • OHLCArray[1,3] =    4490.25 // HIGH
  • OHLCArray[1,4] =    4410.25 // LOW
  • OHLCArray[1,5] =    4480.75 // CLOSE
  • OHLCArray[2,1] =  1210904.00 // DATE
  • OHLCArray[2,2] =    4470.25 // OPEN
  • OHLCArray[2,3] =    4490.25 // HIGH
  • OHLCArray[2,4] =    4420.25 // LOW
  • OHLCArray[2,5] =    4440.75 // CLOSE

Visualize 2-D Array as a Table

Column 1 Column 2 Column 3 Column 4 Column 5
1210903 44202.25 4490.25 4410.25 4480.75
1210904 4470.25 4490.25 4420.25 4440.76
The CCI function is only concerned with H, L, C and that data is in columns 3, 4, 5.  If you know the structure of the array before you program the function, then you now which columns or fields you will need to access.  If you don’t know the structure beforehand , then that information would need to be passed into the function as well.   Let us assume we know the structure.  Part of the housekeeping that I mentioned earlier was keeping track of the current row where the latest data is being stored.  This “index” plus the length of the CCI indicator is the last two things we will need to know to do a proper calculation.

CCI_2D Function Formal Parameter List

// This function needs data, current data row, and length
// Notice how I declare the OHLCArray using the dummy X and Y
// Variable - this just tells TradeStation to expect 2-D array
// ------------------
//                | |
//                * *
inputs: OHLCArray[x,y](numericArray), currentRow(numericSimple), length(numericSimple);
//                         ***
//                         |||
//----------------------------
// Also notice I tell TradeStation that the array is of type numeric
// We are not changing the array but if we were, then the type would be 
// numericArrayRef - the actual location in memory not just a copy 
	
CCI_2D Formal Parameter List

2-D Array Must Run Parallels with Actual Data

The rest of the function expects the data to be just like the H, L, C built-in data – so there cannot be gaps.  This is very important when you pack the data and  you will see this in the function driver code a.k.a an indicator. The data needs to align with the bars.  Now if you are using large arrays this can slow things down a bit.  You can also shuffle the array and keep the array size to a minimum and I will post how to do this in a post later this week.  The CCI doesn’t care about the order of the H,L,C as long as the last N element is the latest values.

variables: 	
	Mean( 0 ),sum1(0),sum2(0), 
	AvgDev( 0 ),rowNum(0), 
	Counter( 0 ) ;


AvgDev = 0 ;
if currentRow > length then // make sure enough rows
begin

	sum1 = 0;
	sum2 = 0;
	for rowNum = currentRow  - (length-1) to currentRow
	begin
		value1 = OHLCArray[rowNum,3];
		value2 = OHLCArray[rowNum,4];
		value3 = OHLCArray[rowNum,5];
		sum1 = sum1 + value1 + value2 + value3;
	end;
	//Mean = Average( H + L + C, Length ) ; { don't have to divide H+L+C by 3, cancels out } 
	Mean = sum1/length;
	print(d," Mean ",mean," ",mean/3);
	
	for rowNum = currentRow - (length-1) to currentRow
	begin
		value1 = OHLCArray[rowNum,3];
		value2 = OHLCArray[rowNum,4];
		value3 = OHLCArray[rowNum,5];
		sum2 = sum2 + AbsValue((value1 + value2 + value3) - Mean);
	end ;
	//	AvgDev = AvgDev + AbsValue( ( H + L + C )[Counter] - Mean ) ;
	AvgDev = sum2 / Length ;
	print(d," avgDev ",AvgDev," ",AvgDev/3);

	value1 = OHLCArray[currentRow,3];
	value2 = OHLCArray[currentRow,4];
	value3 = OHLCArray[currentRow,5];
end;

if AvgDev = 0 then
	CCI_2D = 0
else
	CCI_2D = ( value1 + value2 + value3 - Mean ) / ( .015 * AvgDev ) ;
CCI-2D Function
This function could be streamlined, but I wanted to show you how to access the different data values with the currentRow variable and columns 3, 4, and 5.  I extract these data and store them in Values variables.  Notice the highlighted line where I check to make sure there are enough rows to handle the calculation.  If you try to access data before row #1, then you will get an out of bounds error and a halt to program execution.

Function Driver in the form of an Indicator

array: OHLCArray[5000,5](0);
Inputs: CCI2DLen(14),CCILen(14);

vars: numRows(0),myCCI(0),regCCI(0);

numRows = numRows + 1;
OHLCArray[numRows,1] = d;
OHLCArray[numRows,2] = o;
OHLCArray[numRows,3] = h;
OHLCArray[numRows,4] = l;
OHLCArray[numRows,5] = c;

myCCI = CCI_2D(OHLCArray,numRows,14);
regCCI = CCI(14);

plot1(myCCI," CCI_2D ");
plot2(regCCI," CCI ");
CCI-2D Indicator

Notice lines 16 and 17 where I am plotting both function results – my CCI_2D and CCI.   Also notice how I increment numRows on each bar – this is the housekeeping that keeps that array synched with the chart.  In the following graphic I use 14 for CCI_2D and 9 for the built-in CCI.

Two CCI functions with different Lengths

Now the following graphic uses the same length parameters for both functions.  Why did just one line show up?

Both CCI Functions with same Lengths – were did second line go to?

Make Your Unique Coding Replicate a Known Entity – If You Can

 

Here is where your programming is graded.  The replication of the CCI using a 2-D Array instead of the built-in H, L, C data streams, if programmed correctly, should create the exact same results and it does, hence the one line.  Big Deal right!  Why did I go through all this to do something that was already done?  Great programming is not supposed to re-invent the wheel.  And we just did exactly that.  But read between the lines here.   We validated code that packed a 2-D array with data and then passed it to a function that then accessed the data correctly and applied a known formula and compared it to a known entity.  So now you have re-usable code for passing a 2-D array to a function.  All you have to do is use the template and modify the calculations.  Re-inventing the wheel is A-Okay if you are using it as a tool for validation.

The Foundation Edition – First Book In Easing Into EasyLanguage

Hello to All!  I just published the first book in this series.  It is the Foundation Edition and is designed for the new user of EasyLanguage or for those you would like to have a refresher course.  There are 13 total tutorials ranging from creating Strategies to PaintBars.  Learn how to create your own functions or apply stops and profit objectives.  Ever wanted to know how to find an inside day that is also a Narrow Range 7 (NR7?)  Now you can, and the best part is you get over 4 HOURS OF VIDEO INSTRUCTION – one for each tutorial.  Each video is created by yours truly and Beau my trustworthy canine companion.  I go over every line of code to really bring home the concepts that are laid out in each tutorial.  All source code is available too, and if you have TradeStation, so are the workspaces.  Plus you can always email George for any questions.  george.p.pruitt@gmail.com.

The Cover of my latest book. The first in the series.

If you like the information on my blog, but find the programming code a little daunting, then go back and build a solid foundation with the Foundation Edition.  It starts easy but moves up the Learning Curve at comfortable pace.  On sale now for $24.95 at Amazon.com.  I am planning on having two more advanced books in the series.  The second book, specifically designed for intraday trading and day-trading, will be available this winter.  And the third book, Advanced Topics, will be available next spring.

Pick up your copy today – e-Book or Paperback format!

Here is the link to buy the book now!

Let me know if you buy either format  and I will send you a PDF of the source code – just need proof of purchase.  With the  PDF you can copy and paste the code.  After you buy the book come back here to the Easing Into EasyLanguage Page and download  the ELD and workspaces.

If You Can’t Go Forward, Then Go Backward [Back To The Future]

Calculate MAE/MFE 30 Bars after A Signal

A very astute reader of this blog brought a snippet of code that looks like EasyLanguage and sort of behaves like it, but not exactly.  This code was presented on the exceptional blog of Quant Trader posted by Kahler Philipp.  He used some of the ideas from  Dave Bergstrom.

Equilla Programming Language

The theory behind the code is quite interesting and I haven’t gotten into it thoroughly, but will do so in the next few days.  The code was derived from Trade-Signal’s Equilla Programming Language.  I looked at the website and it seems to leans heavily on an EasyLanguage like syntax, but unlike EZLang allows you to incorporate indicators right in the Strategy.  It also allows you, and I might be wrong, to move forward in time from a point in the past quite easily.  The code basically was fed a signal (+1,0,-1) and based on this value progressively moved forward one bar at a time  (over a certain time period) and calculated the MAE and MFE (max. adverse/favorable excursion for each bar.  The cumulative MAE/MFE were then stored in a BIN for each bar.  At the end of the data, a chart of the ratio between the MAE and MFE was plotted.

EasyLanguage Version

I tried to replicate the code to the best of my ability by going back in time and recording a trading signal and then moving Back to The Future thirty bars, in this case, to calculated and store the MAE/MFE in the BINS.

Simple Moving Average Cross Over Test

After 100 bars, I looked back 30 bars to determine if the price was either greater than or less than the 21 day moving average.   Let’s assume the close was greater than the 21 day moving average 30 days ago, I then kept going backward until this was not the case.  In other words I found the bar that crossed the moving average.  It could have been 5 or 18 or whatever bars further back.  I stored that close and then started moving forward calculating the MAE/MFE by keeping track of the Highest Close and Lowest Close made during 30 bar holding period.  You will see the calculation in the code.  Every time I got a signal I accumulated the results of the calculations for each bar in the walk forward period.  At the end of the chart or test I divided each bars MFE by its MAE and plotted the results.  A table was also created in the Print Log.  This code is barely beta, so let me know if you see any apparent errors in logic or calculations.


inputs: ilb(30); //ilb - initial lookback
vars: lb(0),signal(0),btf(0),mf(0),ma(0),hh(0),ll(99999999),arrCnt(0),numSigs(0);
arrays : mfe[40](0),mae[40](0);
lb = ilb;
if barNumber > 100 then 
begin
	signal = iff(c[ilb] > average(c[ilb],21),1,-1);
//	print(d," signal ",signal," ",ilb);
	if  signal <> signal[1] then
	begin	
		numSigs = numSigs + 1; // keep track of number of signals
//		print("Inside loop ", date[ilb]," ",c[ilb]," ",average(c[ilb],21));
		if signal = 1 then // loop further back to get cross over
		begin
//			print("Inside signal = 1 ",date[lb]," ",c[lb]," ",average(c[lb],21));
			while c[lb] > average(c[lb],21)
			begin
				lb = lb + 1;
			end;
//			print("lb = ",lb);
		end;
		
		if signal = -1 then // loop further back to get cross over
		begin
//			print("Inside signal = -1 ",date[lb]," ",c[lb]," ",average(c[lb],21));
			while c[lb] < average(c[lb],21)
			begin
				lb = lb + 1;
			end;
		end;
		lb = lb - 1;
		
		hh = 0;
		ll = 999999999;
		
		arrCnt = 0;
		for btf = lb downto (lb - ilb) //btf BACK TO FUTURE INDEX
		begin
			mf=0;
			ma=0;
			hh=maxList(c[btf],hh);
//			print("inside inner loop ",btf," hh ",hh," **arrCnt ",arrCnt);
			ll=minList(c[btf],ll);	
			if signal>0 then 
			begin
				mf=iff(hh>c[lb],(hh-c[lb])/c[lb],0); // mf long signal
				ma=iff(ll<c[lb],(c[lb]-ll)/c[lb],0); // ma long signal
			end;
			if signal<0 then begin
				ma=iff(hh>c[lb],(hh-c[lb])/c[lb],0); // ma after short signal
				mf=iff(ll<c[lb],(c[lb]-ll)/c[lb],0); // mf after short signal
			end;
//			print(btf," signal ",signal," mf ",mf:0:5," ma ",ma:0:5," hh ",hh," ll ",ll," close[lb] ",c[lb]);
			mfe[arrCnt]=mfe[arrCnt]+absValue(signal)*mf;
			mae[arrCnt]=mae[arrCnt]+absValue(signal)*ma;
			arrCnt = arrCnt + 1;
		end;
	end;
end;

if lastBarOnChart then
begin
    print(" ** MFE / MAE ** ");
	for arrCnt = 1 to 30
	begin
		print("Bar # ",arrCnt:1:0," mfe / mae ",(mfe[arrCnt]/mae[arrCnt]):0:5);
	end;
	
	for arrCnt = 30 downto 1
	begin
		plot1[arrCnt](mfe[31-arrCnt]/mae[31-arrCnt]," mfe/mae ");
	end;
end;
Back to The Future - going backward then forward

Here is an output at the end of a test on Crude Oil

 ** MFE / MAE ** 
Bar # 1 mfe / mae 0.79828
Bar # 2 mfe / mae 0.81267
Bar # 3 mfe / mae 0.82771
Bar # 4 mfe / mae 0.86606
Bar # 5 mfe / mae 0.87927
Bar # 6 mfe / mae 0.90274
Bar # 7 mfe / mae 0.93169
Bar # 8 mfe / mae 0.97254
Bar # 9 mfe / mae 1.01002
Bar # 10 mfe / mae 1.03290
Bar # 11 mfe / mae 1.01329
Bar # 12 mfe / mae 1.01195
Bar # 13 mfe / mae 0.99963
Bar # 14 mfe / mae 1.01301
Bar # 15 mfe / mae 1.00513
Bar # 16 mfe / mae 1.00576
Bar # 17 mfe / mae 1.00814
Bar # 18 mfe / mae 1.00958
Bar # 19 mfe / mae 1.02738
Bar # 20 mfe / mae 1.01948
Bar # 21 mfe / mae 1.01208
Bar # 22 mfe / mae 1.02229
Bar # 23 mfe / mae 1.02481
Bar # 24 mfe / mae 1.00820
Bar # 25 mfe / mae 1.00119
Bar # 26 mfe / mae 0.99822
Bar # 27 mfe / mae 1.01343
Bar # 28 mfe / mae 1.00919
Bar # 29 mfe / mae 0.99960
Bar # 30 mfe / mae 0.99915
Ratio Values over 30 Bins

Using Arrays for Bins

When  newcomers  start to program EasyLanguage and encounter arrays it sometimes scares them away.  They are really easy and in many cases necessary to complete a project.  In this code I used two 40 element or bins arrays MFE and MAE.  I only use the first 30 of the bins to store my information.  You can change this to 30 if you like, and when you start using a fixed array it is best to define them with the exact number you need, so that TradeStation will tell you if you step out of bounds (assign value to a bin outside the length of the array).  To learn more about arrays just search my blog.  The cool thing about arrays is  you control what data goes in and what you do with that data afterwards.  Anyways play with the code, and I will be back with a more thorough explanation of the theory behind it.

 

 

 

 

 

Murray Ruggiero

Goodbye my old friend!

I first spoke to Murray in 1989 when he worked with Promise Land Technologies – an AI company that improved trading signals and I worked at Futures Truth.  He went from there to form his own companies and become an editor of Futures Magazine.  He developed one of the best back testing platforms available today – TraderStudio.  His dream was to compete with TradeStation and in his last days he saw a beta version of his software – 64 bit – and real time that could run his concepts of a trading session and a trading plan.  The session was simply a singular algorithm whereas the plan was an overlay that could manage multiple sessions and utilize complex money management schemes.  All this while collecting real time minute data.  So congratulations my friend – you damn well did it!

I-Master

Murray co-developed this phenomena that caught the attention of almost all Futures Brokers in the late 90s and early 00s.  When this system waded into the market you could see the wave it created.  It became over traded but boy did it have a run.

Intermarket Convergence/Divergence

This concept did not catch on until Murray started focusing on it.  He turned it into an art form and most of his focus was spent on uncovering the relationships between different markets and different derivatives.  I can say that he become the leading expert in this field.

Futures Magazine

If you can get your hands on his collection of articles, I would definitely advise doing so.  He touched on so many topics and explained them thoroughly.  Futures was fortunate to have him onboard.

Family

He was always talking about his family and how much he cared for them.  Murray was a workaholic – no doubt, but he was always there whenever they needed him.

Friends

I can’t list them all.  He knew everybody.  All the legends and all of them recognized him for his intelligence and innate market sense.

Legacy

Murray will be missed for being a good man – in every possible way.  That is truly the best compliment I can pay his memory.   His ideas will live on for sure, but we will all miss out on the great ideas he was yet to dream up.

Murray – thank you!

 

 

Converting Method() To Function – MultiCharts

MultiCharts Doesn’t Support Methods

Methods are wonderful tools that are just like functions, but you can put them right into your Analysis Technique and they can share the variables that are defined outside the Method.  Here is an example that I have posted previously.  Note:  This was in response to a question I got on Jeff Swanson’s EasyLanguage Mastery Facebook Group.

{'('  Expected line 10, column 12  }
//the t in tradeProfit. // var: double tradeProfit;
	
vars: mp(0);
array: weekArray[5](0);



method void dayOfWeekAnalysis()   {method definition}
var: double tradeProfit;
begin
	If mp = 1 and mp[1] = -1 then tradeProfit = (entryPrice(1) - entryPrice(0))*bigPointValue;
 	If mp = -1 and mp[1] = 1 then tradeProfit = (entryPrice(0) - entryPrice(1))*bigPointValue;
 	weekArray[dayOfWeek(entryDate(1))] = weekArray[dayOfWeek(entryDate(1))] + tradeProfit;
end;

Buy next bar at highest(high,9)[1] stop;
Sellshort next bar at lowest(low,9)[1] stop;

mp = marketPosition;
if mp <> mp[1] then dayOfWeekAnalysis();
If lastBarOnChart then
Begin
 	print("Monday ",weekArray[1]);
 	print("Tuesday ",weekArray[2]);
 	print("Wednesday ",weekArray[3]);
 	print("Thursday ",weekArray[4]);
 	print("Friday ",weekArray[5]);
end;
PowerEditor Cannot Handle Method Syntax

Convert Method to External Function

Sounds easy enough – just remove Method and copy code and put into a new function.  This method keeps track of Day Of Week Analysis.  So what is the function going to return?  It needs to return the performance metrics for Monday, Tuesday, Wednesday, Thursday and Friday.  That is five values so you can’t simply  assign the Function Name a single value – right?

Create A New Function – Call It DayOfWeekAnalysis

inputs: weekArray[n](numericArrayRef);

vars: mp(0);
var: tradeProfit(0);
mp = marketPosition;

tradeProfit = -999999999;
If mp = 1 and mp[1] = -1 then tradeProfit = (entryPrice(1) - entryPrice(0))*bigPointValue;
If mp = -1 and mp[1] = 1 then tradeProfit = (entryPrice(0) - entryPrice(1))*bigPointValue;
if tradeProfit <> -999999999 then
 	weekArray[dayOfWeek(entryDate(1))] = weekArray[dayOfWeek(entryDate(1))] + tradeProfit;
print(d," ",mp," ",mp[1]," ",dayOfWeek(entryDate(1)),tradeProfit," ",entryDate," ",entryDate(1)," ",entryPrice(0)," ",entryPrice(1));

DayOfWeekAnalysis = 1;
Simple Function - What's the Big Deal

Looks pretty simple and straight forward.  Take a look at the first line of code.  Notice how I inform the function to expect an array of [n] length to passed to it.  Also notice I am not passing by value but by reference.  Value versus reference – huge difference.  Value is a scalar value such as 5, True or a string.  When you pass by reference you are actually passing a pointer to actual location in computer memory – once you change it – it stays changed and that is what we want to do.  When you pass a variable to an indicator function you are simple passing a value that is not modified within the body of the function.  If you want a function to modify and return more than one value you can pass the variable and catch it as a numericRef.  TradeStation has a great explanation of multiple output functions.

Multiple Output Function per EasyLanguage

Some built-in functions need to return more than a single value and do this by using one or more output parameters within the parameter list.  Built-in multiple output functions typically preface the parameter name with an ‘o’ to indicate that it is an output parameter used to return a value.  These are also known as ‘input-output’ parameters because they are declared within a function as a ‘ref’ type of  input (i.e. NumericRef, TrueFalseRef, etc.) which allows it output a value, by reference, to a variable in the EasyLanguage code calling the function.

I personally don’t follow the “O” prefacing, but if it helps you program then go for it.

Series Function – What Is It And Why Do I Need to Worry About It?

A series function is a specialized function that refers to a previous function value within its calculations.  In addition, series functions update their value on every bar even if the function call is placed within a conditional structure that may not be true on a given bar.  Because a series function automatically stores its own previous values and executes on every bar, it allows you to write function calculations that may be more streamlined than if you had to manage all of the resources yourself.  However, it’s a good idea to understand how this might affect the performance of your EasyLanguage code.

Seems complicated, but it really isn’t.  It all boils down to SCOPE – not the mouthwash.  See when you call a function all the variables inside that function are local to that particular function – in other words it doesn’t have a memory.  If it changes a value in the first call to the function, it has amnesia so the next time you call the function it forgets what it did just prior – unless its a series function.  Then it remembers.  This is why I can do this:

 	If mp = 1 and mp[1] = -1 then tradeProfit = (entryPrice(1) - entryPrice(0))*bigPointValue;
 	If mp = -1 and mp[1] = 1 then tradeProfit = (entryPrice(0) - entryPrice(1))*bigPointValue;
I Can Refer to Prior Values - It Has A Memory

Did you notice TradeProfit = -99999999 and then if it changes then I accumulate it in the correct Day Bin.  If I didn’t check for this then the values in the Day Bin would be accumulated with the values returned by EntryPrice and ExitPrice functions.  Remember this function is called on every bar even if you don’t call it.  I could have tested if a trade occurred and passed this information to the function and then have the function access the EntryPrice and ExitPrice values.  This is up to your individual taste of style.  One more parameter for readability, or one less parameter for perhaps efficiency?

This Is A Special Function – Array Manipulator and Series Type

When you program a function like this the EasyLanguage Dev. Environment can determine what type of function you are using.  But if you need to change it you can.  Simply right click inside the editor and select Properites.

Function Properties – AutoDetect Selected

How Do You Call Such a “Special”  Function?

The first thing you need to do is declare the array that you will be passing to the function.  Use the keyword Array and put the number of elements it will hold and then declare the values of each element.  Here I create a 5 element array and assign each element zero.  Here is the function wrapper.

array: weekArray[5](0);
vars: mp(0),newTrade(false);

Buy next bar at highest(high,9)[1] stop;
Sellshort next bar at lowest(low,9)[1] stop;
mp = marketPosition;
newTrade = False;
//if mp <> mp[1] then newTrade = true;
	
value1 = dayOfWeekAnalysis(weekArray);
If lastBarOnChart then
Begin
 	print("Monday ",weekArray[1]);
 	print("Tuesday ",weekArray[2]);
 	print("Wednesday ",weekArray[3]);
 	print("Thursday ",weekArray[4]);
 	print("Friday ",weekArray[5]);
end;
Wrapper Function - Notice I only Pass the Array to the Function

Okay that’s how you convert a Method from EasyLanguage into a Function.  Functions are more re-uasable, but methods are easier.  But if you can’t use a method you now know how to convert one that uses Array Manipulation and us a “Series” type.

 

 

Videos Describing Free ES.D DayTrade System

Videos Published Explaining Code for the ES.D DayTrade (V-ORBO) Strategy

Two videos have been uploaded to youTube describing the strategy and strategy based indicator that I discussed in the prior post.  Here is todays action (Friday 9th of April).

2021-04-09
Friday Action – Sometimes It Works

What’s In The Videos?

Getting the Shading of the Break Out Box requires some tweaking of the indicator properties.  Part A shows how to do this – remember the code is available in the prior post.  In Part B I break down the code and show I first was inspired to develop the indicator and then figured developing the strategy would help create the indicator.  I describe both sources in the Part B.

Here are the videos:

PART-A

PART-B

Volatility, Volatility, Volatility – A Building Block for Day Trading the ES.D – Free System

Did that Title get your Attention?

I didn’t say a very good Free System!  This code is really cool so I thought I would share with you.  Take a look at this rather cool picture.

Six Bar Break Out with Volatility Buffer and Volatility Trailing Stop

Thanks to a reader of this blog (AG), I got this idea and programmed a very simple day trading system that incorporated a volatility trailing stop.  I wanted to make sure that I had it programmed correctly and always wanted to draw a box on the chart – thanks to (TJ) from MC forums for getting me going on the graphic aspect of the project.

Since I have run out of time for today – need to get a haircut.  I will have to wait till tomorrow to explain the code.  But real quickly the system.

Buy x% above first y bar high and then set up a trailing stop z% of y bar average range – move to break-even when profits exceed  $w.  Opposite goes for the short side.  One long and one short only allowed during the day and exit all at the close.

What the heck here is the code for the Strategy.

inputs: startTradeTime(930),startTradeBars(6),endTradeTime(1530),
		breakOutVolPer(0.5),trailVolPer(.25),breakEven$(500);
		

vars:	longsToday(0),shortsToday(0),
		longStop(0),shortStop(0),
		longTrail(0),shortTrail(0),
		trailVolAmt(0),
		barCount(0),highToday(0),lowToday(0),
		volAmt(0),mp(0);
		
if t = startTradeTime + barinterval then
begin
	longsToday = 0;
	shortsToday = 0;
	longStop = 0;
	shortStop = 0;
	longTrail = 0;
	shortTrail = 99999999;
	barCount = 0;
	highToday = 0;
	lowToday = 999999999;
end;

highToday = maxList(h,highToday);
lowToday = minList(l,lowToday);

mp = marketPosition;

barCount +=1;

if barCount >= startTradeBars then
begin
	volAmt = average(range,startTradeBars);
	if barCount = startTradeBars then
	begin
		longStop = highToday + breakOutVolPer * volAmt;
		shortStop = lowToday - breakOutVolPer * volAmt;
	end;
	if t < endTradeTime then
		begin
		if longsToday = 0 then buy("volOrboL") next bar at longStop stop;
		if shortsToday = 0 then sellShort("volOrboS") next bar shortStop stop;
	end;

	trailVolAmt = volAmt * trailVolPer;
	if mp = 1 then
	begin
		longsToday +=1;
		if c > entryPrice + breakEven$/bigPointValue then
			longTrail = maxList(entryPrice,longTrail);
		longTrail = maxList(c - trailVolAmt,longTrail);
		sell("L-TrlX") next bar at longTrail stop;
	end;
	if mp = -1 then
	begin
		shortsToday +=1;
		if c < entryPrice - breakEven$/bigPointValue then
			shortTrail = minList(entryPrice,shortTrail);
		shortTrail = minList(c + trailVolAmt,shortTrail);
		buyToCover("S-TrlX") next bar at shortTrail stop;
	end;
end;
setExitOnClose;
I will comment in a later post!

And the code for the Strategy Tracking Indicator.

inputs: startTradeTime(930),startTradeBars(6),endTradeTime(1530),
		breakOutVolPer(0.5),trailVolPer(.25),breakEven$(500);
		

vars:	longsToday(0),shortsToday(0),
		longStop(0),shortStop(0),
		longTrail(0),shortTrail(0),
		trailVolAmt(0),
		barCount(0),highToday(0),lowToday(0),
		volAmt(0),mp(0);
		
if t = startTradeTime + barinterval then
begin
	longsToday = 0;
	shortsToday = 0;
	longStop = 0;
	shortStop = 0;
	longTrail = 0;
	shortTrail = 99999999;
	barCount = 0;
	highToday = 0;
	lowToday = 999999999;
	mp = 0;
end;

highToday = maxList(h,highToday);
lowToday = minList(l,lowToday);
		
barCount +=1;

vars: iCnt(0),mEntryPrice(0),myColor(0);

if barCount >= startTradeBars  then
begin
	volAmt = average(range,startTradeBars);
	if barCount = startTradeBars then
	begin
		longStop = highToday + breakOutVolPer * volAmt;
		shortStop = lowToday - breakOutVolPer * volAmt;
		for iCnt = 0 to startTradeBars-1
		begin
			plot1[iCnt](longStop,"BuyBO",default,default,default);
			plot2[iCnt](shortStop,"ShrtBo",default,default,default);
		end;

	end;
	if t < endTradeTime then
	begin
		if longsToday = 0 and h >= longStop then 
		begin
			mp = 1;
			mEntryPrice = maxList(o,longStop);
			longsToday += 1;
		end;
		if shortsToday = 0 and l <= shortStop then
		begin
			mp = -1;
			mEntryPrice = minList(o,shortStop);
			shortsToday +=1;
		end;	
		plot3(longStop,"BuyBOXTND",default,default,default);
		plot4(shortStop,"ShrtBOXTND",default,default,default);
	end;
	
	trailVolAmt = volAmt * trailVolPer;
	
	if mp = 1 then
	begin
		if c > mEntryPrice + breakEven$/bigPointValue then
			longTrail = maxList(mEntryPrice,longTrail);

		longTrail = maxList(c - trailVolAmt,longTrail);
		plot5(longTrail,"LongTrail",default,default,default);
	end;
	if mp = -1 then
	begin
		if c < mEntryPrice - breakEven$/bigPointValue then
			shortTrail = minList(mEntryPrice,shortTrail);
		shortTrail = minList(c + trailVolAmt,shortTrail);
		plot6(shortTrail,"ShortTrail",default,default,default);
	end;
end;
Cool code for the indicator

Very Important To Set Indicator Defaults Like This

For the BO Box use these settings – its the first 4 plots:

Use these colors and bar high and bar low and set opacity

The box is created by drawing thick semi-transparent lines from the BuyBo and BuyBOXTND down to ShrtBo and ShrtBOXTND.   So the Buy components of the 4 first plots should be Bar High and the Shrt components should be Bar Low.  I didn’t specify this the first time I posted.  Thanks to one of my readers for point this out!

Use bar low for ShrtBo and ShrtBOXTND plots

Also I used different colors for the BuyBo/ShrtBo and the BuyBOXTND/ShrtBOXTND.  Here is that setting:

The darker colored line on the last bar of the break out is caused by the overlap of the two sets of plots.

Here is how you set up the trailing stop plots:

Make Dots and Make Then Large – I have Red and Blue Set

 

EasyLanguage Programming Workshop Part 1: 2D Array, Print Format, and Loops

Storing Trades for Later Use in a 2D Array

Since this is part 1 we are just going to go over a very simple system:  SAR (stop and reverse) at highest/lowest high/low for past 20 days.

A 2D Array in EasyLanguage is Immutable

Meaning that once you create an array all of the data types must be the same.  In a Python list you can have integers, strings, objects whatever.   In C and its derivatives you also have a a data structure (a thing that stores related data) know as a Structure or Struct.  We can mimic a structure in EL by using a 2 dimensional array.  An array is just a list of values that can be referenced by an index.

array[1] = 3.14

array[2] = 42

array[3] = 2.71828

A 2 day array is similar but it looks like a table

array[1,1], array[1,2], array[1,3]

array[2,1], array[2,2], array[2,3]

The first number in the pair is the row and the second is the column.  So a 2D array can be very large table with many rows and columns.  The column can also be referred to as a field in the table.  To help use a table you can actually give your fields names.  Here is a table structure that I created to store trade information.

  1. trdEntryPrice (0) – column zero – yes we can have a 0 col. and row
  2. trdEntryDate(1)
  3. trdExitPrice (2)
  4. trdExitDate(3)
  5. trdID(4)
  6. trdPos(5)
  7. trdProfit(6)
  8. trdCumuProfit(7)

So when I refer to tradeStruct[0, trdEntryPrice] I am referring to the first column in the first row.

This how you define a 2D array and its associate fields.

arrays: tradeStruct[10000,7](0);

vars: trdEntryPrice (0),
      trdEntryDate(1), 
      trdExitPrice (2),
      trdExitDate(3),
      trdID(4),
      trdPos(5),
      trdProfit(6),
      trdCumuProfit(7);
2D array and its Fields

In EasyLanguage You are Poised at the Close of a Yesterday’s Bar

This paradigm allows you to sneak a peek at tomorrow’s open tick but that is it.  You can’t really cheat, but it also limits your creativity and makes things more difficult to program when all you want is an accurate backtest.   I will go into detail, if I haven’t already in an earlier post, the difference of sitting on Yesterday’s close verus sitting on Today’s close with retroactive trading powers.  Since we are only storing trade information when can use hindsight to gather the information we need.

Buy tomorrow at highest(h,20) stop;

SellShort tomorrow at lowest(l,20) stop;

These are the order directives that we will be using to execute our strategy.  We can also run a Shadow System, with the benefit of hindsight, to see where we entered long/short and at what prices. I call it a Shadow because its all the trades reflected back one bar.   All we need to do is offset the highest and lowest calculations by 1 and compare the values to today’s highs and lows to determine trade entry.  We must also test the open if a gap occurred and we would have been filled at the open.  Now this code gets a bit hairy, but stick with it.

Shadow System

stb = highest(h,20);
sts = lowest(l,20);
stb1 = highest(h[1],20);
sts1 = lowest(l[1],20);

buy("Sys-L") 1 contract next bar at stb stop;
sellShort("Sys-S") 1 contract next bar at sts stop;

mp = marketPosition*currentContracts;
totTrds = totalTrades;

if mPos <> 1 then
begin
	if h >= stb1 then
	begin
		if mPos < 0 then // close existing short position
		begin
			mEntryPrice = tradeStruct[numTrades,trdEntryPrice];
			mExitPrice = maxList(o,stb1);
			tradeStruct[numTrades,trdExitPrice] = mExitPrice;
			tradeStruct[numTrades,trdExitDate] = date;
			mProfit = (mEntryPrice - mExitPrice) * bigPointValue - mCommSlipp;
			cumuProfit += mProfit;
			tradeStruct[numTrades,trdCumuProfit] = cumuProfit;
			tradeStruct[numTrades,trdProfit] = mProfit;
			print(d+19000000:8:0," shrtExit ",mEntryPrice:4:5," ",mExitPrice:4:5," ",mProfit:6:0," ",cumuProfit:7:0);
		print("-------------------------------------------------------------------------");	
		end;	
		numTrades +=1;
		mEntryPrice = maxList(o,stb1);
		tradeStruct[numTrades,trdID] = 1;
		tradeStruct[numTrades,trdPOS] = 1;
		tradeStruct[numTrades,trdEntryPrice] = mEntryPrice;
		tradeStruct[numTrades,trdEntryDate] = date;
		mPos = 1;
		print(d+19000000:8:0," longEntry ",mEntryPrice:4:5);
	end;
end;
if mPos <>-1 then
begin
	if l <= sts1 then
	begin
		if mPos > 0 then // close existing long position
		begin
			mEntryPrice = tradeStruct[numTrades,trdEntryPrice];
			mExitPrice = minList(o,sts1);
			tradeStruct[numTrades,trdExitPrice] = mExitPrice;
			tradeStruct[numTrades,trdExitDate] = date;
			mProfit = (mExitPrice - mEntryPrice ) * bigPointValue - mCommSlipp;
			cumuProfit += mProfit;
			tradeStruct[numTrades,trdCumuProfit] = cumuProfit;
			tradeStruct[numTrades,trdProfit] = mProfit;
			print(d+19000000:8:0," longExit ",mEntryPrice:4:5," ",mExitPrice:4:5," ",mProfit:6:0," ",cumuProfit:7:0);
			print("---------------------------------------------------------------------");
		end;	
		numTrades +=1;
		mEntryPrice =minList(o,sts1);
		tradeStruct[numTrades,trdID] = 2;
		tradeStruct[numTrades,trdPOS] =-1;
		tradeStruct[numTrades,trdEntryPrice] = mEntryPrice;
		tradeStruct[numTrades,trdEntryDate] = date;
		mPos = -1;
		print(d+19000000:8:0," ShortEntry ",mEntryPrice:4:5);
	end;
end;
Shadow System - Generic forany SAR System

Notice I have stb and stb1.  The only difference between the two calculations is one is displaced a day.  I use the stb and sts in the EL trade directives.  I use stb1 and sts1 in the Shadow System code.  I guarantee this snippet of code is in every backtesting platform out there.

All the variables that start with the letter m, such as mEntryPrice, mExitPrice deal with the Shadow System.  Theyare not derived from TradeStation’s back testing engine only our logic.  Lets look at the first part of just one side of the Shadow System:

if mPos <> 1 then
begin
	if h >= stb1 then
	begin
		if mPos < 0 then // close existing short position
		begin
			mEntryPrice = tradeStruct[numTrades,trdEntryPrice];
			mExitPrice = maxList(o,stb1);
			tradeStruct[numTrades,trdExitPrice] = mExitPrice;
			tradeStruct[numTrades,trdExitDate] = date;
			mProfit = (mEntryPrice - mExitPrice) * bigPointValue - mCommSlipp;
			cumuProfit += mProfit;
			tradeStruct[numTrades,trdCumuProfit] = cumuProfit;
			tradeStruct[numTrades,trdProfit] = mProfit;
			print(d+19000000:8:0," shrtExit ",mEntryPrice:4:5," ",mExitPrice:4:5," ",mProfit:6:0," ",cumuProfit:7:0);
		print("-------------------------------------------------------------------------");	
		end;	

mPos and mEntryPrice and mExitPrice belong to the Shadow System

if mPos <> 1 then the Shadow Systems [SS] is not long.  So we test today’s high against stb1 and if its greater then we know a long position was put on.  But what if mPos = -1 [short], then we need to calculate the exit and the trade profit and the cumulative trade profit.  If mPos = -1 then we know a short position is on and we can access its particulars from the tradeStruct 2D arraymEntryPrice = tradeStruct[numTrades,trdEntryPrice].  We can gather the other necessary information from the tradeStruct [remember this is just a table with fields spelled out for us.]  Once we get the information we need we then need to stuff our calculations back into the Structure or table so we can regurgitate later.  We stuff date in to the following fields trdExitPrice, trdExitDate, trdProfit and trdCumuProfit in the table.

Formatted Print: mEntryPrice:4:5

Notice in the code how I follow the print out of variables with :8:0 or :4:5?  I am telling TradeStation to use either 0 or 5 decimal places.  The date doesn’t need decimals but prices do.  So I format that so that they will line up really pretty like.

Now that I take care of liquidating an existing position all I need to do is increment the number of trades and stuff the new trade information into the Structure.

		numTrades +=1;
		mEntryPrice = maxList(o,stb1);
		tradeStruct[numTrades,trdID] = 1;
		tradeStruct[numTrades,trdPOS] = 1;
		tradeStruct[numTrades,trdEntryPrice] = mEntryPrice;
		tradeStruct[numTrades,trdEntryDate] = date;
		mPos = 1;
		print(d+19000000:8:0," longEntry ",mEntryPrice:4:5);

The same goes for the short entry and long exit side of things.  Just review the code.  I print out the trades as we go along through the history of crude.  All the while stuffing the table.

If LastBarOnChart -> Regurgitate

On the last bar of the chart we know exactly how many trades have been executed because we were keeping track of them in the Shadow System.  So it is very easy to loop from 0 to numTrades.

if lastBarOnChart then
begin
	print("Trade History");
	for arrIndx = 1 to numTrades
	begin
		value20 = tradeStruct[arrIndx,trdEntryDate];
		value21 = tradeStruct[arrIndx,trdEntryPrice];
		value22 = tradeStruct[arrIndx,trdExitDate];
		value23 = tradeStruct[arrIndx,trdExitPrice];
		value24 = tradeStruct[arrIndx,trdID];
		value25 = tradeStruct[arrIndx,trdProfit];
		value26 = tradeStruct[arrIndx,trdCumuProfit];
		
		print("---------------------------------------------------------------------");
		if value24 = 1 then
		begin
			string1 = buyStr;
			string2 = sellStr;
		end;
		if value24 = 2 then
		begin
			string1 = shortStr;
			string2 = coverStr;
		end;	
		print(value20+19000000:8:0,string1,value21:4:5," ",value22+19000000:8:0,string2,
			  value23:4:5," ",value25:6:0," ",value26:7:0);
	end;
end;

Add 19000000 to Dates for easy Translation

Since all trade information is stored in the Structure or Table then pulling the information out using our Field Descriptors is very easy.  Notice I used EL built-in valueXX to store table information.  I did this to make the print statements a lot shorter.  I could have just used tradeStruct[arrIndx, trdEntry] or whatever was needed to provide the right information, but the lines would be hard to read.  To translate EL date to a normal looking data just add 19,000,000 [without commas].

If you format your PrintLog to a monospaced font your out put should look like this.

 

PrintLog OutPut

Why Would We Want to Save Trade Information?

The answer to this question will be answered in Part 2.  Email me with any other questions…..

Backtesting with [Trade Station,Python,AmiBroker, Excel]. Intended for informational and educational purposes only!

Follow

Get every new post delivered to your Inbox

Join other followers: