| //+------------------------------------------------------------------+
|
| //| CNewsImpactAnalyzer.mqh - Dynamic News-Based Threshold Adjustment |
|
| //| Analyzes news impact in real-time and adjusts trading thresholds |
|
| //| dynamically based on market conditions and news sentiment |
|
| //+------------------------------------------------------------------+
|
| #ifndef CNEWSIMPACTANALYZER_MQH
|
| #define CNEWSIMPACTANALYZER_MQH
|
|
|
| #include "CEconomicCalendar.mqh"
|
| #include "CErrorRecovery.mqh"
|
|
|
| // News impact state
|
| enum ENUM_NEWS_STATE
|
| {
|
| NEWS_STATE_QUIET = 0, // No significant news
|
| NEWS_STATE_WARNING = 1, // News approaching
|
| NEWS_STATE_ACTIVE = 2, // News happening now
|
| NEWS_STATE_AFTERMATH = 3 // Post-news volatility
|
| };
|
|
|
| // Threshold adjustment direction
|
| enum ENUM_THRESHOLD_ADJUSTMENT
|
| {
|
| THRESHOLD_NORMAL = 0, // No adjustment
|
| THRESHOLD_CONSERVATIVE = 1, // Increase thresholds (harder to trade)
|
| THRESHOLD_AGGRESSIVE = 2, // Decrease thresholds (easier to trade)
|
| THRESHOLD_BLOCK = 3 // Block trading completely
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Threshold Adjustment Result |
|
| //+------------------------------------------------------------------+
|
| struct SThresholdAdjustment
|
| {
|
| ENUM_THRESHOLD_ADJUSTMENT direction;
|
| double confidence_multiplier;
|
| double risk_multiplier;
|
| double position_size_multiplier;
|
| int sl_pips_adjustment;
|
| int tp_pips_adjustment;
|
| string reason;
|
| datetime effective_until;
|
| bool should_trade;
|
|
|
| SThresholdAdjustment()
|
| {
|
| direction = THRESHOLD_NORMAL;
|
| confidence_multiplier = 1.0;
|
| risk_multiplier = 1.0;
|
| position_size_multiplier = 1.0;
|
| sl_pips_adjustment = 0;
|
| tp_pips_adjustment = 0;
|
| reason = "";
|
| effective_until = 0;
|
| should_trade = true;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Market Response Metrics |
|
| //+------------------------------------------------------------------+
|
| struct SMarketResponse
|
| {
|
| double price_change_pct;
|
| double volatility_spike;
|
| double spread_widening;
|
| int volume_surge;
|
| bool is_trending;
|
| int trend_direction;
|
| datetime measurement_time;
|
|
|
| SMarketResponse()
|
| {
|
| price_change_pct = 0.0;
|
| volatility_spike = 0.0;
|
| spread_widening = 0.0;
|
| volume_surge = 0;
|
| is_trending = false;
|
| trend_direction = 0;
|
| measurement_time = 0;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| News Impact History Entry |
|
| //+------------------------------------------------------------------+
|
| struct SNewsImpactHistory
|
| {
|
| long event_id;
|
| string event_name;
|
| datetime event_time;
|
| int importance;
|
| double actual_value;
|
| double forecast_value;
|
| double surprise_magnitude;
|
| SMarketResponse market_response;
|
| bool profitable_to_trade;
|
| double ml_confidence_score;
|
|
|
| SNewsImpactHistory()
|
| {
|
| event_id = 0;
|
| event_name = "";
|
| event_time = 0;
|
| importance = 0;
|
| actual_value = 0.0;
|
| forecast_value = 0.0;
|
| surprise_magnitude = 0.0;
|
| profitable_to_trade = false;
|
| ml_confidence_score = 0.0;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| News Impact Analyzer |
|
| //+------------------------------------------------------------------+
|
| class CNewsImpactAnalyzer
|
| {
|
| private:
|
| static CNewsImpactAnalyzer* s_instance;
|
|
|
| // Components
|
| CEconomicCalendar* m_calendar;
|
| CErrorRecovery* m_error_recovery;
|
|
|
| // State tracking
|
| ENUM_NEWS_STATE m_current_state;
|
| datetime m_state_since;
|
| SThresholdAdjustment m_current_adjustment;
|
|
|
| // History for ML
|
| SNewsImpactHistory m_impact_history[];
|
| int m_history_count;
|
| int m_max_history;
|
|
|
| // Real-time metrics
|
| double m_baseline_volatility;
|
| double m_baseline_spread;
|
| datetime m_baseline_measured;
|
| int m_baseline_lookback_bars;
|
|
|
| // Configuration
|
| bool m_use_ml_predictions;
|
| bool m_export_for_training;
|
| string m_export_filename;
|
| int m_volatility_measurement_bars;
|
| double m_spread_widening_threshold;
|
| double m_volatility_spike_threshold;
|
|
|
| // Telemetry
|
| int m_analysis_count;
|
| int m_trade_blocked_count;
|
| int m_threshold_adjusted_count;
|
|
|
| public:
|
| CNewsImpactAnalyzer()
|
| {
|
| m_calendar = CEconomicCalendar::Instance();
|
| m_error_recovery = CErrorRecovery::Instance();
|
|
|
| m_current_state = NEWS_STATE_QUIET;
|
| m_state_since = 0;
|
|
|
| m_history_count = 0;
|
| m_max_history = 200;
|
| ArrayResize(m_impact_history, m_max_history);
|
|
|
| m_baseline_volatility = 0.0;
|
| m_baseline_spread = 0.0;
|
| m_baseline_measured = 0;
|
| m_baseline_lookback_bars = 20;
|
|
|
| m_use_ml_predictions = true;
|
| m_export_for_training = true;
|
| m_export_filename = "DualEA\\news_impact_training.csv";
|
| m_volatility_measurement_bars = 10;
|
| m_spread_widening_threshold = 1.5; // 150% of normal
|
| m_volatility_spike_threshold = 2.0; // 200% of normal
|
|
|
| m_analysis_count = 0;
|
| m_trade_blocked_count = 0;
|
| m_threshold_adjusted_count = 0;
|
| }
|
|
|
| ~CNewsImpactAnalyzer()
|
| {
|
| }
|
|
|
| static CNewsImpactAnalyzer* Instance()
|
| {
|
| if(s_instance == NULL)
|
| s_instance = new CNewsImpactAnalyzer();
|
| return s_instance;
|
| }
|
|
|
| static void Destroy()
|
| {
|
| if(s_instance != NULL)
|
| {
|
| delete s_instance;
|
| s_instance = NULL;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Configuration |
|
| //+------------------------------------------------------------------+
|
| void SetUseMLPredictions(bool use) { m_use_ml_predictions = use; }
|
| void SetExportForTraining(bool export_data) { m_export_for_training = export_data; }
|
| void SetBaselineLookback(int bars) { m_baseline_lookback_bars = bars; }
|
| void SetSpreadThreshold(double threshold) { m_spread_widening_threshold = threshold; }
|
| void SetVolatilityThreshold(double threshold) { m_volatility_spike_threshold = threshold; }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Main analysis entry point |
|
| //+------------------------------------------------------------------+
|
| SThresholdAdjustment AnalyzeNewsImpact(const string symbol, int buffer_minutes_before = 30, int buffer_minutes_after = 60)
|
| {
|
| m_analysis_count++;
|
|
|
| SThresholdAdjustment adjustment;
|
|
|
| // Get news impact from calendar
|
| SNewsImpact news_impact = m_calendar.CheckNewsImpact(symbol, buffer_minutes_before, buffer_minutes_after);
|
|
|
| // Update baseline if needed
|
| UpdateBaselineMetrics(symbol);
|
|
|
| // Measure current market response
|
| SMarketResponse response = MeasureMarketResponse(symbol);
|
|
|
| // Determine news state
|
| ENUM_NEWS_STATE new_state = DetermineNewsState(news_impact, response);
|
|
|
| // Handle state transition
|
| if(new_state != m_current_state)
|
| {
|
| Log("News state changed from " + StateToString(m_current_state) + " to " + StateToString(new_state));
|
| m_current_state = new_state;
|
| m_state_since = TimeCurrent();
|
| }
|
|
|
| // Calculate threshold adjustment
|
| adjustment = CalculateThresholdAdjustment(new_state, news_impact, response);
|
| m_current_adjustment = adjustment;
|
|
|
| // Update statistics
|
| if(!adjustment.should_trade)
|
| m_trade_blocked_count++;
|
| if(adjustment.direction != THRESHOLD_NORMAL)
|
| m_threshold_adjusted_count++;
|
|
|
| // Record for ML training
|
| if(m_export_for_training && news_impact.is_news_time)
|
| {
|
| RecordForTraining(symbol, news_impact, response, adjustment);
|
| }
|
|
|
| return adjustment;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update baseline volatility and spread |
|
| //+------------------------------------------------------------------+
|
| void UpdateBaselineMetrics(const string symbol)
|
| {
|
| datetime now = TimeCurrent();
|
|
|
| // Update every 5 minutes
|
| if((now - m_baseline_measured) < 300)
|
| return;
|
|
|
| // Calculate baseline volatility (ATR)
|
| int atr_handle = iATR(symbol, PERIOD_CURRENT, m_baseline_lookback_bars);
|
| if(atr_handle != INVALID_HANDLE)
|
| {
|
| double atr[];
|
| if(CopyBuffer(atr_handle, 0, 0, 1, atr) == 1)
|
| {
|
| m_baseline_volatility = atr[0];
|
| }
|
| IndicatorRelease(atr_handle);
|
| }
|
|
|
| // Get baseline spread
|
| m_baseline_spread = SymbolInfoInteger(symbol, SYMBOL_SPREAD) * SymbolInfoDouble(symbol, SYMBOL_POINT);
|
|
|
| m_baseline_measured = now;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Measure current market response to news |
|
| //+------------------------------------------------------------------+
|
| SMarketResponse MeasureMarketResponse(const string symbol)
|
| {
|
| SMarketResponse response;
|
| response.measurement_time = TimeCurrent();
|
|
|
| // Price change over last N bars
|
| MqlRates rates[];
|
| if(CopyRates(symbol, PERIOD_CURRENT, 0, m_volatility_measurement_bars, rates) == m_volatility_measurement_bars)
|
| {
|
| double price_start = rates[0].close;
|
| double price_end = rates[m_volatility_measurement_bars - 1].close;
|
| response.price_change_pct = (price_end - price_start) / price_start * 100.0;
|
|
|
| // Calculate volatility spike
|
| double current_atr = 0.0;
|
| for(int i = 1; i < m_volatility_measurement_bars; i++)
|
| {
|
| current_atr += MathMax(rates[i].high - rates[i].low,
|
| MathMax(MathAbs(rates[i].high - rates[i-1].close),
|
| MathAbs(rates[i].low - rates[i-1].close)));
|
| }
|
| current_atr /= m_volatility_measurement_bars;
|
|
|
| if(m_baseline_volatility > 0)
|
| {
|
| response.volatility_spike = current_atr / m_baseline_volatility;
|
| }
|
|
|
| // Determine if trending
|
| double highest_high = rates[0].high;
|
| double lowest_low = rates[0].low;
|
| for(int i = 1; i < m_volatility_measurement_bars; i++)
|
| {
|
| highest_high = MathMax(highest_high, rates[i].high);
|
| lowest_low = MathMin(lowest_low, rates[i].low);
|
| }
|
|
|
| double range = highest_high - lowest_low;
|
| if(range > 0)
|
| {
|
| response.is_trending = MathAbs(response.price_change_pct) > (range / price_start * 100.0 * 0.6);
|
| response.trend_direction = (response.price_change_pct > 0) ? 1 : -1;
|
| }
|
| }
|
|
|
| // Current spread vs baseline
|
| double current_spread = SymbolInfoInteger(symbol, SYMBOL_SPREAD) * SymbolInfoDouble(symbol, SYMBOL_POINT);
|
| if(m_baseline_spread > 0)
|
| {
|
| response.spread_widening = current_spread / m_baseline_spread;
|
| }
|
|
|
| // Volume surge (if available)
|
| long volume[];
|
| if(CopyTickVolume(symbol, PERIOD_CURRENT, 0, m_volatility_measurement_bars, volume) == m_volatility_measurement_bars)
|
| {
|
| long avg_volume = 0;
|
| for(int i = 0; i < m_volatility_measurement_bars; i++)
|
| {
|
| avg_volume += volume[i];
|
| }
|
| avg_volume /= m_volatility_measurement_bars;
|
|
|
| if(avg_volume > 0)
|
| {
|
| response.volume_surge = (int)((volume[m_volatility_measurement_bars - 1] * 100) / avg_volume);
|
| }
|
| }
|
|
|
| return response;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Determine current news state |
|
| //+------------------------------------------------------------------+
|
| ENUM_NEWS_STATE DetermineNewsState(const SNewsImpact &news, const SMarketResponse &response)
|
| {
|
| // Check for active news
|
| if(news.is_news_time)
|
| {
|
| return NEWS_STATE_ACTIVE;
|
| }
|
|
|
| // Check for aftermath (high volatility after recent news)
|
| if(response.volatility_spike > m_volatility_spike_threshold &&
|
| (TimeCurrent() - m_state_since) < 1800) // Within 30 min of state change
|
| {
|
| return NEWS_STATE_AFTERMATH;
|
| }
|
|
|
| // Check for warning (news approaching within 15 minutes)
|
| if(news.next_event_time > 0)
|
| {
|
| int seconds_to_event = (int)(news.next_event_time - TimeCurrent());
|
| if(seconds_to_event > 0 && seconds_to_event <= 900) // 15 minutes
|
| {
|
| return NEWS_STATE_WARNING;
|
| }
|
| }
|
|
|
| return NEWS_STATE_QUIET;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate threshold adjustment based on state |
|
| //+------------------------------------------------------------------+
|
| SThresholdAdjustment CalculateThresholdAdjustment(ENUM_NEWS_STATE state,
|
| const SNewsImpact &news,
|
| const SMarketResponse &response)
|
| {
|
| SThresholdAdjustment adj;
|
|
|
| switch(state)
|
| {
|
| case NEWS_STATE_QUIET:
|
| // Normal trading conditions
|
| adj.direction = THRESHOLD_NORMAL;
|
| adj.confidence_multiplier = 1.0;
|
| adj.risk_multiplier = 1.0;
|
| adj.position_size_multiplier = 1.0;
|
| adj.should_trade = true;
|
| adj.reason = "Normal market conditions";
|
| break;
|
|
|
| case NEWS_STATE_WARNING:
|
| // News approaching - be more conservative
|
| adj.direction = THRESHOLD_CONSERVATIVE;
|
| adj.confidence_multiplier = 1.2; // 20% harder to meet confidence
|
| adj.risk_multiplier = 0.8; // 20% less risk
|
| adj.position_size_multiplier = 0.7; // 30% smaller positions
|
| adj.sl_pips_adjustment = 5; // Wider SL
|
| adj.tp_pips_adjustment = 3; // Wider TP
|
| adj.should_trade = true;
|
| adj.reason = "News approaching: " + news.next_event_name;
|
| adj.effective_until = news.next_event_time + 3600; // 1 hour after event
|
| break;
|
|
|
| case NEWS_STATE_ACTIVE:
|
| // News happening now - most conservative or block
|
| if(news.current_importance >= EVENT_IMPORTANCE_HIGH)
|
| {
|
| adj.direction = THRESHOLD_BLOCK;
|
| adj.should_trade = false;
|
| adj.reason = "HIGH IMPACT NEWS ACTIVE: " + news.reason;
|
| }
|
| else
|
| {
|
| adj.direction = THRESHOLD_CONSERVATIVE;
|
| adj.confidence_multiplier = 1.5; // 50% harder
|
| adj.risk_multiplier = 0.5; // 50% less risk
|
| adj.position_size_multiplier = 0.5; // 50% smaller
|
| adj.sl_pips_adjustment = 10; // Much wider SL
|
| adj.tp_pips_adjustment = 5;
|
| adj.should_trade = true;
|
| adj.reason = "News active: " + news.reason;
|
| }
|
| adj.effective_until = TimeCurrent() + 1800; // 30 minutes
|
| break;
|
|
|
| case NEWS_STATE_AFTERMATH:
|
| // Post-news volatility - conservative
|
| adj.direction = THRESHOLD_CONSERVATIVE;
|
| adj.confidence_multiplier = 1.3;
|
| adj.risk_multiplier = 0.7;
|
| adj.position_size_multiplier = 0.6;
|
| adj.should_trade = true;
|
| adj.reason = "Post-news volatility detected";
|
| adj.effective_until = TimeCurrent() + 900; // 15 minutes
|
| break;
|
| }
|
|
|
| // Additional adjustments based on market response
|
| if(response.volatility_spike > m_volatility_spike_threshold)
|
| {
|
| adj.confidence_multiplier *= 1.2;
|
| adj.reason += " | High volatility detected";
|
| }
|
|
|
| if(response.spread_widening > m_spread_widening_threshold)
|
| {
|
| adj.confidence_multiplier *= 1.1;
|
| adj.position_size_multiplier *= 0.8;
|
| adj.reason += " | Spread widening";
|
| }
|
|
|
| return adj;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Record data for ML training |
|
| //+------------------------------------------------------------------+
|
| void RecordForTraining(const string symbol,
|
| const SNewsImpact &news,
|
| const SMarketResponse &response,
|
| const SThresholdAdjustment &adjustment)
|
| {
|
| // Build CSV line
|
| string line = StringFormat("%s,%s,%.4f,%.4f,%.4f,%d,%.2f,%.2f,%d,%.2f,%d,%.2f,%s\n",
|
| TimeToString(TimeCurrent(), TIME_DATE|TIME_SECONDS),
|
| symbol,
|
| news.volatility_prediction,
|
| response.volatility_spike,
|
| response.spread_widening,
|
| response.volume_surge,
|
| response.price_change_pct,
|
| (double)response.is_trending,
|
| adjustment.direction,
|
| adjustment.confidence_multiplier,
|
| (adjustment.should_trade ? 1 : 0),
|
| CalculateProfitabilityScore(news, response),
|
| news.reason
|
| );
|
|
|
| // Append to training file
|
| int handle = FileOpen(m_export_filename,
|
| FILE_WRITE|FILE_READ|FILE_CSV|FILE_COMMON,
|
| ',');
|
|
|
| if(handle != INVALID_HANDLE)
|
| {
|
| FileSeek(handle, 0, SEEK_END);
|
|
|
| // Write header if new file
|
| if(FileSize(handle) == 0)
|
| {
|
| FileWriteString(handle,
|
| "timestamp,symbol,volatility_prediction,volatility_spike,spread_widening," +
|
| "volume_surge,price_change_pct,is_trending,threshold_direction," +
|
| "confidence_multiplier,should_trade,profitability_score,news_reason\n");
|
| }
|
|
|
| FileWriteString(handle, line);
|
| FileClose(handle);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate profitability score for ML (0-1) |
|
| //+------------------------------------------------------------------+
|
| double CalculateProfitabilityScore(const SNewsImpact &news, const SMarketResponse &response)
|
| {
|
| // This is a heuristic - in production, this would be calculated from actual trade results
|
| double score = 0.5; // Neutral
|
|
|
| // Reduce score for high volatility
|
| if(response.volatility_spike > 2.0)
|
| score -= 0.2;
|
|
|
| // Reduce score for wide spreads
|
| if(response.spread_widening > 1.5)
|
| score -= 0.15;
|
|
|
| // Increase score if trending clearly
|
| if(response.is_trending && MathAbs(response.price_change_pct) > 0.1)
|
| score += 0.15;
|
|
|
| // Clamp
|
| if(score < 0) score = 0;
|
| if(score > 1) score = 1;
|
|
|
| return score;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get current adjustment (cached) |
|
| //+------------------------------------------------------------------+
|
| SThresholdAdjustment GetCurrentAdjustment()
|
| {
|
| // Check if expired
|
| if(m_current_adjustment.effective_until > 0 &&
|
| TimeCurrent() > m_current_adjustment.effective_until)
|
| {
|
| // Reset to normal
|
| m_current_adjustment = SThresholdAdjustment();
|
| m_current_state = NEWS_STATE_QUIET;
|
| }
|
|
|
| return m_current_adjustment;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Apply adjustment to a confidence value |
|
| //+------------------------------------------------------------------+
|
| double ApplyToConfidence(double base_confidence)
|
| {
|
| SThresholdAdjustment adj = GetCurrentAdjustment();
|
| return base_confidence / adj.confidence_multiplier;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Apply adjustment to position size |
|
| //+------------------------------------------------------------------+
|
| double ApplyToPositionSize(double base_lots)
|
| {
|
| SThresholdAdjustment adj = GetCurrentAdjustment();
|
| return base_lots * adj.position_size_multiplier;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Check if trading should proceed |
|
| //+------------------------------------------------------------------+
|
| bool ShouldTrade()
|
| {
|
| SThresholdAdjustment adj = GetCurrentAdjustment();
|
| return adj.should_trade;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Statistics and reporting |
|
| //+------------------------------------------------------------------+
|
| string GetStatistics()
|
| {
|
| string stats = StringFormat(
|
| "=== News Impact Analyzer Statistics ===\n" +
|
| "Analyses performed: %d\n" +
|
| "Trades blocked: %d (%.1f%%)\n" +
|
| "Thresholds adjusted: %d (%.1f%%)\n" +
|
| "Current state: %s\n" +
|
| "Training records: %d\n" +
|
| "Baseline volatility: %.5f\n" +
|
| "Baseline spread: %.5f",
|
| m_analysis_count,
|
| m_trade_blocked_count,
|
| (m_analysis_count > 0 ? 100.0 * m_trade_blocked_count / m_analysis_count : 0),
|
| m_threshold_adjusted_count,
|
| (m_analysis_count > 0 ? 100.0 * m_threshold_adjusted_count / m_analysis_count : 0),
|
| StateToString(m_current_state),
|
| m_history_count,
|
| m_baseline_volatility,
|
| m_baseline_spread
|
| );
|
|
|
| return stats;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Utility functions |
|
| //+------------------------------------------------------------------+
|
| string StateToString(ENUM_NEWS_STATE state)
|
| {
|
| switch(state)
|
| {
|
| case NEWS_STATE_QUIET: return "QUIET";
|
| case NEWS_STATE_WARNING: return "WARNING";
|
| case NEWS_STATE_ACTIVE: return "ACTIVE";
|
| case NEWS_STATE_AFTERMATH: return "AFTERMATH";
|
| default: return "UNKNOWN";
|
| }
|
| }
|
|
|
| void Log(const string message)
|
| {
|
| Print("[NewsImpactAnalyzer] " + message);
|
| }
|
|
|
| // Getters
|
| ENUM_NEWS_STATE GetCurrentState() const { return m_current_state; }
|
| bool IsActive() const { return m_current_state != NEWS_STATE_QUIET; }
|
| string GetCurrentReason() const { return m_current_adjustment.reason; }
|
| };
|
|
|
| // Static instance initialization
|
| CNewsImpactAnalyzer* CNewsImpactAnalyzer::s_instance = NULL;
|
|
|
| // Convenience macros
|
| #define ANALYZE_NEWS(symbol) \
|
| CNewsImpactAnalyzer::Instance().AnalyzeNewsImpact(symbol)
|
|
|
| #define GET_NEWS_ADJUSTMENT() \
|
| CNewsImpactAnalyzer::Instance().GetCurrentAdjustment()
|
|
|
| #define SHOULD_TRADE_NEWS() \
|
| CNewsImpactAnalyzer::Instance().ShouldTrade()
|
|
|
| #define APPLY_NEWS_TO_CONFIDENCE(base_conf) \
|
| CNewsImpactAnalyzer::Instance().ApplyToConfidence(base_conf)
|
|
|
| #define APPLY_NEWS_TO_SIZE(base_lots) \
|
| CNewsImpactAnalyzer::Instance().ApplyToPositionSize(base_lots)
|
|
|
| #endif // CNEWSIMPACTANALYZER_MQH
|
