Weighted Average of Standard Deviations

What Is the Weighted Average of Standard Deviations?

When evaluating Forex Expert Advisors (EAs), a simple average of standard deviations across multiple periods or systems can be dangerously misleading. If one period contains far more trades than another, treating both equally distorts your overall volatility estimate. The Weighted Average of Standard Deviations (also called the pooled standard deviation) solves this by weighting each period's volatility contribution according to its sample size—giving you a far more accurate picture of true risk.

Why a Simple Average Fails

Suppose your EA produced trades across two distinct market regimes. In a quiet consolidation period you recorded 20 trades with a standard deviation of 15 pips. In a high-volatility trending period you recorded 200 trades with a standard deviation of 80 pips. A naive average gives σ = (15 + 80) / 2 = 47.5 pips. But that number is dominated by the small, unrepresentative quiet period—your real risk exposure is far closer to 80 pips because the vast majority of your trade history lived there.

Step-by-Step Worked Example

Let's walk through the calculation with three distinct market periods to see exactly how the weighting changes the result.

5 Practical Applications for EA Traders

MQL5 Implementation

Here's how to calculate the weighted standard deviation across multiple defined periods directly inside MetaTrader 5:

struct PeriodStats
{
   int    trades;     // sample size for this period
   double stdDev;     // standard deviation of returns
};
 
double WeightedStdDev(PeriodStats &periods[], int count)
{
   double sumWeightedVariance = 0.0;
   int    totalTrades         = 0;
   
   for(int i = 0; i < count; i++)
   {
      sumWeightedVariance += (double)periods[i].trades
                             * MathPow(periods[i].stdDev, 2);
      totalTrades         += periods[i].trades;
   }
   
   if(totalTrades == 0) return 0.0;
   return MathSqrt(sumWeightedVariance / totalTrades);
}
 
void OnStart()
{
   // Define three market regime periods
   PeriodStats periods[3];
   
   periods[0].trades = 20;   periods[0].stdDev = 15.0;  // Low vol
   periods[1].trades = 80;   periods[1].stdDev = 45.0;  // Medium vol
   periods[2].trades = 200;  periods[2].stdDev = 80.0;  // High vol
   
   double simpleAvg = (15.0 + 45.0 + 80.0) / 3.0;
   double weightedSD = WeightedStdDev(periods, 3);
   
   Print("Simple average σ  : ", DoubleToString(simpleAvg,  2), " pips");
   Print("Weighted σ (σ_w)  : ", DoubleToString(weightedSD, 2), " pips");
   Print("Difference        : ", DoubleToString(weightedSD - simpleAvg, 2), " pips");
   
   // Interpret risk level
   string riskLabel = "";
   if(weightedSD < 30)       riskLabel = "Low volatility — normal sizing";
   else if(weightedSD < 60)  riskLabel = "Moderate volatility — consider reduced sizing";
   else if(weightedSD < 90)  riskLabel = "High volatility — reduce lot size significantly";
   else                      riskLabel = "Extreme volatility — minimal sizing or pause trading";
   
   Print("Risk assessment: ", riskLabel);
}

Interpreting Your Weighted Standard Deviation

These thresholds will vary by instrument and strategy. Calibrate them against your EA's historical equity curve to identify the σ_w levels at which drawdowns historically escalated.

Practical Steps for Applying This to Your EA

1. Segment your trade history — Split results by time period, market regime, or currency pair to create distinct groups. Common splits: monthly, quarterly, by session (London/New York/Asia), or by detected volatility regime (ATR-based).
2. Calculate σᵢ per group — Compute the standard deviation of trade returns (in pips or R-multiples) within each segment. Ensure you use population standard deviation (÷ n) rather than sample standard deviation (÷ n−1) for consistency across groups.
3. Record nᵢ per group — Note the number of trades in each segment; this becomes your weighting factor. Groups with fewer than 10 trades should be flagged as low-confidence and handled with caution.
4. Apply the formula — Compute Σ(nᵢ · σᵢ²) / Σnᵢ, then take the square root to get σ_w.
5. Use σ_w in your risk model — Feed this value into position sizing, stop-loss width, and drawdown projections instead of any simple average or single-period estimate.
6. Monitor rolling σ_w — Recalculate every 20–50 new trades to detect volatility regime shifts early, before they register as drawdown on your equity curve.
7. Set σ_w alert thresholds — Define your personal upper limit. When rolling σ_w crosses it, trigger an automated lot-size reduction or send a MetaTrader alert to review manually.
8. Document and review quarterly — Keep a log of σ_w readings over time alongside your equity curve. This gives you a volatility-adjusted lens to explain drawdown periods and identify when conditions suit your EA best.

How σ_w Compares to Other Volatility Measures

EA traders have several volatility tools available, and each answers a different question. Understanding when to use σ_w versus the alternatives prevents both under- and over-estimating risk.

Applying σ_w to R-Multiple Distributions

Pip-based standard deviations are instrument-dependent — a σ_w of 60 pips means very different things on USDJPY versus EURUSD. A more transferable approach is to work in R-multiples: expressing each trade's outcome as a multiple of your initial risk (1R = 1× the amount risked on that trade). R-multiples let you compare EAs across instruments, account sizes, and time periods on a level playing field.

A well-behaved EA should have a σ_w(R) close to 1.0–2.0. Here's what different ranges signal:

Rolling Window σ_w: Monitoring Volatility in Real Time

A static σ_w calculated over your entire trade history tells you about the past. To manage risk prospectively, you need a rolling calculation that updates with every new trade. The idea is to divide your trade history into consecutive non-overlapping windows of equal size, compute σ for each window, then pool those standard deviations using the weighted formula.

The MQL5 implementation below maintains a circular buffer of the last WINDOW_SIZE trade profits, computes standard deviation per window, and outputs a rolling σ_w that updates every time a trade closes:

#define WINDOW_SIZE  50     // trades per rolling window
#define MAX_WINDOWS  10     // how many windows to pool
 
double g_tradeBuffer[WINDOW_SIZE * MAX_WINDOWS];  // circular buffer
int    g_bufferIndex = 0;
int    g_totalTrades = 0;
 
// Call this after every trade closes, passing the R-multiple result
void UpdateRollingWeightedSD(double rMultiple)
{
   g_tradeBuffer[g_bufferIndex % (WINDOW_SIZE * MAX_WINDOWS)] = rMultiple;
   g_bufferIndex++;
   g_totalTrades++;
   
   if(g_totalTrades < WINDOW_SIZE) return;  // not enough data yet
   
   int    completedWindows = MathMin(g_totalTrades / WINDOW_SIZE, MAX_WINDOWS);
   double sumWeightedVar   = 0.0;
   int    totalUsed        = 0;
   
   for(int w = 0; w < completedWindows; w++)
   {
      // Gather trades for this window
      int    startIdx = w * WINDOW_SIZE;
      double sum      = 0.0;
      
      for(int t = 0; t < WINDOW_SIZE; t++)
         sum += g_tradeBuffer[startIdx + t];
      
      double mean = sum / WINDOW_SIZE;
      double variance = 0.0;
      
      for(int t = 0; t < WINDOW_SIZE; t++)
      {
         double diff = g_tradeBuffer[startIdx + t] - mean;
         variance += diff * diff;
      }
      variance /= WINDOW_SIZE;  // population variance
      
      sumWeightedVar += WINDOW_SIZE * variance;
      totalUsed      += WINDOW_SIZE;
   }
   
   double rollingWeightedSD = MathSqrt(sumWeightedVar / totalUsed);
   
   Print("Rolling σ_w (R-multiple): ", DoubleToString(rollingWeightedSD, 3),
         " | Windows pooled: ", completedWindows,
         " | Total trades: ", g_totalTrades);
   
   // Trigger alert if volatility exceeds threshold
   double alertThreshold = 2.5;
   if(rollingWeightedSD > alertThreshold)
   {
      Alert("⚠ Elevated volatility detected! σ_w = ",
            DoubleToString(rollingWeightedSD, 2),
            " — consider reducing lot size.");
   }
}

Hook UpdateRollingWeightedSD() into your EA's OnTrade() or post-close handler, passing the closed trade's R-multiple. The function automatically pools the last MAX_WINDOWS complete windows and fires a MetaTrader alert the moment σ_w exceeds your defined threshold.

Using σ_w to Build a More Honest Sharpe Ratio

The standard Sharpe ratio divides average return by standard deviation. When your EA has operated across multiple market regimes or been tested across multiple walk-forward windows, the standard deviation in the denominator should be σ_w rather than a single-period SD — otherwise you're dividing by a number that doesn't accurately represent the risk your account actually experienced.

The same logic extends to the Sortino ratio, which replaces σ with downside deviation (only counting losing trades in the variance calculation). Simply apply the weighted pooling formula to downside deviations instead of total standard deviations, and you get a weighted Sortino that is equally robust across regimes.

5 Common Mistakes When Using Weighted Standard Deviations

Even traders who know the formula fall into these traps. Avoid them to ensure your σ_w calculations are genuinely informative rather than just statistically sophisticated-looking noise.

Quick-Reference Cheat Sheet

Bookmark this summary for fast reference when reviewing EA backtests or live trade logs.