Optimal F in EasyLanguage for TradeStation and MultiCharts
Here is the code for the Optimal F calculation. For a really good explanation of Optimal f, I refer you to Ralph Vince’s Book Portfolio Management FORMULAS. We had programmed this years ago for our Excalibur software and I was surprised the EasyLanguage code was not really all that accessible on the internet. Finding the Optimal f is found through an iterative process or in programmers terms a loop. The code is really quite simple and I put it into a Function. I decided to create this function because I wanted to demonstrate the ideas from my last post on how a function can store variable and array data. Plus this code should be readily available somewhere out there.
//OptimalFGeo by George Pruitt //My interpretation Sept. 2018 //www.georgepruitt.com //georgeppruitt@gmail.com
totalTradesCount = totalTrades; If totalTradesCount > totalTradesCount[1] then begin tradeCnt = tradeCnt + 1; tradesArray[tradeCnt] = positionProfit(1); end;
// Taken from my Fortran library - GPP and Vince Book PMF
optF = 0.0; gMean = 1.00; gat = 0.00; //Only calculate if new trade IF(tradeCnt>minNumTrades and totalTradesCount > totalTradesCount[1]) then Begin biggestLoser = 0; grandTot = 0; For iCnt = 1 to tradeCnt //get the biggest loser begin grandTot = grandTot + tradesArray[iCnt]; IF(tradesArray[iCnt]<biggestLoser) then biggestLoser = tradesArray[iCnt]; end; // print(grandTot," ",biggestLoser); IF({grandTot > 0 and} biggestLoser <0) then begin // print("Inside TWR Calculations"); highI = 0; hiTWR = 0.0; for iCnt = 1 to 100 begin fVal = .01 * iCnt; TWR = 1.0; for jCnt = 1 to tradeCnt // calculate the Terminal Wealth Relative begin HPR = 1. + (fVal * (-1*tradesArray[jCnt]) / biggestLoser); TWR = TWR * HPR; // print(fVal," ",iCnt," " ,jCnt," Trades ",tradesArray[jCnt]," HPR ",HPR:6:4," TWR : ",TWR:6:4," hiTWR",hiTWR:6:4," bl ",biggestLoser); end; // print(iCnt," ",TWR," ",hiTWR); IF(TWR>hiTWR) THEN begin hiTWR = TWR; optF = fVal; // assign optF to fVal in case its the correct one end else break; //highest f found - stop looping end; If (TWR <= hiTWR or optF >= 0.999999) then begin TWR = hiTWR; OptimalFGeo = optF; //assign optF to the name of the function end; gmean = power(TWR,(1.0 / tradeCnt));
if(optF<>0) then GAT = (gMean - 1.0) * (biggestLoser / -(optF)); print(d," gmean ",gmean:6:4," ",GAT:6:4); // I calculate the GMEAN and GeoAvgTrade end; end;
Optimal F Calculation by Ralph Vince code by George Pruitt
VBA version of Optimal F
For those of you who have a list of trades and want to see how this works in Excel here is the VBA code:
Sub OptimalF()
Dim tradesArray(1000) As Double i = 0 biggestLoser = 0# Do While (Cells(3 + i, 1) <> "") tradesArray(i) = Cells(3 + i, 1) If tradesArray(i) < bigLoser Then biggestLoser = tradesArray(i) i = i + 1 Loop tradeCnt = i - 1 highI = 0 hiTWR = 0# rc = 3 For fVal = 0.01 To 1 Step 0.01 TWR = 1# For jCnt = 0 To tradeCnt HPR = 1# + (fVal * (-1 * tradesArray(jCnt)) / biggestLoser) TWR = TWR * HPR Cells(rc, 5) = jCnt Cells(rc, 6) = tradesArray(jCnt) Cells(rc, 7) = HPR Cells(rc, 8) = TWR rc = rc + 1 Next jCnt Cells(rc, 9) = fVal Cells(rc, 10) = TWR rc = rc + 1
If (TWR > hiTWR) Then hiTWR = TWR optF = fVal Else Exit For End If
Next fVal If (TWR <= hiTWR Or optF >= 0.999999) Then TWR = hiTWR OptimalFGeo = optF End If Cells(rc, 8) = "Opt f" Cells(rc, 9) = optF rc = rc + 1 gMean = TWR ^ (1# / (tradeCnt + 1)) If (optF <> 0) Then GAT = (gMean - 1#) * (biggestLoser / -(optF)) Cells(rc, 8) = "Geo Mean" Cells(rc, 9) = gMean rc = rc + 1 Cells(rc, 8) = "Geo Avg Trade" Cells(rc, 9) = GAT
End Sub
VBA code for Optimal F
I will attach the eld and .xlsm file a little later.
Function Variable Data Survives from One Call to the Next – A Pretty Nifty Tool in EasyLanguage!
Creating a function that can store data and then have that data survive on successive function calls without having to pass information back and forth is really a cool and powerful tool in EasyLanguage. In most programming languages, the variables defined in a function are local to that particular bit of code and once program execution exits the function, then the data is destroyed. There are two exceptions (in other languages) that come to mind – if the variable is passed back and forth via their addresses, then the data can be maintained or if the variable is global in scope to the function and the calling program. EasyLanguage prevents you from having to do this and this can definitely save on headaches. I wrote a function that defines an array that will hold a list of trades. Once the number of trades reaches a certain level, I then calculate a moving average of the last 10 trades. The average is then passed back to the calling strategy. Here is the simple code to the function.
{Function Name: StoreTradesFunc by George Pruitt} {Function to Calculate the average trade for past N trades. ---------------------------------------------------------- Function remembers the current trade count in tradeCnt. It also remembers the values in the array tradesArray. It does this between function calls. Values - simple and array - undoubtedly are global to the function}
totalTradesCount = totalTrades; If totalTradesCount > totalTradesCount[1] then begin tradeCnt = tradeCnt + 1; tradesArray[tradeCnt] = positionProfit(1); // print("Storing data ",tradesArray[tradeCnt]," ",tradeCnt); end;
If totalTrades > avgTradeCalcLen then begin Value2 = 0; For value1 = totalTrades downTo totalTrades - avgTradeCalcLen begin Value2 = value2 + tradesArray[value1]; end; print("Sum of last 10 Trades: ",value2); StoreTradesFunc = value2/avgTradeCalcLen; end;
Store A List of Trades in a Function
I call this function on every bar (daily would be best but you could do it on intra-day basis) and it polls the function/keyword totalTrades to see if a new trade has occurred. If one has, then the variable tradeCnt is incremented and the trade result is inserted into the tradesArray array by using the tradeCnt as the array index. When you come back into the function from the next bar of data tradeCnt and tradesArray are still there for you and most importantly still intact. In other words there values are held static until you change them and remembered. This really comes in handy when you want to store all the trades in an array and then do some type of calculation on the trades and then have that information readily available for use in the strategy. My example just provides the average trade for the past ten trades. But you could do some really exotic things like Optimal F. The thing to remember is once you define a variable or an array in a function and start dumping stuff in them, the stuff will be remembered throughout the life of the simulation. The function data and variables are encapsulated to just the function scope – meaning I can’t access tradesArray outside of the function. One last note – notice how I was able to determine a new trade had occurred. I assigned the result of totalTrades to my own variable totalTradesCount and then compared the value to the prior bar’s value. If the values were different than I knew a new trade had just completed.
Converting A List of Trades, Dates and Prices Into EasyLanguage Arrays:
As the old saying goes “a picture is worth a thousand words!” Have you ever been given a list of trades like this:
Sell Short,20010622,1178.50 Buy to Cover,20010626,1159.75 Sell Short,20010801,1150.00 Buy to Cover,20010807,1139.75 Sell Short,20010814,1129.00 Buy to Cover,20010816,1117.25 Sell Short,20011001,976.75 Buy to Cover,20011004,1016.75 Sell Short,20011107,1053.00 Buy to Cover,20011123,1069.50 Sell Short,20011219,1076.25 Buy to Cover,20020102,1075.00 Sell Short,20020129,1067.25 Buy to Cover,20020131,1046.75 Sell Short,20020131,1046.75 Buy to Cover,20020205,1026.75 Sell Short,20020520,1033.25 Buy to Cover,20020522,1011.50 Sell Short,20020731,832.00 Buy to Cover,20020805,792.50 Sell Short,20020812,834.00 Buy to Cover,20020814,811.75 Sell Short,20020911,838.50 Buy to Cover,20020913,816.75
List of Trades : Order, Date, Price
But really wanted to see this:
I have created a small Python script that will take a list of trades like those listed in table above and create the following EasyLanguage:
This just creates the arrays that you can use to graph the trades on a chart. If you are using exact prices you got to make sure your data aligns with the prices in the list of trades. If you are only entering on the open or the close of the bar then the price array isn’t necessary.
The following Python script will also be helpful if you want to learn how to open a file in csv format, read it into lists, convert it and then save the output to a file.
#------------------------------------------------------------------------------- # Name: Read csv file via askOpen and save txt file via askSave # Purpose: Read the trade metrics from a TradeStation csv format # and build arrays from the information to display on charts in # TradeStation # Author: georg # # Created: 29/08/2018 # Copyright: (c) georg 2018 #------------------------------------------------------------------------------- import csv import tkinter as tk import os.path from tkinter.filedialog import askopenfilenames from tkinter.filedialog import asksaveasfilename
# make sure you know the format ahead of time # I know "Buy",20180828,2745.75 # cnt = 0 for files in range(0,fileListLen): head,tail = os.path.split(fileList[files]) with open(fileList[files]) as f: f_csv = csv.reader(f) for row in f_csv: numCols = len(row) tradeType.append(row[0]) tradeDate.append(int(row[1])) tradePrice.append(float(row[2])) cnt += 1 f.close
filename = asksaveasfilename(title="Will Save File with '.txt'",defaultextension=".txt") # filename = filename + '.txt' target1 = open(filename,'w') outString = 'arrays: DateArr[500](0),TradeArr[500](0),PriceArr[500](0);\n' target1.write(outString) for x in range(0,cnt): if tradeType[x] == "Sell Short": tradeType[x] = "SS" if tradeType[x] == "Buy": tradeType[x] = "B" if tradeType[x] == "Buy to Cover": tradeType[x] = "SX" if tradeType[x] == "Sell": tradeType[x] = "LX" outString = 'DateArr['+str(x)+']='+str(tradeDate[x]-19000000)+';TradeArr['+str(x)+']="'+tradeType[x]+'";PriceArr['+str(x)+']='+str(tradePrice[x])+';\n' target1.write(outString) target1.close
if __name__ == '__main__': main()
Python Script Open, Read, Convert and Write A File Using TK Dialogs
And here is the EasyLanguage code that will step through the arrays and place the trades accordingly. I noticed that sometimes two trades could occur on the same bar, but only two and you will notice in the code where I programmed this occurrence.
vars: cnt(0);
If date of tomorrow = DateArr[cnt] then Begin print("Inside: ",d," ",dateArr[cnt]); If tradeArr[cnt] = "B" then begin buy next bar at PriceArr[cnt] stop; end; If tradeArr[cnt] = "LX" then begin sell next bar at PriceArr[cnt] stop; end; If tradeArr[cnt] = "SS" then begin sellShort next bar at PriceArr[cnt] stop; end; If tradeArr[cnt] = "SX" then begin buyToCover next bar at PriceArr[cnt] stop; end; cnt = cnt + 1; If DateArr[cnt] = DateArr[cnt-1] then Begin print("two trades same day ",d," ",dateArr[cnt]); If tradeArr[cnt] = "B" then begin buy next bar at PriceArr[cnt] stop; end; If tradeArr[cnt] = "LX" then begin sell next bar at PriceArr[cnt] stop; end; If tradeArr[cnt] = "SS" then begin print("looking to go short at ",PriceArr[cnt]); sellShort next bar at PriceArr[cnt] stop; end; If tradeArr[cnt] = "SX" then begin buyToCover next bar at PriceArr[cnt] stop; end; cnt = cnt + 1; end; end;
EasyLanguage Snippet To Execute Trades Stored in Arrays
TradeStation’s COT (Commitment of Traders) Indicator:
TradeStation COT Indicator
TradeStation now includes the historic COT (Commitment of Traders) report in the form of an indicator.
If you can plot it then you can use it in a Strategy. The following code listing takes the Indicator code and with very few modifications turns it into a trading system.
{ Net positions of various groups of traders from the CFTC's weekly Commitments of Traders report. "Net" positions are calculated by taking the number of contracts that a group of traders is long and subtracting the number of contracts that that group of traders is short.
The user input "FuturesOnly_Or_FuturesAndOptions_1_or_2" determines whether the CFTC's "Futures Only" report is used, or the "Futures and Options" report is used to determine the positions of the various groups of traders. By default, the "Futures Only" report is used.
Plot1: Commercial traders' net position Plot2: Non-commercial traders' net position Plot3: Speculators' net positions, for speculators not of reportable size Plot4: Zero line
If an error occurs retrieving one of the values used by this study, or if the value is not applicable or non-meaningful, a blank cell will be displayed in RadarScreen or in the OptionStation assets pane. In a chart, no value will be plotted until a value is obtained without generating an error when retrieved. }
input: FuturesOnly_Or_FuturesAndOptions_1_or_2( 1 ) ; { set to 1 to use the CFTC's "Futures Only" report, set to 2 (or to any value other than 1) to use the "Futures and Options" report }
if oCommLongErr = fdrOk and oCommShortErr = fdrOk then begin CommNet = CommLong - CommShort ; Print ("CommNet ",commNet); end ;
if oNonCommLongErr = fdrOk and oNonCommShortErr = fdrOk then begin NonCommNet = NonCommLong - NonCommShort ; end ;
if oSpecLongErr = fdrOk and oSpecShortErr = fdrOk then begin SpecNet = SpecLong - SpecShort ; end ; If CommNet < 0 then sellShort tomorrow at open; If CommNet > 0 then buy tomorrow at open;
{ ** Copyright (c) 2001 - 2010 TradeStation Technologies, Inc. All rights reserved. ** ** TradeStation reserves the right to modify or overwrite this analysis technique with each release. ** }
COT Indicator Converted To Strategy
Line numbers 90 and 91 informs TS to take a long position if the Net Commercial Interests are positive and a short position if the Commercials are negative. I kept the original comments in place in case you wanted to see how the indicator and its associated function calls work. The linchpin of this code lies in the function call FundValue. This function call pulls fundamental data from the data servers and provides it in an easy to use format. Once you have the data you can play all sorts of games with it. This is just a simple system to see if the commercial traders really do know which direction the market is heading.
if you test this strategy on the ES you will notice a downward sloping 45 degree equity curve. This leads me to believe the commercials are trying their best to use the ES futures to hedge other market positions. If you go with the non Commercials you will see a totally different picture. To do this just substitute the following two lines:
If CommNet < 0 then sellShort tomorrow at open; If CommNet > 0 then buy tomorrow at open;
With:
If NonCommNet < 0 then sellShort tomorrow at open; If NonCommNet > 0 then buy tomorrow at open;
I said a totally different picture not a great one. Check out if the speculators know better.
As long as you are in a bull market buying dips can be very consistent and profitable. But you want to use some type of entry signal and trade management other than just buying a dip and selling a rally. Here is the anatomy of a mean reversion trading algorithm that might introduce some code that you aren’t familiar. Scroll through the code and I will summarize below.
meanRevBuy = condition1 and condition2 and dontCatchFallingKnife; meanRevSell = not(condition1) and condition3 and dontCatchFallingKnife;
If meanRevBuy then buy this bar on close; If marketPosition = 1 and condition1 and value1 >= consecUpClose then sell("ConsecUpCls") this bar on close;
If meanRevSell then sellShort this bar on close; If marketPosition = -1 and not(condition1) and value2 >= consecDnClose then buyToCover this bar close;
setStopLoss(stopLoss$);
If barsSinceEntry = holdPeriod then Begin if marketPosition = 1 and not(meanRevBuy) then sell this bar on close; if marketPosition =-1 and not(meanRevSell) then buytocover this bar on close; end;
Mean Reversion System
I am using a very short term RSI indicator, a la Connors, to initiate long trades. Basically when the 2 period RSI dips below 30 and the close is above the 200-day moving average I will buy only if I am not buying “a falling knife.” In February several Mean Reversion algos kept buying as the market fell and eventually got stopped out with large losses. Had they held on they probably would have been OK. Here I don’t buy if the absolute price difference between today’s close and yesterday’s is greater than 2 X the ten day average true range. Stay away from too much “VOL.”
Once a trade is put on I use the following logic to keep track of consecutive closing relationships:
For iCnt = 0 to consecUpClose - 1 Begin value1 = value1 + iff(c[iCnt] > c[iCnt+1],1,0); end;
Using the IFF function in EasyLanguage
Here I am using the IFF function to compare today’s close with the prior day’s. iCnt is a loop counter that goes from 0 to 1. IFF checks the comparison and if it’s true it returns the first value after the comparison and if false it returns the last value. Here if I have two consecutive up closes value1 accumulates to 2. If I am long and I have two up closes I get out. With this template you can easily change this by modifying the input: consecUpClose. Trade management also includes a protective stop and a time based exit. If six days transpire without two up closes then the system gets out – if the market can’t muster two positive closes, then its probably not going to go anywhere. The thing with mean reversion, more so with other types of systems, is the use or non use of a protective stop. Wide stops are really best, because you are betting on the market to revert. Look at the discrepancy of results using different stop levels on this system:
Here an $1,800 stop only cut the max draw down by $1,575. But it came at a cost of $17K in profit. Stops, in the case of Mean Reversion, are really used for the comfort of the trader.
This code has the major components necessary to create a complete trading system. Play around with the code and see if you can come up with a better entry mechanism.
What will you learn : string manipulation, for-loops, optimization
Before proceeding I would suggest reading my original post on this subject. If you believe the relationship of the last few bars of data can help determine future market direction, then this post will be in you wheel house. Another added benefit is that you will also learn some cool EasyLanguage.
Original post was limited to four day patterns!
This version is limitless (well not really, but pretty close). Let’s stick with the original string pattern nomenclature (+ + – – : two up closes followed by two down closes.) Let’s also stick with our binary pattern representation:
Pattern #
2^3
2^2
2^1
1
3
0
0
1
1
4
0
1
0
0
5
0
1
0
1
6
0
1
1
1
Remember a 0 represents a down close and a 1 represents an up close. We will deviate from the original post by doing away with the array and stick with only strings (which are really just arrays of characters.) This way we won’t have to worry about array manipulation.
How to create a dynamic length string pattern
This was the difficult part of the programming. I wanted to be able to optimize 3, 4 and 5 day patterns and I wanted to control this with using just inputs. I discovered that pattern three is different in a three day pattern than it is in a four day pattern: in a three day pattern it is 011 or – + + and in a four day pattern it is 0011 or – – + +. Since I am counting 0’s as down closes, pattern #3 depends on the ultimate size of the pattern string. No worries I will have eventually have another version where I utilize a different value for down closes and we can then have holes in our string patterns. But I digress – so to differentiate the patterns based on the pattern length I included a maxPatternLen input. So if maxPatternLen is three and we are trying to match pattern #3 then we will be looking for 011 and not 0011. That was an easy fix. But then I wanted to build a string pattern based on this input and the pattern number dynamically. Here is some psuedo code on how I figured it out.
{Psuedo code to translate pattern number into binary number} patternNumber = 3 maxPatternLen = 3
numBits = 0 // stick with binary representation testValue = 0 // temporary test value numBits = maxPatternLen-1 // how many bits will it take to get to the // center of - or numBits to represent max // number of patterns or 2^numBits currentBit =numBits // start wit current bit as total numBits
value1 = patternOptTest // value1 represents current pattern number testString = "" // build test string from ground up
for icnt = numBits downto 0 //building string from left to right begin // notice keyword downto if power(2,currentBit) > value1 then // must use power function in EL begin // if the very far left bit value > testString = testString + "-" // patten number then plug in a "-" end else begin // else plug in a "+" and deccrement by testString = testString + "+" // that bits value - if its the 3rd bit value1 = value1 - power(2,currentBit)// then decrement by 8 end; currentBit = currentBit - 1 // move onto the next bit to the right end;
Pseudocode for Binary Representation of Pattern #
Now if you want to optimize then you must make sure your pattern number search space or range can be contained within maxPatternLen. For example, if you want to test all the different combinations of a four day pattern, then your maxPatternLen would naturally be four and you would optimize the pattern number from 0 to 15. Don’t use 1-16 as I use zero as the base. A five day pattern would include the search space from 0 – 31. The rest of the code was basically hacked from my original post. Here is the rest of the code to do optimizations on different length pattern strings. Notice how I use strings, for-loops and comparisons.
If patternOptimize then begin numBits = 0; testValue = 0; value = maxPatternLen; numBits = maxPatternLen-1; currentBit =numBits; remainder = patternOptTest; testString = ""; for icnt = numBits downto 0 begin if power(2,currentBit) > remainder then {note this originally had value1 instead of remainder} begin testString = testString + "-"; end else begin testString = testString + "+"; remainder = remainder - power(2,currentBit); end; currentBit = currentBit - 1; end; numCharsInBuyPattern = maxPatternLen; numCharsInSellPattern = maxPatternLen; if patternOptBuySell = 1 then Begin buyPatternMatch = testString; sellPatternMatch = "0"; end; If patternOptBuySell = 2 then Begin buyPatternMatch = "0"; sellPatternMatch = testString; end; end;
buyPatternString = ""; sellPatternString = "";
For icnt = numCharsInBuyPattern-1 downto 0 Begin If close[icnt] >= close[icnt+1] then buyPatternString = buyPatternString + "+"; If close[icnt] < close[icnt+1] then buyPatternString = buyPatternString + "-"; end; For icnt = numCharsInSellPattern-1 downto 0 Begin If close[icnt] >= close[icnt+1] then sellPatternString = sellPatternString + "+"; If close[icnt] < close[icnt+1] then sellPatternString = sellPatternString + "-"; end;
okToBuy = false; okToSell = false;
if buyPatternMatch <> "" then If buyPatternString = buyPatternMatch then okToBuy = true; If buyPatternMatch = "" then okToBuy = true; If sellPattern <> "" then If sellPatternString = sellPatternMatch then okToSell = true; If sellPatternMatch = "" then okToSell = true;
If okToBuy then buy next bar at open; If okToSell then sellshort next bar at open;
If marketPosition = 1 and barsSinceEntry > holdDays then sell next bar at open; If marketPosition = -1 and barsSinceEntry > holdDays then buytocover next bar at open;
If lastBarOnChart then print(d," ",buyPatternMatch);
Final Version of New Pattern Smasher
Also see how I incorporate a profit target and protective stop. I use the built in BarsSinceEntry function to count the number of days I am in a trade so I can utilize a time based exit. Here is an interesting equity curve I developed using a two day pattern ( – –) to go long.
Register on the website and I will email you an ELD of the improved Pattern Smasher. Or just shoot me an email.
In real time trading I have noticed that once you reach a certain loss for the month its best, sometimes, to circle the wagons and quit trading until the beginning of the next month. This concept works best for very short term or day trade algorithms, as its very easy to get started back up. You can do this with Trend Following, but you must build a logical and replicable process for re-entering existing positions. Let’s assume a trading algorithm whose averaging losing month is $1500 and you are currently down $2000 – what are the chances that you will revert to the mean or draw down further? Probably 50/50. Who knows you might turn around and actually make money by month’s end. If you review a track record of a hedge fund manager, trader, or algorithm and they show a bar chart of monthly returns and there sticking out like a sore thumb is a big down bar, that kind of makes you think that could happen again. If you can control the monthly downside without sacrificing the existing Profit:DrawDown ratio, then why not do it.
Sample Code To Monitor IntraMonth $P/L
if month(date) <> month(date[1]) then Begin begMonthProf = netProfit; print(d," ",t," ",begMonthProf); canTrade = true; end;
Capture Beginning Of Month Net Profit
Here I am comparing the month of the current bar against the month of the prior bar. If they are not equal, then we have a new month. Store the netProfit in the variable begMonthProf. All you have to do is compare the current bar’s netProfit to begMonthProf and make a decision. Here is some code:
Making a Trading Decision Based on Monthly $P/L
If dayOfMonth(date) > 15 and begMonthProf - netProfit >= intraMonthMaxLoss then canTrade = false;
If Down MaxLoss for Month and Past Mid-Month - Quit Trading
If the day of the month is greater than 15 (month half over) and the difference between the current netProfit and begMonthProfit is greater than a negative intraMonthMaxLoss then quit trading for the month. Only turn it back on the first bar of the next month. See how this works for your algos.
We all know how to use the reserved word/function MarketPosition – right? Brief summary if not – use MarketPosition to see what your current position is: -1 for short, +1 for long and 0 for flat. MarketPosition acts like a function because you can index it to see what you position was prior to the current position – all you need to do is pass a parameter for the number of positions ago. If you pass it a one (MarketPosition(1)) then it will return the your prior position. If you define a variable such as MP you can store each bars MarketPosition and this can come in handy.
mp = marketPosition;
If mp[1] <> 1 and mp = 1 then buysToday = buysToday + 1; If mp[1] <> -1 and mp = -1 then sellsToday = sellsToday + 1;
Keeping Track of Buy and Sell Entries on Daily Basis
The code compares prior bar’s MP value with the current bar’s. If there is a change in the value, then the current market position has changed. Going from not 1 to 1 indicates a new long position. Going from not -1 to -1 implies a new short. If the criteria is met, then the buysToday or sellsToday counters are incremented. If you want to keep the number of buys or sells to a certain level, let’s say once or twice, you can incorporate this into your code.
If time >= startTradeTime and t < endTradeTime and buysToday < 1 and rsi(c,rsiLen) crosses above rsiBuyVal then buy this bar on close; If time >= startTradeTime and t < endTradeTime and sellsToday < 1 and rsi(c,rsiLen) crosses below rsiShortVal then sellShort this bar on close;
Using MP to Keep Track of BuysToday and SellsToday
This logic will work most of the time, but it depends on the robustness of the builtin MarketPosition function. Look how this logic fails in the following chart:
I only wanted 1 short entry per day!
MarketPosition Failure
Failure in the sense that the algorithm shorted twice in the same day. Notice on the first trade how the profit objective was hit on the very next bar. The problem with MarketPosition is that it only updates at the end of the bar one bar after the entry. So MarketPosition stays 0 during the duration of this trade. If MarketPosition doesn’t change then my counter won’t work. TradeStation should update MarketPosition at the end of the entry bar. Alas it doesn’t work this way. I figured a way around it though. I will push the code out and explain it later in more detail.
If d <> d[1] then Begin buysToday = 0; sellsToday = 0; startOfDayNetProfit = netProfit; end;
{mp = marketPosition;
If mp[1] <> 1 and mp = 1 then buysToday = buysToday + 1; If mp[1] <> -1 and mp = -1 then sellsToday = sellsToday + 1;}
If entriesToday(date) > buysToday + sellsToday then Begin If marketPosition = 1 then buysToday = buysToday + 1; If marketPosition =-1 then sellsToday = sellsToday + 1; If marketPosition = 0 then Begin if netProfit > startOfDayNetProfit then begin if exitPrice(1) > entryPrice(1) then buysToday = buysToday + 1; If exitPrice(1) < entryPrice(1) then sellsToday = sellsToday + 1; end;; if netProfit < startOfDayNetProfit then Begin if exitPrice(1) < entryPrice(1) then buysToday = buysToday + 1; If exitPrice(1) > entryPrice(1) then sellsToday = sellsToday + 1; end; end; print(d," ",t," ",buysToday," ",sellsToday); end;
If time >= startTradeTime and t < endTradeTime and buysToday < 1 and rsi(c,rsiLen) crosses above rsiBuyVal then buy this bar on close; If time >= startTradeTime and t < endTradeTime and sellsToday < 1 and rsi(c,rsiLen) crosses below rsiShortVal then sellShort this bar on close;
TradeStation does update EntriesToday at the end of the bar so you can use this keyword/function to help keep count of the different type of entries. If MP is 0 and EntriesToday increments then you know an entry and an exit has occurred (takes care of the MarketPosition snafu) – all you need to do is determine if the entry was a buy or a sell. NetProfit is also updated when a trade is closed. I establish the StartOfDayNetProfit on the first bar of the day (line 9 in the code) and then examine EntriesToday and if NetProfit increased or decreased. EntryPrice and ExitPrice are also updated at the end of the bar so I can also use them to extract the information I need. Since MarketPosition is 0 I have to pass 1 to the EntryPrice and ExitPrice functions – prior position’s prices. From there I can determine if a Long/Short entry occurred. This seems like a lot of work for what you get out of it, but if you are controlling risk by limiting the number of trades (exposure) then an accurate count is so very important.
An alternative is to test on a higher resolution of data – say 1 minute bars. In doing this you give a buffer to the MarketPosition function – more bars to catch up.
If you don’t like seeing blank days in your charts then make sure you tell TradeStation to skip these Holidays. It doesn’t make a difference in your calculations on a historic basis – TS skips these days already, but it’s more aesthetically pleasing not seeing the gaps.
I just learned something new! I guess I never programmed a strategy that pyramided at different price levels and scaled out at different price levels.
Initially I thought no problem. But I couldn’t get it to work – I tried everything and then I came across the keyword Total and then I remembered. If you don’t specify Total in you exit directives then the entire position is liquidated. Unless you are putting all your positions on at one time – like I did in my last post. So remember if you are scaling out of a pyramid position use Total in your logic.
vars: maxPosSize(2);
If currentContracts < maxPosSize - 1 and c > average(c,50) and c = lowest(c,3) then buy("L3Close") 1 contract this bar on close; If currentContracts < maxPosSize and c > average(c,50) and c = lowest(c,4) then buy("L4Close") 1 contract this bar on close;
If currentContracts = 2 and c = highest(c,5) then sell 1 contract total this bar on close; If currentContracts = 1 and c = highest(c,10) then sell 1 contract total this bar on close;
Scaling Out Of Pyramid
Why you have to use the Total I don’t know. You specify the number of contracts in the directive and that is sufficient if you aren’t pyramiding. The pyramiding throws a “monkey wrench” in to the works.
Backtesting with [Trade Station,Python,AmiBroker, Excel]. Intended for informational and educational purposes only!
Get All Five Books in the Easing Into EasyLanguage Series - The Trend Following Edition is now Available!
Announcement – A Trend Following edition has been added to my Easing into EasyLanguage Series! This edition will be the fifth and final installment and will utilize concepts discussed in the Foundation editions. I will pay respect to the legends of Trend Following by replicating the essence of their algorithms. Learn about the most prominent form of algorithmic trading. But get geared up for it by reading the first four editions in the series now. Get your favorite QUANT the books they need!
The Foundation Edition. The first in the series.
This series includes five editions that covers the full spectrum of the EasyLanguage programming language. Fully compliant with TradeStation and mostly compliant with MultiCharts. Start out with the Foundation Edition. It is designed for the new user of EasyLanguage or for those you would like to have a refresher course. There are 13 tutorials ranging from creating Strategies to PaintBars. Learn how to create your own functions or apply stops and profit objectives. Ever wanted to know how to find an inside day that is also a Narrow Range 7 (NR7?) Now you can, and the best part is you get over 4 HOURS OF VIDEO INSTRUCTION – one for each tutorial.
Hi-Res Edition Cover
This book is ideal for those who have completed the Foundation Edition or have some experience with EasyLanguage, especially if you’re ready to take your programming skills to the next level. The Hi-Res Edition is designed for programmers who want to build intraday trading systems, incorporating trade management techniques like profit targets and stop losses. This edition bridges the gap between daily and intraday bar programming, making it easier to handle challenges like tracking the sequence of high and low prices within the trading day. Plus, enjoy 5 hours of video instruction to guide you through each tutorial.
Advanced Topics Cover
The Advanced Topics Edition delves into essential programming concepts within EasyLanguage, offering a focused approach to complex topics. This book covers arrays and fixed-length buffers, including methods for element management, extraction, and sorting. Explore finite state machines using the switch-case construct, text graphic manipulation to retrieve precise X and Y coordinates, and gain insights into seasonality with the Ruggiero/Barna Universal Seasonal and Sheldon Knight Seasonal methods. Additionally, learn to build EasyLanguage projects, integrate fundamental data like Commitment of Traders, and create multi-timeframe indicators for comprehensive analysis.
Get Day Trading Edition Today!
The Day Trading Edition complements the other books in the series, diving into the popular approach of day trading, where overnight risk is avoided (though daytime risk still applies!). Programming on high-resolution data, such as five- or one-minute bars, can be challenging, and this book provides guidance without claiming to be a “Holy Grail.” It’s not for ultra-high-frequency trading but rather for those interested in techniques like volatility-based breakouts, pyramiding, scaling out, and zone-based trading. Ideal for readers of the Foundation and Hi-Res editions or those with EasyLanguage experience, this book offers insights into algorithms that shaped the day trading industry.
Trend Following Cover.
For thirty-one years as the Director of Research at Futures Truth Magazine, I had the privilege of collaborating with renowned experts in technical analysis, including Fitschen, Stuckey, Ruggiero, Fox, and Waite. I gained invaluable insights as I watched their trend-following methods reach impressive peaks, face sharp declines, and ultimately rebound. From late 2014 to early 2020, I witnessed a dramatic downturn across the trend-following industry. Iconic systems like Aberration, CatScan, Andromeda, and Super Turtle—once thriving on robust trends of the 1990s through early 2010s—began to falter long before the pandemic. Since 2020 we have seen the familiar trends return. Get six hours of video instruction with this edition.
Pick up your copies today – e-Book or paperback format – at Amazon.com
