Currency strength meters and the lag problem

[Amanhasnoname]

Strength meters combine the movements of several pairs into a ranking of which currencies are strong and which are weak. They appeal as an overview and a source of pair selection: buy the strongest against the weakest.

The tools smooth data over a chosen period, and smoothing means lag. By the time a currency appears strongest, much of the move may be done.

Another concern is how they are built. Different formulas produce different rankings, and the results depend on which pairs are included.

Used as a filter, they can steer attention to pairs with real momentum. Used as a trigger, they tend to lead to late entries.

A fair test is recording the pair chosen by the meter, the time, and the result over the next ten minutes, across at least a few hundred cases, with costs included.

A lot of tools claim miracles. A little data shows what they do.

Has a strength meter improved the pair selection, and was the test done properly?

[PTScalper]

Strength meters combine the movements of several pairs into a ranking of which currencies are strong and which are weak. They appeal as an overview and a source of pair selection: buy the strongest against the weakest.

The tools smooth data over a chosen period, and smoothing means lag. By the time a currency appears strongest, much of the move may be done.

Another concern is how they are built. Different formulas produce different rankings, and the results depend on which pairs are included.

Used as a filter, they can steer attention to pairs with real momentum. Used as a trigger, they tend to lead to late entries.

A fair test is recording the pair chosen by the meter, the time, and the result over the next ten minutes, across at least a few hundred cases, with costs included.

A lot of tools claim miracles. A little data shows what they do.

Has a strength meter improved the pair selection, and was the test done properly?

Hi,

thank you for interesting topic.

To answer the two core questions directly from my point of view: no, a currency strength meter on its own has not meaningfully improved edge or pair selection, and the fair test outlined is a solid conceptual starting point, but as described, it is still incomplete and flawed.

Here is an analytical breakdown of why currency strength meters struggle, where the proposed test falls short, and how to rigorously validate one.

[PTScalper]

1. Has a Strength Meter Improved Pair Selection?

In systematic backtesting and live trading, basic currency strength meters rarely provide a standalone statistical edge for entry selection. While appealing visually, they suffer from structural design limitations:

Lag and the "Buying the Top" Fallacy: Most strength meters calculate relative performance using moving averages, ROC (Rate of Change), or RSI across standard 8 major pairs. Because smoothing introduces lag, identifying a currency as "strongest" often occurs at or near the climax of a short-term momentum move (exhaustion), leading directly to buying at resistance or selling at support.

The Basket Calculation Illusion: A meter measuring EUR strength aggregates pairs like EUR/USD, EUR/JPY, EUR/GBP, and EUR/AUD. A single violent impulse in one cross (e.g., a 100-pip Bank of Japan intervention impact on EUR/JPY) artificially inflates the overall EUR strength score across the board, giving a false signal on EUR/USD where no genuine momentum exists.

Filter vs. Trigger Distinction: As noted in your prompt, treating a strength meter as an entry trigger produces negative expectancy once spread, commission, and slippage are factored in. When used strictly as a higher-timeframe directional filter (e.g., assessing H4/D1 currency bias), it can narrow focus to trending pairs, but secondary price action or liquidity context is still required to time the entry.

[PTScalper]

2. Was the Test Done Properly?

The suggested methodology—recording the chosen pair, entry time, and outcome over a 10-minute horizon across several hundred trade instances including transaction costs—is a good empirical baseline.

[PTScalper]

Core Takeaways for Currency Strength Indicators

Beware Spliced Correlation: A strength meter is merely a synthetic reflection of price inputs you can already see on individual charts. It creates no new information.

Raw Price > Indicator Averages: True momentum selection is often better measured using raw rate-of-change, order flow sweeps, or relative volume metrics across correlated pairs rather than smoothed cross-pair averages.

[PTScalper]

3.) Execution Edge:

Any strategy evaluating short-term (10-minute) holding periods lives or dies by transaction costs. Unless the average win strictly exceeds $2 \times \text{spread} + \text{commission}$, the statistical edge will bleed out to broker friction.

[PTScalper]

Building a backtesting framework for a multi-currency strength meter requires handling a major architectural challenge: synchronizing multiple currency pairs simultaneously so that the cross-sectional ranking can be calculated dynamically at every historical bar.

Whether you choose MQL5 (Strategy Tester) or a custom C# event-driven framework, the implementation must account for exact array alignments, dynamic spreads, and execution slippage.

[PTScalper]

Method 1: MQL5 Multi-Symbol Strategy Tester Approach

MQL5 handles historical data well, but the built-in Strategy Tester is traditionally mono-symbol. To test a strength meter across 28 pairs, your Expert Advisor (EA) must run on a "Dummy" chart (or a major pair like EURUSD) and explicitly pull historical data arrays for all other required instruments using CopyRates and CopySpread.

Core Architecture Pattern (MQL5)

Code: Select all

//+------------------------------------------------------------------+
//|                                   CSM_Backtest_Framework.mq5     |
//|                                  Copyright 2026                  |
//|                                                                  |
//+------------------------------------------------------------------+
property copyright "Copyright 2026"
property link      "https://www.mql5.com"
property version   "1.00"

input int    InpLookbackBars = 14;     // Strength calculation period
input double InpMinSpreadPips = 2.0;   // Maximum allowed spread filter

// Array of the 8 major currencies building the 28 pairs
string MajCurrencies[8] = {"USD", "EUR", "GBP", "JPY", "AUD", "CAD", "CHF", "NZD"};
string AllPairs[28]     = {"EURUSD", "GBPUSD", "USDJPY", "AUDUSD", "USDCAD", "USDCHF", "NZDUSD", 
                           "EURGBP", "EURJPY", "EURAUD", "EURCAD", "EURCHF", "EURNZD", 
                           "GBPJPY", "GBPAUD", "GBPCAD", "GBPCHF", "GBPNZD", 
                           "AUDJPY", "AUDCAD", "AUDCHF", "AUDNZD", 
                           "CADJPY", "CADCHF", "CADNZD", 
                           "CHFJPY", "NZDJPY", "NZDCHF"};

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   // Ensure all symbols are available in Market Watch for history loading
   for(int i = 0; i < ArraySize(AllPairs); i++)
   {
      SymbolSelect(AllPairs[i], true);
   }
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   // Check for a new bar to avoid excessive tick calculations
   static datetime last_bar_time = 0;
   datetime current_bar_time = iTime(_Symbol, PERIOD_CURRENT, 0);
   
   if(current_bar_time == last_bar_time) return;
   last_bar_time = current_bar_time;

   // 1. Calculate Currency Strength Ranks
   double currency_scores[8];
   CalculateStrengthScores(InpLookbackBars, currency_scores);

   // 2. Identify Strongest and Weakest Currencies
   int strongest_idx = 0;
   int weakest_idx = 0;
   
   for(int i = 1; i < 8; i++)
   {
      if(currency_scores[i] > currency_scores[strongest_idx]) strongest_idx = i;
      if(currency_scores[i] < currency_scores[weakest_idx]) weakest_idx = i;
   }

   string target_pair;
   ENUM_ORDER_TYPE order_type;
   
   // Resolve pair name and order direction (e.g., Strong vs Weak)
   if(ResolvePairMapping(MajCurrencies[strongest_idx], MajCurrencies[weakest_idx], target_pair, order_type))
   {
      // 3. Check Spread Guardrails on the Target Pair
      double current_spread = SymbolInfoInteger(target_pair, SYMBOL_SPREAD) * 0.1; // convert points to pips (approx)
      if(current_spread > InpMinSpreadPips) return; 

      // 4. Execute Simulation Logic or Open Position
      // (For strict short-term 10-minute tests, track entry time and price locally or manage via market orders)
   }
}

//+------------------------------------------------------------------+
//| Dummy strength scorer placeholder                                |
//+------------------------------------------------------------------+
void CalculateStrengthScores(int bars, double &scores[])
   {
      // Initialize scores array
      ArrayInitialize(scores, 0.0);
      
      // Implement ROC or Moving Average rate-of-change aggregation across AllPairs here...
      // Accumulate score components for each of the 8 currencies based on quote/base position.
   }

//+------------------------------------------------------------------+
//| Helper to match two currencies to a valid broker symbol & side   |
//+------------------------------------------------------------------+
bool ResolvePairMapping(string base, string quote, string &out_pair, ENUM_ORDER_TYPE &out_type)
{
   string direct = base + quote;
   string inverse = quote + base;

   if(SymbolExist(direct))
   {
      out_pair = direct;
      out_type = ORDER_TYPE_BUY; // Buy base, sell quote
      return true;
   }
   else if(SymbolExist(inverse))
   {
      out_pair = inverse;
      out_type = ORDER_TYPE_SELL; // Sell base, buy quote
      return true;
   }
   return false;
}

bool SymbolExist(string name)
{
   for(int i = 0; i < ArraySize(AllPairs); i++)
   {
      if(AllPairs[i] == name) return true;
   }
   return false;
}

[PTScalper]

MQL5 Execution Cost Nuance: In the MT5 Strategy Tester settings panel, you must manually inject realistic variable spreads or use "Every tick based on real ticks" mode. Standard fixed-spread testing will heavily flatter short-term (e.g., 10-minute) strategies because it hides widening spreads during session rollovers or volatile structural events.

[PTScalper]

Method 2: Custom C# Backtesting Framework Architecture

If you prefer a decoupled approach using C# (e.g., loading historical CSV/Parquet tick or M1 data files), you can build an object-oriented backtester that explicitly tracks transaction costs down to the millisecond.

Core C# Class Structure

Code: Select all

using System;
using System.Collections.Generic;
using System.Linq;

public class TickData
{
    public DateTime Timestamp { get; set; }
    public string Symbol { get; set; }
    public decimal Bid { get; set; }
    public decimal Ask { get; set; }
}

public class TradePosition
{
    public string Symbol { get; set; }
    public bool IsBuy { get; set; }
    public DateTime EntryTime { get; set; }
    public decimal EntryPrice { get; set; }
    public decimal SpreadAtEntry { get; set; }
    public decimal Commission { get; set; }
    public DateTime ExitTime { get; set; }
    public decimal ExitPrice { get; set; }
    
    public decimal CalculateNetPnL(decimal lotSize, decimal contractSize)
    {
        decimal rawDiff = IsBuy ? (ExitPrice - EntryPrice) : (EntryPrice - ExitPrice);
        decimal grossPnL = rawDiff * lotSize * contractSize;
        return grossPnL - Commission;
    }
}

public class CurrencyStrengthBacktester
{
    private Dictionary<string, List<TickData>> _historicalData;
    private decimal _commissionPerLot;

    public CurrencyStrengthBacktester(Dictionary<string, List<TickData>> historicalData, decimal commissionPerLot)
    {
        _historicalData = historicalData;
        _commissionPerLot = commissionPerLot;
    }

    public List<TradePosition> RunSimulation(TimeSpan holdingPeriod)
    {
        var trades = new List<TradePosition>();
        
        // Align data timelines across symbols and evaluate bar-by-bar or tick-by-tick
        // For each evaluation timestamp:
        // 1. Calculate currency strength rankings.
        // 2. Select top strongest vs weakest pair.
        // 3. Simulate execution accounting for the Ask price on Buy, Bid price on Sell.
        
        return trades;
    }
}