| //+------------------------------------------------------------------+
|
| //| AdaptiveSignalOptimizer.mqh |
|
| //| Purpose: ML-Driven Adaptive Signal Optimization System |
|
| //| Features: Strategy-specific profiles, Multi-pass validation, |
|
| //| Learning-based parameter tuning |
|
| //+------------------------------------------------------------------+
|
| #ifndef __ADAPTIVESIGNALOPTIMIZER_MQH__
|
| #define __ADAPTIVESIGNALOPTIMIZER_MQH__
|
|
|
| #include "LearningBridge.mqh"
|
| #include "EnhancedEfficientGateSystem.mqh"
|
| #include "GateSystemAutoLearning.mqh"
|
|
|
| // Strategy-specific adjustment profile
|
| struct StrategyProfile
|
| {
|
| string strategy_name;
|
|
|
| // Adjustment ranges (min, max, step)
|
| double price_adjust_range[3]; // [min, max, step]
|
| double sl_adjust_range[3];
|
| double tp_adjust_range[3];
|
| double volume_adjust_range[3];
|
|
|
| // Learning metrics
|
| double success_rate;
|
| int total_adjustments;
|
| int successful_adjustments;
|
| datetime last_update;
|
|
|
| // ML-derived optimal adjustments
|
| double optimal_price_tweak;
|
| double optimal_sl_tweak;
|
| double optimal_tp_tweak;
|
| double optimal_volume_tweak;
|
| };
|
|
|
| // Gate journey step - tracks what happened at each gate
|
| struct GateJourneyStep
|
| {
|
| string gate_name;
|
| int gate_index;
|
| bool passed;
|
| string reason;
|
|
|
| // Adjustments made at this gate
|
| double price_before;
|
| double price_after;
|
| double sl_before;
|
| double sl_after;
|
| double tp_before;
|
| double tp_after;
|
| double volume_before;
|
| double volume_after;
|
|
|
| bool was_adjusted;
|
| datetime step_time;
|
| };
|
|
|
| // Adjustment attempt record
|
| struct AdjustmentAttempt
|
| {
|
| int attempt_number;
|
| string gate_blocked;
|
| double price_tweak;
|
| double sl_tweak;
|
| double tp_tweak;
|
| double volume_tweak;
|
| bool passed;
|
| string reason;
|
|
|
| // Full gate journey for this attempt
|
| GateJourneyStep journey[8];
|
| int journey_length;
|
| };
|
|
|
| // Enhanced decision with adjustment tracking
|
| class CAdaptiveDecision : public CSignalDecision
|
| {
|
| public:
|
| // Note: is_adjusted is inherited from CSignalDecision, don't redeclare
|
| int adjustment_attempts;
|
| AdjustmentAttempt attempts[3]; // Max 3 attempts
|
| string original_signal_id;
|
|
|
| // Full gate journey (all gates, all attempts)
|
| GateJourneyStep complete_journey[24]; // 8 gates × 3 attempts max
|
| int complete_journey_length;
|
|
|
| CAdaptiveDecision() : CSignalDecision()
|
| {
|
| is_adjusted = false;
|
| adjustment_attempts = 0;
|
| original_signal_id = "";
|
| complete_journey_length = 0;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Main Adaptive Signal Optimizer Class |
|
| //+------------------------------------------------------------------+
|
| class CAdaptiveSignalOptimizer
|
| {
|
| private:
|
| CLearningBridge* m_learning;
|
| CEfficientGateManagerEnhanced* m_gate_manager;
|
|
|
| // Simple array-based profile storage (MQL5 HashMap doesn't support structs)
|
| string m_profile_keys[];
|
| StrategyProfile m_profile_values[];
|
|
|
| // Configuration
|
| int m_max_attempts;
|
| bool m_use_ml_optimization;
|
| bool m_verbose_logging;
|
|
|
| // Statistics
|
| int m_total_optimizations;
|
| int m_successful_optimizations;
|
|
|
| // Helper methods for profile storage
|
| int FindProfileIndex(const string key)
|
| {
|
| for(int i = 0; i < ArraySize(m_profile_keys); i++)
|
| {
|
| if(m_profile_keys[i] == key) return i;
|
| }
|
| return -1;
|
| }
|
|
|
| bool GetProfile(const string key, StrategyProfile &out_profile)
|
| {
|
| int idx = FindProfileIndex(key);
|
| if(idx >= 0)
|
| {
|
| out_profile = m_profile_values[idx];
|
| return true;
|
| }
|
| return false;
|
| }
|
|
|
| void SetProfile(const string key, const StrategyProfile &profile)
|
| {
|
| int idx = FindProfileIndex(key);
|
| if(idx >= 0)
|
| {
|
| m_profile_values[idx] = profile;
|
| }
|
| else
|
| {
|
| int size = ArraySize(m_profile_keys);
|
| ArrayResize(m_profile_keys, size + 1);
|
| ArrayResize(m_profile_values, size + 1);
|
| m_profile_keys[size] = key;
|
| m_profile_values[size] = profile;
|
| }
|
| }
|
|
|
| // Initialize strategy profiles for all 23 strategies
|
| void InitializeStrategyProfiles()
|
| {
|
| string strategies[] = {
|
| "MovingAverageStrategy", "ADXStrategy", "RSIStrategy", "BollingerBandsStrategy",
|
| "MACDStrategy", "StochasticStrategy", "IchimokuStrategy", "ParabolicSARStrategy",
|
| "CCIStrategy", "WilliamsRStrategy", "ATRStrategy", "FibonacciStrategy",
|
| "PivotPointStrategy", "BreakoutStrategy", "MomentumStrategy", "VolumeStrategy",
|
| "GapStrategy", "NewsStrategy", "CorrelationStrategy", "SeasonalStrategy",
|
| "MachineLearningStrategy", "EnsembleStrategy", "HybridStrategy"
|
| };
|
|
|
| for(int i = 0; i < ArraySize(strategies); i++)
|
| {
|
| StrategyProfile profile;
|
| profile.strategy_name = strategies[i];
|
|
|
| // Default adjustment ranges (will be ML-optimized)
|
| // Price: ±1% adjustment range (more conservative)
|
| profile.price_adjust_range[0] = -0.01;
|
| profile.price_adjust_range[1] = 0.01;
|
| profile.price_adjust_range[2] = 0.0025; // 0.25% steps
|
|
|
| // SL: 0.8x to 1.2x (more conservative)
|
| profile.sl_adjust_range[0] = 0.8;
|
| profile.sl_adjust_range[1] = 1.2;
|
| profile.sl_adjust_range[2] = 0.05;
|
|
|
| // TP: 0.9x to 1.5x (more conservative)
|
| profile.tp_adjust_range[0] = 0.9;
|
| profile.tp_adjust_range[1] = 1.5;
|
| profile.tp_adjust_range[2] = 0.1;
|
|
|
| // Volume: 0.5x to 1.0x (reduce only for safety)
|
| profile.volume_adjust_range[0] = 0.5;
|
| profile.volume_adjust_range[1] = 1.0;
|
| profile.volume_adjust_range[2] = 0.05;
|
|
|
| // Initialize metrics
|
| profile.success_rate = 0.0;
|
| profile.total_adjustments = 0;
|
| profile.successful_adjustments = 0;
|
| profile.last_update = 0;
|
|
|
| // Start with more conservative tweaks
|
| profile.optimal_price_tweak = 0.0;
|
| profile.optimal_sl_tweak = 1.0;
|
| profile.optimal_tp_tweak = 1.1; // Slightly more aggressive TP
|
| profile.optimal_volume_tweak = 0.8; // Less conservative volume
|
|
|
| SetProfile(strategies[i], profile);
|
| }
|
|
|
| PrintFormat("✅ AdaptiveSignalOptimizer: Initialized %d strategy profiles", ArraySize(strategies));
|
| }
|
|
|
| // Learn optimal adjustments from historical data
|
| void LearnOptimalAdjustments(string strategy_name)
|
| {
|
| if(m_learning == NULL) return;
|
|
|
| StrategyProfile profile;
|
| if(!GetProfile(strategy_name, profile))
|
| return;
|
|
|
| // Query learning bridge for successful adjustments
|
| // This is where ML magic happens - analyze what tweaks led to profitable trades
|
|
|
| // For now, use simple heuristics based on success rate
|
| if(profile.total_adjustments > 10)
|
| {
|
| double success_rate = (double)profile.successful_adjustments / profile.total_adjustments;
|
|
|
| if(success_rate > 0.7)
|
| {
|
| // Good performance - be more aggressive
|
| profile.optimal_volume_tweak = MathMin(1.0, profile.optimal_volume_tweak * 1.1);
|
| }
|
| else if(success_rate < 0.4)
|
| {
|
| // Poor performance - be more conservative
|
| profile.optimal_volume_tweak = MathMax(0.3, profile.optimal_volume_tweak * 0.9);
|
| profile.optimal_sl_tweak = MathMax(0.5, profile.optimal_sl_tweak * 0.95);
|
| }
|
|
|
| profile.last_update = TimeCurrent();
|
| SetProfile(strategy_name, profile);
|
|
|
| if(m_verbose_logging)
|
| PrintFormat("📊 ML Update [%s]: Success=%.1f%% Vol=%.2f SL=%.2f",
|
| strategy_name, success_rate * 100,
|
| profile.optimal_volume_tweak, profile.optimal_sl_tweak);
|
| }
|
| }
|
|
|
| bool ValidateAdjustedSignal(const TradingSignal &signal, string &reason) const
|
| {
|
| string symbol = (signal.symbol != "") ? signal.symbol : _Symbol;
|
| if(symbol == "") symbol = _Symbol;
|
|
|
| if(!MathIsValidNumber(signal.price) || signal.price <= 0.0)
|
| {
|
| reason = "invalid price";
|
| return false;
|
| }
|
|
|
| if(!MathIsValidNumber(signal.sl) || !MathIsValidNumber(signal.tp))
|
| {
|
| reason = "invalid SL/TP";
|
| return false;
|
| }
|
|
|
| bool is_buy = (signal.type == 0);
|
| if(is_buy)
|
| {
|
| if(signal.sl >= signal.price)
|
| {
|
| reason = "buy SL above price";
|
| return false;
|
| }
|
| if(signal.tp <= signal.price)
|
| {
|
| reason = "buy TP below price";
|
| return false;
|
| }
|
| }
|
| else if(signal.type == 1)
|
| {
|
| if(signal.sl <= signal.price)
|
| {
|
| reason = "sell SL below price";
|
| return false;
|
| }
|
| if(signal.tp >= signal.price)
|
| {
|
| reason = "sell TP above price";
|
| return false;
|
| }
|
| }
|
|
|
| double vol_min = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
|
| double vol_max = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
|
| if(vol_min <= 0.0) vol_min = 0.01;
|
| if(vol_max <= 0.0) vol_max = 100.0;
|
|
|
| if(!MathIsValidNumber(signal.volume) || signal.volume < vol_min || signal.volume > vol_max)
|
| {
|
| reason = "invalid volume";
|
| return false;
|
| }
|
|
|
| return true;
|
| }
|
|
|
| public:
|
| CAdaptiveSignalOptimizer(CLearningBridge* learning, CEfficientGateManagerEnhanced* gate_mgr,
|
| int max_attempts = 3, bool use_ml = true)
|
| {
|
| m_learning = learning;
|
| m_gate_manager = gate_mgr;
|
| m_max_attempts = max_attempts;
|
| m_use_ml_optimization = use_ml;
|
| m_verbose_logging = true;
|
|
|
| m_total_optimizations = 0;
|
| m_successful_optimizations = 0;
|
|
|
| InitializeStrategyProfiles();
|
|
|
| PrintFormat("🎯 AdaptiveSignalOptimizer initialized: max_attempts=%d, ML=%s",
|
| m_max_attempts, m_use_ml_optimization ? "ON" : "OFF");
|
| }
|
|
|
| ~CAdaptiveSignalOptimizer()
|
| {
|
| PrintFormat("AdaptiveSignalOptimizer stats: %d/%d optimizations successful (%.1f%%)",
|
| m_successful_optimizations, m_total_optimizations,
|
| m_total_optimizations > 0 ? (double)m_successful_optimizations/m_total_optimizations*100 : 0);
|
| }
|
|
|
| // Main optimization function with multi-pass validation
|
| bool OptimizeSignal(TradingSignal &signal, CAdaptiveDecision &decision,
|
| const string strategy_name, string &blocking_reason)
|
| {
|
| m_total_optimizations++;
|
|
|
| // First attempt: Try original signal
|
| CSignalDecision temp_decision;
|
| string block_reason;
|
| bool passed = m_gate_manager.ProcessSignalEnhanced(signal, temp_decision, block_reason);
|
|
|
| if(passed)
|
| {
|
| // Original signal passed - no adjustment needed
|
| CopyDecision(temp_decision, decision);
|
| decision.is_adjusted = false;
|
| decision.adjustment_attempts = 0;
|
|
|
| blocking_reason = "Original signal passed all gates";
|
| return true;
|
| }
|
|
|
| // Original failed - start adaptive optimization
|
| blocking_reason = "Original signal blocked";
|
| decision.original_signal_id = signal.id;
|
| decision.is_adjusted = true;
|
|
|
| if(m_verbose_logging)
|
| PrintFormat("🔧 Optimizing blocked signal: %s [%s]", signal.id, strategy_name);
|
|
|
| // Get strategy profile
|
| StrategyProfile profile;
|
| if(!GetProfile(strategy_name, profile))
|
| {
|
| // Unknown strategy - use default profile
|
| if(m_verbose_logging)
|
| PrintFormat("⚠️ Unknown strategy: %s, using defaults", strategy_name);
|
|
|
| profile.optimal_price_tweak = 0.0;
|
| profile.optimal_sl_tweak = 1.0;
|
| profile.optimal_tp_tweak = 1.0;
|
| profile.optimal_volume_tweak = 0.7;
|
| }
|
|
|
| // Update ML-learned adjustments
|
| if(m_use_ml_optimization)
|
| LearnOptimalAdjustments(strategy_name);
|
|
|
| // Multi-attempt optimization
|
| for(int attempt = 0; attempt < m_max_attempts; attempt++)
|
| {
|
| TradingSignal adjusted_signal = signal;
|
|
|
| // Normalize symbol and volume bounds early so validation doesn't skip all attempts.
|
| string symbol = (adjusted_signal.symbol != "") ? adjusted_signal.symbol : _Symbol;
|
| if(symbol == "") symbol = _Symbol;
|
| double vol_min = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
|
| double vol_max = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
|
| double vol_step = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
|
| if(vol_min <= 0.0) vol_min = 0.01;
|
| if(vol_max <= 0.0) vol_max = 100.0;
|
| if(vol_step <= 0.0) vol_step = vol_min;
|
| if(!MathIsValidNumber(adjusted_signal.volume) || adjusted_signal.volume <= 0.0)
|
| adjusted_signal.volume = vol_min;
|
| // Clamp and round to step
|
| if(adjusted_signal.volume < vol_min) adjusted_signal.volume = vol_min;
|
| if(adjusted_signal.volume > vol_max) adjusted_signal.volume = vol_max;
|
| adjusted_signal.volume = MathFloor(adjusted_signal.volume / vol_step + 1e-9) * vol_step;
|
| if(adjusted_signal.volume < vol_min) adjusted_signal.volume = vol_min;
|
| if(adjusted_signal.volume > vol_max) adjusted_signal.volume = vol_max;
|
|
|
| // Calculate adjustments based on attempt number and ML insights
|
| // Use more conservative adjustments to increase success rate
|
| double aggressiveness = 1.0 + (attempt * 0.15); // Slower increase in adjustments
|
|
|
| // Apply ML-optimized adjustments with more conservative ranges
|
| adjusted_signal.price = signal.price * (1.0 + profile.optimal_price_tweak * aggressiveness * 0.5); // Reduce price adjustment impact
|
| double sl_dist = MathAbs(signal.price - signal.sl);
|
| double tp_dist = MathAbs(signal.tp - signal.price);
|
| if(sl_dist <= 0.0) sl_dist = MathAbs(signal.price) * 0.001;
|
| if(tp_dist <= 0.0) tp_dist = MathAbs(signal.price) * 0.001;
|
| double sl_mult = (profile.optimal_sl_tweak * (1.0 - attempt * 0.05));
|
| double tp_mult = (profile.optimal_tp_tweak * (1.0 + attempt * 0.075));
|
| if(sl_mult <= 0.01) sl_mult = 0.01;
|
| if(tp_mult <= 0.01) tp_mult = 0.01;
|
| if(signal.type == 0)
|
| {
|
| adjusted_signal.sl = adjusted_signal.price - sl_dist * sl_mult;
|
| adjusted_signal.tp = adjusted_signal.price + tp_dist * tp_mult;
|
| }
|
| else
|
| {
|
| adjusted_signal.sl = adjusted_signal.price + sl_dist * sl_mult;
|
| adjusted_signal.tp = adjusted_signal.price - tp_dist * tp_mult;
|
| }
|
| adjusted_signal.volume = adjusted_signal.volume * (profile.optimal_volume_tweak * (1.0 - attempt * 0.075)); // Gentler volume reduction
|
| // Re-clamp after applying tweaks
|
| if(adjusted_signal.volume < vol_min) adjusted_signal.volume = vol_min;
|
| if(adjusted_signal.volume > vol_max) adjusted_signal.volume = vol_max;
|
| adjusted_signal.volume = MathFloor(adjusted_signal.volume / vol_step + 1e-9) * vol_step;
|
| if(adjusted_signal.volume < vol_min) adjusted_signal.volume = vol_min;
|
| if(adjusted_signal.volume > vol_max) adjusted_signal.volume = vol_max;
|
|
|
| // Special adjustments based on confidence
|
| if(signal.confidence < 0.3)
|
| {
|
| // Very low confidence - be extra conservative
|
| adjusted_signal.volume *= 0.7;
|
| double dist = MathAbs(adjusted_signal.price - adjusted_signal.sl);
|
| adjusted_signal.sl = (adjusted_signal.type == 0) ? adjusted_signal.price - dist * 0.9 : adjusted_signal.price + dist * 0.9;
|
| }
|
| else if(signal.confidence < 0.5)
|
| {
|
| // Low confidence - be moderately conservative
|
| adjusted_signal.volume *= 0.85;
|
| double dist = MathAbs(adjusted_signal.price - adjusted_signal.sl);
|
| adjusted_signal.sl = (adjusted_signal.type == 0) ? adjusted_signal.price - dist * 0.95 : adjusted_signal.price + dist * 0.95;
|
| }
|
|
|
| // Update signal ID to track adjustment
|
| adjusted_signal.id = signal.id + "_adj" + IntegerToString(attempt + 1);
|
|
|
| // Record attempt
|
| AdjustmentAttempt att;
|
| att.attempt_number = attempt + 1;
|
| att.price_tweak = (adjusted_signal.price - signal.price) / signal.price;
|
| if(MathIsValidNumber(signal.sl) && MathAbs(signal.sl) > 1e-12)
|
| att.sl_tweak = adjusted_signal.sl / signal.sl;
|
| else
|
| att.sl_tweak = 0.0;
|
| if(MathIsValidNumber(signal.tp) && MathAbs(signal.tp) > 1e-12)
|
| att.tp_tweak = adjusted_signal.tp / signal.tp;
|
| else
|
| att.tp_tweak = 0.0;
|
| if(MathIsValidNumber(signal.volume) && MathAbs(signal.volume) > 1e-12)
|
| att.volume_tweak = adjusted_signal.volume / signal.volume;
|
| else
|
| att.volume_tweak = 0.0;
|
|
|
| // Try adjusted signal through gates
|
| CSignalDecision adj_decision;
|
| string validation_reason;
|
| if(!ValidateAdjustedSignal(adjusted_signal, validation_reason))
|
| {
|
| att.passed = false;
|
| att.reason = "Sanity check failed: " + validation_reason;
|
| decision.attempts[attempt] = att;
|
| decision.adjustment_attempts++;
|
| if(m_verbose_logging)
|
| PrintFormat("⚠️ Adjustment attempt %d skipped (%s)", attempt + 1, validation_reason);
|
| continue;
|
| }
|
|
|
| string adj_block_reason;
|
| bool adj_passed = m_gate_manager.ProcessSignalEnhanced(adjusted_signal, adj_decision, adj_block_reason);
|
|
|
| att.passed = adj_passed;
|
| att.gate_blocked = adj_passed ? "NONE" : "Multiple";
|
| att.reason = adj_passed ? "Passed after adjustment" : "Still blocked";
|
|
|
| decision.attempts[attempt] = att;
|
| decision.adjustment_attempts++;
|
|
|
| if(adj_passed)
|
| {
|
| // Success! Multi-pass validation (2 re-validation cycles)
|
| if(m_verbose_logging)
|
| PrintFormat("✅ Adjustment attempt %d succeeded, starting re-validation...", attempt + 1);
|
|
|
| bool revalidation_passed = true;
|
|
|
| for(int revalidation = 1; revalidation <= 2; revalidation++)
|
| {
|
| CSignalDecision revalidation_decision;
|
| string rev_block_reason;
|
| bool revalidation_result = m_gate_manager.ProcessSignalEnhanced(adjusted_signal, revalidation_decision, rev_block_reason);
|
|
|
| if(!revalidation_result)
|
| {
|
| revalidation_passed = false;
|
| if(m_verbose_logging)
|
| PrintFormat("❌ Re-validation cycle %d FAILED", revalidation);
|
| break;
|
| }
|
| else
|
| {
|
| if(m_verbose_logging)
|
| PrintFormat("✅ Re-validation cycle %d PASSED", revalidation);
|
|
|
| // Update decision with latest validation
|
| CopyDecision(revalidation_decision, adj_decision);
|
| }
|
| }
|
|
|
| if(revalidation_passed)
|
| {
|
| // All validations passed!
|
| CopyDecision(adj_decision, decision);
|
| decision.is_adjusted = true;
|
|
|
| // Update profile statistics
|
| profile.total_adjustments++;
|
| profile.successful_adjustments++;
|
| SetProfile(strategy_name, profile);
|
|
|
| m_successful_optimizations++;
|
|
|
| blocking_reason = StringFormat("Optimized on attempt %d, passed 2 re-validations", attempt + 1);
|
|
|
| if(m_verbose_logging)
|
| PrintFormat("🎉 Signal optimized successfully: %s → %s (Volume: %.2f → %.2f)",
|
| signal.id, adjusted_signal.id, signal.volume, adjusted_signal.volume);
|
|
|
| return true;
|
| }
|
| else
|
| {
|
| // Re-validation failed, try next adjustment
|
| if(m_verbose_logging)
|
| PrintFormat("⚠️ Adjustment passed gates but failed re-validation, trying next adjustment...");
|
| continue;
|
| }
|
| }
|
|
|
| // This attempt failed, log and try next
|
| if(m_verbose_logging)
|
| PrintFormat("❌ Adjustment attempt %d failed: V%.2f SL%.2f TP%.2f",
|
| attempt + 1, att.volume_tweak, att.sl_tweak, att.tp_tweak);
|
| }
|
|
|
| // All attempts exhausted
|
| profile.total_adjustments++;
|
| SetProfile(strategy_name, profile);
|
|
|
| blocking_reason = StringFormat("All %d optimization attempts failed", m_max_attempts);
|
|
|
| if(m_verbose_logging)
|
| PrintFormat("🚫 Signal optimization FAILED after %d attempts: %s", m_max_attempts, signal.id);
|
|
|
| return false;
|
| }
|
|
|
| // Helper to copy decision data
|
| void CopyDecision(const CSignalDecision &source, CSignalDecision &dest)
|
| {
|
| dest.signal_id = source.signal_id;
|
| dest.strategy = source.strategy; // CRITICAL: Copy strategy name
|
| dest.timestamp = source.timestamp;
|
| dest.symbol = source.symbol;
|
| dest.timeframe = source.timeframe;
|
| dest.original_price = source.original_price;
|
| dest.original_type = source.original_type;
|
| dest.original_sl = source.original_sl;
|
| dest.original_tp = source.original_tp;
|
| dest.original_volume = source.original_volume;
|
| dest.executed = source.executed;
|
| dest.final_price = source.final_price;
|
| dest.final_sl = source.final_sl;
|
| dest.final_tp = source.final_tp;
|
| dest.final_volume = source.final_volume;
|
| dest.confidence = source.confidence;
|
| dest.volatility = source.volatility;
|
| dest.correlation_score = source.correlation_score;
|
| dest.market_regime = source.market_regime;
|
|
|
| // Copy gate results
|
| for(int i = 0; i < 8; i++)
|
| {
|
| dest.gate_results[i] = source.gate_results[i];
|
| dest.gate_reasons[i] = source.gate_reasons[i];
|
| dest.gate_timestamps[i] = source.gate_timestamps[i];
|
|
|
| for(int j = 0; j < 5; j++)
|
| dest.gate_tweaks[i][j] = source.gate_tweaks[i][j];
|
| }
|
| }
|
|
|
| // Get optimization statistics
|
| void GetStatistics(int &total, int &successful, double &success_rate)
|
| {
|
| total = m_total_optimizations;
|
| successful = m_successful_optimizations;
|
| success_rate = total > 0 ? (double)successful / total * 100.0 : 0.0;
|
| }
|
|
|
| // Print detailed report
|
| void PrintOptimizationReport()
|
| {
|
| PrintFormat("\n=== 📊 Adaptive Signal Optimization Report ===");
|
| PrintFormat("Total Optimizations: %d", m_total_optimizations);
|
| PrintFormat("Successful: %d (%.1f%%)", m_successful_optimizations,
|
| m_total_optimizations > 0 ? (double)m_successful_optimizations/m_total_optimizations*100 : 0);
|
|
|
| Print("\nStrategy-Specific Performance:");
|
|
|
| // Print top 5 strategies by success rate
|
| // (Full implementation would iterate through all profiles)
|
| Print("(Strategy profiles tracked internally)");
|
| }
|
|
|
| // Print complete gate journey
|
| void PrintCompleteGateJourney(CAdaptiveDecision &decision)
|
| {
|
| if(decision.complete_journey_length == 0) return;
|
|
|
| PrintFormat("\n📍 ==== COMPLETE GATE JOURNEY for %s ====", decision.signal_id);
|
| PrintFormat("Original Signal: %s | Total Attempts: %d | Is Adjusted: %s",
|
| decision.original_signal_id != "" ? decision.original_signal_id : decision.signal_id,
|
| decision.adjustment_attempts,
|
| decision.is_adjusted ? "YES" : "NO");
|
|
|
| int current_attempt = 0;
|
|
|
| for(int i = 0; i < decision.complete_journey_length; i++)
|
| {
|
| GateJourneyStep step = decision.complete_journey[i];
|
|
|
| // Check if new attempt started
|
| if(i > 0 && step.gate_index == 0)
|
| {
|
| current_attempt++;
|
| PrintFormat("\n--- Attempt %d ---", current_attempt + 1);
|
| }
|
| else if(i == 0)
|
| {
|
| PrintFormat("--- Attempt 1 (Original Signal) ---");
|
| }
|
|
|
| // Print gate status
|
| string status_icon = step.passed ? "✅" : "❌";
|
| PrintFormat(" Gate %d [%s]: %s %s",
|
| step.gate_index + 1,
|
| step.gate_name,
|
| status_icon,
|
| step.passed ? "PASSED" : "BLOCKED");
|
|
|
| if(!step.passed)
|
| PrintFormat(" Reason: %s", step.reason);
|
|
|
| // Print adjustments if any
|
| if(step.was_adjusted)
|
| {
|
| PrintFormat(" 🔧 ADJUSTMENTS:");
|
|
|
| if(step.price_before != step.price_after)
|
| PrintFormat(" Price: %.5f → %.5f (%+.2f%%)",
|
| step.price_before, step.price_after,
|
| (step.price_after - step.price_before) / step.price_before * 100);
|
|
|
| if(step.sl_before != step.sl_after)
|
| PrintFormat(" SL: %.5f → %.5f (%+.2f%%)",
|
| step.sl_before, step.sl_after,
|
| (step.sl_after - step.sl_before) / step.sl_before * 100);
|
|
|
| if(step.tp_before != step.tp_after)
|
| PrintFormat(" TP: %.5f → %.5f (%+.2f%%)",
|
| step.tp_before, step.tp_after,
|
| (step.tp_after - step.tp_before) / step.tp_before * 100);
|
|
|
| if(step.volume_before != step.volume_after)
|
| PrintFormat(" Volume: %.2f → %.2f (%+.2f%%)",
|
| step.volume_before, step.volume_after,
|
| (step.volume_after - step.volume_before) / step.volume_before * 100);
|
| }
|
| }
|
|
|
| PrintFormat("\n🏁 FINAL OUTCOME: %s", decision.executed ? "✅ EXECUTED" : "❌ REJECTED");
|
| if(decision.executed)
|
| {
|
| PrintFormat(" Final Price: %.5f | SL: %.5f | TP: %.5f | Volume: %.2f",
|
| decision.final_price, decision.final_sl, decision.final_tp, decision.final_volume);
|
| }
|
| PrintFormat("==========================================\n");
|
| }
|
| };
|
|
|
| #endif
|
