Fixed Contract Position Sizing

The fixed-share method is a non-risk-based method. In this case we simply buy the same number of contracts (1) for each signal. I use this technique all the time when developing a strategy. But it's probably not the best way to trade something live.

Contracts = 1

Percent Risk Position Sizing

The percent-risk method is a strategy grounded in risk management. In this approach, we allocate a fixed percentage of our equity—2% in this example—to risk on each trading signal. The choice of 2% is guided by a widely accepted principle in trading that suggests risking anywhere from 0.5% to 2% of your account balance on any single trade. This strategy aims to mitigate the impact of a series of losses, preventing them from significantly damaging your trading account. We then use this predetermined risk percentage to calculate the specific dollar amount you're willing to risk on an individual trade.

Example:

Contracts  = (2% of Account Equity) / ( Stop Loss Per Contract)
Contracts  = (2% * $100,000)/ $500
Contracts = $2,000 / $500
Contracts = 4

In the example provided, we have the methodology to calculate the number of contracts to purchase while maintaining a consistent risk level of 2% of the account size per trade. As mentioned, the stop-loss value for the 'Better Breakout' strategy adjusts based on recent market volatility, as detailed in the original article.

This adaptive approach means that if market volatility increases, our stop-loss threshold will widen. Consequently, to adhere to our 2% risk per trade guideline, we might find ourselves buying fewer contracts. Conversely, in periods of reduced volatility, our stop-loss tightens, allowing us to purchase more contracts without breaching the 2% risk rule.

The essence of this strategy is that we never risk more than 2% of our account on a single trade. This flexibility enables us to adjust the number of contracts traded in response to the volatility of the market, effectively normalizing our risk exposure relative to market conditions.

But what implications does this have for our trading outcomes?

Performance Comparison

In our analysis, we observed an increase in profits while maintaining the same number of trades (almost, there is one extra trade), without escalating our maximum intraday drawdown. We also increased every other metric!. 

This is a clear win. More profit. Identical risk. 

It's important to note that in our Percent Risk model, we are not reinvesting profits. We started trading with an account balance of $100,000 which remains constant for the purpose of calculating position sizes.

Why adopt this approach?

The goal was to evaluate the impact of scaling trades based on market volatility and to compare its performance with that of the Fixed Model. Incorporating profits into our calculations would undoubtedly enhance our returns further. However, I preferred to avoid complicating the analysis with additional variables. This decision was made to provide a clearer comparison and to focus solely on the influence of the position sizing model.

Pitfalls To Avoid

Don't Using Position Sizing To Improve A Poor System

First, let’s tackle a common misconception: thinking position sizing can turn a mediocre system into a winner.

Here’s the truth – position sizing isn’t a magic fix. If your trading system doesn’t have a solid foundation, even the best position sizing approach won’t make it profitable in the long run.

Imagine trying to fix a car with no engine by just repainting it; it might look better, but it’s still not going anywhere. You should always start with a positive expectancy system, meaning it’s capable of generating returns based on the market behavior it was designed to exploit.

Think of position sizing as the tool that can amplify or protect your returns, not create them from scratch. So, before diving into advanced sizing techniques, ensure your system is already well-tuned and thoroughly backtested. Only then can you expect position sizing to help elevate your results.

Don’t Risk Too Much Per Trade

Now, here’s a mistake that every beginner should be wary of risking too much per trade. It’s easy to think that a higher risk per trade means faster growth, but the opposite is true – the more you risk, the faster you can blow up your account.

In professional trading, a common rule is to keep risk per trade around 1-2% of your account. Why? Because this allows you to survive the inevitable losing streaks. Even the best trading systems will experience losses, sometimes back-to-back.

If you’re risking 5%, 10%, or more on a single trade, it won’t take long for a few bad trades to wipe out a significant portion of your capital. Here’s the bottom line: keeping your risk per trade at around 2% or lower gives you the breathing room to recover from losses and make adjustments if needed. It’s all about protecting your account so you can stay in the game for the long haul.

Remember, in trading, slow and steady does win the race.

Conclusion

Alright, let’s recap the main points.

We started with the concept of position sizing and why it’s essential for traders who want consistent, long-term results. We saw how adjusting trade size based on a percent-risk approach – rather than a fixed contract method – can help align your trades with market conditions, providing flexibility and stability in a volatile environment.

We also dug into the two common pitfalls to avoid: first, don’t rely on position sizing to make up for a weak system. Build a solid foundation with a proven strategy, and then let position sizing enhance it. Second, keep your risk per trade at a reasonable level, around 2%, to avoid those devastating losses that can sideline even the most promising traders.

Key takeaway? Strategic position sizing is a powerful tool when used with a robust trading system and disciplined risk management. It’s about managing your exposure, protecting your capital, and allowing your account to grow consistently.

Good luck with your trading.

The Logic Behind the Better Breakout Strategy

Now, let's explore how Murray's strategy can help us improve a typical breakout system.

Using Yesterday's Price Action

Instead of relying on the traditional opening range, we'll use yesterday's price action to set our breakout levels. Let's consider yesterday's bar, which includes:

• Open
• High
• Low
• Close

We will use this information to build our breakout levels. Specifically, we'll calculate offsets based on the difference between yesterday's close and its high or low. The larger of these two values is averaged over three days to create a dynamic breakout range.

Calculating the Offsets

Here's how the process works:

Here's how the process works:

1. Calculate the High Offset:
   High Offset=High−Close
2. Calculate the Low Offset:
   Low Offset=Close−Low

These calculations are straightforward. We're essentially measuring the distance from the close to the high and the close to the low.

3. Determine the Maximum Offset:
   • Take the larger of the two offsets.
   • For instance, if the close is near the high, the high offset will be small, and the low offset will be larger.
   • Store the larger value as the Max Offset.
4. Compute the Three-Day Average:
   • Calculate the max offset for each of the last three days.
   • Compute the average of these three values.
   • Store this in a variable called Max Offset Average.

This approach gives us a more adaptive breakout level that reflects recent market conditions. It's less dependent on the arbitrary opening price and more aligned with current volatility. As market conditions change, our offset adapts accordingly.

The Logic Behind the Adaptation

By accounting for significant price movements from the previous day—both the highs and lows relative to the close—we create a breakout strategy that's responsive to the market's recent behavior. Smoothing out anomalies by averaging over three days ensures that our breakout levels aren't overly influenced by a single day's extreme movement.

Implementing the Strategy in EasyLanguage

Now, let's delve into how to implement the Better Breakout strategy using EasyLanguage in TradeStation. Don't worry if you're new to EasyLanguage; I'll break down each part of the code so it's easy to understand. Remember, mastering EasyLanguage is a crucial skill for becoming a successful algorithmic trader.

Code Breakdown

Let's go through the code step by step to understand how each part contributes to the strategy.

Inputs

• CloseTime(1500): This sets the time (in military format) when we want to close all positions. Here, it's set to 3:00 PM (1500 hours).
• Lookback(40): This determines the number of periods (in this case, days) for calculating the momentum indicator

Variables

• LastBar(0): Will store the time of the last bar before the close time.
• StopLoss$(0): The calculated dollar amount for the stop loss.
• vMomentum(0, Data2): The momentum indicator based on the daily chart (Data2).
• LowOffset(0, Data2) and HighOffset(0, Data2): Variables to store the offsets from the close to the low and high of the previous day.
• MaxOffset(0, Data2): The maximum of the two offsets.
• MaxOffsetAvg(0, Data2): The three-day average of the maximum offset, rounded to the nearest valid price increment.

Calculate Last Bar Time

• Purpose: Determines the time of the last bar before CloseTime.
• CalcTime(CloseTime, -BarInterval): Calculates the time by subtracting the bar interval from the close time. This ensures we don't enter new trades too close to the market close.

Calculating the Offsets

• LowOffset: The absolute value of the difference between yesterday's close and low.
• HighOffset: The absolute value of the difference between yesterday's close and high.
• Data Reference: Data2 refers to the daily data series we've added to our chart. This allows us to access daily high, low, and close prices while trading on a 5-minute chart (Data1).

Determining the Maximum Offset and Average

• MaxOffset: Selects the larger of the two offsets for each day.
• Average(MaxOffset, 3): Calculates the average of the maximum offsets over the last three days.
• Round2Fraction(...): Rounds the average to the nearest valid price increment (tick size), ensuring our calculations align with the market's price increments.

Calculating the Dynamic Stop Loss

• Purpose: Sets a dynamic stop loss based on recent market volatility.
• MaxOffsetAvg / 2: We take half of the average maximum offset to determine a reasonable stop distance.
• BigPointValue: A built-in variable representing the dollar value of a full point move in the contract (e.g., $50 for the ES futures).
• StopLoss$: The stop loss value in dollars, adjusted to market increments.

Calculating the Momentum Filter

• Purpose: Measures market momentum to filter trades.
• Close of Data2: The closing price from the daily data series.
• Average(Close of Data2, Lookback): The 40-day simple moving average of the close.
• vMomentum: When this value is negative, it indicates that the current price is below the 40-day moving average, suggesting a potential buying opportunity in a pullback.

Entry Conditions

• (vMomentum < 0): Ensures we're only entering trades when the momentum indicator is negative (price below the moving average).
• (EntriesToday(Date) = 0): Limits us to one trade per day.
• (Time < LastBar): Prevents new entries too close to the market close.
• Buy("LE") 1 Contract Next Bar at Close of Data2 + MaxOffsetAvg Stop;:
  • Action: Places a stop order to buy one contract.
  • Price Level: At yesterday's close plus the average maximum offset.
  • Order Name: "LE" (Long Entry).

Exit Conditions

• (Time >= LastBar): Checks if we've reached the time to close positions.
• Sell("EOD") Next Bar at Market;:
  • Action: Sells the position at the market price on the next bar.
  • Order Name: "EOD" (End of Day)

Setting the Stop Loss

• Purpose: Implements the stop loss calculated earlier.
• Dynamic Stop Loss: Because StopLoss$ is based on recent volatility, it adapts to changing market conditions.

By understanding each component of the code, you can see how the Better Breakout strategy uses recent price action and market momentum to determine entry and exit points. The use of dynamic calculations makes the strategy adaptive to changing market conditions, which is crucial for long-term success in algorithmic trading.

If you're new to EasyLanguage, I highly recommend taking the time to learn it. The best way to do that is to have me teach you in my System Development Master Class.  Being able to code and test your own strategies is an invaluable skill that can significantly enhance your trading performance.

Setting Up the Chart in TradeStation

To implement this strategy in TradeStation:

Chart Settings:

• Session Times: 8:30 AM to 3:00 PM Central Time.
• Time Frame: 5-minute chart.
• Slippage and Commissions: $30 deducted per round trip.
• Data Stream:
  • Data1: 5-minute chart (trading timeframe).
  • Data2: Daily chart (for calculations).

Trading Rules:

• Long Only: The strategy is designed for long entries.
• One Trade Per Day: Ensures risk management and prevents overtrading.
• Close All Trades at End of Day: All positions are closed at the specified close time.

Performance Analysis

The equity curve shows a steady upward trend since 2012, indicating consistent performance. While there has been some choppiness in recent times, the strategy has maintained its profitability

Key Performance Metrics:

• Total Net Profit: Approximately $35,000.
• Average Trade Profit: $181 (including slippage and commissions).
• Total Trades: 191.

Annual Returns Breakdown:

• Profitable in most years since 2012.
• Notable exceptions in 2013 and potentially 2024.

Trying the Strategy on Different Markets

One of the great aspects of algorithmic trading is the ability to test strategies on different markets. Let's see how the Better Breakout strategy performs on the NASDAQ futures (NQ).

A New Market and New Chart Setting

In an effort to explore the robustness and adaptability of the Better Breakout strategy, I decided to apply it to the NASDAQ futures (NQ) market. The NASDAQ futures often exhibit higher volatility and different trading dynamics compared to the S&P E-Mini Futures (ES), which can potentially enhance the strategy's performance.

Next I adjusting Data2 to use a 1,440-minute chart (equivalent to a daily chart), we can test the strategy on the NASDAQ futures.

The 1,440-minute chart provides more accurate pricing information because the closing price represents the actual last traded price, rather than the settlement price used in daily bars. Settlement prices can introduce inaccuracies due to adjustments made at the end of the trading day, which can affect real-time trading strategies. By using the last traded price, we eliminate issues with changing settlement prices, leading to more precise entry and exit signals.

Using a 1,440-minute chart leads to more accurate backtesting results. It removes discrepancies between daily Open, High, Low, and Close (OHLC) prices and minute bar OHLC prices that can significantly impact backtested strategy performance. 

Improved Performance Metrics:

• Total Net Profit: Approximately $60,000.
• Average Trade Profit: $308.
• Total Trades: 193.

The equity curve for NQ shows an even more impressive upward trend, with a new equity high as recent as August 2024

Experimenting with the Momentum Filter

In the original Better Breakout strategy code, we included a momentum filter to improve the quality of our trade signals. This filter is designed to ensure that we only enter trades when certain momentum conditions are met, potentially increasing the efficiency and profitability of the strategy.

I also experimented with removing the momentum filter to see its impact.

Without Momentum Filter:

• Total Net Profit: Approximately $67,800.
• Average Trade Profit: $108.
• Total Trades: 627.
• Profit Factor: 1.63.
• Equity Curve: More volatile with a larger number of trades and lower efficiency.

With Momentum Filter:

• Total Net Profit: Approximately $60,000.
• Average Trade Profit: $308.
• Total Trades: 193.
• Profit Factor: 1.88.
• Equity Curve: Smooth upward trend with fewer trades and higher efficiency.

By only allowing trades when the price is below the 40-day moving average, the filter reduces the number of trades. It helps us focus on higher-probability setups where the market may be poised for a rebound after a pullback.

This illustrates the importance of testing different ideas. Removing the momentum filter increased the number of trades and total profit but reduced efficiency. Depending on your trading goals, you might prefer one setup over the other.

Avoiding Rookie Mistakes

When experimenting with algorithmic trading, keep these common pitfalls in mind:

1. Not Trying Different Markets:
   • Don't limit yourself to a single market. Testing on similar markets can yield better results, as we saw when switching from ES to NQ.
2. Not Trying Different Time Frames:
   • Experiment with different time frames, both for your trading chart and data inputs. Small changes can lead to significant differences in performance.

Conclusion

In this article, we've explored the Better Breakout strategy, a robust and adaptive approach to intraday breakout trading that has stood the test of time since its inception in 2012.

The Better Breakout strategy continues to demonstrate its effectiveness in today's markets, proving to be a reliable and adaptable approach for algorithmic traders. Its strength lies in its simplicity and the use of dynamic calculations that adjust to changing market conditions. Whether you're a novice trader or an experienced professional, this strategy offers a solid foundation upon which you can build and customize your own trading system.

By understanding the underlying logic and experimenting with different time frames, and filters—you can tailor the strategy to fit your trading style and objectives. I think the Better Breakout only works well for the stock index markets, but it's worth testing other markets. 

Final Thoughts

Algorithmic trading is a journey of continuous learning and adaptation. The Better Breakout strategy serves as an excellent starting point, encouraging you to delve deeper into the mechanics of trading systems and the nuances of market behavior. As you apply and modify this strategy, you'll gain valuable insights and develop the skills necessary to become a successful algorithmic trader.

Remember, the key to success lies in diligent testing, thoughtful analysis, and a willingness to experiment. Don't hesitate to explore different markets, adjust parameters, and incorporate new ideas. The more you engage with the strategy, the more proficient you'll become in crafting systems that align with your goals.

The Five Key Benefits of Breakout Trading Strategies

Now that we understand what breakout strategies are, let's explore the key benefits they offer to enhance your trading performance:

1. Reduced Market Exposure

Breakout strategies are ideal for day trading, allowing you to enter and exit positions within the same day. This approach minimizes the risk of overnight gaps and unexpected news events that can cause significant price swings when the market is closed. By focusing on intraday movements, you limit your exposure to unpredictable events, making it a safer strategy for many traders.

2. Adaptability

Another significant advantage is their adaptability. Breakout strategies can be adjusted to suit current market conditions, and many have built-in parameters that automatically adapt to market volatility. This flexibility makes them robust across different market environments, which is essential for consistent performance.

3. A Proven Track Record

Breakout strategies have been around for decades—and for good reason: they work. Tested and refined in countless market conditions, they boast a proven track record of success. Building on this solid foundation gives you confidence, knowing you're not starting from scratch but leveraging strategies that have stood the test of time.

4. Scalability

These strategies aren't limited to just one market. They can be applied across multiple markets—stocks, futures, forex, or even cryptocurrency—and various timeframes. This versatility allows you to diversify your portfolio, spread risk, and capture opportunities in different asset classes. The fact that breakout strategies work across different markets and timeframes underscores their effectiveness—they simply work.

5. Ideal for Beginners

Finally, breakout strategies are excellent for beginners. If you're a new trader—not yet making money consistently—why reinvent the wheel? Breakout trading is a smart choice, providing a straightforward and effective approach. I always recommend that both new and seasoned traders consider incorporating breakout strategies into their trading arsenal.

Implementing Breakout Strategies with EasyLanguage

Now that we've explored the benefits, let's look at how to implement a breakout strategy using TradeStation and EasyLanguage.

20-Day Price Channel on NASDAQ Futures Chart

In TradeStation, we're examining the daily chart of the NASDAQ futures. I've applied a simple indicator—a 20-day price channel:

• The green line represents the 20-day highest high.

• The red line represents the 20-day lowest low.

We're looking for a breakout when the price closes above this 20-day high. When this happens, we initiate a long position, aiming to catch a momentum trade and capture some profit. The red line signifies our exit—we hold the position until the price closes below the 20-day low.

Writing the EasyLanguage Code

Here's how to implement this strategy in EasyLanguage:

Inputs:
breakout(20);
Variables:
hiBreakout(0),
loBreakout(0);

hiBreakout = Highest(High, breakout)[1];
loBreakout = Lowest(Low, breakout)[1];

If Close > hiBreakout Then
   Buy Next Bar at Market;
If Close < loBreakout Then
   Sell Next Bar at Market;

Breaking Down the Code:

Inputs: We define the breakout range (breakout) as 20 days.

Variables: We calculate the highest high (hiBreakout) and the lowest low (loBreakout) over the breakout range.

• hiBreakout = Highest(High, breakout)[1]; tells TradeStation to look at the highest high starting from the previous bar ([1]) over the past 20 days.
• loBreakout = Lowest(Low, breakout)[1]; does the same for the lowest low.

Trading Logic:

• Buy Signal: We buy when the closing price is greater than the high breakout.
• Sell Signal: We sell when the closing price is less than the low breakout.

Applying the Strategy

When we apply this strategy to our chart:

• Entry Point: The strategy buys when the price breaks above the upper channel (green line).
• Exit Point: It sells when the price closes below the lower channel (red line).
• This simple approach effectively captures trending markets.

Evaluating Performance

The performance report reveals:

• An equity curve trending upward.
• A profit of $192,000 over 58 trades.
• An average profit of over $3,300 per trade.
• A maximum intraday drawdown of about $83,000.

We don't have a lot of trades for this strategy, which could be a problem. However, the concept looks good as we have a rising equity curve. Of course, the NASDAQ market has a long side bias so building long trading systems is really easy to do. 

Let's try a different timeframe to generate more trades.

Testing Different Timeframes

You don't have to limit yourself to daily charts. Let's switch to a 120-minute chart, where each bar represents two hours of trading.

Applying the same strategy:

• Increased Trades: Shorter timeframes result in more trading opportunities.
• Consistent Results: The strategy continues to capture significant trends.
• Equity Curve: Shows consistent growth, even though individual trades might yield smaller profits.

Looking at the equity curve, it's far from perfect, but we have an upwards rising equity curve that is clearly making money. Keep in mind we don't have any filters, stops or exits on this strategy. It's just the starting point of a breakout strategy. Furthermore, it's is non-optimized and it's really easy to build.

Enhancing the Strategy

What would I do to improve the strategy? Well, I've talked about that in other articles but in short, I would test different filters. Maybe a regime filter so the strategy is only taking  long trades in a strong bull market. I might try an ADX for filtering on volatility. I would also, of course, put in stops, and test profit targets.

The point of this article isn't to show you a complete system, but is to show you that just a few lines of easy language code can produce a breakout strategy that looks really good without profits, targets, without stop losses, or without adding any other filters. The skeleton of this strategy is solid—that's the true power of breakout strategies.

• Adding Profit Targets: Set specific profit goals for your trades.
• Implementing Regime Filters: Use filters to only take trades in favorable market conditions, such as a strong bull market.
• Applying Volatility Filters: Incorporate indicators like ADX to filter based on market volatility.
• Setting Stop Losses: Always recommended to manage risk effectively.

Common Rookie Mistakes to Avoid

While breakout strategies offer many advantages, it's important to steer clear of common pitfalls:

Mistake #1: Reinventing the Wheel

Many traders attempt to create exotic trading systems from scratch. If you're not consistently making money yet, stick to what works. Simplify your approach. Breakout systems are easy to understand, easy to code, and are proven models used by many successful traders.

Mistake #2: Overcomplicating Your Strategy

The strength of a breakout strategy lies in its simplicity and clarity. Simple strategies are often more adaptable and continue to work well into the future. Stick to straightforward rules and avoid overcomplicating your strategy. By doing so, you'll enhance adaptability and long-term effectiveness.

By avoiding these common mistakes, you'll be well on your way to trading success.

Key Takeaways

• Breakout Strategies Are Momentum-Based: They capitalize on upward market movements by buying into strength.
• Reduced Risk: Day trading with breakout strategies minimizes exposure to overnight market risks.
• Adaptable and Scalable: These strategies can be tailored to different market conditions and applied across various markets and timeframes.
• Proven Effectiveness: Decades of use have shown that breakout strategies consistently work.
• Ideal for All Levels: Suitable for both beginners and seasoned traders looking for a robust trading approach.

What The Video Version of This Article

Final Thoughts

Today we've explored the powerful benefits of breakout trading strategies—from reducing risk to offering scalability across markets. Breakout systems work, and I highly recommend considering them before exploring more complex trading methods.

Here are some related articles to breakout trading

• Opening Range Breakout Trading Strategy Design and Implementation
• The Anatomy Of A Breakout Automated Trading Strategy: Markets, Timeframes, Exits, Strategies
• The Anatomy Of A Breakout Automated Trading Strategy: The Components
• The Anatomy Of A Breakout Automated Trading Strategy: The Concept

That's all for now.

Testing the "Buy in November, Sell in May" Strategy

Test Parameters and Assumptions

Strong Seasonality Trade (November-May) With Filters

Strong Seasonality Trade (November-May) With Filters

Utilizing the MACD filter and comparing it to our baseline system, we can see we don't make as much more as the simple moving average filter, however, we increased our risk adjusted return with a NP vs DD of 3.8. So, if drawdown is your concern and not just pure profit it looks the MACD filter is slightly better.

RSI Filter

For our final filter I will try the RSI indicator with its default loopback period of 14. Again, like the MACD calculation, I want price moving in our direction so I want the RSI calculation to be above zero when opening a position and below zero when closing a position.

Strong Seasonality Trade (November-May) With Filters

Weak Seasonality Trade (May-November) With Filters

Explanation

1. Inputs: These are user-defined parameters for the colors used in the plots.

2. Variables: These store the high, low, and close prices for the current and prior periods, as well as the trend direction and counters.

3. End of Period Check: The script checks if the current day is the week's or month's end and updates the trend accordingly.

4. High and Low Updates: The script continuously updates the highest and lowest prices observed throughout the period.

5. Plotting: The script plots the trend direction based on the evaluated conditions.

Below is an image of a PaintBar indicator using the Price-Time filter. Bearish trends are coloring the price bars red. Bullish trends are in green.

Testing the Price-Time Filter

I transformed the indicator into a simple trading strategy to evaluate the effectiveness of the Price-Time Filtering technique. This strategy will buy when the filter indicates an uptrend and sell short during a downtrend. By doing this, we can gauge how well the Price-Time Filter can identify and capitalize on trending markets.

Here's the plan:

1. Strategy Setup:
   • We'll use the EasyLanguage code for the Price-Time Filtering indicator, which we've already discussed.
   • The strategy will enter a long position when the filter signals an uptrend and enter a short position when it signals a downtrend.
   • We'll be using the Weekly version of the Price-Time Filter.
2. Testing Parameters:
   • We'll apply this strategy to several futures markets that represent a good basket of unique markets I trade, including:
     • Soybeans (S)
     • Euro Currency Futures (EC)
     • Crude Oil (CL)
     • S&P 500 (ES)
     • Gold (GC)
   • The testing will use daily bars to capture significant price movements over time.
   • We'll be using historical dates from 2000-2023. 
   • Slippage and commission will not be taken into account for this analysis.
3. Performance Metrics:
   • We'll evaluate the strategies based on key performance metrics such as net profit, maximum drawdown, and net profit vs. maximum drawdown ratio.
   • Additionally, we'll analyze the average duration of trades to understand how long trends typically last.

By converting the Price-Time Filter into a simple strategy and testing it across different futures markets, I aim to provide you with actionable insights into its effectiveness. This practical approach will help you determine if this method can enhance your trading systems and improve your overall trading success. In the following sections, we'll dive into the results of these tests and draw meaningful conclusions to guide your trading decisions.

Price-Time Results

Now it's time to test this indicator on our markets. Below is a table with the results of apply the Price-Time strategy.

Some markets yield higher net profits than others which is expected. Soybeans and Gold do not perform well, whereas Crude Oil performs the best.

I couldn't help but notice that the Price-Time filter serves as a momentum or trend indicator. Thus, the markets with higher net profit are likely markets that have some trending characterisitic.

What if we were to invert the trading logic? We'll explore that in the next section.

Inverted Price-Time Results

In this case we're going to do the opposite of the original rules. That is, when we get a long signal, we're going to sell short. Why? We want to test the mean reversion characteristic of the market. We would expect to see results that are opposite of above. 

We can see that soybeans and gold do much better while the other market moves into negative territory. This tells me that Soybeans and Gold have mean reverting characteristics while the other markets have more trending characteristics. At least based on this indicator and this indicators hold times. We'll look at hold times in the final table. below.

Let's now create a table with the best results for each market.

Price-Time Best Results

In this table we're going to select the best performing side (Long, Short, or Both) and we'll select the best performing trading style (Trend Following or Mean Reversion)

The weakest market is the Euro Currency Futures. The Price-Time filter does not hold some potential when using the mean reversion version of the indicator.  

The Crude Oil market does best in terms of net profit while talking both  long and short trades, with our filter acting as a trend-following indicator. See the image below for example trades. Click on the image for a larger version.

The remaining markets (Soybeans, S&P 500, Gold) all do well on the long side, with our filter acting as a mean reverting indicator.

What have we learned?

We have discovered which trading style (mean reversion or trend following) may work well for each market and which side of the market we should trade (long, short, or both).

This can be valuable information! We now have some critical information if we wish to start building trading systems on the daily timeframes for these markets.

Remember, depending on the market, the average holding time for these trades is between 29 days (GC) and 47 days (ES). So, the characteristics we're measuring in this study must unfold over several weeks.

How could you use this indicator?

As stated earlier, the Price-Time filter is not meant to generate trading signals. We used it to perform our market study this way, but it's better as a filter. 

For example, you might use this indicator on the ES market to activate your trading model and start looking for long trades. 

I did not explore the monthly signals in this study. However, the code can be modified to use the monthly closing price to produce an even longer-term filter, which presents a promising avenue for future studies. You will find that code in the original article, requiring a subscription to Technical Analysis For Stocks & Commodities magazine. I recommend the publication highly.

Lastly, if you trade intraday strategies, use this filter on a daily chart to filter which direction you should be trading on your 60-minute chart. This is another idea worth testing.

@GC Market Results

For the gold market, we're taking both long a short trades. However, the long side does appear stronger. This market appears to be the best performing with the Gap Momentum indicator. 

@CL Market Results

The crude oil market is also taking both long and short trades. The first thing I noticed was moving to the out-of-sample did very poorly. Virtually no net profit and huge drawdown.

Summary Results of the Gap Momentum

Keep in mind these are not trading systems! This is a market study to test the potential value of using a Gap Momentum indicator in my trading. 

Overall, I'm not overly impressed with the results, but I will add it to my toolbox as it shows some promise.

Practical Application for Traders

How might you use Gap Momentum?

Understanding the theoretical foundation and implementation of the Gap Momentum strategy is just the beginning. To truly harness its potential, it is crucial to explore practical applications that can be seamlessly integrated into your trading routine. 

The Gap Momentum could be used as a filter for existing strategies. For example, when the gap ratio is climbing, this would be seen as a time to take long trades. If it's falling, this is a time to go short to halt trading. Below are more detailed examples.

Intraday Trading: You could use the Gap Momentum strategy to identify a bias in the market and focus on intraday price movements. If the Gap Momentum is rising, you look for intraday-long opportunities.

Swing Trading: For those who prefer holding positions for several days, the Gap Momentum strategy might help identify short-term trends and potential reversals, providing entry and exit signals based on accumulated gap data.

Risk Management: The strategy can be integrated into a broader framework. With gap momentum signals, traders can set more informed stop-loss levels and manage position sizes to reduce exposure during volatile market conditions.

Supplementing Technical Analysis: Gap Momentum can be used alongside other technical indicators to confirm signals. For example, traders might use it to validate signals from moving averages, RSI, or MACD, enhancing overall decision-making.

Volatility Trading: Traders can use the strategy to take advantage of periods of high volatility, where gaps are more prevalent. By focusing on markets and times when gaps are common, they can exploit these opportunities for potential profits.

Key Takeaways

In this article, we delved into the gap momentum trading. Here are the key takeaways:

1. Understanding Gap Momentum:
   • Gap momentum trading leverages the differences between today's opening price and yesterday's closing price to gauge market momentum.
   • The strategy draws inspiration from J. Welles Wilder and Joseph Granville’s On-Balance Volume (OBV) method, incorporating their insights into a modern trading approach.
2. Calculating Gap Momentum:
   • Positive and negative gaps are accumulated over a specified period to calculate a gap ratio.
   • This gap ratio, when smoothed with a moving average, forms the gap momentum indicator used for generating trading signals.
3. Implementing the Strategy:
   • We provided a detailed EasyLanguage script to calculate the gap momentum indicator and generate buy/sell signals.
   • The strategy involves defining inputs and variables, calculating gaps, computing the gap ratio, smoothing the indicator, and implementing trading logic based on the signal.
4. Testing and Results:
   • The strategy was tested on various futures markets, including the E-mini S&P 500 (@ES), Gold (@GC), and Crude Oil (@CL).
   • Optimization of input parameters was conducted to evaluate performance, and results were analyzed for both in-sample and out-of-sample data.
5. Practical Applications:
   • The Gap Momentum strategy might act as a primary single for a trading system. Other stops, target and exits will need to be explored.
   • The Gap Momentum indicator may act as a filter for strategies locating potential bias (long/short) in a given market. This how I plan on using the Gap Momentum indicator in my own trading.

By integrating the Gap Momentum strategy into your trading routine, you can potentially enhance your ability to filter the over all market bias (long/short) allowing you to generate better trading signals.

I plan on adding Gap Momentum as part of my testing process. In particular I'm looking at using it as a Regime Filter.

As always, continuous testing is required.

The inefficient way:

if c > c[1] and c[1] > c[2] and c[2] > c[3] then
buy somewhere tomorrow

value1 = patternTests - 1;

if(value1 > 0) then
begin

if(mod(value1,2) = 1) then patternBitChanger[0] = 1;
value2 = value1 - patternBitChanger[0] * 1;

if(value2 >= 8) then begin
patternBitChanger[3] = 1;
value2 = value2 - 8;
end;

if(value2 >= 4) then begin
patternBitChanger[2] = 1;
value2 = value2 - 4;
end;
if(value2 = 2) then patternBitChanger[1] = 1;
end;

Do you remember binary based systems where 0 – off and 1 – on? If you don’t remember its OK. Here is a quick review for everyone.

0 0 0 0 pattern = 0
0 0 0 1 pattern = 1
0 0 1 0 pattern = 2
0 1 0 0 pattern = 4
1 0 0 0 pattern = 8

Each 1 or 0 is a placeholder and its placeholder is a bit than can either be on or off. The leftmost bit is 1’s place. The next bit is the 2’s place. The next bit is the 4’s place. And finally the rightmost bit is the 8’s place. So if we plug in 1 1 1 1 we get (8 + 4 + 2 + 1) = 15. If we start counting at 0 [ 0 0 0 0 ] then we can represent 16 distinct patterns with our four bits. Following?

So using this bit scheme and TradeStation’s optimizer we can run 16 different patterns sequentially. Now how do we get the bit pattern scheme to relate to the last four day’s close to close relationships. This is where the eloquence continues [if I have to say so myself]. EasyLanguage has a library of powerful string functions. One of those is the ability to concatenate or add a string to a string.

Let’s pretend we are the computer and we are optimizing thru 16 different runs. Let’s call the first run [0 run]. In our tests 1’s will be represented by “+” and 0’s by “-“. Using our 4 bit scheme how to we represent the number 0? Zero means no bits are on so 0 = [0 0 0 0]. If we translate our bits to a string where 1’s are “+” and 0’s are “-” then we get “- – – -“]. Right? If a “+” represents an up close and “-” represents a down close then the string “- – – -” would indicate four straight down closes.

Run 0 = 0 0 0 0 = ” – – – – ” – four straight closes down
Run 1 = 0 0 0 1 = ” – – – + ” – three straight closes down followed by 1 up close
Run 2 = 0 0 1 0 = ” – – + – ” – two straight closes down, one up close, one down close
Run 3 = 0 0 1 1 = ” – – + + ” – two straight closes down, two straight closes up
…
…
…
Run 15= 1 1 1 1 = ” + + + + ” – four straight closes up

Following this scheme we can easily check out 16 different 4 day patterns. Let’s see what pattern is the most prolific on the long side. What do you guess – maybe after 4 consecutive down closes?

Simply buying the next bar’s open and exiting two days later, let’s see which pattern is king. Here is the pattern and its profit/loss:

Well it seems they were mostly winners but you shouldn’t buy after ” + + + + “ or "+ + + -". Pattern ” – – – +” was the best followed by ” + – – – “.

Oh yeah this was tested in the ES over the past five years so we are probably witnessing a bullish bias. Let’s see if we sell using the same patterns.

Well the bullish bias is definitely evident. The best 4 day pattern to sell the next bar is to wait for 4 consecutive up closes or 3 consecutive up closes followed by 1 down close.

Is there anything to this pattern recognition? I think it can be used to filter trades and that’s about it. We tested a four day pattern for illustration purposes only but that might be too many. A two day pattern might work better. Please check this out and let me know.

Here is the program in its entirety:

input: patternTests(14),orbAmount(0.20),LorS(1),holdDays(0),atrAvgLen(10);

var: patternTest(""),patternString(""),tempString("");
var: iCnt(0),jCnt(0);
array: patternBitChanger[4](0);

{written by George Pruitt -- copyright 2006 by George Pruitt
This will test a 4 day pattern based on the open to close
relationship. A plus represents a close greater than its
open, whereas a minus represents a close less than its open.
The default pattern is set to pattern 14 +++- (1110 binary).
You can optimize the different patterns by optimizing the
patternTests input from 1 to 16 and the orbAmount from .01 to
whatever you like. Same goes for the hold days, but in this
case you optimize start at zero. The LorS input can be
optimized from 1 to 2 with 1 being buy and 2 being sellshort.}

patternString = "";
patternTest = "";

patternBitChanger[0] = 0;
patternBitChanger[1] = 0;
patternBitChanger[2] = 0;
patternBitChanger[3] = 0;

value1 = patternTests - 1;

if(value1 > 0) then
begin

if(mod(value1,2) = 1) then patternBitChanger[0] = 1;
value2 = value1 - patternBitChanger[0] * 1;

if(value2 >= 8) then begin
patternBitChanger[3] = 1;
value2 = value2 - 8;
end;

if(value2 >= 4) then begin
patternBitChanger[2] = 1;
value2 = value2 - 4;
end;
if(value2 = 2) then patternBitChanger[1] = 1;
end;

patternString = "";

for iCnt = 3 downto 0 begin
if(patternBitChanger[iCnt] = 1) then
begin
patternTest = patternTest + "+";
end
else
begin
patternTest = patternTest + "-";
end;
end;

for iCnt = 3 downto 0
begin
if(close[iCnt]> close[iCnt+1]) then
begin
patternString = patternString + "+";
end
else
begin
patternString = patternString + "-";

end;
end;

if(barNumber = 1) then print(elDateToString(date)," pattern ",patternTest," ",patternTests-1);
if(patternString = patternTest) then begin

// print(date," ",patternString," ",patternTest); //uncomment this and you can print out the pattern
// if(LorS = 2) then SellShort("PatternSell") next bar at open of tomorrow - avgTrueRange(atrAvgLen) * orbAmount stop;
// if(LorS = 1) then buy("PatternBuy") next bar at open of tomorrow + avgTrueRange(atrAvgLen) * orbAmount stop;

if(LorS = 2) then SellShort("PatternSell") next bar at open;
if(LorS = 1) then buy("PatternBuy") next bar at open;

end;

if(holdDays = 0 ) then setExitonClose;
if(holdDays > 0) then
begin
if(barsSinceEntry = holdDays and LorS = 2) then BuyToCover("xbarLExit") next bar at open;
if(barsSinceEntry = holdDays and LorS = 1) then Sell("xbarSExit") next bar at open;
end;

-- George Pruitt from GeorgePruitt.com.

The total number of contracts for a full position will be 10. I initiated the purchase of 4 contracts because dividing 10 over three entries is not a viable option when working with contracts. Can't buy a fraction of a contract!

Let's look at the results of our two simulations. One performing an all-in approach vs our scale-in technqiue.

I would have to say the results are underwhelming. It's true that the Max Drawdown and Net Profit fell. That was expected, but the risk-adjusted return (NP vs DD) also fell. I would like to see this value increase, not fall.

In essence, we're generating less profit with only a marginal improvement in the drawdown. This serves as a valuable lesson in testing ideas. What may seem promising in theory, may not always yield the expected results in practice. This learning experience underscores the dynamic and unpredictable nature of trading strategies. 

Below is an example of the all-in (left side) take a trade. The scale-in (right side) is taking the same trade with three entries.

I will test the same two strategies with a 200-bar regime filter added. I'll only take trades when the price is above this simple moving average.

 By focusing our trades during a bull market, the scale-in version does what is intended. That is, we see an improvement in the risk-adjusted return. We go from a 4.7 to a 5.0 in the net profit vs. drawdown metric. It's not too impressive, but it's a positive change.

Conclusion: The Importance of Testing Scaling In Strategies

Throughout this article, we have explored scaling into positions as a technique for algorithmic traders using TradeStation and EasyLanguage. We have discussed the potential benefits, such as managing risk and optimizing entry prices. We have also provided examples of implementing scaling-in strategies using EasyLanguage code and shared tips for customizing your approach.

However, this exploration's most critical takeaway is the importance of testing your scaling-in strategies before deploying them in live trading. Using the RSI(2) strategy on the @ES.D market, the example we provided demonstrates that what may seem like a promising idea in theory may not always yield the expected results in practice.
In our initial test, we found that scaling into positions led to lower net profit and only a marginal improvement in drawdown, resulting in a decreased risk-adjusted return. This outcome highlights that not all scaling-in strategies will be effective in every market condition or with every trading system.

However, adding a simple 200-bar regime filter to focus our trades during a bull market showed a slight improvement in the risk-adjusted return. This finding underscores the importance of testing and refining your scaling-in strategy to suit your specific trading system and market conditions.

As algorithmic traders, it is crucial to approach scaling-in with a scientific mindset. Thorough backtesting and forward-testing of your strategies are essential to ensure they align with your trading objectives and risk management rules. It is also necessary to regularly review and optimize your scaling-in approach based on changes in your trading system's performance and market conditions.

Remember, the goal of scaling in is to improve your trading performance, not to add unnecessary complexity or risk to your system. By diligently testing and refining your strategies, you can determine whether scaling in is viable for your specific trading style and market conditions.

In conclusion, scaling into positions is a powerful tool for algorithmic traders using TradeStation and EasyLanguage. However, its effectiveness relies heavily on thorough testing, customization, and continuous optimization. By embracing the importance of testing and adapting your strategies to suit your unique trading environment, you can harness the potential benefits of scaling in and working towards achieving consistent, risk-adjusted returns.

The code I used for this study is available for download. See below.

What we have here is not a trading system. This strategy code is just a simple price pattern-based entry and exit. This is a Key Idea and the start of a potential trading system. We will test this Key Idea on different markets and timeframes to see how it performs. I want to know what market or timeframes this Key idea is viable on. Doing so will give me a starting point for building a final trading system.

Testing Across Different Markets & Timeframes

I will use Tradesq to test this momentum code across all available futures markets and time frames. Tradesq is an online tool that will allow you to test your code and many popular futures markets across eight intraday timeframes. You can read more about Tradesq in the article, "How I Trade Like A Hedge Fund."

Futures markets tested include AD, BD, BO, BP, C, CC, CD, CL, CT, DX, EMD, ES, EU, FV, GC, GF, HE, HG, HO, JPY, KC, KW, LB, LE, MW, NG, NQ, OJ, PA, PL, RB, RR, RTY, S, SB, SF, SI, SM, TY, US, W, XG, YM.

The timeframes tested include the following:

• Daily
• 1,440-minute
• 600-minute
• 360-minute
• 240-minute
• 180-minute
• 120-minute
• 60-minute

I had Tradesq vary the rlookback between 2-20 in steps of one and mlookback between 25-100 in steps of 5. 

I performed two tests with Tradesq. The first was to look at the daily results and then look at the intraday results. 

Interpreting The Results

When Tradesq has completed all backtests, it generates a results table. This table lists the markets and the number of edges. 

What is an "edge?" An edge is a successful run that's passed filter requirements. Remember, we tested different lookback periods. 

When a particular run passes the filter, this is called an "edge." The higher edges mean more backtests in that specific category passed the filter. So, many edges show that more backtest produced passing results. For example, the different input values (our lookback period) had a passing performance. 

When a particular run passes the filter, this is called an "edge." The higher edges mean more backtests in that specific category passed the filter. So, many edges show that more backtest produced passing results.

The filter applied to the backtest required that a backtest must...

• Minimum number of trades 50
• Minimum PnL: $0
• Minimum R2: .50
• Minimum NP vs. DD: 1.0

Remember, this is a market study, not a complete trading system. It's a market study. We're not looking for great numbers; thus, the filter is not overly restrictive. 

Best Performing Markets on Daily Timeframe

I took the results from Tradesq and loaded them into a spreadsheet to find the best-performing markets. 

Best Performing Markets On Intraday Timeframes

I took the results from Tradesq and loaded them into a spreadsheet to find the best-performing markets. 

The top-performing markets on the daily timeframe are

1.  Bitcoin (BTC)
2. Etherium (ETH)
3. Lean Hogs (LH)
4. Soybean Oil (BO)
5. Soybean Meal (SM)

We see the crypto markets rising to the top. I'm not too keen on trading these on a daily bar as those markets don't have a lot of history thus, they are generating too few trades.

We also have Lean Hogs making an appearance again. Because lean hogs appear on both the intraday and daily results, this may be an excellent market to trade this strategy. I'm not overly familiar with the other markets, BO and SM.

What's Next?

We covered just the first step in creating a trading system. We used tradesq to help us locate potential markets to look into. Next is to test the momentum key idea using my development process. My process is called the Profit Lab Method and consists of 10 steps. I teach this method as part of System Development Master Class. 

1. Test various filters
2. Test exits
3. Validate the strategy
4. Attempt to incorporate into a portfolio

I would start with Lean Hogs on a daily bar and then explore Lean Hogs on a 240-minute bar. 

If you want to work exclusively with micro contracts, look at the RTY & ES markets. Keep in mind just because we don't see other index markets like NQ or YM rising to the top, that we can't make a strategy for those markets. The Tradesq results are just great places to start.

What Else Can You Test?

Remember, we're testing both long and short trades. You could separate these. Build a version of this that only goes long. Then build another version that only goes short. This will allow you to have a unique lookback period for each. You could then use Tradesq to test all markets and time frames while only taking long trades. Then short trades only. Kevin Davey prefers not to do this, but it might be worth looking into.

Conclusion

In conclusion, Kevin Davey tested a momentum-based trading system using John Rosenstock's concept of entering trades after a retracement against the trend. The system used two momentum calculations to determine the overall market trend and identify pullbacks for entry points. The trading idea was tested across various futures markets and time frames using the Tradesq tool, and the results showed several promising markets. The next step would be to test various filters, exits, and stops to create a final trading system.