Mean Reversion EA Strategies

Markets oscillate around averages. Mean reversion EAs profit when price stretches too far and snaps back.

Understanding Mean Reversion

The Core Principle:

Prices tend to return to their average over time. When price moves significantly above or below average, there's a statistical tendency for it to revert.

When It Works:

✅ Ranging markets ✅ Pairs/assets with strong mean reversion characteristics ✅ After extreme moves ✅ Low-volatility environments

When It Fails:

❌ Trending markets ❌ During fundamental shifts ❌ High-impact news events ❌ Regime changes

Bollinger Band Mean Reversion

Classic BB Strategy:

class CBollingerMeanReversion {
private:
    int m_period;
    double m_deviation;
    int m_handle;
    double m_upper[], m_middle[], m_lower[];
    
public:
    CBollingerMeanReversion(int period = 20, double deviation = 2.0) {
        m_period = period;
        m_deviation = deviation;
        m_handle = iBands(_Symbol, PERIOD_CURRENT, m_period, 0, m_deviation, PRICE_CLOSE);
    }
    
    int CheckSignal() {
        CopyBuffer(m_handle, 0, 0, 3, m_middle);  // Middle band
        CopyBuffer(m_handle, 1, 0, 3, m_upper);   // Upper band
        CopyBuffer(m_handle, 2, 0, 3, m_lower);   // Lower band
        
        double close = iClose(_Symbol, PERIOD_CURRENT, 1);
        double prev_close = iClose(_Symbol, PERIOD_CURRENT, 2);
        
        // Buy signal: Price touched lower band and reverting
        if(prev_close <= m_lower[2] && close > m_lower[1]) {
            if(HasReversalCandle(true)) {
                return 1;  // Buy signal
            }
        }
        
        // Sell signal: Price touched upper band and reverting
        if(prev_close >= m_upper[2] && close < m_upper[1]) {
            if(HasReversalCandle(false)) {
                return -1;  // Sell signal
            }
        }
        
        return 0;
    }
    
    bool HasReversalCandle(bool bullish) {
        MqlRates rates[];
        CopyRates(_Symbol, PERIOD_CURRENT, 1, 1, rates);
        
        double body = rates[0].close - rates[0].open;
        
        if(bullish && body > 0) return true;   // Bullish candle
        if(!bullish && body < 0) return true;  // Bearish candle
        
        return false;
    }
    
    double GetTargetPrice() {
        return m_middle[0];  // Target middle band
    }
    
    double GetBandWidth() {
        return (m_upper[0] - m_lower[0]) / m_middle[0];
    }
};

Band Width Filter:

bool IsBandWidthSuitable(double min_width, double max_width) {
    double width = bb_strategy.GetBandWidth();
    
    // Too narrow = squeeze, expect breakout
    if(width < min_width) return false;
    
    // Too wide = trending market
    if(width > max_width) return false;
    
    return true;
}

RSI Mean Reversion

RSI Extremes Strategy:

class CRSIMeanReversion {
private:
    int m_period;
    double m_oversold;
    double m_overbought;
    int m_handle;
    double m_rsi[];
    
public:
    CRSIMeanReversion(int period = 14, double oversold = 30, double overbought = 70) {
        m_period = period;
        m_oversold = oversold;
        m_overbought = overbought;
        m_handle = iRSI(_Symbol, PERIOD_CURRENT, m_period, PRICE_CLOSE);
    }
    
    int CheckSignal() {
        CopyBuffer(m_handle, 0, 0, 5, m_rsi);
        
        // Buy: RSI crosses above oversold
        if(m_rsi[2] < m_oversold && m_rsi[1] > m_oversold) {
            return 1;
        }
        
        // Sell: RSI crosses below overbought
        if(m_rsi[2] > m_overbought && m_rsi[1] < m_overbought) {
            return -1;
        }
        
        return 0;
    }
    
    double GetRSI() {
        CopyBuffer(m_handle, 0, 0, 1, m_rsi);
        return m_rsi[0];
    }
};

RSI Divergence Confirmation:

class CRSIDivergence {
public:
    bool HasBullishDivergence(int lookback = 20) {
        // Find recent price low
        int price_low_idx = FindLowestLow(lookback);
        int prev_low_idx = FindPreviousLow(price_low_idx, lookback);
        
        if(prev_low_idx < 0) return false;
        
        // Compare RSI at these lows
        double rsi_current = GetRSI(price_low_idx);
        double rsi_prev = GetRSI(prev_low_idx);
        
        double price_current = iLow(_Symbol, PERIOD_CURRENT, price_low_idx);
        double price_prev = iLow(_Symbol, PERIOD_CURRENT, prev_low_idx);
        
        // Price lower low, RSI higher low = bullish divergence
        return (price_current < price_prev && rsi_current > rsi_prev);
    }
    
    bool HasBearishDivergence(int lookback = 20) {
        // Similar logic for bearish
        // Price higher high, RSI lower high
        // ...
        return false;
    }
};

Statistical Mean Reversion

Z-Score Approach:

class CZScoreMeanReversion {
private:
    int m_period;
    double m_entry_zscore;
    double m_exit_zscore;
    
public:
    CZScoreMeanReversion(int period = 50, double entry = 2.0, double exit = 0.5) {
        m_period = period;
        m_entry_zscore = entry;
        m_exit_zscore = exit;
    }
    
    double CalculateZScore() {
        double prices[];
        ArrayResize(prices, m_period);
        
        for(int i = 0; i < m_period; i++) {
            prices[i] = iClose(_Symbol, PERIOD_CURRENT, i);
        }
        
        double mean = ArrayAverage(prices);
        double std_dev = ArrayStdDev(prices);
        double current = iClose(_Symbol, PERIOD_CURRENT, 0);
        
        return (current - mean) / std_dev;
    }
    
    int CheckSignal() {
        double zscore = CalculateZScore();
        
        if(zscore < -m_entry_zscore) return 1;   // Buy
        if(zscore > m_entry_zscore) return -1;   // Sell
        return 0;
    }
    
    bool ShouldExit(int position_type) {
        double zscore = CalculateZScore();
        
        if(position_type == 1 && zscore > -m_exit_zscore) return true;
        if(position_type == -1 && zscore < m_exit_zscore) return true;
        return false;
    }
};

Need mean reversion EAs? Contact us for development.