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.
Backtesting with [Trade Station,Python,AmiBroker, Excel]. Intended for informational and educational purposes only!
Get All Four Books in the Easing Into EasyLanguage Series - The Day Trade Edition is now Available!
Announcement – A Day Trade Edition will be added to my Easing Into EasyLanguage Series this year! This edition will be the fourth installment and will utilize concepts discussed in the Hi-Res and Advanced Topics editions. I will show how to develop and program algorithms that will enter after the open of the day and get out before the market closes. Hence, no overnight exposure. Most examples will be carried out on the mini Dow, Nasdaq, S&P500 and Russel. The programming skills that you will learn can be carried to any market that provides enough bang for the buck to day trade. Look for this edition later this year. But get geared up for it by reading the first three editions in the series now. Get your favorite QUANT the books they need!
The Cover of my latest book. The first in the series.
Hello to All! The Easing Into EasyLanguage Series is now complete with the publication of the Advanced Topics Edition. This series includes three educational editions. 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. 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.
Hi-Res Edition Cover
This book is for those that have read the Foundation Edition or have some experience working with EasyLanguage and the various functions that help make a trading decision. This book’s audience will be those programmers that want to take an idea, that requires an observation of intraday market movements to make a trading decision, and program it accurately. If you have programmed daily bar systems, and you want to drill down and add some components that require additional market information (like what came first – the high or the low), then you have come to the right place. If you want to buy and sell short in the same day and use trade management principles such as profit targets and stop losses then The Hi-Res Edition is the book you need. There are two paradigms that EasyLanguage covers: daily and intraday bar programming. It’s the same language, but the move from daily to intraday programming can be quite difficult. Learn all the essentials and shortcuts with this edition. 5 HOURS OF VIDEO INSTRUCTION in this Hi-Res edition – one for 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.
Advanced Topics Cover
Advanced Topics (AT) could cover a vast amount of ideas and concepts and be the length of “War and Peace” on steroids. Since this book is part of the series, I wanted to cover a handful of concepts that included the follow programming constructs. Arrays and their manipulation. Buffers (fixed length arrays) and the tools to maintain buffer elements with formulas for extraction and sorting. Finite State Machines using the switch-case construct and range based case values. Using original text graphic objects and retrieving and analyzing their properties to determine X and Y coordinate values of text location. Seasonality: The Ruggiero/Barna Universal Seasonal and the Sheldon Knight Seasonal methods. In AT, you will also find an introduction to EasyLanguage’s Project Concept and the steps to create one by adding/deleting component files. TradeStation now provides access to fundamental data such as Commitment of Traders – learn how to convert the Net Change indicator into a strategy utilizing the FundValue functionality. If you wanted to find out how to merge multiple time frames into a single indicator, you are in luck! Create a MTF indicator for yourself.
Get Day Trading Edition Today!
Day Trading (DT) – This is a surprise installment in my Easing into EasyLanguage Series, as I had only intended on three books. However, I think it will fit well with the other books. Daytrading is a very popular approach as overnight risk is eliminated. Don’t worry there is plenty of risk during the day too! However, it can be very difficult to accurately program a trading idea on higher resolution data such as five- or one-minute bars. Like my other books, there is no “Holy Grail” included. And if you are looking for a book that gets in and out of a trade in a few seconds, this is not the one for you. I discourage trading more than a handful of trades per day – this is best left up to the professionals. But, if you want to learn about volatility-based break outs, pyramiding, scaling out, zone-based trading, accurate trade accounting and having a peek at algorithms that once ruled the systematic daytrading industry, then this is the book for you. A beginner might have a little difficulty in following along with the tutorials. If you have read the first two books (Foundation and Hi-Res) in this series, you are good to go. Or if you have some experience working with EasyLanguage and minute data, you will be OK as well.
Pick up your copies today – e-Book or paperback format – at Amazon.com
