Category Archives: EasyLanguage

Algorithmic Trading Commentary, EasyLanguage, EasyLanguage Function, EasyLanguage Indicator, Free EasyLanguage

Unlocking Sequential™ in EasyLanguage via Dueling Finite State Machines

April 16, 2025 George Pruitt Leave a comment

Disclaimer:
“Sequential™” is a registered trademark of Tom Demark. This post presents an independent, educational interpretation of the components of the Sequential™ pattern as described in Tom Demark’s book, The New Science of Technical Analysis. The analysis, opinions, and code examples provided herein are solely those of the author and are intended for informational and educational purposes only. This work is not affiliated with, endorsed by, or officially connected to Tom Demark or any related entities.

Sequential™ Pattern – Setup and Countdown

This pattern is fully described in Tom Demark’s book and consists of two distinct phases. For brevity’s sake, I will just discuss the buy setup. This indicator is designed to help determine when a trend is becoming or has become exhausted. Unlike a trend following indicator that helps you get in at the genesis of the trend, Sequential indicates when to take an opposing position after trend termination. This post doesn’t concern itself with the efficacy of Sequential, but with the process of programming such a difficult pattern and all the conditions that it involves. The indicator consists of two parts or phases. The Setup phase is stringent, requiring that the same price pattern occur for at least nine consecutive days (bars). In contrast, the Countdown phase is less strict; it mandates that a different price pattern occurs over a span of 13 days (or bars), although these occurrences do not need to be consecutive. Setup is complete when an “intersection” occurs, marking the point where prices start to brake or consolidate. Countdown, on the other hand, is finished when the 13th instance of the designated price pattern is observed. Because the pattern in the Countdown phase does not have to appear on consecutive bars, this phase can take many days to complete. During Countdown, three scenarios can occur that either restarts or recycles the process.

Setup – Sequence

close[0] > close[4]
followed by nine consecutive Close[0] < Close[4]

Intersection- Sequence

If nine bars fulfill the Setup then examine the following
- Bar 8 High[1] > Lowest(Low[4],5)
- Bar 9 High[0] > Lowest(Low[3],5)

Countdown – Sequence

13 days or bars fulfill Close[0] < Low[2] over any number of days

Sequential™ – Completion, Restart, Recycle

Completion – once Countdown reaches 13, the Sequential pattern is completed.
Restart – during countdown if a Close > Highest High during setup or a Sell Setup occurs – start either from scratch or start the Sell Countdown
Recycle – a new Buy Setup occurs, then start from the Countdown phase again.

Because we have to monitor a Sell Setup during the Countdown phase, we need to run two Finite State Machines concurrently. These two state machines will duel with each other. Both searching for their own solutions and knocking each other out during the process.

Finite State Machine Structure

Years ago, I embarked on building a theoretical compiler—a challenging project I nearly finished. The initial step was to create a parser that transforms high-level code into tokens according to the language’s grammar. In doing so, I learned about Finite State Machines (FSMs) as my program processed source code one character at a time and used FSM logic to build a token table.

Sample FSM to Find Pivot Highs and Pivot Lows

From this experience, I quickly discovered that even the most complex patterns can be detected using a Finite State Machine. Below is a graphical representation of a simple FSM that identifies the following pattern that can take up to 90 days (bars) to complete.

A high pivot with strength 2
Followed by a low pivot with strength 2
Followed by another high pivot with strength 2

In this example, a pivot is defined such that the central (or “pivot”) bar must have a higher high (for a high pivot) or a lower low (for a low pivot) than both the two bars preceding it and the two bars following it. Additionally, I also added the high pivot requires that the two prior bars exhibit ascending highs and that the two subsequent bars exhibit descending highs, while a low pivot follows the opposite pattern.

Finite State Machines (FSMs) consist of a limited number of states that describe the various conditions of a system:

Start State: The initial point where processing begins. Looking for the first Pivot High.
Intermediate States: The stages the FSM progresses through as it processes input. Looking for the first Pivot Low.
Terminal (or Accepting) States: The final state(s) indicating the system has completed its task. Locating the final Pivot High.

Transition logic (the “rules” for shifting between states) guides the FSM’s movement, and some FSMs include a timeout function that resets the machine if it stays in one state too long.

Transition from FSM State 0 to FSM State 1

Acting like Pac-Man, the FSM gobbles one bar at a time and looks for this pattern:

high[2] >high[1] – right side
high[1] >high[0] – right side
high[2] > high[3] – left side
high[3] > high[4] – left side

Transition from FSM State 1 to FSM State 2

Now we look for the specific low pivot pattern

low[2] <low[1] – right side
low[1] <low[0] – right side
low[2] < low[3] – left side
low[3] < low[4] – left side

Transition from FSM State 2 to Completion and then back to FSM State 0

The pattern is completed after the subsequent high pivot pattern is confirmed. Once completed the machine resets itself to FSM State 0.

high[2] >high[1] – right side
high[1] >high[0] – right side
high[2] > high[3] – left side
high[3] > high[4] – left side

FSM Clock Override

If the pattern is not recognized within 90 days or bars from the first pivot high, then the machine resets back to FSM State 0.

Pivot Point FSM Output

Switch Case in EasyLanguage

When I started programming in Python, the Case statement was not included which shocked me. Since Python 3.10 it has been introduced. A Switch Case structure lets a program choose among several execution paths based on a variable’s value, using distinct cases instead of long if-else chains. This results in cleaner, more efficient, and more readable code. Take a look at the syntax of the Switch Case in EasyLanguage – remember much of the following code is dedicated to painting the bars.


Inputs: 
    PivotStrength(3);  // Strength parameter for pivot high detection

Variables:
    FSMState(0),barCount(0),j(0);       // FSM state: 0 (none), 1 (first), 2 (second), 3 (third)

switch (FSMState)
begin 
    case 0: 
	begin
        if h[2] > h[3] and h[3] > h[4] and h[2] > h[1] and h[1] > h then
        begin
            FSMState = 1;
            Print(d," First pivot high found: ",h[2]); 
            barCount = 0;
            for j = 0 to 4
            begin
            	plotPB[j](h[j],l[j],"FSM PVT Patt.",yellow);
            end;
        end;
    end;
    
    case 1: 
    begin
        if l[2] < l[3] and l[3] < l[4] and l[2] < l[1] and l[1] < l then
        begin
            FSMState = 2;
            for j = 0 to 4
            begin
            	plotPB[j](h[j],l[j],"FSM PVT Patt.",red);
            end;

 		end;
    end;
    
    case 2:
    begin
        if h[2] > h[3] and h[3] > h[4] and h[2] > h[1] and h[1] > h then
        begin
            FSMState = 0;
            for j = 0 to 4
            begin
            	plotPB[j](h[j],l[j],"FSM PVT Patt.",cyan);
            end;
        end;
 	end;

end;  // End case-switch 
			
barCount = barCount + 1;
if barCount = 90 then
	FSMState = 0;

Simple FSM to locate Pivot Point Pattern

The syntax is straightforward: the keyword switch is used, and the variable FSMState directs the flow through different case blocks. Initially, FSMState is set to 0, and a transition occurs only when the specified criteria are met. Once met, FSMState is updated to 1. EasyLanguage follows a non-fall-through paradigm—once a state transition occurs, no other case statements are evaluated during that iteration; the program simply reaches the end of the block and awaits the next cycle. By contrast, in some languages, when the state changes (for example, from 0 to 1), the corresponding case for state 1 may be evaluated immediately within the same cycle.

Is it as Complicated as it Looks?

Not at all. Look at the different case blocks and you will see a very similar structure. As stated earlier the code to paint the bars take up 12 lines of code. The timer is located at the bottom of the code – once barCount = 90, the FSM resets to 0.

Is Sequential ™ Easy to Program with a Finite State Machine?

I wouldn’t say easy, but I wouldn’t say hard either. With a little elbow grease and knowledge of how TradeStation works, and some EasyLanguage knowledge it is not difficult. If it were easy, you would see the code all over the place. I have previously programmed parts of it in my Easing into EasyLanguage books.

You might think you could have ChatGPT generate the code for you, and for laughs, I tried asking ChatGPT to program Sequential™ using FSM and Switch/Case in EasyLanguage. While the output provided a foundation, most of the syntax was off, and the patterns weren’t defined properly. Ultimately, I discovered that simplifying the design—by using separate FSMs for the buy side and the sell side—made the implementation more manageable. To simplify the process, I focused exclusively on the buy side at first. I figured that once I had programmed the complete pattern for the buy side, adapting it to the sell side would be as simple as reversing the logic—since the overall structure remains identical.

Using “Backward Scanning” for the Setup Phase.

Setup requires analyzing at least 10 consecutive bars. When you hear “consecutive,” think of looping through each bar in sequence. A stringent consecutive pattern is best uncovered by looping back through historical data. For example, you can loop through the bars to identify a sequence of nine consecutive bars where the close of the current bar is less than the low from four bars prior. However, immediately preceding those nine bars, you must verify that the prior bar’s close is greater than the close from four days earlier. This additional condition ensures the pattern begins under the correct circumstances.

Is there a Method to this Madness?

I’ve found that using methods in EasyLanguage is a real asset during development. Methods work like functions but are local to the module in which they’re defined, so all the code is right there for easy reference, debugging, and testing. I typically reserve methods for code segments that I’ll reuse multiple times, which helps keep my project organized and efficient as it grows. Here is the method that uses back scanning to uncover the Sequential Setup phase.

method bool seqBuySetup(int numConsDays)
var: int result;
begin
    
	result = countif(c[0] < c[LookBack],suTarg);
	if result = numConsDays and c[suTarg]>c[suTarg+LookBack] then
		return(True)
	else
		return(False);
end;

Notice the syntax of the method structure

You might not recognize all parts of this code at first glance. First, I’m using a method, and I must specify its return type as bool (Boolean) in the method header. This indicates that the method will return either True or False. I’m also passing an integer variable, numConsDays, into the method.

Inside, I use the countIf function to evaluate the relationship between close[0] and close[4]—with LookBack set to 4. Essentially, countIf counts how many times the condition close[0] < close[4] is met over a span of bars defined by suTarg (or SetUpTarg). If this count equals 9, I then compare close[9] with close[13]. If close[9] is greater, I determine that this portion of the Setup phase has been successfully completed.

Does close[0] mean today’s close or the close of what George has penned as the close of the Focus Bar.

close[0] – close of today – not really unless it is the last bar on the chart – we could call this the Focus Bar if not
close[1] – yesterday – 1 day back or 1 day prior to the focus bar
close[2] – 2 days prior
close[3] – 3 days prior
close[4] – 4 days prior

When you run a backtest in TradeStation, the engine iterates through every bar in your dataset—even though your chart window only shows a subset of those bars. To make this clear, I use the term Focus Bar for whichever bar is currently being processed as the system moves from left to right. Think of it like a big loop over all bars: when the loop index is 50, bar #50 is the Focus Bar and you reference its values with [0] (e.g., close[0]). When the loop advances to index 51, bar #51 becomes the Focus Bar—still accessed with [0]—and so on.

Here’s the key point: all price series—high, low, open, etc.—are zero‑indexed, so the Focus Bar is always referenced with index 0. That means the Focus Bar’s closing price is close[0], its high is high[0], and its low is low[0]. For instance, if the Focus Bar is dated January 3, 1999, and it completes the Setup phase, you’d paint it using high[0] and low[0]. Remember, close[0] only represents “today’s” close when you’re on the very last bar; otherwise, it simply refers to whatever bar is currently the Focus Bar during a historical back-test.

Take a look at the following method to see this in action.

method void paintBuySetup(int numPaintDays)
var: int j;
begin
	PlotPB[suTarg](High[suTarg],Low[suTarg],"DMSeq.",cyan,3);  
	for j = 0 to numPaintDays-1
	begin
		PlotPB[j](High[j],Low[j],"DMSeq.",yellow,3);   
	end;
end;

Looping from bar 0 to bar 8 or nine bars

Notice how I loop from 0 to numPaintBars-1 or 8 to paint the last nine bars in the sequence. If you want to paint bars in a back-scan make sure you use the same syntax I have used here. Use an offset for the PlotPB along with the same offset for each bar’s high and low in the loop.

 PlotPB[j](High[j],Low[j],"DMSeq.",yellow,3); // j goes from 0 to 8

If I want to compare the 10th bar in my series, then I refer to it as close[9]. I compare the 10th bar with 13th bar (close[9 + 4]) to see if I have the genesis of the Setup phase. Bar number 0 is the first bar in the series going back in time (Focus Bar.) Could I offset everything by one bar to get rid of the 0 offset? Many people have a problem dealing with 0s so you could but if you want to turn this into a strategy and you want to execute on the next bar’s open, then you will need to stick with the 0. Let’s break each state down and you will see how I was able to program this monster.

FSM State 0 – Scanning for the first part of the Setup Phase

    Case 0:
       	// Find a long setup - retroactively 
        if seqBuySetup(suTarg) then
        begin
            stateBuy = 1;
            SetupCountBuy = suTarg;
            SetUpHigh = highest(h,suTarg);
            if plotBuySetUp then
            	paintBuySetUp(suTarg); 
         end;

If the seqBuySetup method returns True, the FSM transitions to State 1 and SetupCount is set to 9. This triggers a look-back over the past nine bars to determine the highest high, which serves as a reset level in the Countdown phase if a close exceeds that value.

In the PaintBar routine, the user can choose to display the Sequential Buy Setup, the Sell Setup, or both. If the user opts to display the Buy Setup, the paintBuySetUp method is executed.

FSM State 1 – Looking for an Intersection

This state uses a hybrid approach to detect an intersection. Now that we’re in FSM State 1, we’re close to completing the first phase. We start by examining bars 8 and 9, which are the final two bars of the nine-bar setup from the latest data. First, we check if the high of bar 8 is greater than any of the low values in bars 5, 4, 3, 2, or 1—if it is, an intersection is found. If not, we compare the high of bar 9 with the low values in bars 6, 5, 4, 3, or 2. Should bar 9 also fail to meet the criteria, we then switch to forward scanning for any subsequent bar that fits the criteria. Note that the bars identified in the forward scan do not have to meet the same stringent conditions as the consecutive bars in the Setup phase. Eventually, a bar will meet the criteria, and we then can move to the Countdown phase also known as FSM State 2

    Case 1:
    // Setup complete now look for intersection
    // may take a couple of days
        if SetupCountBuy = suTarg then
        begin
  			//going back to get lowest lows of 5 bars
  			//prior to bar 8 and bar 9
         	minLow1 = lowest(low[4],5); 
         	minLow2 = lowest(low[5],5);
            if (High[1] > minLow1 or High[2] > minLow2) then
            begin
                stateBuy = 2;
                CountdownCountBuy = 0;
                if close <= Low[2] then
                begin
                	CountdownCountBuy = 1;
                	if PlotBuySetup then 
            			PlotPB(High,Low, "DMSeq.",green);
            	end;
                buyIntersectBarNum = barNumber;
                Value1 = MyColors("Orange");
                Value2 = iff(High[1] < minLow1,2,1);
                if PlotBuySetup then
                	PlotPB[value2](High[value2],Low[value2], "DMSeq.",value1);  // paint intersection 
            end;
        end;

Intersection

The Devil is in the Details

Counting bars is challenging. Because our FSM doesn’t fall through states after a transition, once the consecutive nine-bar sequence is complete, we’re already at the next bar—the tenth. To determine whether the high of the ninth bar exceeds the lows from earlier bars, I compare the high of bar 9 (denoted as high[1]) with the lowest low from three bars earlier (low[4]) across a range covering five bars. If necessary, I repeat a similar comparison, starting with the high of bar 8, using high[2] and the corresponding lows starting from low[5] over a five-bar range. There is a chance neither bar will fulfill the criteria. In this case we start forward scanning to see if high[1] fulfills the criteria. Could we check for high[0] if the bar 8 and bar 9 fail? You might be able to – it might be worth investigating. However, it will add more code. Given some time you’ll see that high[1] will form an intersection. For clarity, I introduced the term Focus Bar to refer to the bar at index [0] in the historical data. In this context, if high[1] represents the prior bar relative to the Focus Bar and meets the intersection criteria, we need to immediately assess the Focus Bar to determine if it signals the start of the Countdown phase. Why act now? Because, without fall-through in our FSM, once a state transition occurs, the Focus Bar, if examined in the next state, would be skipped—so it’s essential to evaluate the Focus Bar (today’s bar if last bar on chart) right away while we are in the current state. If close[0] < low[2], the bar is painted with the Countdown theme color and this phase begins and the state machine transitions

FSM State 2 – Looking for a completion of Countdown

We are almost there. All we need are 13 bars that fulfill this criteria, close[0] < low[2]. From this point on we will be forward scanning and counting bars that fit the previously mentioned criteria. Once we reach 13, we are done. Finally, our journey to program the Sequential has come to an end. Or has it? So far, the description of the pattern has been straightforward, and we are in the home stretch? The completion of 13 bars who’s close[0] < low[2] can take many days to complete and many things can happen during this time. In his book, Tom Demark mentions three things that can derail the completion of the Countdown phase. This is where the fun really begins.

	Case 2:
        // Sell Countdown Phase 
		if close <= Low[2] then
		begin
			CountdownCountBuy = CountdownCountBuy + 1;
			if PlotBuySetup then 
				PlotPB(High,Low, "DMSeq.",green);  // Generate a buy signal 
		end;
		if CountdownCountBuy = ctTarg then
		begin
			if PlotBuySetup then
			begin
				value99 = Text_new(d,t,low - range*0.2,"B"); 
				PlotPB(High,Low, "DMSeq.",red);  // Generate a buy signal 
			end;
			resetBuyFSM();
		end;

Portion of FSM State 2 that looks for and paints Countdown bars

This code is very simple – paint the bar if close[0] < low[2] and then count the bar. Once the number of bars = ctTarg (CountDown Target). then place the letter “B” above the high and paint the bar a different color. Sequential is now complete and so the Buy Finite State Machine needs to be reset. Bar are we really done?

Countdown derailment

If a close exceeds the highest high during Setup – restart the process from scratch – reset the FSM
If a Sell Setup completes while waiting for the 13 bars – cancel the Buy Countdown and start the Sell Countdown
If a fresh Buy Setup reveals itself, recycle and restart the Countdown process.

       // Invalidate buy countdown if 
        // 1.) a close > high during setup
        // 2.) a sell setup occurs
        // 3.) recycling occurs - new buy setup
        if c > SetupHigh then 
        	resetBuyFSM();
        if stateSell = 2 then 
        	resetBuyFSM();
        if (seqBuySetup(suTarg) and barNumber - buyIntersectBarNum > suTarg) then
        begin
        	stateBuy = 1;
    		SetupCountBuy = suTarg;
    		CountdownCountBuy = 0;
            if plotBuySetUp then
            	paintBuySetup(suTarg);
            SetUpHigh = highest(h,suTarg);
        end;

2ND half of FSM State 2

The Dueling Nature of this Pattern Recognition Tool often prevents Sequential from reaching Completion – maybe a good thing.

Well, that is part of the reason. The recycle of the Setup is also a culprit. Because the pattern for the Buy and Sell requires the consumption of so many bars, the two FSM must run independent of each other and at times contradict each other. Here is as good example of the FSMs taking action in the recent (April 2025) GOLD market. Click on images to expand.

It started out really great, but like any Trend Following approach…

Sequential™ Examples

Shampoo, Rinse, Repeat. Bingo!

We had 4 complete buy Setups with interrupted Countdowns before it finally stuck!

Count-Downus Interruptus

Blow off top with Buy Setup completion interrupts the short Countdown.

Market congestion, just like smoking, stunts growth of patterns.

Congestion Phase validated by incomplete Sequential Setups and Countdowns

Many Complex Patterns can be Programmed by using Multiple FSMs

Almost anything can be programmed with EasyLanguage and the concept of a Finite State Machine and the Switch-Case structure. If you don’t know where to start, ask ChatGPT with the best and most descriptive prompt you can come up with. Then start small and build up – always check your progress before moving on to the next phase. Email me with any questions and if you like this type of content check out my books at Amazon.

George’s Amazon Author Page

Algorithmic Trading Commentary, Complete Solutions, EasyLanguage, EasyLanguage Function, EasyLanguage Indicator, EasyLanguage Tutorial, MultiCharts, Must Know, TradeStation

Some EasyLanguage Functions Are Really “Classy”

March 13, 2025 George Pruitt Leave a comment

The Series Function is very special

When a function accesses a previously stored value of one of its own variables, it essentially becomes a “series” function. Few programming languages offer this convenience out of the box. The ability to automatically remember a function’s internal state from one bar (or time step) to the next is known as state retention. In languages like Python, achieving this typically requires using a class structure. In Module #2 of my Easing into EasyLanguage Academy, I explained why EasyLanguage isn’t as simple as its name implies—yet this feature shows how its developers aimed to simplify otherwise complex tasks.

If you’ve ever worked with functions with memory that exchange data using a numericRef input, you’ve essentially been using a pseudo-class—a form of object-oriented programming in its own right. EasyLanguage includes a robust object-oriented library (with excellent resources by Sunny Harris and Sam Tennis – buy their book on Amazon), yet you’re confined to its built-in functionality since it doesn’t yet support user-defined class structures. Nonetheless, the series functionality combined with data passing brings you remarkably close to a true object-oriented approach—and the best part is, you might not even realize it.

Example of a Series Function

I was recently working on the Trend Strength indicator/function and have been mulling this post over for some time, so I thought this would be a good time to write about it. The following indicator to function conversion will create a function of type series (a function with a memory.) The name series is very appropriate in that this type of function runs along with the time series of the chart. It must do this so it can reference prior bar values.

You can ensure a function is treated as a series function in two ways:

Using a Prior Value:
When you reference a previous value within the function, EasyLanguage automatically recognizes the need to remember past data and treats the function as a series function.
Setting the Series Property:
Alternatively, you can explicitly set the function’s property to “series” via a dialog. This instructs EasyLanguage to handle the function as a series function, ensuring that state is maintained across bars.

Manually Set the Function to type Series

Importantly, regardless of the function’s name or even if it’s called within control structures (like an if construct), a series function is evaluated on every bar. This guarantees that the historical data is consistently updated and maintained, which is essential for accurate time series analysis.

Converting an indicator to a function

You can find a wide variety of EasyLanguage indicators online, though many are available solely as indicators. This is fine if you’re only interested in plotting the values. However, if you want to incorporate an indicator into a trading strategy, you’ll need to convert it into a function. For calculation-intensive indicators, it’s best to follow a standard prototype: use inputs for interfacing, perform calculations via function calls, and apply the appropriate plotting mechanisms. By adhering to this development protocol, your indicator functions can be reused across different analysis studies, enhancing encapsulation and modularity. Fortunately, converting an indicator’s calculations into a function is a relatively straightforward process. Here is indicator that I found somewhere.

Inputs: 
    ShortLength(13),  // Shorter EMA length
    LongLength(25),   // Longer EMA length
    SignalSmoothing(7); // Smoothing for signal line
Vars:
    DoubleSmoothedPC(0),
    DoubleSmoothedAbsPC(0),
    TSIValue(0),
    SignalLine(0);
// Price Change (PC)
Value1 = Close - Close[1];
// First Smoothing (EMA of PC and |PC|)
Value2 = XAverage(Value1, LongLength);
Value3 = XAverage(AbsValue(Value1), LongLength);
// Second Smoothing (EMA of First Smoothed Values)
DoubleSmoothedPC = XAverage(Value2, ShortLength);
DoubleSmoothedAbsPC = XAverage(Value3, ShortLength);
// Compute TSI
If DoubleSmoothedAbsPC <> 0 Then
    TSIValue = 100 * (DoubleSmoothedPC / DoubleSmoothedAbsPC);
    
// Compute Signal Line
SignalLine = XAverage(TSIValue, SignalSmoothing);
// Plot the TSI and Signal Line
Plot1(TSIValue, "TSI");
Plot2(SignalLine, "Signal");

TSI via Web

Now we can functionize it.

Below is an example of how you might convert an indicator into a function called TrendStrengthIndex. Notice that the first change is to replace any hard-coded numbers in the indicator’s inputs with parameters declared as numericSimple (or numericSeries where appropriate). This allows the function to accept dynamic values when called. Not to give anything away, but you can also declare variables as numericRef, numericSeries, numericArrayRef, string, stringRef, and stringArrayRef. Let’s not worry about these types right now.

inputs: 
    ShortLength(numericSimple),  // Shorter EMA length
    LongLength(numericSimple),   // Longer EMA length
    SignalSmoothing(numericSimple); // Smoothing for signal line

Inputs must be changed to function nomenclature

Below is an example function conversion for the TrendStrengthIndex indicator. The plot statements have been commented out since—rather than plotting—the function now passes back the calculated value to the calling program.

Vars:
	DoubleSmoothedPC(0),
    DoubleSmoothedAbsPC(0),
    TSIValue(0),
    SignalLine(0);
// Price Change (PC)
Value1 = Close - Close[1];
// First Smoothing (EMA of PC and |PC|)
Value2 = XAverage(Value1, LongLength);
Value3 = XAverage(AbsValue(Value1), LongLength);
// Second Smoothing (EMA of First Smoothed Values)
DoubleSmoothedPC = XAverage(Value2, ShortLength);
DoubleSmoothedAbsPC = XAverage(Value3, ShortLength);
// Compute TSI
If DoubleSmoothedAbsPC <> 0 Then
    TSIValue = 100 * (DoubleSmoothedPC / DoubleSmoothedAbsPC);
    
// Compute Signal Line
SignalLine = XAverage(TSIValue, SignalSmoothing);
// Plot the TSI and Signal Line
//Plot1(TSIValue, "TSI");   commented out
//Plot2(SignalLine, "Signal"); commented out
TrendSTrengthIndex = TSIValue;

Functionalize It!

This works great if we just want the TrendStrengthIndex, but this indicator, like many others has a signal line. The signal line for such indicators is usually a smoothed version of the main calculation. Now you could do this smoothing outside the function, but wouldn’t it be easier if we did everything inside of the function?

Oh no! I need to pass more than one value back!

If we just wanted to pass back TSIValue all we need to do is assign the name of the function to this value.

Passing values by reference

We can adjust the function to return multiple values by defining some of the inputs as numericRef. Essentially, when you pass a variable as a numericRef, you’re actually handing over its memory address—okay, let’s get nerdy for a moment! This means that when the function updates the value at that address, the calling routine immediately sees the change, giving the variable a kind of quasi-global behavior. Without numericRef, any modifications made inside the function stay local and never propagate back to the caller. Not only is the function communicating with the calling strategy or indicator it is also remember its own stuff for future use. Take a look at this code.

inputs: 
    ShortLength(numericSimple),  // Shorter EMA length
    LongLength(numericSimple),   // Longer EMA length
    SignalSmoothing(numericSimple), // Smoothing for signal line
    
    TrendStrength.index(numericRef), // Output
    TrendStrength.signal(numericRef); //OutPut
Vars:
    DoubleSmoothedPC(0),
    DoubleSmoothedAbsPC(0),
    SignalLine(0);
    
// Force series FUNCTION BEHAVIOR
Value4 = Value3[1];
// Price Change (PC)
Value1 = Close - Close[1];
// First Smoothing (EMA of PC and |PC|)
Value2 = XAverage(Value1, LongLength);
Value3 = XAverage(AbsValue(Value1), LongLength);

// Second Smoothing (EMA of First Smoothed Values)
DoubleSmoothedPC = XAverage(Value2, ShortLength);
DoubleSmoothedAbsPC = XAverage(Value3, ShortLength);
// Compute TSI
If DoubleSmoothedAbsPC <> 0 Then
    TrendStrength.index = 100 * (DoubleSmoothedPC / DoubleSmoothedAbsPC);
    
// Compute Signal Line
TrendStrength.signal = XAverage(TrendStrength.index, SignalSmoothing);

TrendStrengthIndex = 1;

Is this a function or is it a class?

There is a lot going on here. Since we are storing our calculations in the two numericRef inputs, TrendStrength.index and TrendStrength.signal the function name can simply be assigned the number 1. You only need to do this because the function needs to be assigned something, or you will get a syntax error. Since we are talking objects, I think it would be appropriate to introduce “dot notation.” When programming with objects you access the class members and methods buy using a dot. If you have an exponential moving average class in python you would access the variables and functions (methods) in the class like this.

class ExponentialMovingAverage:
    # Class-level defaults serve as initial values.
    alpha = 0.2  # Default smoothing factor
    ema = None   # EMA starts as None

    def update(self, price):
        """
        Update the EMA with a new price.
        
        Parameters:
            price (float): The new price to incorporate.
            
        Returns:
            float: The updated EMA value.
        """
        # If ema is None, this is the first update
        if self.ema is None:
            self.ema = price
        else:
            self.ema = self.alpha * price + (1 - self.alpha) * self.ema
        return self.ema

# Create an instance of the class.
ema_calculator = ExponentialMovingAverage()

# Dot notation to access the class attribute.
print("Alpha value:", ema_calculator.alpha)

# Dot notation to access the EMA attribute before any updates.
print("Initial EMA (should be None):", ema_calculator.ema)

# Dot notation to call the update method.
ema_value = ema_calculator.update(10)
print("EMA after update with 10:", ema_value)

Using dot notation to extract values from a class

Since you are using EasyLanguage and a series function, you don’t have to deal with something like this. On the surface this looks a little gross but coming from a programming background this is quite eloquent. I only show this to demonstrate dot notation. In an attempt to mimic dot notation in the EasyLanguage function, I simply add a period ” , ” to the input variable names that will return the numbers we need to plot. Take a look at the nomenclature I am using.

    TrendStrength.index(numericRef), // Output
    TrendStrength.signal(numericRef); //OutPut

Function Name +

I am using the function name a ” . ” and an appropriate variable name. This is not necessary. Historically, input names that were modified within a function were preceded by the letter “O.” In this example, Oindex and Osignal. This represented “output.” Remember these naming conventions are all up to you. Here is the new indicator using our EasyLanguage “Classy” function and our pseudo dot notation nomenclature.

//Utilize the TrendStrengthIndex classsy function

inputs:  shortLength1(9), longLength1(19), signalSmoothing1(9);
inputs:  shortLength2(19), longLength2(39), signalSmoothing2(13);

vars: trendStrength1.index(0), trendStrength1.signal(0);
vars: trendStrength2.index(0), trendStrength2.signal(0);
value1 = TrendStrengthIndex(shortLength1,longLength1,signalSmoothing1,trendStrength1.index,trendStrength1.signal);
value2 = TrendStrengthIndex(shortLength2,longLength2,signalSmoothing2,trendStrength2.index,trendStrength2.signal);


plot1(trendStrength1.index,"TS-Index-1");
plot2(trendStrength1.signal,"TS-Signal-1");

plot3(trendStrength2.index,"TS-Index-2");
plot4(trendStrength2.signal,"TS-Signal-2");

Take a look at how we access the information we need from the function calls.

You might be surprised to learn that you may have been doing object-oriented programming all along without realizing it. Do you prefer the clarity of dot notation for accessing function output, or would you rather stick with a notation that uses a big “O” combined with the input name to represent functions with multiple outputs? Also, notice how each function call behaves like a new instance—the internal values remain discrete, meaning that each call remembers its own state independently. In other words, each function call remembers its own stuff.

Two distinct function values from the same function – called twice on the same bar.

Algorithmic Trading Commentary, Complete Solutions, EasyLanguage, EasyLanguage Tutorial, Python, TradeStation

Use Python and ChatGPT to fill the gaps of TradeStation

January 31, 2025 George Pruitt Leave a comment

Merge Equity Curves 2.0

Exporting Strategy Performance XML files that use 15 years of 5-minute bars can be cumbersome. Using Maestro can be cumbersome too. I know there are great programs out there that will quickly analyze the XML files and do what we are about to do plus a bunch more. But if you want to do it yourself, try working with 224,377 KB files.

If you want to do a quick merge of equity curves of different markets or systems use this simple method. That is if you have Python, MatPlotLib and Pandas installed on your computer. Installing these are really simple and everybody is doing it. I created this script with the help of a paid version of ChatGPT.

Using Python et al. to plot combined equity curve.

Steps:

1,) Create a folder on you C drive: C:\Data

2.) Put this code into your strategy code. Make sure you change the output file name for each market/system combo that the strategy is applied to.

if t = sessionEndtime(0,1) then
begin
	print(file("C:\Data\Sysname-NQ.csv"),d+19000000:8:0,",",netProfit + Openpositionprofit);
end;

Code snippet to output daily equity

This will create a csv file that looks like this.

20100201,1960.00
20100202,2790.00
20100203,2330.00
20100204,-2290.00
20100205,-3740.00
20100208,-3970.00
20100209,-2360.00
20100210,-3020.00
20100211,-630.00

3.) Copy and paste the following code into your favorite Python IDE or IDLE.

import tkinter as tk
from tkinter import filedialog
import pandas as pd
import matplotlib.pyplot as plt
import os

def extract_market_name(filename):
    """Extracts the market name from the filename formatted as 'system-market.csv'."""
    return os.path.splitext(filename)[0].split('-')[-1]

def load_equity_data(files):
    """Loads and aligns equity data from multiple CSV files."""
    data_dict = {}

    for file in files:
        market = extract_market_name(os.path.basename(file))
        df = pd.read_csv(file, header=None, names=["Date", market], dtype={0: str, 1: float})
        df["Date"] = pd.to_datetime(df["Date"], format='%Y%m%d')
        data_dict[market] = df.set_index("Date")

    combined_df = pd.concat(data_dict.values(), axis=1, join='outer').fillna(method='ffill').fillna(method='bfill')
    combined_df["Total Equity"] = combined_df.sum(axis=1)
    return combined_df

def calculate_metrics(equity_curve):
    """Calculates total profit and maximum drawdown from the equity curve."""
    total_profit = equity_curve.iloc[-1] - equity_curve.iloc[0]
    peak = equity_curve.cummax()
    drawdown = peak - equity_curve
    max_drawdown = drawdown.max()
    return total_profit, max_drawdown, drawdown

def calculate_correlation(df):
    """Calculates and prints the correlation matrix of equity curves."""
    correlation_matrix = df.corr()
    print("\n--- Correlation Matrix ---")
    print(correlation_matrix.to_string())
    print("\n--------------------------")

def plot_equity_and_drawdown(df, drawdown):
    """Plots the combined equity curve and drawdown as separate subplots."""
    fig, ax = plt.subplots(2, 1, figsize=(12, 8), sharex=True)

    # Plot equity curves
    ax[0].set_title("Equity Curve")
    ax[0].set_ylabel("Equity Value")
    for column in df.columns[:-1]:  # Exclude "Total Equity"
        ax[0].plot(df.index, df[column], linestyle='dotted', alpha=0.6, label=f"{column} (Individual)")
    ax[0].plot(df.index, df["Total Equity"], label="Total Equity", linewidth=2, color='black')
    ax[0].legend()
    ax[0].grid()

    # Plot drawdown
    ax[1].set_title("Drawdown")
    ax[1].set_xlabel("Date")
    ax[1].set_ylabel("Drawdown Amount")
    ax[1].plot(drawdown.index, drawdown, color='red', linestyle='solid', alpha=0.7, label='Drawdown')
    ax[1].fill_between(drawdown.index, drawdown, color='red', alpha=0.3)
    ax[1].legend()
    ax[1].grid()

    plt.show()

def main():
    root = tk.Tk()
    root.withdraw()
    files = filedialog.askopenfilenames(title="Select Equity Files", filetypes=[("CSV files", "*.csv")])

    if not files:
        print("No files selected.")
        return

    combined_df = load_equity_data(files)
    total_profit, max_drawdown, drawdown = calculate_metrics(combined_df["Total Equity"])

    print("\n--- Performance Metrics ---")
    print(f"Total Profit: {total_profit:.2f}")
    print(f"Maximum Drawdown: {max_drawdown:.2f}")
    print("--------------------------")

    calculate_correlation(combined_df.drop(columns=["Total Equity"]))
    plot_equity_and_drawdown(combined_df, drawdown)

if __name__ == "__main__":
    main()

Equity Curve Merge Python Script

4.) Run it and multi-select all the system/market .csv files

5.) Examine the results:

Combined equity, maximum draw down, and correlation matrix

How did I get ChatGPT to code this for me.

I pay $20 a month for Chat and it learns from my workflows. The more I work with it, the more it knows my end goals to the scripts I am asking it to create.

Here are the prompts I provided Chat:

I want the user to be able to use tkinter to select multiple files that contain two columns: 1-date in yyyymmdd format and 2 – the equity value for that date. The filename consists of the system name and the market name and follows the following patterm: system name”-“market name”.csv”. I need you to extract the market from the filename. If the filename is “Gatts-GC.csv”, the market name is “GC.” Once all the files are opened, I need you to align the dates and create a combined equity curve. We can do this in matplotlib if you like. I need you to calculate the total profit and the maximum drawdown among the combined equity curves.

[SCRIPT FAILED]

My data does not included headers. The first column is the date in yyyymmdd with no separators and the second column is a float value. I think your pandas are having a hard time interpreting this

[SCRIPT WORKED]

That is perfect. Can we had a correlation analysis to the equity curves and print that out too.

[SCRIPT WORKED]

Can we plot the draw down on the same canvas as the equity curves?

[SCRIPT WORKED]

Could we put the draw down in a subplot instead of in the profit plot?

[FINAL SCRIPT] Look above

Am I Worried About Being Replaced by Chat GPT?

With Python and its data visualization libraries and EasyLanguage you can overcome some of the limitations of TradeStation. And of course, ChatGPT. I have been programming in Python for nine years now and I am very good at base Python. However, Pandas are still a mystery to me and interfacing with MatPlotLib is not super simple. Does it frustrate me that I don’t know exactly what ChatGPT is coding? Yes, it did at first. But now I use it as a tool. I may not be coding the Python, but I am managing ChatGPT through my well thought out prompts and my feedback. Does my knowledge of Python help streamline this process? – I think it does. And I have trained ChatGPT during the process. I am becoming a manager-programmer and ChatGPT is my assistant.

EasyLanguage, EasyLanguage equivalent to cool code, EasyLanguage Indicator, EasyLanguage Snippets, EasyLanguage Tutorial, EasyLanguage Tutorial, Free EasyLanguage, MultiCharts, Must Know, Must Know EasyLanguage, TradeStation

RMI Trend Sniper in EasyLanguage

December 27, 2024 George Pruitt Leave a comment

RMI Trend Sniper Indicator – Described on ProRealTime in PR Code.

RMI Trend Sniper Indicator – Indicators – ProRealTime

RMI Trend Sniper: An Innovative Trading Indicator

The following is from the RealCode website – I have just copied and pasted this here. Here is the header information that provides credit to the original programmer.

//PRC_RMI Trend Sniper
//version = 0
//26.03.24
//Iván González @ www.prorealcode.com
//Sharing ProRealTime knowledge

Here is the description of the Indicator via ProRealCode. Please check out the website for further information regarding the indicator and how to use it.

The RMI Trend Sniper indicator is designed to identify market trends and trading signals with remarkable precision.

This tool combines the analysis of the Relative Strength Index (RSI) with the Money Flow Index (MFI) and a unique approach to range-weighted moving average to offer a comprehensive perspective on market dynamics.

Configuration and Indicator Parameters

The RMI Trend Sniper allows users to adjust various parameters according to their trading needs, including:

RMI Length: Defines the calculation period for the RMI.
Positive and Negative Momentum (Positive above / Negative below): Sets thresholds to determine the strength of bullish and bearish trends.
Range MA Visualization (Show Range MA): Enables users to visualize the range-weighted moving average, along with color indications to quickly identify the current market trend.

Many of my clients ask me to convert indicators from different languages. One of my clients came across this from ProRealCode and asked me to convert for his MulitCharts. Pro Real code is very similar to EasyLanguage with a few exceptions. If you are savvy in EL, then I think you could pick up PRC quite easily. Here it is. It is a trend following indicator. It is one of a few that I could not find the Easylanguage equivalent so I thought I would provide it. Play around with it and let me know what you think. Again, all credit goes to:

//Iván González @ www.prorealcode.com
//Sharing ProRealTime knowledge


inputs:Length(14),//RMI Length
pmom(66),//Positive above
nmom(30);//Negative below

//-----RSI and MFI calculation-----------------------------//

vars: alpha(0),src1(0),src2(0),up(0),down(0),myrsi(0),seed(True);

alpha = 1/length;
//-----Up
src1 = maxList(close-close[1],0);
if seed then
	up = average(src1,length)
else
	up = alpha*src1 + (1-alpha)*up[1];

//-----Down
src2 = -1 * minList(close-close[1],0);
if seed then
	down = average(src2,length)
else
	down = alpha*src2 + (1-alpha)*down[1];
	
seed = False;

//-----Rsi
if down = 0 then
	myrsi = 100
else if up = 0 then
	myrsi = 0
else
	myrsi = 100 - (100/(1+up/down));
vars: mfiVal(0),rsimfi(0),bpmom(False),bnmom(False),positive(0),negative(0),ema(0);
//-----MFI
mfiVal = moneyFlow(length);
//-----RsiMfi
rsimfi = (myrsi+mfiVal)/2;
//----------------------------------------------------------//
//-----Long Short Conditions--------------------------------//
ema = average(c,5);

bpmom = rsimfi[1] < pmom and rsimfi > pmom and rsimfi > nmom and (ema-ema[1])>0;
bnmom = rsimfi<nmom and (ema-ema[1])<0;
 
if bpmom then
begin
	positive = 1;
	negative = 0;
end
else if bnmom then
begin
	positive = 0;
	negative = 1;
end;
	
//----------------------------------------------------------//
//------Calculate RWMA--------------------------------------//
vars: band(0),band20(0),barRange(0),weight(0),sum(0),twVal(0),rwma(0);

band = minList(avgtruerange(30)*0.3,close*(0.3/100));
band20 = band[20]/2*8;
barRange = high-low;
 
weight = BarRange/summation(BarRange,20);
sum = summation(close*weight,20);
twVal = summation(weight,20);
rwma = sum/twVal;

vars: r(0),g(0),b(0);

if positive = 1 then
begin
	rwma = rwma-band;
	r=0;
	g=188;
	b=212;
end
else if negative = 1 then
begin
	rwma = rwma+band;
	r=255;
	g=82;
	b=82;
end
else
	rwma = 0;

//------------------------------------------------------------//
//-----Calculate MA bands-------------------------------------//
vars: mitop(0),mibot(0);

mitop = rwma+band20;
mibot = rwma-band20;
	

plot1(mitop,"TOP");
plot2((mitop+mibot)/2,"TOP-BOT");
plot3((mitop+mibot)/2,"BOT-TOP");
plot4(mibot,"BOT");
if positive = 1 then
begin
	plot5(rwma,"Pos",GREEN);
	noPlot(plot4);
end;
if negative =1 then
begin
	plot6(rwma,"Neg",RED);
	noPlot(plot3);
end;

Ignore the RGB Color Codes

Getting Creative to Shade Between Points on the Chart

TradeStation doesn’t provide an easy method to do shading, so you have to get a little creative. The plot TOP is of type Bar High with the thickest line possible. The plot TOP-BOT (bottom of top) is of type Bar Low. I like to increase transparency as much as possible to see what lies beneath the shading . The BOT-TOP (top of bottom) is Bar High and BOT is Bar Low. Pos and Neg are of type Point. I have colored them to be GREEN or RED.

Happy New Year!

Algorithmic Trading Commentary, Complete EasyLanguage Systems, EasyLanguage, EasyLanguage equivalent to cool code, EasyLanguage Function, EasyLanguage Indicator, EasyLanguage Snippets, EasyLanguage Tutorial, EasyLanguage Tutorial, Free EasyLanguage, MultiCharts, Must Know, PortfolioTrader, Uncategorized

Should you use a profit taking algorithm in your Trend Following system?

October 23, 2024 George Pruitt Leave a comment

If letting profits run is key to the success of a trend following approach, is there a way to take profit without diminishing returns?

Most trend following approaches win less than 40% of the time. So, the big profitable trades are what saves the day for this type of trading approach. However, it is pure pain to simply sit there and watch a large profit erode, just because the criteria to exit the trade takes many days to be met.

Three methods to take a profit on a Trend Following algorithm

Simple profit objective – take a profit at a multiple of market risk.
Trail a stop (% of ATR) after a profit level (% of ATR) is achieved.
Trail a stop (Donchian Channel) after a profit level (% of ATR) is achieved.

Use an input switch to determine which exit to incorporate

Inputs: initCapital(200000),rskAmt(.02),
useMoneyManagement(False),exitLen(13),
maxTradeLoss$(2500),
// the following allows the user to pick
// which exit to use
// 1:  pure profit objective
//     exit1ProfATRMult allows use to select
//     amount of profit in terms of ATR
// 2:  trailing stop 1 - the user can choose
//     the treshhold amount in terms of ATR
//     to be reached before trailing begins
// 3:  trailing stop 2 - the user can chose
//     the threshold amount in terms of ATR
//     to be reached before tailing begins
whichExit(1),
exit1ProfATRMult(3),
exit2ThreshATRMult(2),exit2TrailATRMult(1),
exit3ThreshATRMult(2),exit3ChanDays(5);

Exit switch and the parameters needed for each switch.

The switch determines which exit to use later in the code. Using inputs to allow the user to change via the interface also allows us to use an optimizer to search for the best combination of inputs. I used MultiCharts Portfolio Trader to optimize across a basket of 21 diverse markets. Here are the values I used for each exit switch.

MR = Market risk was defined as 2 X avgTrueRange(15).

Pure profit objective -Multiple from 2 to 10 in increments of 0.25. Take profit at entryPrice + or – Profit Multiple X MR
Trailing stop using MR – Profit Thresh Multiple from 2 to 4 in increments of 0.1. Trailing Stop Multiple from 1 to 4 in increments of 0.1.
Trailing stop using MR and Donchian Channel – Profit Thresh Multiple from 2 to 4 in increments of 0.1. Donchian length from 3 to 10 days.

Complete strategy code incorporating exit switch. This code is from Michael Covel’s 2005 Trend Following book (Covel, Michael. Trend Following: How Great Traders Make Millions in Up or Down Markets. FT Press, 2005.) This strategy is highlighted in my latest installment in my Easing into EasyLanguage series – Trend Following edition.


vars:buyLevel(0),shortLevel(0),longExit(0),shortExit(0);

Inputs: initCapital(200000),rskAmt(.02),
useMoneyManagement(False),exitLen(13),
maxTradeLoss$(2500),whichExit(1),
exit1ProfATRMult(3),
exit2ThreshATRMult(2),exit2TrailATRMult(1),
exit3ThreshATRMult(2),exit3ChanDays(5);

Vars: marketRisk(0), workingCapital(0),
marketRisk1(0),marketRisk2(0),
numContracts1(0),numContracts2(0);
 
//Reinvest profits? - uncomment the first line and comment out the second
//workingCapital = Portfolio_Equity-Portfolio_OpenPositionProfit;
workingCapital = initCapital;


buyLevel   = highest(High,89) + minMove/priceScale;
shortLevel = lowest(Low,89)   - minMove/priceScale;
longExit   = lowest(Low,exitLen)   - minMove/priceScale;
shortExit  = highest(High,exitLen) + minMove/priceScale;

marketRisk = avgTrueRange(15)*2*BigPointValue;
marketRisk1 =(buyLevel - longExit)*BigPointValue;
marketRisk2 =(shortExit - shortLevel)*BigPointValue; 
marketRisk1 = minList(marketRisk,marketRisk1);
marketRisk2 = minList(marketRisk,marketRisk2);

numContracts1 = (workingCapital * rskAmt) /marketRisk1;
numContracts2 = (workingCapital * rskAmt) /marketRisk2;

if not(useMoneyManagement) then
begin
    numContracts1 = 1;
    numContracts2 =1;
end;

numContracts1 = maxList(numContracts1,intPortion(numContracts1));  {Round down to the nearest whole number}
numContracts2 = MaxList(numContracts2,intPortion(numContracts1));


if c < buyLevel then buy numContracts1 contracts next bar at buyLevel stop;
if c > shortLevel then Sellshort numContracts2 contracts next bar at shortLevel stop;

buytocover next bar at shortExit stop;
Sell  next bar at longExit stop;

vars: marketRiskPoints(0);
marketRiskPoints = marketRisk/bigPointValue;
if marketPosition = 1 then
begin
	if whichExit = 1 then
		sell("Lxit-1") next bar at entryPrice + exit1ProfATRMult * marketRiskPoints limit;
	if whichExit = 2 then
		if maxcontractprofit > (exit2ThreshATRMult * marketRiskPoints ) * bigPointValue then
			sell("Lxit-2") next bar at entryPrice + maxContractProfit/bigPointValue - exit2TrailATRMult*marketRiskPoints stop;
	if whichExit = 3 then
		if maxcontractprofit > (exit3ThreshATRMult * marketRiskPoints ) * bigPointValue then
			sell("Lxit-3") next bar at lowest(l,exit3ChanDays) stop;
end;

if marketPosition = -1 then
begin
	if whichExit = 1 then
		buyToCover("Sxit-1") next bar at entryPrice - exit1ProfATRMult * marketRiskPoints limit;
	if whichExit = 2 then
		if maxcontractprofit > (exit2ThreshATRMult * marketRiskPoints ) * bigPointValue then
			buyToCover("Sxit-2") next bar at entryPrice - maxContractProfit/bigPointValue + exit2TrailATRMult*marketRiskPoints stop;
	if whichExit = 3 then
		if maxcontractprofit > (exit3ThreshATRMult * marketRiskPoints ) * bigPointValue then
			buyToCover("Sxit-3") next bar at highest(h,exit3ChanDays) stop;
end;

setStopLoss(maxTradeLoss$);

Here’s the fun code from the complete listing.

vars: marketRiskPoints(0);
marketRiskPoints = marketRisk/bigPointValue;
if marketPosition = 1 then
begin
	if whichExit = 1 then
		sell("Lxit-1") next bar at entryPrice + exit1ProfATRMult * marketRiskPoints limit;
	if whichExit = 2 then
		if maxContractProfit > (exit2ThreshATRMult * marketRiskPoints ) * bigPointValue then
			sell("Lxit-2") next bar at entryPrice + maxContractProfit/bigPointValue - exit2TrailATRMult*marketRiskPoints stop;
	if whichExit = 3 then
		if maxContractProfit > (exit3ThreshATRMult * marketRiskPoints ) * bigPointValue then
			sell("Lxit-3") next bar at lowest(l,exit3ChanDays) stop;
end;

if marketPosition = -1 then
begin
	if whichExit = 1 then
		buyToCover("Sxit-1") next bar at entryPrice - exit1ProfATRMult * marketRiskPoints limit;
	if whichExit = 2 then
		if maxContractProfit > (exit2ThreshATRMult * marketRiskPoints ) * bigPointValue then
			buyToCover("Sxit-2") next bar at entryPrice - maxContractProfit/bigPointValue + exit2TrailATRMult*marketRiskPoints stop;
	if whichExit = 3 then
		if maxContractProfit > (exit3ThreshATRMult * marketRiskPoints ) * bigPointValue then
			buyToCover("Sxit-3") next bar at highest(h,exit3ChanDays) stop;
end;

The first exit is rather simple – just get out on a limit order at a nice profit level. The second and third exit mechanisms are a little more complicated. The key variable in the code is the maxContractProfit keyword. This value stores the highest level, from a long side perspective, reached during the life of the trade. If max profit exceeds the exit2ThreshATRMult, then trail the apex by exit2TrailATRMult. Let’s take a look at the math from a long side trade.

if maxContractProfit > (exit2ThreshATRMult * marketRiskPoints ) * bigPointValue

Since maxContractProfit is in dollar you must convert the exit2ThreshATRMult X marketRiskPoints into dollars as well. If you review the full code listing you will see that I convert the dollar value, marketRisk, into points and store the value in marketRiskPoints. The conversion to dollars is accomplished by multiplying the product by bigPointValue.

sell("Lxit-2") next bar at
entryPrice + maxContractProfit / bigPointValue - exit2TrailATRMult * marketRiskPoints stop;

I know this looks complicated, so let’s break it down. Once I exceed a certain profit level, I calculate a trailing stop at the entryPrice plus the apex in price during the trade (maxContractProfit / bigPointValue) minus the exit2TrailATRMult X marketRiskPoints. If the price of the market keeps rising, so will the trailing stop. That last statement is not necessarily true, since the trailing stop is based on market volatility in terms of the ATR. If the market rises a slight amount, and the ATR increases more dramatically, then the trailing stop could actually move down. This might be what you want. Give the market more room in a noisier market. What could you do to ratchet this stop? Mind your dollars and your points in your calculations.

The third exit uses the same profit trigger, but simply installs an exit based on a shorter term Donchian channel. This is a trailing stop too, but it utilizes a chart point to help define the exit price.

Results of the three exits

Exit 1 – Pure Profit Objective

Take a profit on a limit order once profit reaches a multiple of market risk aka 2 X ATR(15).

Pure profit object. Profit in terms of ATR or perceived market risk.

The profit objective that proved to be the best was using a multiple of 7. A multiple of 10 basically negates the profit objective. With this system several profit objective multiples seemed to work.

Exit – 2 – Profit Threshold and Trailing Stop in terms of ATR or market risk

Trail a stop a multiple of ATR after a multiple of ATR in profit is reached.

3-D view of parameters

This strategy liked 3 multiples of ATR of profit before trailing and applying a multiple of 1.3 ATR as a stop.

Like I said in the video, watch out for 1.3 as you trailing amount multiple as it seems to be on a mountain ridge.

Exit – 3 – Profit Threshold in terms of ATR or market risk and a Donchain Channel trailing stop

Trail a stop using a Donchian Channel after a multiple of ATR in profit is reached. Here was a profit level is reached, incorporate a tailing stop at the lowest low or the highest high of N days back.

Using Donchian Channel as trailing stop.

3-D view of parameters

Conclusion

The core strategy is just an 89-day Donchian Channel for entry and a 13-Day Donchian Channel for exit. The existing exit is a trailing exit and after I wrote this lengthy post, I started to think that a different strategy might be more appropriate. However, as you can see from the contour charts, using a trailing stop that is closer than a 13-day Donchian might be more productive. From this analysis you would be led to believe the ATR based profit and exit triggers (Exit #2) is superior. But this may not be the case for all strategies. I will leave this up to you to decide. Here is the benchmark performance analysis with just the core logic.

If you like this type of explanation and code, make sure you check at my latest book at amazon.com. Easing into EasyLanguage – Trend Following Edition.

Complete EasyLanguage Systems, EasyLanguage, EasyLanguage Snippets, EasyLanguage Tutorial, EasyLanguage Tutorial, Free EasyLanguage, MultiCharts, Must Know

Buy in November, Sell in May Strategy Framework

August 29, 2024 George Pruitt 2 Comments

Thanks to Jeff Swanson for the basis of this post

I like to post something educational at least once a month. Sometimes, it’s difficult to come up with stuff to write about. Jeff really got me thinking with his Buy November… post. Check out his post “Riding the Market Waves: How to Surf Seasonal Trends to Trading Success.” Hopefully you have read his post and now have returned. As you know, the gist of his post was to buy in November and sell in May. Jeff was gracious enough to provide analysis, source and suggestions for improvement for this base strategy.

Why Change Jeff’s Code to a Framework?

I found Jeff’s post most intriguing, so the first think I start thinking about is how could I optimize the buy and sell months, a max loss, the three entry filters that he provided and in addition add a sell short option. If you have read my books, you know I like to develop frameworks for further research when I program an algorithm or strategy. Here is how I developed the framework:

Optimize the entry month from January to December or 1 to 12.
Optimize the exit month from January to December or 1 to 12.
Optimize to go long or go short or 1 to 2 (to go short any number other than 1 really).

input: startMonth(11),endMonth(5),
       longOrShort(1),


currentMonth = Month(Date of tomorrow);
If currentMonth = startMonth and mp = 0 and entriesThisMonth = 0 Then
begin
// a trade can only occur if canBuy is True - start month is active as
// long as the filtering allows it.  Until the filter is in alignment
// keep looking for a trading during the ENTIRE startMonth
    if longOrShort = 1 and canBuy then
    	entriesThisMonth = 1; 
	if longOrShort = 1 and canBuy then
 		buy("Buy Month") iShares contracts next bar at market;
 	if longOrShort <> 1 and canShort then
 		sellShort("Short Month") iShares contracts next bar at market;
 	if longOrShort = -1 and canShort then
 		entriesThisMonth = 1;
end;
 
if CurrentMonth = endMonth Then
begin
	if longOrShort = 1 then
 		sell("L-xit Month") currentShares contracts next bar at market
 	else
 		buyToCover("S-xit Month") currentShares contracts next bar at market;
 end;
 
 if mp = 1 then 
 	sell("l-xitMM") next bar at entryPrice - maxTradeRisk/bigPointValue stop;
 if mp =-1 then
 	buyToCover("s-xitMM") next bar at entryPrice + maxTradeRisk/bigPointValue stop;

Snippet of the bones with extra flavor to enter and exit on certain months

You can see that I have provided the three inputs:

startMonth
endMonth
longOrShort

I get the currentMonth by peeking at the date of tomorrow and passing this date to the month function. If tomorrow is the first day of the month that I want to enter a long or short and the current market position (mp), and entriesThisMonth = 0, then a long or short position will be initiated. If the filters I describe a little later allow it, I know that I will be executing a trade tomorrow, and I can go ahead assign a 1 to entries this month. Why do I do this? Just wait and you will see. Long entries depend on the variable longOrShort being equal to 1 and the toggle canBuy set to True. What is canBuy. Just wait and you will see. The sell short is similar, but conversely longOrShort needs to not equal 1. In addition, canShort needs to be true too.

If the currentMonth = endMonth, then based on the market position a sell or a buy to cover will be executed.

How to add filters to Determine canBuy and canShort

inputs: 
useMACDFilter(1), MACDFast(9), MACDSlow(26), MACDAvgLen(9), MACDLevel(0),
useMAFilter(0), MALength(30),
useRSIFilter(0), RSILength(14), RSILevel(50)

RSIVal = rsi(close,RSILength);
MAVal = xAverage(close,MALength);
MACDVal = macd(close,MACDFast,MACDSlow);
MACDAvg = xAverage(MACDVal,MACDAvgLen);

if useMACDFilter = 1 then
begin
	canBuy = MACDVal > MACDLevel;
	canShort = MACDVal < MACDLevel;
end;

if useMAFilter = 1 then
begin
	canBuy = close > MAVal and canBuy;
	canShort = close < MAVal and canShort;
end;

if useRSIFilter = 1 then
begin
	canBuy = RSIVal > RSILevel and canBuy;
	canShort = RSIVal < RSILevel and canShort;
end;

Calculate Filter Components and then test them

You cannot optimize a True to False toggle, but you can optimize 0 for off and 1 for on. Here the useFilterName inputs are initially set to 0 or off. Each filter indicator has respective inputs so that the filters can be calculated with the user’s input. If the filters are equal to one, then a test to turn canBuy and canShort to on or off is laid out in the code. Each test depends on either the state of price compared to the indicator value, or the indicator’s relationship to a user defined level or value.

Will this code test all the combination of the filters?

Yes! F1 is Filter 1 and F2 is Filter 2 and F3 is Filter 3. By optimizing each filter from 0 to 1, you will span this search space.

F1 = On; F2 = Off; F3 = Off
F1 = On; F2 = On; F3 = Off
F1 = On; F2 = On; F3 = On
F1 = Off; F2 = On; F3 = Off
F1 = Off; F2 = On; F3 = On
F1 = Off; F2 = Off: F3 = On
F1 = On; F2 = Off; F3 = On

You will notice I initially set canBuy and canShort to True and then turn them off if an offending filter occurs. Notice how I AND the results for Filter 2 and Filter 3 with canBuy or canShort. Doing this allows me to cascade the filter combinations. I do want to test when all filters are in alignment. In other words, they must all be True to initiate a position.

Should the Filters be Active During the Entire Entry Month?

What if the first day of the month arrives and you can’t initiate a trade due to a conflict of one of the filters. Should we allow a trade later in the entry month if the filters align properly? If we are testing 25 years of history and allow for entry later on in the month, we could definitely generate as close to 25 trades as possible. This line of code keeps the potential of a trade open for the entire month.


//  only set entriesThisMonth to true
// when all the stars align - might enter a long
// trade on the last day of the month

if longOrShort = 1 and canBuy then
    	entriesThisMonth = 1;

Keep the entire start month active

Some Tricky Code

I wanted to allow a money management exit on a contract basis. I had to devise some code that would not allow me to reenter the startMonth if I got stopped out prematurely in the startMonth (the same month as entry.)

if entriesThisMonth = 1 and monthOfTomorrow <> startMonth then
	entriesThisMonth = 0;

This code resets entriesThisMonth

If a position is initiated, I know entriesThisMonth will be set to one. If I enter into another month that is not the startMonth then entriesThisMonth is set to 0. This prevents reentry in case we get stopped out in the same month we initially enter a position. In other words, entriesThisMonth stays one until a new month is observed. And we can’t enter when entriesThisMonth is equal to one.

Full Code

input: startMonth(11),endMonth(5),
       longOrShort(1),
       useMACDFilter(1),MACDFast(9),MACDSlow(26),MACDAvgLen(9),MACDLevel(0),
       useMAFilter(0),MALength(30),
       useRSIFilter(0),RSILength(14),RSILevel(50),
       startAccountSize(100000),
       marketRiskLen(30),
       riskPerTrade(5000),
       maxTradeRisk(5000);

vars: currentMonth(0),mp(0),iShares(0),entriesThisMonth(0),monthOfTomorrow(0),
      RSIVal(0),MAVal(0),MACDVal(0),MACDAvg(0),canBuy(True),canShort(True);

mp = marketPosition;
iShares = riskPerTrade/bigPointValue/avgTrueRange(marketRiskLen);

RSIVal = rsi(close,RSILength);
MAVal = xAverage(close,MALength);
MACDVal = macd(close,MACDFast,MACDSlow);
MACDAvg = xAverage(MACDVal,MACDAvgLen);

canBuy = True;
canShort = True;

mp = marketPosition;

monthOfTomorrow = month(date of tomorrow);

if entriesThisMonth = 1 and monthOfTomorrow <> startMonth then
	entriesThisMonth = 0;
	
if useMACDFilter = 1 then
begin
	canBuy = MACDVal > MACDLevel;
	canShort = MACDVal < MACDLevel;
end;

if useMAFilter = 1 then
begin
	canBuy = close > MAVal and canBuy;
	canShort = close < MAVal and canShort;
end;

if useRSIFilter = 1 then
begin
	canBuy = RSIVal > RSILevel and canBuy;
	canShort = RSIVal < RSILevel and canShort;
end;

currentMonth = Month(Date of tomorrow);
//print(d," ",currentMonth," ",startMonth," ",entriesThisMonth);
If currentMonth = startMonth and mp = 0 and entriesThisMonth = 0 Then
begin
//	print(d," ",currentMonth," ",canBuy);
    if longOrShort = 1 and canBuy then
    	entriesThisMonth = 1;
	if longOrShort = 1 and canBuy then
 		buy("Buy Month") iShares contracts next bar at market;
 	if longOrShort <> 1 and canShort then
 		sellShort("Short Month") iShares contracts next bar at market;
 	if longOrShort = -1 and canShort then
 		entriesThisMonth = 1;
end;
 
if CurrentMonth = endMonth Then
begin
	if longOrShort = 1 then
 		sell("L-xit Month") currentShares contracts next bar at market
 	else
 		buyToCover("S-xit Month") currentShares contracts next bar at market;
 end;
 
 if mp = 1 then 
 	sell("l-xitMM") next bar at entryPrice - maxTradeRisk/bigPointValue stop;
 if mp =-1 then
 	buyToCover("s-xitMM") next bar at entryPrice + maxTradeRisk/bigPointValue stop;

Complete Code Framework

Here is the best equity curve I uncovered when I optimized the startMonth from 1 to 12 and the endMonth from 1 to 12 and the maxTradeRisk per contract and the three entry filters. Entering in November when the moving average filter aligns and exiting on the first day of August and risking $5,500 per contract produced this equity curve.

Enter November get out the beginning of August

The test returned what would basically be similar to a buy and hold scenario; the difference being you only hold the trade between seven and eight months of the year and risk only $5,500 per contract. If you get stopped out, you wait until November to get back in – whenever the moving average filter allows. Net profit to draw down ratio is north of 4.0.

Last Comment

If I optimize from 1 to 12 for the start month and 1 to 12 for end month, will this not cause an error? What if the two values equal? I mean I can’t enter and exit in the same month – a one-day trade? You could make the code smarter, but it doesn’t matter. As a user you will know better than to use the same number and the optimizer will test the combination with the same number, but the results will fall off the table. In this case, error trapping doesn’t prevent a necessarily unwanted or dangerous scenario.

Algorithmic Trading Commentary, Complete EasyLanguage Systems, EasyLanguage, EasyLanguage equivalent to cool code, EasyLanguage Function, EasyLanguage Snippets, EasyLanguage Tutorial, EasyLanguage Tutorial, Free EasyLanguage, MultiCharts, Must Know, Must Know EasyLanguage, PortfolioTrader, Trend Following

Prune Your Trend Following Algorithm

July 5, 2024 George Pruitt Leave a comment

Multiple trading decisions based on “logic” may not add to the bottom line

In this post, I will present a trend following system that uses four exit techniques. These techniques are based on experience and also logic. The problem with using multiple exit techniques is that it is difficult to see the synergy that is generated from all the moving parts. Pruning your algorithm may help cut down on invisible redundancy and opportunities to over curve fit. The trading strategy I will be presenting will use a very popular entry technique overlaid with trade risk compression.

Entry logic

Long:

Criteria #1: Penetration of the closing price above an 85 day (closing prices) and 1.5X standard deviation-based Bollinger Band.

Criteria #2: The mid-band or moving average must be increasing for the past three consecutive days.

Criteria #3: The trade risk (1.5X standard deviation) must be less than 3 X average true range for the past twenty days and also must be less than $4,500.

Risk is initially defined by the standard deviation of the market but is then compared to $4,500. If the trade risk is less than $4,500, then a trade is entered. I am allowing the market movement to define risk, but I am putting a ceiling on it if necessary.

Short:

Criteria #1: Penetration of the closing price below an 85 day (closing prices) and 1.5X standard deviation-based Bollinger Band.

Criteria #2: The mid-band or moving average must be decreasing for the past three consecutive days.

Criteria #3: Same as criteria #3 on the long side

Exit Logic

Exit #1: Like any Bollinger Band strategy, the mid band or moving average is the initial exit point. This exit must be included in this particular strategy, because it allows exits at profitable levels and works synergistically with the entry technique.

Exit #2: Fixed $ stop loss ($3,000)

Exit #3: The mid-band must be decreasing for three consecutive days and today’s close must be below the entry price.

Exit #4: Todays true range must be greater than 3X average true range for the past twenty days, and today’s close is below yesterday’s, and yesterday’s close must be below the prior days.

Here is the logic of exits #2 through exit #4. With longer term trend following system, risk can increase quickly during a trade and capping the maximum loss to $3,000 can help in extreme situations. If the mid-band starts to move down for three consecutive days and the trade is underwater, then the trade probably should be aborted. If you have a very wide bar and the market has closed twice against the trade, there is a good chance the trade should be aborted.

Short exits use the same logic but in reverse. The close must close below the midband, or a $3,000 maximum loss, or three bars where each moving average is greater than the one before, or a wide bar and two consecutive up closes.

Here is the logic in PowerLanguage/EasyLanguage that includes the which exit seletor.

[LegacyColorValue = true]; 
Inputs:	maxEntryRisk$(4500),maxNATRLossMult(3),maxTradeLoss$(3000),
		indicLen(85),numStdDevs(1.5),highVolMult(3),whichExit(7); 
		
Vars: 	upperBand(0), lowerBand(0),slopeUp(False),slopeDn(False), 
		largeAtr(0),sma(0),
		initialRisk(0),tradeRisk(0),
		longLoss(0),shortLoss(0),permString("");

upperBand = bollingerBand(close,indicLen,numStdDevs); 
lowerBand = bollingerBand(close,indicLen,-numStdDevs);
largeATR = highVolMult*(AvgTrueRange(20));

sma = average(close,indicLen);

slopeUp = sma>sma[1] and sma[1]>sma[2] and sma[2]>sma[3];
slopeDn = sma<sma[1] and sma[1]<sma[2] and sma[2]<sma[3];

initialRisk = AvgTrueRange(20);
largeATR = highVolMult * initialRisk; 
tradeRisk = (upperBand - sma);
// 3 objects in our permutations 
// exit 1, exit 2, exit 3
// perm #     exit #
//      1          1
//      2        1,2
//      3        1,3
//      4          2
//      5        2,3
//      6          3
//      7      1,2,3

if whichExit = 1 then permString = "1";
if whichExit = 2 then permString = "1,2";
if whichExit = 3 then permString = "1,3";
if whichExit = 4 then permString = "2";
if whichExit = 5 then permString = "2,3";
if whichExit = 6 then permString = "3";
if whichExit = 7 then permString = "1,2,3";



{Long Entry:}
If (MarketPosition = 0) and
	Close crosses above upperBand and slopeUp and 
	(tradeRisk < initialRisk*maxNATRLossMult and tradeRisk<maxEntryRisk$/bigPointValue) then 
	begin
		Buy ("LE") Next Bar  at Market;
	End;


{Short Entry:}

If (MarketPosition = 0) and slopeDn and 
	Close crosses below lowerBand and
	(tradeRisk < initialRisk*maxNATRLossMult and tradeRisk<maxEntryRisk$/bigPointValue) then 
	begin
		Sell Short ("SE") Next Bar  at Market; 
	End;


{Long Exits:}

if marketPosition = 1 Then
Begin
	longLoss = initialRisk * maxNATRLossMult;
	longLoss = minList(longLoss,maxTradeLoss$/bigPointValue);
	
	If Close < sma then
			Sell ("LX Stop") Next Bar  at Market;;
	
	if inStr(permString,"1") > 0 then
		sell("LX MaxL") next bar at entryPrice - longLoss stop;

	if inStr(permString,"2") > 0 then
		If sma < sma[1] and sma[1] < sma[2] and sma[2] < sma[3] and close < entryPrice then
			Sell ("LX MA") Next Bar  at Market;
	if inStr(permString,"3") > 0 then
		If TrueRange > largeATR and close < close[1] and close[1] < close[2] then
			Sell ("LX ATR") Next Bar  at Market;
end;

{Short Exit:}

If (MarketPosition = -1) Then
Begin

	shortLoss = initialRisk * maxNATRLossMult;
	shortLoss = minList(shortLoss,maxTradeLoss$/bigPointValue);
	if Close > sma then
		Buy to Cover ("SX Stop") Next Bar  at Market;

	if inStr(permString,"1") > 0 then
		buyToCover("SX MaxL") next bar at entryPrice + shortLoss stop;

	if inStr(permString,"2") > 0 then
		If sma > sma[1] and sma[1] > sma[2] and sma[2] > sma[3] and  close > entryPrice then
			Buy to Cover ("SX MA") Next Bar  at Market;
	if inStr(permString,"3") > 0 then
		If TrueRange > largeAtr and close > close[1] and close[1] > close[2] then
			Buy to Cover ("SX ATR") Next Bar  at Market;
end;

Trend following with exit selector

Please note that I modified the code from my original by forcing the close to cross above or below the Bollinger Bands. There is a slight chance that one of the exits could get you out of a trade outside of the bands, and this could potentially cause and automatic re-entry in the same direction at the same price. Forcing a crossing, makes sure the market is currently within the bands’ boundaries.

This code has an input that will allow the user to select which combination of exits to use.

Since we have three exits, and we want to evaluate all the combinations of each exit separately, taken two of the exits and finally all the exits, we will need to rely on a combinatorial table. In long form, here are the combinations:

3 objects in our combinations of exit 1, exit 2, exit 3

one – 1
two – 1,2
three – 1,3
four – 2
five – 2,3
six – 3
seven – 1,2,3

There are a total of seven different combinations. Given the small set, we can effectively hard-code this using string manipulation to create a combinatorial table. For larger sets, you may find my post on the Pattern Smasher beneficial. A robust programming language like Easy/PowerLanguage offers extensive libraries for string manipulation. The inStr string function, for instance, identifies the starting position of a substring within a larger string. When keyed to the whichExit input, I can dynamically recreate the various combinations using string values.

if whichExit = 1 then permString = “1”
if whichExit = 2 then permString= “1,2”
if whichExit = 3 then permString = “1,2,3”
etc…

As I optimize from one to seven, permString will dynamically change its value, representing different rows in the table. For my exit logic, I simply check if the enumerated string value corresponding to each exit is present within the string.

	if inStr(permString,"1") > 0 then
		sell("LX MaxL") next bar at entryPrice - longLoss stop;
	if inStr(permString,"2") > 0 then
		If sma < sma[1] and sma[1] < sma[2] and sma[2] < sma[3] and close < entryPrice then
			Sell ("LX MA") Next Bar  at Market;
	if inStr(permString,"3") > 0 then
		If TrueRange > largeATR and close < close[1] and close[1] < close[2] then
			Sell ("LX ATR") Next Bar  at Market;

Using inStr to see if the current whichExit input applies

When permString = “1,2,3” then all exits are used. If permString = “1,2”, then only the first two exits are utilized. Now all we need to do is optimize whichExit from 1 to 7. Let’s see what happens:

The best combination of exits was “3”. Remember 3 is the permString that = “1,3” – this combination includes the money management loss exit, and the wide bar against position exit. It only slightly improved overall profitability instead of using all the exits – combo #7. In reality, just using the max loss stop wouldn’t be a bad way to go either. Occam uses his razor to shave away unnecessary complexities again!

If you like this code, you should check out the Summer Special at my digital store. I showcase over ten more trend-following algorithms with different entry and exit logic constructs. These other algorithms are derived from the best Trend Following “Masters” of the twentieth century. IMHO!

Here is a video you can watch that goes over the core of this trading strategy.

Complete EasyLanguage Systems, EasyLanguage, EasyLanguage Function, EasyLanguage Snippets, EasyLanguage Tutorial, Free EasyLanguage, MultiCharts, Must Know, Must Know EasyLanguage

Multi-Agents and the Power of the Series Function

May 8, 2024 George Pruitt Leave a comment

Jeff Swanson wrote a great post on multi-agent trading a few years ago.

Jeff created a simple mean reversion system and then created two derivatives that culminated in three systems (or three agents.) Using Murray Ruggiero’s Equity Curve Feedback, he was able to poll which system was doing the best, synthetically, and execute the strategy that showed the best performance. If memory serves, picking the highflyer turned out to be the way to go. Jeff had just touched the surface of Murray’s tool. but it definitely did the job. Murray contracted me to fix some problems with the ECF tool and I did, but the tool is just way too cumbersome, resource hungry and requires a somewhat higher level of EasyLanguage knowledge to be universally applicable. I was doing similar research in the area of polling multiple strategies and picking the best, just like Jeff did, and just executing that one system, when I thought about this post. Traders do this all the time. They have multiple strategies in the pipeline and monitor the performance and if one is head and shoulders better than what they are currently trading, they will switch systems. This was one of the side benefits of the ECF tool.

What is an agent

An agent is any trading system that produces a positive expectancy. Using multiple agents in a polling process allows a trader to go with the strategy that is currently performing the best. This sounds reasonable, but there are pitfalls. You could always be behind the curve – picking the best system right before it has its draw down. Agents can be similar, or they can be totally different types of systems. I am going to follow in Jeff’s footsteps and create three agents with the same DNA. Here is what I call the AgentSpawner strategy.

inputs: movAvgLen(200),numDownDays(3),numDaysInTrade(2),stopLoss(5000);


value1 = countIf(c < c[1],numDownDays);
if c > average(c,movAvgLen) and value1 = numDownDays then
	buy next bar at open;
if barsSinceEntry = numDaysInTrade then
	sell next bar at open;
if marketPosition = 1 then sell next bar at entryPrice - stopLoss/bigPointValue stop;

Use this template and optimize inputs to spawn new agents

This code trades in the direction of the longer-term moving average and waits for a pull back on N consecutive down closes. I am using the neat function countIF. This function counts the number of times the conditional test occurs in the last N bars. If I want to know the number of times I have had a down close in the last 3 days, I can use this function like this.

Value1 = countIF(c<c[1],3);

// this is what the function doues
// 1.) todays close < yesterdays close + 1
// 2.) yesterdays close < prior days close + 2
// 3.) day before yesterdays close < prior cays close + 3

//  If value3 = 3 then I know I had three conscecutive down 
//  closes.  If value3 is less than three then I did not.

If the close is greater than the longer-term moving average and I have N consecutive down closings, then I buy the next bar at the open. I use a wide protective stop and get out after X bars since entry. Remember EasyLanguage does not count the day of entry in its barsSinceEntry calculation. I am not using the built-in setStopLoss as I don’t want to get stopped out on the day of entry. In real trading, you may want to do this, but for testing purposes my tracking algorithm was not this sophisticated. I spawned three agents with the following properties.

	Case 1: //Agent 1
		movAvgLen = 200;
		numDownDays = 2;
		numDaysInTrade = 15;
		stopLoss = 7500;
	Case 2:  //Agent 2
		movAvgLen = 140;
		numDownDays = 3;
		numDaysInTrade = 9;
		stopLoss = 2500;
	Case 3: //Agent 3
		movAvgLen = 160;
		numDownDays = 3;
		numDaysInTrade = 15;
		stopLoss = 2500;

System Tracking Algorithm

This is why I love copy-paste programming. This can be difficult if you don’t know your EasyLanguage or how TradeStation processes the bars of data. Get educated by checking my books out at amazon.com – that is if you have not already. This code is a very simplistic approach for keeping track of a system’s trades and its equity.

value4 = countIf(c<c[1],4);
value3 = countIf(c<c[1],3);
value2 = countIf(c<c[1],2);
//Agent #1 tracking algorithm
if sys1Signal<> 1 and c[1] > average(c[1],160) and value2[1] = 2 then
begin
	sys1Signal = 1;
	sys1BarCount = -1;
	sys1TradePrice = open;
	sys1LExit = open - 7500/bigPointValue;
end;
if sys1Signal = 1 then
begin
	sys1BarCount+=1;
	if low < sys1LExit and sys1BarCount > 0 then
	begin
		sys1TradePrice = sys1LExit;
		sys1Signal = 0;
	end;
	if sys1BarCount = 16 and sys1Signal = 1 then
	begin
		sys1TradePrice = open;
		sys1Signal = 0;
	end;
end;

Yes, this looks a little hairy, but it really is simple stuff

I am pretending to be TradeStation here. First, I need to test to see if Agent#1 entered into a long position. If the close of yesterday is greater than the moving average, inclusive of yesterdays close, and there has been two consecutive down closes, then I know a trade should have been entered on todays open. EasyLanguage’s next bar paardigm cannot be utilized here. Remember I am not generating signals, I am just seeing if today’s (not tomorrows or the next bars) trading action triggered a signal and if so, I need to determine the entry/exit price. I am gathering this information so I can feed it into a series function. If a trade is triggered, I set four variables:

sys1Signal – 1 for long, -1 for short, and 0 for flat.
sys1BarCount – set to a -1 because I immediately increment.
sys1TradePrice – at what price did I enter or exit
sys1LExit – set this to our stop loss level

If I am theoretically long, remember we are just tracking here, then I need to test, starting with the following day, if the low of the day is below our stop loss level and if it is I need to reset two variables:

sys1TradePrice – where did I get out
sys1Signal – set to 0 for a flat position

If not stopped out, then I start counting the number of bars sys1Signal is equal to 1. If sys1BarCount = 16, then I get out at the open by resetting the following variables:

sys1TradePrice = open
sys1Signal = 0

If you look back at the properties for Agent#1 you will see I get out after 15 days, not 16. Here is where the next bar paradigm can make it confusing. The AgentSpawner strategy says to sell next bar at open when barsSinceEntry = 15. The next bar after 15 is 16, so we store the open of the 16th bar as our trade price.

Now copy and paste the code into a nice editor such as NotePad++ or NotePad and replace the string sys1 with sys2. Copy the code from NotePad++ into your EasyLanguage editor. Now back to NotePad++ and replace sys2 with sys3. Copy that code into the EL edition too. Now all you need to do is change the different properties for each agent and you will have three tracking modules.

The Power of the EasyLanguage Series Function

The vanilla version of EasyLanguage has object-oriented nuances that you may not see right off the bat. In my opinion, a series function is like a class. Before I get started, let me explain what I mean by series. All EasyLanguage function are of three types.

simple – like a Bollinger band calculation
series – like we are talking about here
auto-detect – the interpreter/compiler decides

The series function has a memory for the variables that are used within the function. Take a look at this.

input: funcID(string),seed(numericSimple);

vars: count(0);
if barNumber = 1 then // on first bar seed count
	count = seed;
count = count+1;
print(d," ",funcID," ", count);
SeriesFunctionTest = count;

Count is class-like member

On the first bar of the function call – remember it will be called on each bar in the chart, the function variable count is assigned seed. Seed will be ignored on subsequent bars. What makes this magical is that no matter how many times you call the function on the same bar it remembers the internal variables on somewhat of a hierarchical basis (each call remembers its own stuff.) It like a class in that it gets instantiated on the very first call. Meaning if you call it three times on the first bar of the data, you will have three distinct internal variable memories. Take a look at my sandbox function driver and its output.

result = SeriesFunctionTest("Call #1",50);
result = SeriesFunctionTest("Call #2",5);
result = SeriesFunctionTest("Call #3",100);

//outPut

1170407.00 Call #1   51.00  //first bar  51 = seed + count + 1
1170407.00 Call #2    6.00  //first bar   6 = seed + count + 1
1170407.00 Call #3  101.00  //first bar 101 = seed + count + 1
	
1170410.00 Call #1   52.00 // second bar it remembered count was 51
1170410.00 Call #2    7.00 // second bar it remembered count was 6
1170410.00 Call #3  102.00 // second bar it remembered count was 101
	
1170411.00 Call #1   53.00 // you have a unique function values that
1170411.00 Call #2    8.00 // were instantiated on the first bar
1170411.00 Call #3  103.00 // of the test.
	
1170412.00 Call #1   54.00
1170412.00 Call #2    9.00
1170412.00 Call #3  104.00

Series functions rock - but they are resource hungry

Why is this important?

I have created a PLSimulator function that keeps track of the three agent’s performance. I need the profit or loss to stick with each function and then also add or subtract from it. This is a neat function. Remember if you like this stuff buy my books at Amazon.com.

//ProfitLoss Simulator
Inputs:  signal(numericseries),tradePrice(numericSimple),orderType(numericSimple),useOte(Truefalse);
Vars:dmode(0),LEPrice(-99999),LXPrice(-99999),SEPrice(-99999),SXPrice(-99999);
vars: GProfit(0),OpenProfit(0);
vars: modTradePrice(0);

vars: printOutTrades(True);

modTradePrice = tradePrice;

if orderType = 1 then // stop order
begin
	if signal = 1 or (signal = 0 and signal[1] = - 1) then
		modTradePrice = maxList(open,modTradePrice);
	if signal = -1 or (signal = 0 and signal[1] = 1) then
		modTradePrice = minList(open,modTradePrice);
end;

if orderType = 2 then // limit order
begin
	if signal = 1 or (signal = 0 and signal[1] = - 1) then
		modTradePrice = minList(open,modTradePrice);
	if signal = -1 or (signal = 0 and signal[1] = 1) then
		modTradePrice = maxList(open,modTradePrice);
end;
if orderType = 3 then // market order
begin
	modTradePrice = open;
end;
		
If Signal[0]=1 And (Signal[1]=-1 Or Signal[1]=0) Then
begin
	LEPrice=modTradePrice; 
	SXPrice = -999999; 
	condition1 = false;
	If Signal[1]=-1 Then
	begin
    	SXPrice=modTradePrice;  
    	GProfit=(SEPrice-SXPrice)+GProfit;
    	condition1 = True;
    End;
    if not(condition1) then
    	if printOutTrades then Print(d," L:Entry ",LEPrice)
    else
    	if printOutTrades then Print(d," L:Entry ",LEPrice," ",(SEPrice-SXPrice)*bigPointValue:8:2," ",GProfit*bigPointValue:9:2);
End;
{('***********************************************}
If Signal[0]=-1 And (Signal[1]=1 Or Signal[1]=0) Then
begin
	SEPrice=modTradePrice;  
	LXPrice = 999999;
	condition1 = false;
    If Signal[1]=1 Then
    begin
    	condition1 = True;
      	LXPrice=modTradePrice;  
    	GProfit=(LXPrice-LEPrice)+GProfit;
    End;
    if not(condition1) then
    	if printOutTrades then Print(d," S:Entry ",SEPrice)
    else
    	if printOutTrades then Print(d," L:Exit ",LXPrice," ",(LXPrice-LEPrice)*bigPointValue:8:2," ",GProfit*bigPointValue:9:2);

End;
If Signal[0]=0 And Signal[1]=-1 Then
begin
	SXPrice = modTradePrice; 
    GProfit=(SEPrice-SXPrice)+GProfit;
    if printOutTrades then Print(d," S:Exit ",SXPrice," ",(SEPrice-SXPrice)*bigPointValue:8:2," ",GProfit*bigPointValue:9:2);

end;
If Signal[0]=0 And Signal[1]=1 Then
begin
	LXPrice = modTradePrice;
    GProfit=(LXPrice-LEPrice)+GProfit;
   if printOutTrades then Print(d," L:Exit ",LXPrice," ",(LXPrice-LEPrice)*bigPointValue:8:2," ",GProfit*bigPointValue:9:2);

end;

If Signal[1]=1 And useOte=True Then
begin
	OpenProfit=(Close[1]-LEPrice);
End;
If Signal[1]=-1 and useOte=True Then
begin
	OpenProfit=(SEPrice-Close[1]);
End;
If Signal[1]=0 Or useOte=False Then
begin
	OpenProfit=0;
End;

PLSimulator=(GProfit+OpenProfit)*bigpointvalue;

Simulate profit and loss and more importantly keep track of it

Feed tracker algorithm data into the function

Your information must be properly assigned to get this to work. First, I show how to get the information into the function. The function does all the work and returns the equity. I then determine the best agent by looking at the ROC over the past thirty days of equity for each agent and pick the very best. I then trade the very best. This is a very quick application of the function. I will have a more sophisticated function, something akin to Murray’s ECF but with much less overhead and more strategy templates.

sys1Equity = PLSimulator(sys1Signal,sys1TradePrice,1,True);
sys2Equity = PLSimulator(sys2Signal,sys2TradePrice,1,True);
sys3Equity = PLSimulator(sys3Signal,sys3TradePrice,1,True);


vars: multiAgent(0);

value1 = maxList(sys1Equity-sys1Equity[30],sys2Equity-sys2Equity[30],sys3Equity-sys3Equity[30]);
multiAgent = 1;
if sys2Equity-sys2Equity[30] = value1 then multiAgent = 2;
if sys3Equity-sys3Equity[30] = value1 then multiAgent = 3;

	
{print(d," ",sys1Equity-sys1Equity[30]," ",sys1Equity);
print(d," ",sys2Equity-sys2Equity[30]," ",sys2Equity);
print(d," ",sys3Equity-sys3Equity[30]," ",sys2Equity);}
print(d," MultiAgent ",multiAgent);

//system parameters
vars: movAvgLen(200),numDownDays(3),numDaysInTrade(2),stopLoss(5000);
Switch ( multiAgent )
Begin
	Case 1: 
		movAvgLen = 200;
		numDownDays = 2;
		numDaysInTrade = 15;
		stopLoss = 7500;
	Case 2: 
		movAvgLen = 140;
		numDownDays = 3;
		numDaysInTrade = 9;
		stopLoss = 2500;
	Case 3: 
		movAvgLen = 160;
		numDownDays = 3;
		numDaysInTrade = 15;
		stopLoss = 2500;
 End;
// Actual system execution
value1 = countIf(c < c[1],numDownDays);

if multiAgent <> multiAgent[1] then print(d," ---->multiagent trans ");

if c > average(c,movAvgLen) and value1 = numDownDays then
begin
	if multiAgent = 1 then buy("Sys1") next bar at open;
	if multiAgent = 2 then buy("Sys2") next bar at open;
	if multiAgent = 3 then buy("Sys3") next bar at open;
end;
if barsSinceEntry >= numDaysInTrade then
	sell next bar at open;
if marketPosition = 1 then sell next bar at entryPrice - stopLoss/bigPointValue stop;

Cool usage of a switch-case and agent determination

If this seems over your head…

Get one of my books are check out Jeff Swanson’s course. EasyLanguage has so many little nuggets that can help you define your algorithm into an actionable strategy. You will never know how your strategy will work until your program it (properly) and back test it. And then potentially improve it with optimization.

Multi-Agent Results

Complete EasyLanguage Systems, EasyLanguage, EasyLanguage equivalent to cool code, EasyLanguage Function, EasyLanguage Indicator, EasyLanguage Snippets, EasyLanguage Tutorial, EasyLanguage Tutorial, Free EasyLanguage, MultiCharts, Must Know EasyLanguage, Trend Following

How to Fix the Fixed Fractional Position Size

February 29, 2024 George Pruitt Leave a comment

The Fixed Fractional position sizing scheme is the most popular, so why does it need fixed?

Problems solved with Fixed Fractional:

Efficient usage of trading capital
Trade size normalization between different futures contracts
Trade size normalization across different market environments

These are very good reasons why you should use positions sizing. Problem #2 doesn’t apply if you are only trading one market. This sounds idyllic, right? It solves these two problems, but it introduces a rather bothersome side effect – huge draw down. Well, huge draw down in absolute terms. Draw downs when using a fixed fractional approach are proportional to the prior run up. If you make a ton of money on a prior trade, then your position sizing reflects that big blip in the equity curve. So, if you have a large loser following a large winner, the draw down will be a function of the run up. In most cases, a winning trading system using fixed fractional position sizing will scale profit up as well as draw down. A professional money manager will look at the profit to draw down ratio instead of the absolute draw down value. The efficient use of capital will reflect a smaller position size after a draw down, so that is good right? It is unless you believe in a Martingale betting algorithm – double up on losses and halve winners. Are we just stuck with large “absolute” draw downs when using this size scheme?

Possible solutions to fixing Fixed Fractional (FF)

The first thing you can do is risk less than the industry standard 2% per trade. Using 1% will cause equity to grow at a slower rate and also reduce the inevitable draw down. But this doesn’t really solve the problem as we are giving up the upside. And that might be okay with you. Profit will increase and you are using an algorithm for size normalization. In this blog I am going to propose a trading equity adjustment feature while using FF. What if we act like money managers, and you should even if you are trading your own personal money, and at the end of the year or month we take a little off the table (theoretically – we are not removing funds from the account just from the position sizing calculation) that is if there is any extra on the table. This way we are getting the benefit of FF while removing a portion of the compounding effect, which reduces our allocation for the next time interval. How do you program such a thing? Well first off let’s code up the FF scheme.

positionSize = round((tradingCapital * riskPerTrade) / (avgTrueRange(30)*bigPointValue),0);

Nothing new here. Simply multiply tradingCapital by the riskPerTrade (1 or 2%) and then divide by a formula that defines current and inherent market risk. This is where you can become very creative. You could risk the distance between entry and exit if you know those values ahead of time or you can use a value in terms of the current market. Here I have chosen the 30-day average true range. This value gives a value that predicts the market movement into the future. However, this value only gives the expected market movement for a short period of time into the future. You could us a multiplier since you will probably remain in a trade for more than a few days – that is if you are trying to capture the trend. In my experiment I just use one as my multiplier.

Capture and store the prior year/month NetProfit

When I come up with a trading idea I usually just jump in and program it. I don’t usually take time to see if Easy Language already provides a solution for my problem. Many hours have been used to reinvent the wheel, which isn’t always a bad thing. So, I try to take time and search the functions to see if the wheel already exists. This time it looks like I need to create the wheel. I will show the code first and then explain afterward.

inputs: useAllocateYearly(True),useAllocateMonthly(False),initCapital(100000),removePerProfit(0.50),riskPerTrade(0.01);
vars: tradingCapital(0),prevNetProfit(0),tradingCapitalAdjustment(0);
vars: oLRSlope(0),oLRAngle(0),oLRIntercept(0), oLRValueRaw(0),mp(0);
arrays: yearProfit[250](0),snapShotNetProfit[250](0);vars: ypIndex(0);


once
begin
	tradingCapital = initCapital;
end;

if useAllocateYearly then
begin
	value1 = year(d);
	value2 = year(d[1]); 
end;

if useAllocateMonthly then //remember make sure your array is 12XNumYears
begin
	value1 = month(d);
	value2 = month(d[1]);
end;

if useAllocateYearly or useAllocateMonthly then
begin
	if value1 <> value2 then
	begin
		if ypIndex > 0 then
			yearProfit[ypIndex] = prevNetProfit - snapShotNetProfit[ypIndex-1]
		else
			yearProfit[ypIndex] = prevNetProfit;	
			
		snapShotNetProfit[ypIndex] = prevNetProfit;
		tradingCapitalAdjustment = yearProfit[ypIndex];	
		if yearProfit[ypIndex] > 0 then
			tradingCapitalAdjustment = yearProfit[ypIndex] * (1-removePerProfit);
		tradingCapital = tradingCapital + tradingCapitalAdjustment;
		print(d,",",netProfit,",",yearProfit[ypIndex],",",tradingCapitalAdjustment,",",tradingCapital);
		ypIndex +=1;
	end;
end
else
	tradingCapital = initCapital + netProfit;

Capture either the prior years or months net profit

I wanted to test the idea of profit retention on a monthly and yearly basis to see if it made a difference. I also wanted to just use the vanilla version of FF. The use of Arrays may not be necessary, but I didn’t know ahead of time. When you program on the fly, which is also called “ad hoc” programming you create first and then refine later. Many times, the “ad hoc” version turns out to be the best approach but may not be the most efficient. Like writing a book, many times your code needs revisions. When applying a study or strategy that uses dates to a chart, you don’t know exactly when the data starts so you always need to assume you are starting in the middle of a year. If you are storing yearly data into an array, make sure you dimension you array sufficiently. You will need 12X the number of years as the size you need to dimension your array if you want to store monthly data.


//250 element array will contain more than 20 years of monthly data
//You could increase these if you like just to be safe
arrays: yearProfit[250](0),snapShotNetProfit[250](0);
//Remember you dimension you arrray variable first and then
//Pass it a value that you want to initiate all the values
//in the array to equal
vars: ypIndex(0);

Dimension and Initiate Your Arrays

The first thing we need to do is capture the beginning of the year or month. We can do this by using the year and month function. If the current month or year value is not the same as the prior day’s month or year value, then we know we crossed the respective timeline boundary. We are using two arrays, snapShotNetProfit and yearProfit (to save time I use this array to store monthlty values as well, when that option is chosen) and a single array index ypIndex. If we have crossed the time boundary, the first thing we need to do is capture the EasyLanguage function NetProfit’s value. NetProfit keeps track of the cumulative closed out trade profits and losses. Going forward in this description I am going to refer to a yearly reallocation. If it’s the first year, the ypIndex will be zero, and in turn the first year’s profit will be the same as netProfit. We store netProfit in the yearProfit array at the ypIndex location. Since we are in a new year, we take a snapshot of netProfit and store it in the snapShotNetProfit array at the same ypIndex location. You will notice I use the variable prevNetProfit in the code for netProfit. Here is where the devil is in the details. Since we are comparing today’s year value with yesterday’s year value and when they are different, we are already inside the new year, so we need to know yesterday’s netProfit. Before you say it, you can’t pass netProfit a variable for prior values; you know like netProfit(1) or netProfit[1] – this is a function that has no historic values, but you can record the prior day’s value by using our own prevNetProfit variable. Now we need to calculate the tradingCapitalAdjustment. The first thing we do is assign the variable the value held in yearProfit[ypIndex]. We then test the yearProfit[ypIndex] value to see if it is positive. If it is, then we multiply it by (1-removePerProfit). If you want to take 75% of the prior year’s profit off the table, then you would multiply the prior year’s profit by 25%. Let’s say you make $10,000 and you want to remove $7,500, then all you do is multiply $10,000 by 25%. If the prior year’s netProfit is a loss, then this value flows directly through the code to the position sizing calculation (auto deallocation on a losing year). If not, the adjusted profit portion of funds are deallocated in the position sizing equation.

The next time we encounter a new year, then we know this is the second year in our data stream, so we need to subtract last year’s snapshot of netProfit (or prevNetProfit) from the current netProfit. This will give us the change in the yearly net profit. We stuff this information into the yearProfit array. The snapShotNetProfit is stuffed with the current prevNetProfit. ypIndex is incremented every time we encounter a new year. Notice how I increment the ypIndex – it is incremented after all the calculations in the new year. The tradingCapitalAdjustment is then calculated with the latest information.

Here is a table of how the tradingCapital and profit retention adjustment are calculated. A yearly profit adjustment only takes place after a profitable year. A losing year passes without adjustment.

All tests were carried out on the trend friendly crude oil futures with no execution costs from 2006 thru 2/28/2204.

See how money is removed from the allocation model after winning years.

Here are some optimization tests with 75% profit retention on yearly and monthly intervals.

Yearly First-

Yearly retention with no stop loss or break-even levels.

Now Monthly-

Monthly retention with no stop loss or break-even levels.

What if we didn’t reallocate on any specific interval?

Huge drawdowns with very little change in total profit.

Add some trade management into the mix.

Here we optimize a protective stop and a break-even level to see if we can juice the results. All the trade management is on a position basis.

200K with No Reallocating with $14k and $8.5 stop/break-even levels [ranked by Profit Factor]

No position sizing and no reallocation with $5K and $10K stop/break-even levels

200K and monthly reallocating with $7K and $5.5K stop/break-even levels [BEST PROFIT FACTOR]

200K and monthly reallocating with $7K and $8.5K stop/break-even levels [2ND BEST PROFIT FACTOR]

Are we really using our capital in the most efficient manner?

If we retain profit, should we remove some of the loss form the position sizing engine as well. All the tests I performed retained profit from the position size calculations. I let the loss go full bore into the calculation. This is a very risk averse approach. Why don’t I retain 25% of losses and deduct that amount from the yearly loss and feed that into the position sizing engine. This will be less risk averse – let’s see what it does.

Not as good. But I could spend a week working different permutations and optimization sessions.

Are you wondering what Trend Following System I was using as the foundation of this strategy? I used EasyLanguage’s Linear Regression function to create buy and short levels. Here is the very simple code.

Value1 = LinearReg (Close, 60, 1, oLRSlope, oLRAngle, oLRIntercept, oLRValueRaw);

Value2 = oLRSlope;

Value3 = oLRAngle;

Value4 = oLRIntercept;

Value5 = oLRValueRaw;


//Basically I am buying/shorting on the change of the linear regression slope
//Also I have a volatility filter but it really isn't used
If value2 >=0 and value2[1] < 0 and avgTrueRange(30)*bigPointValue < 10000 then 
	buy positionSize contracts next bar at market;
If value2 <=0 and value2[1] > 0 and avgTrueRange(30)*bigPointValue < 10000 then 
	sellShort positionSize contracts next bar at market;

mp = marketPosition;

//I also have incorporated a 3XATR(30) disaster stop
if mp = 1 and c <= entryPrice - 3 * avgTrueRange(30) then sell next bar at market;
if mp = -1 and c >= entryPrice + 3 * avgTrueRange(30) then buyToCover next bar at market

If you want to see some more Trend Following models and their codes in EasyLanguage and TS-18 Python check out my TrendFollowing Guide and Kit.

…

Complete EasyLanguage Systems, EasyLanguage, EasyLanguage equivalent to cool code, EasyLanguage Function, EasyLanguage Snippets, EasyLanguage Tutorial, Free EasyLanguage, MultiCharts, Must Know, Must Know EasyLanguage

How To Test and Optimize Turn of the Month Seasonality

January 25, 2024 George Pruitt Leave a comment

Historical evidence suggests a potential seasonal pattern around the end of the month in the markets.

If you have been involved with the markets for even a short period of time, you have heard about this trade. Buy N days prior to the end of the month and then exit M days after the end of the month. This is a simple test to perform if you have a way to determine the N and the M in the algorithm. You could always buy on the 24th of the month, but the 24th of the month may not equal N days prior to the end of the month.

Simple approach that doesn’t always work – buy the 24th of the month and exit the 5th of the following month.

if dayOfMonth(d) = 24 then buy next bar at open;

if marketPosition = 1 and dayOfMonth(d) = 5 then sell next bar at open;

Before we get into a little better coding of this algorithm, let’s see the numbers. The first graph is trading one contract of the ES futures once a month – no execution fees were applied. The same goes for the US bond futures chart that follows. Before reading further please read this.

CFTC-required risk disclosure for hypothetical results:

Hypothetical performance results have many inherent limitations, some of which are described below. No representation is being made that any account will or is likely to achieve profits or losses similar to those shown. in fact, there are frequently sharp differences between hypothetical performance results and the actual results subsequently achieved by any particular trading program.

One of the limitations of hypothetical performance results is that they are generally prepared with the benefit of hindsight. In addition, hypothetical trading does not involve financial risk, and no hypothetical trading record can completely account for the impact of financial risk in actual trading. For example, the ability to withstand losses or to adhere to a particular trading program in spite of trading losses are material points which can also adversely affect actual trading results. There are numerous other factors related to the markets in general or to the implementation of any specific trading program which cannot be fully accounted for in the preparation of hypothetical performance results and all of which can adversely affect actual trading results.

Buying N days before EOM and Selling M days after EOM

No Pain No Gain

Looking into the maw of draw down and seeing the jagged and long teeth.

Draw down as a percentage of account value.

The bonds had more frequent draw down but not so deep. These teeth can cause a lot of pain.

Well, George what is the N and M?

I should have done M days before and N days after to maintain alphabetic order, but here you go.

ES: N = 6 AND M = 6

US: N =10 AND M = 1

How did you do this?

Some testing platforms have built-in seasonality tools, but, and I could be wrong I didn’t find what I needed in the TradeStation function library. So, I built my own.

A TradingDaysLeftInMonth function had to be created. This function is a broad swipe at attempting to determining this value. It’s not very smart because it doesn’t take HOLIDAYS into consideration. But for a quick analysis it is fine. How does one design such a function? First off, what do we know to help provide information that might be useful? We know how many days are in each month (again this function isn’t smart enough to take into consideration leap years) and we know what day of the week each trading day belongs to. We have this function DayOfWeek(Date) already in EasyLanguage. And we know the DayOfMonth(Date) (built-in too!) With these three tidbits of information, we should be able to come up with a useful function. Not to mention a little programming knowledge. I was working on a Python project when I was thinking of this function, so I decided to prototype it there. No worries, the algorithm can be easily translated to EasyLanguage. And yes, I could have used my concept of a Sandbox to prototype in EasyLanguage as well. Remember a sandbox is a playground where you can quickly test a snippet of code. Using the ONCE keyword, you can quickly throw some generic EasyLanguage together sans trade directives and mate it to a chart and get to the nuts and bolts quickly. I personally like having an indicator and a strategy sandbox. Here is a generic snippet of code where we assume the day of month is the 16th and it is a Monday ( 2 – 1 for Sunday thru 7 for Saturday) and there are 31 days in whatever month.

currentDayOfWeek = 2;
currentDayOfMonth = 16;
loopDOW = currentDayOfWeek;
daysInMonth = 31
#create the calender for the remaining month
tdToEOM=0; #total days to EOM
for j in range(currentDayOfMonth,daysInMonth+1):
    if loopDOW != 1 and loopDOW != 7:
       tdToEOM +=1;
    print(j," ",loopDOW," ",tdToEOM)
    loopDOW +=1;
    if loopDOW > 7: loopDOW = 1; #start back on Monday

Create a synthetic calendar from the current day of month

I just absolutely love the simplicity of Python. When I am prototyping for EasyLanguage, I put a semicolon at the end of each line. Python doesn’t care. Here is the output from this snippet of code.

Cur>Day    DOWDay  DaysLeftAccum.
-----------------------------------
16           2       1  Monday
17           3       2  Tuesday
18           4       3  Wednesday
19           5       4  Thursday
20           6       5  Friday
21           7       5  Saturday
22           1       5  Sunday
23           2       6  Monday
24           3       7  Tuesday
25           4       8  Wednesday
26           5       9  Thursday
27           6      10  Friday
28           7      10  Saturday
28           1      10  Sunday
30           2      11  Monday
31           3      12  Tuesday

On Monday 16th there were 12 Trading Days Left In Month Inclusive

Output of Python Snippet - use in EZLang.

I start out with the current day of the month, 16 and loop through the rest of the days of the month. Whenever I encounter a Sunday (1) or a Saturday (7) I do not increment tdToEOM, else I do increment.

Here is how the function works on a chart. Remember in TradeStation I am placing a market order for the NEXT BAR.

This snippet of code is the heart of the function, but you must make in generic for any day of any month. Here it is in EasyLanguage – you will see the similarity between the Python snippet and its corresponding EasyLanguage.

array: monthDays[12](0);

monthDays[1] = 31;
monthDays[2] = 28;
monthDays[3] = 31;
monthDays[4] = 30;
monthDays[5] = 31;
monthDays[6] = 30;
monthDays[7] = 31;
monthDays[8] = 31;
monthDays[9] = 30;
monthDays[10] = 31;
monthDays[11] = 30;
monthDays[12] = 31;

vars: curDayOfMonth(0),curDayOfWeek(0),loopDOW(0),tdToEOM(0),j(0);

curDayOfWeek = dayOfWeek(d);
curDayOfMonth = dayOfMonth(d);

{Python prototype
tdToEOM=0;
for j in range(currentDayOfMonth,daysInMonth+1):
    if loopDOW != 1 and loopDOW != 7:
       tdToEOM +=1;
    print(j," ",loopDOW," ",tdToEOM)
    loopDOW +=1;
    if loopDOW > 7: loopDOW = 1;
}

loopDOW = curDayOfWeek+1; 
tdToEOM=0;

for j = curDayOfMonth to monthDays[month(d)]
begin
    if loopDOW <> 1 and loopDOW <> 7 then
       tdToEOM +=1; // tdToEOM = tdToEOM + 1;
    loopDOW +=1;
    if loopDOW > 7 then loopDOW = 1;
end;
TradingDaysLeftInMonth = tdToEOM;

EasyLanguage Function : TradingDaysLeftInMonth

I used arrays to store the number of days in each month. You might find a better method. Once I get the day of the month and the day of the week I get to work. EasyLanguage uses a 0 for Sunday so to be compliant with the Python function I add a 1 to it. I then loop from the current day of month through monthDays[month(d)]. Remember month(d) returns the month number [1…12]. A perfect index into my array. That is all there is to it. The code is simple, but the concept requires a little thinking. Okay, now that we have the tools for data mining, let’s do some. I did this by creating the following strategy (the same strategy that create the original equity curves.)

inputs: numDaysBeforeEOM(8),numDaysAfterEOM(10),movingAvgLen(100);
inputs: stopLossAmount(1500),profitTargetAmount(4000);

vars: TDLM(0),TDIM(0);

TDLM = tradingDaysLeftInMonth;
TDIM = tradingDayOfMonth;

if c >= average(c,movingAvgLen) and TDLM = numDaysBeforeEOM then
begin
	buy("Buy B4 EOM") next bar at open;	
end;

if marketPosition = 1 and barsSinceEntry > 3 then
begin
	if TDIM = numDaysAfterEOM then 
	begin
		sell("Sell TDOM") next bar at open;	
	end;
end;
setStopLoss(stopLossAmount);
setProfitTarget(profitTargetAmount);

EasyLanguage function driver in form of Strategy

A complete strategy has trade management and an entry and an exit. In this case, I added an additional feature – a trend detector in the form of a longer-term moving average. Let’s see if we can improve the trading system. Thank goodness for Genetic Optimization. Here is the @ES market.

Smoothed the equity curve – took the big draw down out.

Genetically MODIFIED – Data Mining at its best!

Here are the parameters:

Did not like the moving average. Wide stop and wide profit objective. Days to EOM and after EOM stayed the same.

Bond System:

If you like this type of programming check out my books at Amazon.com. I have books on Python and of course EasyLanguage. I quickly assembled a YouTube video discussing this post here.

Conclusion – there is something here, no doubt. But it can be a risky proposition. It definitely could provide fodder for the basis of a more complete trading system.

George’s Amazon Page