| //+------------------------------------------------------------------+
|
| //| CorrelationManager.mqh |
|
| //| FR-05: Correlation Exposure Caps Management |
|
| //+------------------------------------------------------------------+
|
| #property copyright "DualEA"
|
| #property version "1.00"
|
|
|
| //+------------------------------------------------------------------+
|
| //| Correlation exposure management and filtering |
|
| //+------------------------------------------------------------------+
|
| class CCorrelationManager
|
| {
|
| private:
|
| string m_symbol;
|
| ENUM_TIMEFRAMES m_timeframe;
|
|
|
| // Configuration
|
| bool m_enabled;
|
| double m_max_correlation;
|
| int m_lookback_days;
|
| int m_min_periods;
|
|
|
| // Correlation cache
|
| struct CorrelationData
|
| {
|
| string symbol_pair;
|
| double correlation;
|
| datetime last_update;
|
| };
|
| CorrelationData m_correlation_cache[];
|
|
|
| public:
|
| CCorrelationManager(const string symbol, const ENUM_TIMEFRAMES timeframe) :
|
| m_symbol(symbol), m_timeframe(timeframe), m_enabled(false),
|
| m_max_correlation(0.7), m_lookback_days(30), m_min_periods(20) {}
|
|
|
| // Configuration
|
| void SetEnabled(const bool enabled) { m_enabled = enabled; }
|
| void SetMaxCorrelation(const double max_corr) { m_max_correlation = max_corr; }
|
| void SetLookbackDays(const int days) { m_lookback_days = days; }
|
| void SetMinPeriods(const int periods) { m_min_periods = periods; }
|
|
|
| // Calculate correlation between two symbols
|
| double CalculateCorrelation(const string symbol1, const string symbol2, const int periods)
|
| {
|
| if(symbol1 == symbol2) return 1.0;
|
|
|
| double prices1[], prices2[];
|
| ArrayResize(prices1, periods);
|
| ArrayResize(prices2, periods);
|
|
|
| // Get price data for both symbols
|
| int copied1 = CopyClose(symbol1, m_timeframe, 0, periods, prices1);
|
| int copied2 = CopyClose(symbol2, m_timeframe, 0, periods, prices2);
|
|
|
| if(copied1 != periods || copied2 != periods)
|
| return 0.0; // Unable to calculate
|
|
|
| // Calculate returns
|
| double returns1[], returns2[];
|
| ArrayResize(returns1, periods - 1);
|
| ArrayResize(returns2, periods - 1);
|
|
|
| for(int i = 1; i < periods; i++)
|
| {
|
| returns1[i-1] = (prices1[i] - prices1[i-1]) / prices1[i-1];
|
| returns2[i-1] = (prices2[i] - prices2[i-1]) / prices2[i-1];
|
| }
|
|
|
| // Calculate correlation coefficient
|
| double sum1 = 0, sum2 = 0, sum1_sq = 0, sum2_sq = 0, sum_prod = 0;
|
| int n = periods - 1;
|
|
|
| for(int i = 0; i < n; i++)
|
| {
|
| sum1 += returns1[i];
|
| sum2 += returns2[i];
|
| sum1_sq += returns1[i] * returns1[i];
|
| sum2_sq += returns2[i] * returns2[i];
|
| sum_prod += returns1[i] * returns2[i];
|
| }
|
|
|
| double mean1 = sum1 / n;
|
| double mean2 = sum2 / n;
|
|
|
| double numerator = sum_prod - n * mean1 * mean2;
|
| double denominator = MathSqrt((sum1_sq - n * mean1 * mean1) * (sum2_sq - n * mean2 * mean2));
|
|
|
| if(denominator == 0.0) return 0.0;
|
|
|
| return numerator / denominator;
|
| }
|
|
|
| // Get correlation from cache or calculate if needed
|
| double GetCorrelation(const string other_symbol, bool force_recalc = false)
|
| {
|
| if(!m_enabled) return 0.0;
|
|
|
| string pair_key = m_symbol + "|" + other_symbol;
|
| datetime current_time = TimeCurrent();
|
|
|
| // Check cache first
|
| if(!force_recalc)
|
| {
|
| for(int i = 0; i < ArraySize(m_correlation_cache); i++)
|
| {
|
| if(m_correlation_cache[i].symbol_pair == pair_key)
|
| {
|
| // Use cached value if less than 1 hour old
|
| if(current_time - m_correlation_cache[i].last_update < 3600)
|
| {
|
| return m_correlation_cache[i].correlation;
|
| }
|
| break;
|
| }
|
| }
|
| }
|
|
|
| // Calculate new correlation
|
| int periods = m_lookback_days * 24; // Assuming H1 timeframe, adjust as needed
|
| if(m_timeframe == PERIOD_M1) periods *= 60;
|
| else if(m_timeframe == PERIOD_M5) periods *= 12;
|
| else if(m_timeframe == PERIOD_M15) periods *= 4;
|
| else if(m_timeframe == PERIOD_M30) periods *= 2;
|
| else if(m_timeframe == PERIOD_D1) periods = m_lookback_days;
|
|
|
| periods = MathMax(periods, m_min_periods);
|
|
|
| double correlation = CalculateCorrelation(m_symbol, other_symbol, periods);
|
|
|
| // Update cache
|
| bool found = false;
|
| for(int i = 0; i < ArraySize(m_correlation_cache); i++)
|
| {
|
| if(m_correlation_cache[i].symbol_pair == pair_key)
|
| {
|
| m_correlation_cache[i].correlation = correlation;
|
| m_correlation_cache[i].last_update = current_time;
|
| found = true;
|
| break;
|
| }
|
| }
|
|
|
| if(!found)
|
| {
|
| int size = ArraySize(m_correlation_cache);
|
| ArrayResize(m_correlation_cache, size + 1);
|
| m_correlation_cache[size].symbol_pair = pair_key;
|
| m_correlation_cache[size].correlation = correlation;
|
| m_correlation_cache[size].last_update = current_time;
|
| }
|
|
|
| return correlation;
|
| }
|
|
|
| // Check if correlation exposure is within limits
|
| bool IsCorrelationAllowed(string &symbols_to_check[], string &reason, double &max_correlation_found)
|
| {
|
| reason = "ok";
|
| max_correlation_found = 0.0;
|
|
|
| if(!m_enabled)
|
| return true;
|
|
|
| string problematic_symbol = "";
|
|
|
| for(int i = 0; i < ArraySize(symbols_to_check); i++)
|
| {
|
| if(symbols_to_check[i] == m_symbol) continue;
|
|
|
| double correlation = MathAbs(GetCorrelation(symbols_to_check[i]));
|
|
|
| if(correlation > max_correlation_found)
|
| {
|
| max_correlation_found = correlation;
|
| problematic_symbol = symbols_to_check[i];
|
| }
|
|
|
| if(correlation > m_max_correlation)
|
| {
|
| reason = StringFormat("correlation_limit_exceeded_%.3f_with_%s", correlation, symbols_to_check[i]);
|
| return false;
|
| }
|
| }
|
|
|
| return true;
|
| }
|
|
|
| // Get list of currently open positions for correlation checking
|
| void GetOpenPositionSymbols(string &symbols[])
|
| {
|
| ArrayResize(symbols, 0);
|
|
|
| for(int i = 0; i < PositionsTotal(); i++)
|
| {
|
| if(PositionGetTicket(i) > 0)
|
| {
|
| string pos_symbol = PositionGetString(POSITION_SYMBOL);
|
|
|
| // Add to array if not already present
|
| bool found = false;
|
| for(int j = 0; j < ArraySize(symbols); j++)
|
| {
|
| if(symbols[j] == pos_symbol)
|
| {
|
| found = true;
|
| break;
|
| }
|
| }
|
|
|
| if(!found)
|
| {
|
| int size = ArraySize(symbols);
|
| ArrayResize(symbols, size + 1);
|
| symbols[size] = pos_symbol;
|
| }
|
| }
|
| }
|
| }
|
|
|
| // Main correlation gate check
|
| bool CheckCorrelationLimits(string &reason, double &max_correlation)
|
| {
|
| reason = "ok";
|
| max_correlation = 0.0;
|
|
|
| if(!m_enabled)
|
| return true;
|
|
|
| string open_symbols[];
|
| GetOpenPositionSymbols(open_symbols);
|
|
|
| return IsCorrelationAllowed(open_symbols, reason, max_correlation);
|
| }
|
|
|
| // Clear correlation cache (for testing or manual refresh)
|
| void ClearCache()
|
| {
|
| ArrayResize(m_correlation_cache, 0);
|
| }
|
| };
|
