568 lines
21 KiB
MQL5
568 lines
21 KiB
MQL5
|
//+------------------------------------------------------------------+
|
||
|
|
//| AdvancedRegimeDetector.mqh |
|
||
|
|
//| Sophisticated regime detection with ADX/ATR/HHLL classification |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
#property copyright "DualEA Advanced Regime System"
|
||
|
|
#property version "1.00"
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| REGIME TYPES ENUM |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
enum ENUM_REGIME_TYPE
|
||
|
|
{
|
||
|
|
REGIME_TRENDING_UP, // Strong upward trend
|
||
|
|
REGIME_TRENDING_DOWN, // Strong downward trend
|
||
|
|
REGIME_RANGING_LOW, // Low volatility range
|
||
|
|
REGIME_RANGING_HIGH, // High volatility range
|
||
|
|
REGIME_VOLATILE_UP, // Volatile upward movement
|
||
|
|
REGIME_VOLATILE_DOWN, // Volatile downward movement
|
||
|
|
REGIME_CHOPPY, // Choppy/noisy market
|
||
|
|
REGIME_BREAKING_UP, // Breaking out upward
|
||
|
|
REGIME_BREAKING_DOWN, // Breaking out downward
|
||
|
|
REGIME_UNDEFINED // Undefined/transition
|
||
|
|
};
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| REGIME INDICATORS STRUCT |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
struct SRegimeIndicators
|
||
|
|
{
|
||
|
|
double adx_value; // ADX value
|
||
|
|
double adx_plus; // ADX+ value
|
||
|
|
double adx_minus; // ADX- value
|
||
|
|
double atr_value; // ATR value
|
||
|
|
double atr_percentile; // ATR percentile (0-100)
|
||
|
|
double hhll_range; // High-Low range
|
||
|
|
double avg_true_range; // Average true range
|
||
|
|
double volatility_percentile; // Volatility percentile
|
||
|
|
double trend_strength; // Trend strength (0-1)
|
||
|
|
double range_strength; // Range strength (0-1)
|
||
|
|
double breakout_strength; // Breakout strength (0-1)
|
||
|
|
|
||
|
|
SRegimeIndicators() :
|
||
|
|
adx_value(0), adx_plus(0), adx_minus(0), atr_value(0), atr_percentile(0),
|
||
|
|
hhll_range(0), avg_true_range(0), volatility_percentile(0),
|
||
|
|
trend_strength(0), range_strength(0), breakout_strength(0) {}
|
||
|
|
};
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| REGIME RESULT STRUCT |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
struct SRegimeResult
|
||
|
|
{
|
||
|
|
ENUM_REGIME_TYPE current_regime;
|
||
|
|
ENUM_REGIME_TYPE previous_regime;
|
||
|
|
double confidence; // Confidence level (0-1)
|
||
|
|
string description; // Human-readable description
|
||
|
|
datetime timestamp; // Regime timestamp
|
||
|
|
int duration_bars; // Duration in bars
|
||
|
|
SRegimeIndicators indicators; // Supporting indicators
|
||
|
|
|
||
|
|
SRegimeResult() :
|
||
|
|
current_regime(REGIME_UNDEFINED), previous_regime(REGIME_UNDEFINED),
|
||
|
|
confidence(0), duration_bars(0), timestamp(0) {}
|
||
|
|
};
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| ADVANCED REGIME DETECTOR CLASS |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
class CAdvancedRegimeDetector
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
string m_symbol;
|
||
|
|
int m_timeframe;
|
||
|
|
int m_adx_period;
|
||
|
|
int m_atr_period;
|
||
|
|
int m_hhll_period;
|
||
|
|
int m_lookback_bars;
|
||
|
|
|
||
|
|
// Historical data
|
||
|
|
double m_adx_buffer[];
|
||
|
|
double m_atr_buffer[];
|
||
|
|
double m_high_buffer[];
|
||
|
|
double m_low_buffer[];
|
||
|
|
double m_close_buffer[];
|
||
|
|
|
||
|
|
// Thresholds
|
||
|
|
double m_adx_trend_threshold;
|
||
|
|
double m_adx_strong_trend_threshold;
|
||
|
|
double m_atr_high_threshold;
|
||
|
|
double m_atr_low_threshold;
|
||
|
|
double m_volatility_percentile_high;
|
||
|
|
double m_volatility_percentile_low;
|
||
|
|
|
||
|
|
// State tracking
|
||
|
|
SRegimeResult m_last_regime;
|
||
|
|
int m_regime_duration;
|
||
|
|
|
||
|
|
public:
|
||
|
|
CAdvancedRegimeDetector(const string symbol, const int timeframe);
|
||
|
|
~CAdvancedRegimeDetector();
|
||
|
|
|
||
|
|
// Configuration
|
||
|
|
void SetADXPeriod(const int period) { m_adx_period = period; }
|
||
|
|
void SetATRPeriod(const int period) { m_atr_period = period; }
|
||
|
|
void SetHHLLPeriod(const int period) { m_hhll_period = period; }
|
||
|
|
void SetLookbackBars(const int bars) { m_lookback_bars = bars; }
|
||
|
|
void SetADXThresholds(const double trend, const double strong)
|
||
|
|
{
|
||
|
|
m_adx_trend_threshold = trend;
|
||
|
|
m_adx_strong_trend_threshold = strong;
|
||
|
|
}
|
||
|
|
void SetATRThresholds(const double high, const double low)
|
||
|
|
{
|
||
|
|
m_atr_high_threshold = high;
|
||
|
|
m_atr_low_threshold = low;
|
||
|
|
}
|
||
|
|
void SetVolatilityThresholds(const double high, const double low)
|
||
|
|
{
|
||
|
|
m_volatility_percentile_high = high;
|
||
|
|
m_volatility_percentile_low = low;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Main detection methods
|
||
|
|
SRegimeResult DetectCurrentRegime();
|
||
|
|
SRegimeResult GetLastRegime() const { return m_last_regime; }
|
||
|
|
|
||
|
|
// Indicator calculations
|
||
|
|
double CalculateADX(const int shift = 0);
|
||
|
|
double CalculateATR(const int shift = 0);
|
||
|
|
double CalculateHHLLRange(const int shift = 0);
|
||
|
|
double CalculateVolatilityPercentile(const int bars);
|
||
|
|
double CalculateTrendStrength();
|
||
|
|
double CalculateRangeStrength();
|
||
|
|
double CalculateBreakoutStrength();
|
||
|
|
|
||
|
|
// Utility methods
|
||
|
|
string RegimeToString(const ENUM_REGIME_TYPE regime) const;
|
||
|
|
ENUM_REGIME_TYPE DetermineRegime(const SRegimeIndicators& indicators);
|
||
|
|
double CalculateRegimeConfidence(const ENUM_REGIME_TYPE regime, const SRegimeIndicators& indicators);
|
||
|
|
|
||
|
|
private:
|
||
|
|
void UpdatePriceBuffers();
|
||
|
|
void CalculateIndicators(SRegimeIndicators& indicators);
|
||
|
|
bool IsTrending(const SRegimeIndicators& indicators);
|
||
|
|
bool IsRanging(const SRegimeIndicators& indicators);
|
||
|
|
bool IsVolatile(const SRegimeIndicators& indicators);
|
||
|
|
bool IsBreakingOut(const SRegimeIndicators& indicators);
|
||
|
|
bool IsChoppy(const SRegimeIndicators& indicators);
|
||
|
|
};
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CONSTRUCTOR |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CAdvancedRegimeDetector::CAdvancedRegimeDetector(const string symbol, const int timeframe)
|
||
|
|
{
|
||
|
|
m_symbol = symbol;
|
||
|
|
m_timeframe = timeframe;
|
||
|
|
|
||
|
|
// Default parameters
|
||
|
|
m_adx_period = 14;
|
||
|
|
m_atr_period = 14;
|
||
|
|
m_hhll_period = 20;
|
||
|
|
m_lookback_bars = 100;
|
||
|
|
|
||
|
|
// Default thresholds
|
||
|
|
m_adx_trend_threshold = 25.0;
|
||
|
|
m_adx_strong_trend_threshold = 35.0;
|
||
|
|
m_atr_high_threshold = 2.0;
|
||
|
|
m_atr_low_threshold = 0.5;
|
||
|
|
m_volatility_percentile_high = 75.0;
|
||
|
|
m_volatility_percentile_low = 25.0;
|
||
|
|
|
||
|
|
m_regime_duration = 0;
|
||
|
|
m_last_regime.current_regime = REGIME_UNDEFINED;
|
||
|
|
m_last_regime.timestamp = 0;
|
||
|
|
|
||
|
|
ArrayResize(m_adx_buffer, m_lookback_bars);
|
||
|
|
ArrayResize(m_atr_buffer, m_lookback_bars);
|
||
|
|
ArrayResize(m_high_buffer, m_lookback_bars);
|
||
|
|
ArrayResize(m_low_buffer, m_lookback_bars);
|
||
|
|
ArrayResize(m_close_buffer, m_lookback_bars);
|
||
|
|
|
||
|
|
ArrayInitialize(m_adx_buffer, 0);
|
||
|
|
ArrayInitialize(m_atr_buffer, 0);
|
||
|
|
ArrayInitialize(m_high_buffer, 0);
|
||
|
|
ArrayInitialize(m_low_buffer, 0);
|
||
|
|
ArrayInitialize(m_close_buffer, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| DESTRUCTOR |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CAdvancedRegimeDetector::~CAdvancedRegimeDetector()
|
||
|
|
{
|
||
|
|
// Cleanup handled automatically
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| DETECT CURRENT REGIME |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
SRegimeResult CAdvancedRegimeDetector::DetectCurrentRegime()
|
||
|
|
{
|
||
|
|
SRegimeResult result;
|
||
|
|
result.timestamp = TimeCurrent();
|
||
|
|
result.previous_regime = m_last_regime.current_regime;
|
||
|
|
|
||
|
|
// Update price buffers
|
||
|
|
UpdatePriceBuffers();
|
||
|
|
|
||
|
|
// Calculate indicators
|
||
|
|
SRegimeIndicators indicators;
|
||
|
|
CalculateIndicators(indicators);
|
||
|
|
|
||
|
|
// Determine regime
|
||
|
|
result.current_regime = DetermineRegime(indicators);
|
||
|
|
result.confidence = CalculateRegimeConfidence(result.current_regime, indicators);
|
||
|
|
result.description = RegimeToString(result.current_regime);
|
||
|
|
result.indicators = indicators;
|
||
|
|
|
||
|
|
// Update duration
|
||
|
|
if(result.current_regime == result.previous_regime)
|
||
|
|
{
|
||
|
|
m_regime_duration++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_regime_duration = 1;
|
||
|
|
}
|
||
|
|
result.duration_bars = m_regime_duration;
|
||
|
|
|
||
|
|
// Store result
|
||
|
|
m_last_regime = result;
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| UPDATE PRICE BUFFERS |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CAdvancedRegimeDetector::UpdatePriceBuffers()
|
||
|
|
{
|
||
|
|
// Shift arrays
|
||
|
|
for(int i = m_lookback_bars - 1; i > 0; i--)
|
||
|
|
{
|
||
|
|
m_high_buffer[i] = m_high_buffer[i-1];
|
||
|
|
m_low_buffer[i] = m_low_buffer[i-1];
|
||
|
|
m_close_buffer[i] = m_close_buffer[i-1];
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add latest data
|
||
|
|
m_high_buffer[0] = iHigh(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, 0);
|
||
|
|
m_low_buffer[0] = iLow(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, 0);
|
||
|
|
m_close_buffer[0]= iClose(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CALCULATE INDICATORS |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CAdvancedRegimeDetector::CalculateIndicators(SRegimeIndicators& indicators)
|
||
|
|
{
|
||
|
|
// Calculate ADX
|
||
|
|
indicators.adx_value = CalculateADX();
|
||
|
|
{
|
||
|
|
int adx_handle = iADX(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, m_adx_period);
|
||
|
|
if(adx_handle != INVALID_HANDLE)
|
||
|
|
{
|
||
|
|
double plus[1], minus[1];
|
||
|
|
if(CopyBuffer(adx_handle, 1 /*PLUSDI*/, 0, 1, plus) > 0) indicators.adx_plus = plus[0];
|
||
|
|
if(CopyBuffer(adx_handle, 2 /*MINUSDI*/, 0, 1, minus) > 0) indicators.adx_minus = minus[0];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Calculate ATR
|
||
|
|
indicators.atr_value = CalculateATR();
|
||
|
|
indicators.avg_true_range = indicators.atr_value;
|
||
|
|
|
||
|
|
// Calculate HHLL range
|
||
|
|
indicators.hhll_range = CalculateHHLLRange();
|
||
|
|
|
||
|
|
// Calculate percentiles
|
||
|
|
indicators.atr_percentile = CalculateVolatilityPercentile(m_lookback_bars);
|
||
|
|
indicators.volatility_percentile = indicators.atr_percentile;
|
||
|
|
|
||
|
|
// Calculate strengths
|
||
|
|
indicators.trend_strength = CalculateTrendStrength();
|
||
|
|
indicators.range_strength = CalculateRangeStrength();
|
||
|
|
indicators.breakout_strength = CalculateBreakoutStrength();
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CALCULATE ADX |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CAdvancedRegimeDetector::CalculateADX(const int shift)
|
||
|
|
{
|
||
|
|
int handle = iADX(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, m_adx_period);
|
||
|
|
if(handle == INVALID_HANDLE) return 0.0;
|
||
|
|
double buf[1];
|
||
|
|
if(CopyBuffer(handle, 0 /*MAIN*/, shift, 1, buf) <= 0) return 0.0;
|
||
|
|
return buf[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CALCULATE ATR |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CAdvancedRegimeDetector::CalculateATR(const int shift)
|
||
|
|
{
|
||
|
|
int handle = iATR(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, m_atr_period);
|
||
|
|
if(handle == INVALID_HANDLE) return 0.0;
|
||
|
|
double buf[1];
|
||
|
|
if(CopyBuffer(handle, 0, shift, 1, buf) <= 0) return 0.0;
|
||
|
|
return buf[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CALCULATE HHLL RANGE |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CAdvancedRegimeDetector::CalculateHHLLRange(const int shift)
|
||
|
|
{
|
||
|
|
int hi_index = iHighest(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, MODE_HIGH, m_hhll_period, shift);
|
||
|
|
int lo_index = iLowest(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, MODE_LOW, m_hhll_period, shift);
|
||
|
|
double highest = iHigh(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, hi_index);
|
||
|
|
double lowest = iLow(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, lo_index);
|
||
|
|
return highest - lowest;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CALCULATE VOLATILITY PERCENTILE |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CAdvancedRegimeDetector::CalculateVolatilityPercentile(const int bars)
|
||
|
|
{
|
||
|
|
if(bars <= 0) return 50.0;
|
||
|
|
|
||
|
|
double atr_values[];
|
||
|
|
ArrayResize(atr_values, bars);
|
||
|
|
|
||
|
|
for(int i = 0; i < bars; i++)
|
||
|
|
{
|
||
|
|
int h = iATR(m_symbol, (ENUM_TIMEFRAMES)m_timeframe, m_atr_period);
|
||
|
|
if(h == INVALID_HANDLE) { atr_values[i] = 0.0; continue; }
|
||
|
|
double b[1];
|
||
|
|
if(CopyBuffer(h, 0, i, 1, b) <= 0) atr_values[i] = 0.0; else atr_values[i] = b[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
double current_atr = atr_values[0];
|
||
|
|
double percentile = 0;
|
||
|
|
|
||
|
|
for(int i = 0; i < bars; i++)
|
||
|
|
{
|
||
|
|
if(atr_values[i] <= current_atr)
|
||
|
|
percentile++;
|
||
|
|
}
|
||
|
|
|
||
|
|
return (percentile / bars) * 100.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CALCULATE TREND STRENGTH |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CAdvancedRegimeDetector::CalculateTrendStrength()
|
||
|
|
{
|
||
|
|
double adx = CalculateADX();
|
||
|
|
|
||
|
|
// Normalize ADX to 0-1 range
|
||
|
|
if(adx >= m_adx_strong_trend_threshold)
|
||
|
|
return 1.0;
|
||
|
|
else if(adx <= m_adx_trend_threshold)
|
||
|
|
return 0.0;
|
||
|
|
else
|
||
|
|
return (adx - m_adx_trend_threshold) / (m_adx_strong_trend_threshold - m_adx_trend_threshold);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CALCULATE RANGE STRENGTH |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CAdvancedRegimeDetector::CalculateRangeStrength()
|
||
|
|
{
|
||
|
|
double atr_percentile = CalculateVolatilityPercentile(m_lookback_bars);
|
||
|
|
|
||
|
|
// Lower volatility suggests ranging
|
||
|
|
if(atr_percentile <= m_volatility_percentile_low)
|
||
|
|
return 1.0;
|
||
|
|
else if(atr_percentile >= m_volatility_percentile_high)
|
||
|
|
return 0.0;
|
||
|
|
else
|
||
|
|
return 1.0 - ((atr_percentile - m_volatility_percentile_low) /
|
||
|
|
(m_volatility_percentile_high - m_volatility_percentile_low));
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CALCULATE BREAKOUT STRENGTH |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CAdvancedRegimeDetector::CalculateBreakoutStrength()
|
||
|
|
{
|
||
|
|
double atr_percentile = CalculateVolatilityPercentile(m_lookback_bars);
|
||
|
|
double adx = CalculateADX();
|
||
|
|
|
||
|
|
// High volatility + strong trend = breakout
|
||
|
|
double volatility_factor = (atr_percentile - m_volatility_percentile_low) /
|
||
|
|
(m_volatility_percentile_high - m_volatility_percentile_low);
|
||
|
|
|
||
|
|
double trend_factor = CalculateTrendStrength();
|
||
|
|
|
||
|
|
return MathMin(1.0, volatility_factor * trend_factor);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| DETERMINE REGIME |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
ENUM_REGIME_TYPE CAdvancedRegimeDetector::DetermineRegime(const SRegimeIndicators& indicators)
|
||
|
|
{
|
||
|
|
// Check for undefined regime
|
||
|
|
if(indicators.adx_value < 0 || indicators.atr_value <= 0)
|
||
|
|
return REGIME_UNDEFINED;
|
||
|
|
|
||
|
|
// Check for trending conditions
|
||
|
|
bool is_trending = IsTrending(indicators);
|
||
|
|
bool is_ranging = IsRanging(indicators);
|
||
|
|
bool is_volatile = IsVolatile(indicators);
|
||
|
|
bool is_breaking_out = IsBreakingOut(indicators);
|
||
|
|
bool is_choppy = IsChoppy(indicators);
|
||
|
|
|
||
|
|
// Determine regime based on conditions
|
||
|
|
if(is_breaking_out && indicators.breakout_strength > 0.7)
|
||
|
|
{
|
||
|
|
if(indicators.adx_plus > indicators.adx_minus)
|
||
|
|
return REGIME_BREAKING_UP;
|
||
|
|
else
|
||
|
|
return REGIME_BREAKING_DOWN;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(is_trending && indicators.trend_strength > 0.8)
|
||
|
|
{
|
||
|
|
if(indicators.adx_plus > indicators.adx_minus)
|
||
|
|
return REGIME_TRENDING_UP;
|
||
|
|
else
|
||
|
|
return REGIME_TRENDING_DOWN;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(is_volatile && indicators.volatility_percentile > 75)
|
||
|
|
{
|
||
|
|
if(indicators.adx_plus > indicators.adx_minus)
|
||
|
|
return REGIME_VOLATILE_UP;
|
||
|
|
else
|
||
|
|
return REGIME_VOLATILE_DOWN;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(is_ranging && indicators.range_strength > 0.7)
|
||
|
|
{
|
||
|
|
if(indicators.volatility_percentile < 25)
|
||
|
|
return REGIME_RANGING_LOW;
|
||
|
|
else
|
||
|
|
return REGIME_RANGING_HIGH;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(is_choppy)
|
||
|
|
{
|
||
|
|
return REGIME_CHOPPY;
|
||
|
|
}
|
||
|
|
|
||
|
|
return REGIME_UNDEFINED;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CHECK IF TRENDING |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CAdvancedRegimeDetector::IsTrending(const SRegimeIndicators& indicators)
|
||
|
|
{
|
||
|
|
return indicators.adx_value >= m_adx_trend_threshold;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CHECK IF RANGING |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CAdvancedRegimeDetector::IsRanging(const SRegimeIndicators& indicators)
|
||
|
|
{
|
||
|
|
return indicators.adx_value < m_adx_trend_threshold &&
|
||
|
|
indicators.volatility_percentile <= m_volatility_percentile_high;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CHECK IF VOLATILE |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CAdvancedRegimeDetector::IsVolatile(const SRegimeIndicators& indicators)
|
||
|
|
{
|
||
|
|
return indicators.volatility_percentile > m_volatility_percentile_high;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CHECK IF BREAKING OUT |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CAdvancedRegimeDetector::IsBreakingOut(const SRegimeIndicators& indicators)
|
||
|
|
{
|
||
|
|
return indicators.breakout_strength > 0.6 &&
|
||
|
|
indicators.adx_value >= m_adx_strong_trend_threshold;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CHECK IF CHOPPY |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CAdvancedRegimeDetector::IsChoppy(const SRegimeIndicators& indicators)
|
||
|
|
{
|
||
|
|
return indicators.adx_value < m_adx_trend_threshold &&
|
||
|
|
indicators.volatility_percentile > m_volatility_percentile_low &&
|
||
|
|
indicators.volatility_percentile < m_volatility_percentile_high;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| CALCULATE REGIME CONFIDENCE |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CAdvancedRegimeDetector::CalculateRegimeConfidence(const ENUM_REGIME_TYPE regime,
|
||
|
|
const SRegimeIndicators& indicators)
|
||
|
|
{
|
||
|
|
double confidence = 0.0;
|
||
|
|
|
||
|
|
switch(regime)
|
||
|
|
{
|
||
|
|
case REGIME_TRENDING_UP:
|
||
|
|
case REGIME_TRENDING_DOWN:
|
||
|
|
confidence = indicators.trend_strength;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case REGIME_RANGING_LOW:
|
||
|
|
case REGIME_RANGING_HIGH:
|
||
|
|
confidence = indicators.range_strength;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case REGIME_VOLATILE_UP:
|
||
|
|
case REGIME_VOLATILE_DOWN:
|
||
|
|
confidence = indicators.volatility_percentile / 100.0;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case REGIME_BREAKING_UP:
|
||
|
|
case REGIME_BREAKING_DOWN:
|
||
|
|
confidence = indicators.breakout_strength;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case REGIME_CHOPPY:
|
||
|
|
confidence = 0.5; // Medium confidence for choppy
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
confidence = 0.0;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return MathMin(1.0, MathMax(0.0, confidence));
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| REGIME TO STRING |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
string CAdvancedRegimeDetector::RegimeToString(const ENUM_REGIME_TYPE regime) const
|
||
|
|
{
|
||
|
|
switch(regime)
|
||
|
|
{
|
||
|
|
case REGIME_TRENDING_UP: return "TRENDING_UP";
|
||
|
|
case REGIME_TRENDING_DOWN: return "TRENDING_DOWN";
|
||
|
|
case REGIME_RANGING_LOW: return "RANGING_LOW";
|
||
|
|
case REGIME_RANGING_HIGH: return "RANGING_HIGH";
|
||
|
|
case REGIME_VOLATILE_UP: return "VOLATILE_UP";
|
||
|
|
case REGIME_VOLATILE_DOWN: return "VOLATILE_DOWN";
|
||
|
|
case REGIME_CHOPPY: return "CHOPPY";
|
||
|
|
case REGIME_BREAKING_UP: return "BREAKING_UP";
|
||
|
|
case REGIME_BREAKING_DOWN: return "BREAKING_DOWN";
|
||
|
|
case REGIME_UNDEFINED: return "UNDEFINED";
|
||
|
|
default: return "UNKNOWN";
|
||
|
|
}
|
||
|
|
}
|