Category Archives: Complete EasyLanguage Systems

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

 Well You Have To, Don’t You?

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

Step 1 – Get the rollover dates

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

You can choose type of trigger – (3) Dynamic or (4) Time based.

I am getting ahead of myself, because we can simply use the default @CL data to derive the rollover dates (almost.)  Crude oil is one of those weird markets where LTD (last trade days) occurs before FND (first notice day.)  Most markets will give you a notice before they back up a huge truck and dump a 1000 barrels of oil at your front door.   With crude you have to be Johnny on the spot!  Rollover is just a headache when trading futures, but it can be very expensive headache if you don’t get out in time.  Some markets are cash settled so rollover isn’t that important, but others result in delivery of the commodity.  Most clearing firms will help you unwind an expired contract for a small fee (well relatively small.)  In the good old days your full service broker would give you heads up.  They would call you and say, “George you have to get out of that Sept. crude pronto!”  Some firms would automatically liquidate the offending contract on your behalf – which sounds nice but it could cost you.  Over my 30 year history of trading futures I was caught a few times in the delivery process.   You can determine these FND and LTD from the CME website.  Here is the expiration description for crude futures.

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

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

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

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

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

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

Case "@CL":
	If dayOfMonth(date) = 25 and firstMonthPrint = false then 
	begin
	value1 = value1 + 1;
		print("rollArr[",value1:1:0,"]=",date[9]+19000000:8:0,";");
		firstMonthPrint = true;
	end;
	If(dayOfMonth(date[1]) < 25 and dayOfMonth(date) > 25 ) and firstMonthPrint = false then
	begin
		value1 = value1 + 1;
		print("rollArr[",value1:1:0,"]=",date[10]+19000000:8:0,";");
//		print(date[4]+19000000:8:0);
		firstMonthPrint = true;
	end;


// example of output

rollArr[103]=20210312;
rollArr[104]=20210412;
rollArr[105]=20210512;
rollArr[106]=20210614;
rollArr[107]=20210712;
rollArr[108]=20210812;
rollArr[109]=20210913;
rollArr[110]=20211012;
rollArr[111]=20211111;
rollArr[112]=20211210;
rollArr[113]=20220111;
rollArr[114]=20220211;
rollArr[115]=20220314;
rollArr[116]=20220411;
rollArr[117]=20220512;
rollArr[118]=20220610;
rollArr[119]=20220712;
rollArr[120]=20220812;
Code to print our 9 or 10 bars prior to FND in actual EasyLanguage

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

Actual data I simulated rollovers with.

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

The Open Interest Valley is the rollover date.

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

Using an adjusted continuous contract you would not see these trades.

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

Trading the Equity Curve – Part 1 of N?

Only Trade the Best Segments of the Equity Curve – Cut Out Drawdown and Take Advantage of Run Ups! Really?

Equity curve feedback has been around for many years and seems highly logical, but one can’t get an industry-wide agreement on its benefit.  The main problem is to know when to turn trading off and then back on as you track the equity curve.  The most popular approach is to use a moving average of the equity curve to signal system participation.   When the equity curve moves below 30, 60, or 90 period-moving average of equity, then just turn it off and wait until the curve crosses back above the average.  This approach will be investigated in Part 2 of this series.  Another approach is to stop trading once the curve enters a drawdown that exceeds a certain level and then start back up once the equity curve recovers.  In this post, this method will be investigated.

Programmers Perspective

How do you go about programming this tool to start with.  There are probably multiple ways of accomplishing this task, but the two I have most often observed were the two pass process and the inline simultaneous tracking of the synthetic and actual equity curves.  The two pass process generates an unadulterated equity curve and stores the equity and trades either in memory or in a file.  The second part of the process monitors the external equity curve along with the external trades synchronously and while trading is turned on, the trades are executed as they occur chronologically.  When trading is turned off, the synthetic equity curve and trades are processed along the way.   The second method is to create, which I have coined (maybe others too!), a synthetic equity curve and synthetic trades.  I have done this in my TradingSimula_18 software by creating a SynthTrade Class.  This class contains all the properties of every trade and in turn can use this information to create a synthetic equity curve.  The synthetic equity curve and trades are untouched by the real time trading.

Start Simple

The creation of an equity curve monitor and processor is best started using a very simple system.  One market algorithm that enters and exits on different dates, where pyramiding and scaling in or out are not allowed.  The first algorithm that I tested was a mean reversion system where you buy after two consecutive down closes followed by an up close and then waiting one day.  Since I tested the ES over the past 10 years you can assume the trend is up. I must admit that the day delay was a mistake on my behalf.  I was experimenting with a four bar pattern and somehow forgot to look at the prior day’s action.  Since this is an experiment it is OK!

if marketPosition <> 1 and 
(c[2] < c[3] and c[3] < c[4] and c[1]  > =  c[2]) then 
	buy next bar at open;

//The exit is just as simple - 
//get out after four days (includeing entry bar) on the next bars open - no stops or profit objectives.  

If barsSinceEntry > 2 then sell next bar at open;
Simple Strategy to test Synthetic Trading Engine

Here is the unadulterated equity curve using $0 for execution costs.

Non adjusted equity curve of our simple mean reversion system. Wait for a pull back and then a rally before entering.

The Retrace and Recover Method

In this initial experiment, trading is suspended once you reach a draw down of 10% from the peak of the equity curve and then resumes trading once a rally of 15% of the subsequent valley.  Here is an intriguing graphic.

Green means ON. Red means OFF. The lower curve is the resultant curve.

I did this analysis by hand with Excel and it is best case scenario.  Meaning that when trading is turned back on any current synthetic position is immediately executed in the real world.  This experiment resulted in nearly the same drawdown but a large drop in overall equity curve growth – $75K.

Put the Synthetic Equity Curve Engine to the Test

Now that I had the confirmed results of the experiment, I used them as the benchmark against my TS-18 Synthetic Trade Engine.  But before I installed the Equity Curve algorithm, I needed to make sure my synthetic trades lined up exactly with the real equity curve.  The synthetic curve should align 100% with the real equity curve.  If it doesn’t, then there is a problem.  This is another reason to start with a simple trading strategy.

Take a look here where I print out the Synthetic Equity curve on  a daily basis and compare it with the end result of the analysis.

Synth. matches Reality

Now let’s see if it worked.

Testing with Synth. Equity Curve Trading Turned ON!

The equity curves are very similar.  However, there is a difference and this is caused by how one re-enters after trading is turned back on.  In this version I tested waiting for a new trade signal which might take a few days.  You could re-enter in three different ways:

  1. Automatically enter synthetic position on the next bar’s open
  2. Wait for a new trade signal
  3. Enter immediately if you can get in at a better price

Using the 10% Ret. and 15% Rec. algorithm didn’t help at all.  What if we test 10% and 10%.

10% Ret. and 10% Rec.

Now that performed better – more profit and less draw down.  Now that I have the synthetic engine working on simple algorithms we can do all sorts of equity curve analysis.  In the next installment in this series I will make sure the TS-18 Synthetic Engine can handle more complicated entry and exit algorithms.  I have already tested a simple longer term trend following strategy on a medium sized portfolio and the synthetic engine worked fine.  The retracement/recovery algorithm at 10%/15% did not work and I will go into the “whys” in my next post.

A Tribute to Murray and His Inter-Market Research

Murray Ruggiero’s Inter-Market Research

Well it’s been a year, this month, that Murray passed away.  I was fortunate to work with him on many of his projects and learned quite a bit about inter-market convergence and divergence.  Honestly, I wasn’t that into it, but you couldn’t argue with his results.  A strategy that he developed in the 1990s that compared the Bond market with silver really did stand the test of time.  He monitored this relationship over the years and watched in wane.  Murray replaced silver with $UTY.

The PHLX Utility Sector Index (UTY) is a market capitalization-weighted index composed of geographically diverse public utility stocks.

He wrote an article for EasyLanguage Mastery by Jeff Swanson where he discussed this relationship and the development of inter-market strategies and through statistical analysis proved that these relationships added real value.

I am currently writing Advanced Topics, the final book in my Easing Into EasyLanguage trilogy, and have been working with Murray’s research.  I am fortunate to have a complete collection of his Futures Magazine articles from the mid 1990s to the mid 2000s.  There is a quite a bit of inter-market stuff in his articles.  I wanted, as a tribute and to proffer up some neat code, to show the performance and code of his Bond and $UTY inter-market algorithm.

Here is a version that he published a few years ago updated through June 30, 2022 – no commission/slippage.

Murray’s Bond and $UTY inter-market Strategy

Not a bad equity curve.  To be fair to Murray he did notice the connection between $UTY and the bonds was changing over the past couple of year.  And this simple stop and reverse system doesn’t  have a protective stop.   But it wouldn’t look much different with one, because the system looks at momentum of the primary  data and momentum of the secondary data and if they are in synch (either positively or negatively correlated – selected by the algo) an order is fired off.  If you simply just add a protective stop, and the momentum of the data are in synch, the strategy will just re-enter on the next bar.  However, the equity curve just made a new high  recently.  It has got on the wrong side of the Fed raising rates.  One could argue that this invisible hand has toppled the apple cart and this inter-market relationship has been rendered meaningless.

Murray had evolved his inter-market analysis to include state transitions.  He not only looked at the current momentum, but also at where the momentum had been.  He assigned the transitions of the momentum for the primary and secondary markets a value from one to four and he felt this state transition helped overcome some of the coupling/decoupling of the inter-market relationship.

However,  I wanted to test Murray’s simple strategy with a fixed $ stop and force the primary market to move from positive to negative or negative to positive territory while the secondary market is in the correct relationship.  Here is an updated equity curve.

George’s Adaptation and using a $4500 stop loss

This equity curve was developed  by using a $4500 stop loss.  Because I changed the order triggers, I reoptimized the length of the momentum calculations for the primary and secondary markets.  This curve is only better in the category of maximum draw down.  Shouldn’t we give Murray a chance and reoptimize his momentum length calculations too!  You bet.

Murray Length Optimizations

These metrics were sorted by Max Intraday Draw down.  The numbers did improve, but look at the Max Losing Trade value.  Murray’s later technology,  his State Systems, were a great improvement over this basic system.  Here is my optimization using a slightly different entry technique and a $4500 protective stop.

Standing on the Shoulders of a Giant

This system, using Murray’s overall research, achieved a better Max Draw Down and a much better Max Losing Trade.   Here is my code using the template that Murray provided in his articles in Futures Magazine and EasyLanguage Mastery.

 

// Code by Murray Ruggiero
// adapted by George Pruitt

Inputs: InterSet(2),LSB(0),Type(1),LenTr(4),LenInt(4),Relate(0);
Vars: MarkInd(0),InterInd(0);

If Type=0 Then 
Begin
	InterInd=Close of Data(InterSet)-CLose[LenInt] of Data(InterSet);
	MarkInd=CLose-CLose[LenTr];
end;

If Type=1 Then 
Begin
	InterInd=Close of Data(InterSet)-Average(CLose of Data(InterSet),LenInt);
	MarkInd=CLose-Average(CLose,LenTr);
end;

if Relate=1 then 
begin
	If InterInd > 0 and MarkInd CROSSES BELOW 0 and LSB>=0 then 
		Buy("GO--Long") Next Bar  at open;
	If InterInd < 0 and MarkInd CROSSES ABOVE 0 and LSB<=0 then
		Sell Short("GO--Shrt") Next Bar  at open;

end;
if Relate=0 then begin
	If InterInd<0 and MarkInd CROSSES BELOW 0  and LSB>=0 then 
		Buy Next Bar  at open;
	If InterInd>0 and MarkInd CROSSES ABOVE 0  and LSB<=0 then 
		Sell Short Next Bar  at open;
end;

Here the user can actually include more than two data streams on the chart.  The InterSet input allows the user to choose or optimize the secondary market data stream.  Momentum is defined by two types:

  • Type 0:  Intermarket or secondary momentum simply calculated by close of data(2) – close[LenInt] of date(2) and primary momentum calculated by close – close[LenTr]
  • Type 1:   Intermarket or secondary momentum  calculated by close of data(2) – average( close of data2, LenInt)  and primary momentum calculated by close – average(close, LenTr)

The user can also input what type of Relationship: 1 for positive correlation and 0 for negative correlation.  This template can be used to dig deeper into other market relationships.

George’s Modification

I simply forced the primary market to CROSS below/above 0 to initiate a new trade as long the secondary market was pointing in the right direction.

	If InterInd > 0 and MarkInd CROSSES BELOW 0 and LSB>=0 then 
		Buy("GO--Long") Next Bar  at open;
	If InterInd < 0 and MarkInd CROSSES ABOVE 0 and LSB<=0 then
		Sell Short("GO--Shrt") Next Bar  at open;
Using the keyword CROSSES

This was a one STATE transition and also allowed a protective stop to be used without the strategy automatically re-entering the trade in the same direction.

Thank You Murray – we sure do miss you!

Murray loved to share his research and would want us to carry on with it.  I will write one or two blogs a year in tribute to Murray and his invaluable research.

Super Trend Indicator in EasyLanguage

SuperTrend Indicator – What Is It?

SuperTrend is a trading strategy and indicator all built into one entity.  There are a couple of versions floating around out there.  MultiCharts and Sierra Chart both have slightly different flavors of this combo approach.

Ratcheting Trailing Stop Paradigm

This indic/strat falls into this category of algorithm.  The indicator never moves away from your current position like a parabolic stop or chandelier exit.  I used the code that was disclosed on Futures.io or formerly known as BigMikesTrading blog.   This version differs from the original SuperTrend which used average true range.  I like Big Mike’s version so it will discussed here.

Big Mike’s Math

The math for this indicator utilizes volatility in the terms of the distance the market has travelled over the past N days.  This is determined by calculating the highest high of the last N days/bars and then subtracting the lowest low of last N days/bars.   Let’s call this the highLowRange.  The next calculation is an exponential moving average of the highLowRange.  This value will define the market volatility.   Exponential moving averages of the last strength days/bars highs and lows are then calculated and divided by two – giving a midpoint.  The volatility measure (multiplied my mult) is then added to this midpoint to calculate an upper band.  A lower band is formed by subtracting the volatility measure X mult from the midpoint.

Upper or Lower Channel?

If the closing price penetrates the upper channel and the close is also above the highest high of strength days/bars back (offset by one of course) then the trend will flip to UP.  When the trend is UP,  then the Lower Channel is plotted.  Once the trend flips to DN, the upper channel will be plotted.  If the trend is UP the lower channel will either rise with the market or stay put.  The same goes for a DN trend – hence the ratcheting.  Here is a graphic of the indicator on CL.

Super Trend by Bike Mike

If you plan on using an customized indicator in a strategy it is always best to build the calculations inside a function.  The function then can be used in either an indicator or a strategy.

Function Name: SuperTrend_BM

Function Type: Series – we will need to access prior variable values

SuperTrend_BM Function Code:

//SuperTrend from Big Mike now futures.io

inputs: 
length(NumericSimple), mult(NumericSimple), strength(NumericSimple), STrend(NumericRef);

vars: 
highLowRange(0), 
xAvgRng(0),
xAvg(0), 
dn(0), 
up(0), 
trend(1), 
trendDN(False), 
trendUP(False), 
ST(0); 

highLowRange = Highest(high, length) - Lowest(low, length);

xAvgRng = XAverage(highLowRange, length);

xAvg = (XAverage(high, Strength) + XAverage(low, Strength))/2;

up = xAvg + mult * xAvgRng; 
dn = xAvg - mult * xAvgRng; 

if c > up[1] and c > Highest(High, strength)[1] then
	trend = 1
else 
	if c < dn[1] and c < Lowest(Low, Strength)[1] then
		trend = -1;

//did trend flip?		
trendDN = False;
trendUP = False;

if trend < 0 and trend[1] > 0 then 
	trendDN	= True; 	
if trend > 0 and trend[1] < 0 then 
	trendUP = True;
	
//ratcheting mechanism
if trend > 0 then dn = maxList(dn,dn[1]);
if trend < 0 then up = minList(up,up[1]);

// if trend dir. changes then assign
// up and down appropriately
if trendUP then
	up = xAvg + mult * xAvgRng; 	
if trendDN then
	dn = xAvg - mult * xAvgRng; 

if trend = 1 then 
	ST = dn 
else
	ST = up;
	
STrend = trend;

SuperTrend_BM = ST;
SuperTrend ala Big Mike

The Inputs to the Function

The original SuperTrend did include the Strength input.  This input is a Donchian like signal.  Not only does the price need to close above/below the upper/lower channel but also the close must be above/below the appropriate Donchian Channels to flip the trend,  Also notice we are using a numericRef as the type for STrend.  This is done because we need the function to return two values:  trend direction and the upper or lower channel value.  The appropriate channel value is assigned to the function name and STrend contains the Trend Direction.

A Function Driver in the Form of an Indicator

A function is a sub-program and must be called to be utilized.   Here is the indicator code that will plot the values of the function using: length(9), mult(1), strength(9).

// SuperTrend indicator
// March 25 2010
// Big Mike https://www.bigmiketrading.com 
inputs: 
length(9), mult(1), strength(9);

vars: 
strend(0),
st(0);

st = SuperTrend_BM(length, mult,strength,strend);

if strend = 1 then Plot1(st,"SuperTrendUP");
if strend = -1 then Plot2(st,"SuperTrendDN");
Function Drive in the form of an Indicator

 

This should be a fun indicator to play with in the development of a trend following approach.   My version of Big Mike’s code is a little different as I wanted the variable names to be a little more descriptive.

Update Feb 28 2022

I forgot to mention that you will need to make sure your plot lines don’t automatically connect.

Plot Style Setting

Can You Do This with Just One Plot1?

An astute reader brought it to my attention that we could get away with a single plot and he was right.  The reason I initially used two plot was to enable the user to chose his/her own plot colors by using the Format dialog.

//if strend = 1 then Plot1(st,"SuperTrendUP");
//if strend = -1 then Plot2(st,"SuperTrendDN");

if strend = 1 then SetPlotColor(1,red);
if strend = -1 then SetPlotColor(1,green);

Plot1(st,"SuperTrend_BM");
Method to just use one Plot1

Tracking Last EntryPrice While Pyramiding on Minute Bars

EasyLanguage’s EntryPrice Doesn’t Cut the Mustard

In writing the Hi-Res edition of Easing Into EasyLanguage I should have included this sample program.  I do point out the limitations of the EntryPrice keyword/function in the book.  But recently I was tasked to create a pyramiding scheme template that used minute bars and would initiate a position with N Shares and then pyramid up to three times by adding on N Shares at the last entry price + one 10 -Day ATR measure as the market moves in favor of the original position.  Here is an example of just such a trade.

Pyramid 3 Times After Initial Trade Entry. Where’s the EntryPrice?

EntryPrice only contains the original entry price.  So every time you add on a position, the EntryPrice doesn’t reflect this add on price.  I would like to be able to index into this keyword/function and extract any EntryPrice.  If you enter at the market, then you can keep track of entry prices because a market order is usually issued from an if-then construct:

//Here I can keep track of entry prices because I know
//exactly when and where they occur.

if c > c[1] and value1 > value2 then
begin
	buy("MarketOrder") next bar at market;
	lastEntryPrice = open of next bar;
end;
Last Entry Price tracking is easy if using Market Orders

But what if you are using a stop or limit order.  You don’t know ahead of time where one of these types of orders will hit up.  It could be the next bar or it could be five bars later or who knows.

AvgEntryPrice Makes Up for the Weakness of EntryPrice

AvgEntryPrice is a keyword/function that  returns the average of the entries when pyramiding.  Assume you buy at 42.00 and pyramid the same number of shares at 46.50 – AvgEntryPrice will be equal to (42.00 + 46.50) / 2 = 44.25.  With this information you can determine the two entry prices.  You already know the original price.  Take a look at this code.

// remember currentShares and avgEntryPrice ARE EasyLanguage Keywords/Functions
if mp[1] = mp and mp = -1 and currentShares > curShares then
begin
	totShorts = totShorts + 1;
	if currentShares > initShares then
	begin
		lastEntryPrice = totShorts * avgEntryPrice - entryPriceSums;
		entryPriceSums = entryPriceSums + lastEntryPrice;
		print(d," Short addon ",lastEntryPrice," ",totShorts," ",avgEntryPrice," ",entryPriceSums);
	end;
end;
Calculating the true LastEntryPrice

Remember currentShares is a keyword/function and it is immediately updated when more shares are added or taken off.  CurShares is my own variable where I keep track of the prior  currentShares , so if currentShares (real number of shares) is greater than the prior curShares (currentShares) then I know 100%, a position has been pyramided as long the the mp stays the same.  If currentShares increases and mp stays constant, then you can figure out the last entry price where the pyramid takes place.  First you tick totShorts up by 1.  If currentShares > initShares, then you know you are pyramiding so

lastEntryPrice = totShorts * avgEntryPrice – entryPriceSums

Don’t believe me.  Let’s test it.  Remember original entry was 42.00 and the add on was at 46.50.  TotShorts now equals 2.

  1. Initial entryPrice = 42.00 so entryPriceSums is set to 42.00
  2. After pyramiding avgEntryPrice is set to 44.25
  3. lastEntryPrice = 2 * 44.25 – 42.00 = 46.50
  4. entryPriceSums is then set to 42.00 + 46.50 or 88.50

So every time you add on a position, then you flow through this logic and you can keep track of the actual last entry price even if it is via a limit or stop order.

But wait there is more.  This post is also a small glimpse into what I will be writing about in the Easing Into EasyLanguage:  Advanced Topics.  This system definitely falls into what I discussed in the Hi-Res Edition.  Here is where we tip over into Advanced Topics.  The next book is not about creating dialogs or trading apps using OOEL (object oriented EasyLanguage), but we do use some of those topics to do some rather complicated back testing things.

Now that we know how to calculate the lastEntryPrice wouldn’t it be really cool if we could keep track of all of the entryPrices during the pyramid stream.   If I have pyramided four times, I would like to know entryPrice 1, entryPrice 2, entryPrice 3 and entryPrice 4.

EntryPrice Vector

Dr. VectorLove or How I Learned to Stop Worrying and Love Objects

I have discussed vectors before but I really wanted to discuss them more.  Remember Vectors are just lists or arrays that don’t need all the maintenance.  Yes you have to create them which can be a pain, but once you learn and forget it twenty times it starts to sink in.  Or just keep referring back to this web page.


Using elsystem.collections;

vars: Vector entryPriceVector(Null);

once Begin
	entryPriceVector = new Vector;
end;
The Bare Minimum to Instantiate a Vector
  1. Type – “Using elsystem.collections; “
  2. Declare entryPriceVector as a Vector and set it equal to Null
  3. Use Once and instantiate entryPriceVector by using the keyword new < object type>;

A Vector is part of elsystem’s collection objects.  Take a look at this updated code,

if mp[1] = mp and mp = -1 and currentShares > curShares then
begin
	totShorts = totShorts + 1;
	if currentShares > initShares then
	begin
		lastEntryPrice = totShorts * avgEntryPrice - entryPriceSums;
		entryPriceVector.push_back(lastEntryPrice);
		entryPriceSums = entryPriceSums + lastEntryPrice;
		print(d," Short addon ",lastEntryPrice," ",entryPrice," ",entryPrice(1)," ",totShorts," ",avgEntryPrice," ",entryPriceSums," ",entryPriceVector.back() astype double," ",entryPriceVector.count asType int);
		if not(entryPriceVector.empty()) then
		begin
			for m = 0 to entryPriceVector.count-1
			begin
				print(entryPriceVector.at(m) astype double);
			end;
		end;
	end;
end;
LastEntryPrice and Pushing It onto the Vector and Then Printing Out the Vector

After the lastEntryPrice is calculated it is pushed onto the entryPriceVector using the function (method same thing but it is attached to the Vector class).push_back(lastEntryPrice);

entryPriceVector.push_back(lastEntryPrice);

So every time a new lastEntryPrice is calculated it is pushed onto the Vector at the back end.  Now if the entryPriceVector is not empty then we can print its contents by looping and indexing into the Vector.

if not(entryPriceVector.empty()) then
begin
     for m = 0 to entryPriceVector.count-1
     begin
          print(entryPriceVector.at(m) astype double);
     end;
end;
Looping through a Vector and Printing Out its Contents

Remember if you NOT a boolean value then it turns it to off/on or just the opposite of the boolean valueIf entryPriceVector is not empty then proceed.  entryPriceVector.count holds the number of values stuffed into the vectorYou can index into the Vector by using .at(m),  If you want to print out the value of the Vector .at(m), then you will need to typecast the Vector object as what ever it is holding.  We know we are pushing numbers with decimals (double type) onto the Vector so we know we can evaluate them as a double type.  Just remember you have to do this when printing out the values of the Vector.

Okay you can see where we moved into an Advanced Topics area with this code.  But it really becomes useful when trying to overcome some limitations of EasyLanguage.  Remember keep an eye open for Advanced Topics sometime in the Spring.

Easing Into EasyLanguage: Hi-Res Edition Now Available

Hi-Res Is Now Available

Easing Into EasyLanguage : The Hi-Res Edition

The Hi-Res Edition of Easing Into EasyLanguage

This is my second book in the Easing Into EasyLanguage [EZNGN2EZLANG] series of books.  Here are the table of contents.

Contents

  •  Introduction
  • About Website Computer Code and Fonts In Print Version
  • Using EasyLanguage to Program on Minute Intervals?
  • Tutorial 14 – Why Do I Need to Use Intraday Data
  • Tutorial 15 – An Algorithm Template that Uses Minute Bars to Trade a Daily Bar Scheme
  • Tutorial 16 – Using Data2 as a Daily Bar
  • Tutorial 17 – Let’s Day Trade!
  • Tutorial 18 – Moving From Discrete Day-Trade Strategy to a Framework
  • Tutorial 19 – Day-Trading Continued: Volatility Based Open Range Break Out with Pattern Recognition
  • Tutorial 20 – Pyramiding with Camarilla
  • Tutorial 21 – Programming a Scale Out Scheme
  • Tutorial 22- Crawling Like A Bug on a Five Minute Chart
  • Tutorial 23 – Templates For Further Research
  • Appendix A-Source Code
  • Appendix B-Links to Video Instruction

I have included five hours of video instruction which is included via links in the book and in the supplemental resource download.

What’s In This Book

If you are not a Trend Follower, then in most cases, you will not be able to properly or accurately code and backtest your trading algorithm without the use of higher resolution  data  (minute bars).  A very large portion of the consulting I have done over the years has  dealt with converting a daily bar system to one that uses intraday data such as a 5-minute bar.  Coding a daily bar system is much more simple than taking the same concept and adding it to a higher resolution (Hi-Res) chart.  If you use a 100 day moving average and you apply it to a 5-minute chart you get a 100 five minute bar moving average – a big difference.

Why Do I Need To Use Hi-Res Data?

If all you need to do is calculate a single entry or exit on a daily basis and can manually execute the trades, then you can stick with daily bars.  Many of the famous Trend-Following systems such as Turtle, Aberration,  Aberration Plus,  Andromeda,  and many others fall into this category.  Most CTAs use these types of systems and spend most of their efforts on accurate execution and portfolio management.   These systems, until the genesis of the COVID pandemic, have struggled for many years.  Some of the biggest and brightest futures fund managers had to shut their doors due to their lagging performance and elevated levels of risk in comparison to the stock market.  However, if you need to know the ebb and flow of the intraday market movement to determine accurate trade entry, then intraday data is an absolute necessity.   Also, if you want to automate, Hi-Res data will help too!   Here is an example of a strategy that would need to know what occurs first in chronological order.

Example of a Simple  Algorithm that Needs Intraday Data

If the market closes above the prior day’s close, then  buy the open of the next day plus 20% of today’s range and sellShort the open of the next day minus 40% of today’s range.  Use a protective stop of $500 and a profit objective of $750.  If the market closes below the prior day’s close then sellShort the open of the next day minus 20% of today’s range and buy the open of the next day plus 40% of todays range.  The same trade management of profit and loss is applied as well.  From the low resolution of a daily bar the computer cannot determine if the market moves up 20% or down 40% first.  So the computer cannot accurately determine if a long or short is established first.  And to add insult to injury, if the computer could determine the initial position accurately from a daily bar, it still couldn’t determine if the position is liquidated via a profit or a loss if both conditions could have occurred.

What About “Look Inside Bar”?

There is evidence that if the bar closes near the high and the open near the low of a daily bar, then there is a higher probability that the low was made first.  And the opposite is true as well.  If the market opens near the middle of the bar, then all bets are off.  When real money is in play you can’t count on this type of probability or the lack thereof .  TradeStation allows you to use your daily bar scheme and then Look Inside Bar to see the overall ebb and flow of the intraday movement.  This function allows you to drill down to one minute bars, if you like.  This helps a lot, but it still doesn’t allow you to make intraday decisions, because you are making trading decisions from the close of the prior day.

if c > c[1] then 
begin
	buy next day at open of next day + 0.2 * range stop;
	sellShort next day at open of next day - 0.4 * range stop;
end;

setProfitTarget(750);
setStopLoss(500);
Next Day Order Placement

Using setProfitTarget and setStopLoss helps increase testing accuracy, but shouldn’t you really test on a 5-minute bar just to be on the safe side.

DayTrading in Most Cases Needs Hi-Res Data

If I say buy tomorrow at open of next day and use a setStopLoss(500), then I don’t need Hi-Res data.  I execute the open which is the first time stamp in the chronological order of the day.  Getting stopped out will happen later and any adverse move from the open that  equates to $500 will liquidate the position or the position will be liquidated at the end of the day.

However, if I say buy the high of the first 30 minutes and use the low of the first 30 minutes as my stop loss and take profits if the position is profitable an hour later or at $750, then intraday data is absolute necessity.  Most day trading systems need to react to what the market offers up and only slightly relies on longer term daily bar indicators.

If Intraday Data is So Important then Why ” The Foundation Edition?”

You must learn to crawl before you can walk.  And many traders don’t care about the intraday action – all they care about is where the market closed and how much money should be allocated to a given trade or position.  Or how an open position needs to be managed.  The concepts and constructs of EasyLanguage must be learned first from a daily bar framework before a new EL programmer can understand how to use that knowledge on a five minute bar.  You cannot just jump into a five minute bar framework and start programming accurately unless you are a programmer from the start or you have a sound Foundation in EasyLanguage.

Excerpt from Hi-Res Edition

From Tutorial 21 – Put 2 Units on, Take Profit on 1 Unit, Pull Stop to Break Even on 2nd Unit

Here is an example of a simple and very popular day trading scheme.  Buy 2 units on a break out and take profits on 1 unit at X dollars.  Pull stop on 2nd unit to breakeven to provide a free trade.  Take profit on 2nd unit or get out at the end of the day.

Conceptually this is easy to see on the chart and to understand.  But programming this is not so easy.  The code and video for this algorithm is  from Tutorial 21 in the Hi-Res edition.

Here are the results of the algorithm on a 5 minute ES.D chart going back five years.  Remember these results are the result of data mining.  Make sure you understand the limitations of back-testing.  You can read those here.

No Execution Costs Included! Please read backtesting disclaimer.

There are a total of 10 Tutorials and over 5 hours of Video Instruction included.  If you want to expand your programming capabilities to include intraday algorithm development, including day trading, then get your copy today.

 

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.

 

 

 

 

 

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.

 

 

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…..