674 lines
24 KiB
MQL5
674 lines
24 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| 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
|