282 lines
9.8 KiB
MQL5
282 lines
9.8 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| CGateBase.mqh - Abstract Gate Interface |
| |||
//| Based on chat-8Stage Gate System Integration Guide |
| |||
//| Enhances modularity with shadow logging & auto-tuning support |
| |||
//+------------------------------------------------------------------+
| |||
#ifndef CGATEBASE_MQH
| |||
#define CGATEBASE_MQH
| |||
| |||
#include <Arrays/ArrayLong.mqh>
| |||
#include "IStrategy.mqh"
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Gate Result Structure |
| |||
//+------------------------------------------------------------------+
| |||
struct EGateResult
| |||
{
| |||
bool passed; // Gate passed?
| |||
double confidence; // Confidence score (0.0-1.0)
| |||
double threshold; // Applied threshold
| |||
string block_reason; // Why blocked (if failed)
| |||
ulong latency_us; // Execution time in microseconds
| |||
| |||
void Set(bool p, double c, double t, string r="", ulong l=0)
| |||
{
| |||
passed = p;
| |||
confidence = c;
| |||
threshold = t;
| |||
block_reason = r;
| |||
latency_us = l;
| |||
}
| |||
};
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Auto-Tuning Configuration |
| |||
//+------------------------------------------------------------------+
| |||
struct SGateAutoTuneConfig
| |||
{
| |||
bool enabled; // Auto-tuning active?
| |||
double min_threshold; // Minimum allowed threshold
| |||
double max_threshold; // Maximum allowed threshold
| |||
int lookback_trades; // Trades to analyze
| |||
double target_winrate; // Target win rate for optimization
| |||
double learning_rate; // Adjustment speed (0.01-0.1)
| |||
| |||
void Init(double min_t=0.3, double max_t=0.9, int lookback=20,
| |||
double target_wr=0.55, double lr=0.05)
| |||
{
| |||
enabled = true;
| |||
min_threshold = min_t;
| |||
max_threshold = max_t;
| |||
lookback_trades = lookback;
| |||
target_winrate = target_wr;
| |||
learning_rate = lr;
| |||
}
| |||
};
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Abstract Gate Base Class |
| |||
//+------------------------------------------------------------------+
| |||
class CGateBase
| |||
{
| |||
protected:
| |||
string m_name; // Gate name
| |||
bool m_enabled; // Gate enabled?
| |||
bool m_shadow_mode; // Shadow logging only?
| |||
double m_threshold; // Current threshold
| |||
double m_default_threshold; // Default/fallback threshold
| |||
| |||
// Auto-tuning
| |||
SGateAutoTuneConfig m_autotune; // Auto-tuning config
| |||
double m_trade_history[]; // Trade PnL history for learning
| |||
bool m_pass_history[]; // Gate pass/fail history
| |||
| |||
// Performance tracking
| |||
ulong m_total_evaluations; // Total validations
| |||
ulong m_passed_count; // Passed count
| |||
double m_avg_latency_us; // Average latency
| |||
| |||
public:
| |||
// Constructor
| |||
CGateBase(string name)
| |||
: m_name(name),
| |||
m_enabled(true),
| |||
m_shadow_mode(false),
| |||
m_threshold(0.5),
| |||
m_default_threshold(0.5),
| |||
m_total_evaluations(0),
| |||
m_passed_count(0),
| |||
m_avg_latency_us(0.0)
| |||
{
| |||
ArrayResize(m_trade_history, 0);
| |||
ArrayResize(m_pass_history, 0);
| |||
}
| |||
| |||
// Virtual destructor
| |||
virtual ~CGateBase() {}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Core Interface (MUST OVERRIDE) |
| |||
//+------------------------------------------------------------------+
| |||
virtual bool Initialize() { return true; }
| |||
virtual bool Validate(TradingSignal &signal, EGateResult &result) = 0;
| |||
virtual double CalculateConfidence(const TradingSignal &signal) = 0;
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Configuration Interface |
| |||
//+------------------------------------------------------------------+
| |||
void Enable(bool enable) { m_enabled = enable; }
| |||
void SetShadowMode(bool shadow) { m_shadow_mode = shadow; }
| |||
void SetThreshold(double threshold)
| |||
{
| |||
m_threshold = MathMax(0.0, MathMin(1.0, threshold));
| |||
}
| |||
void SetDefaultThreshold(double threshold)
| |||
{
| |||
m_default_threshold = MathMax(0.0, MathMin(1.0, threshold));
| |||
if(m_threshold == 0.0) m_threshold = m_default_threshold;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Auto-Tuning Interface |
| |||
//+------------------------------------------------------------------+
| |||
void EnableAutoTune(const SGateAutoTuneConfig &config)
| |||
{
| |||
m_autotune = config;
| |||
}
| |||
| |||
void DisableAutoTune() { m_autotune.enabled = false; }
| |||
| |||
void RecordTradeOutcome(double pnl, bool gate_passed)
| |||
{
| |||
// Add to history ring buffer
| |||
int size = ArraySize(m_trade_history);
| |||
if(size >= m_autotune.lookback_trades)
| |||
{
| |||
// Shift array (ring buffer)
| |||
for(int i=0; i<size-1; i++)
| |||
{
| |||
m_trade_history[i] = m_trade_history[i+1];
| |||
m_pass_history[i] = m_pass_history[i+1];
| |||
}
| |||
m_trade_history[size-1] = pnl;
| |||
m_pass_history[size-1] = gate_passed;
| |||
}
| |||
else
| |||
{
| |||
ArrayResize(m_trade_history, size+1);
| |||
ArrayResize(m_pass_history, size+1);
| |||
m_trade_history[size] = pnl;
| |||
m_pass_history[size] = gate_passed;
| |||
}
| |||
| |||
// Trigger auto-tuning if enough data
| |||
if(m_autotune.enabled && size >= m_autotune.lookback_trades/2)
| |||
{
| |||
AutoTuneThreshold();
| |||
}
| |||
}
| |||
| |||
void AutoTuneThreshold()
| |||
{
| |||
if(!m_autotune.enabled) return;
| |||
| |||
int size = ArraySize(m_trade_history);
| |||
if(size < 5) return; // Need minimum data
| |||
| |||
// Calculate win rate for trades that passed this gate
| |||
int wins = 0, total_passed = 0;
| |||
double total_pnl = 0;
| |||
| |||
for(int i=0; i<size; i++)
| |||
{
| |||
if(m_pass_history[i]) // Gate was passed
| |||
{
| |||
total_passed++;
| |||
if(m_trade_history[i] > 0) wins++;
| |||
total_pnl += m_trade_history[i];
| |||
}
| |||
}
| |||
| |||
if(total_passed == 0) return;
| |||
| |||
double winrate = (double)wins / total_passed;
| |||
double profit_factor = total_pnl > 0 ? total_pnl / MathAbs(total_pnl) : 0;
| |||
| |||
// Adjust threshold based on performance
| |||
double adjustment = 0.0;
| |||
if(winrate < m_autotune.target_winrate * 0.9)
| |||
{
| |||
// Win rate too low - make threshold stricter
| |||
adjustment = m_autotune.learning_rate;
| |||
}
| |||
else if(winrate > m_autotune.target_winrate * 1.1 && profit_factor > 1.2)
| |||
{
| |||
// Win rate high and profitable - can relax threshold
| |||
adjustment = -m_autotune.learning_rate;
| |||
}
| |||
| |||
// Apply adjustment with bounds
| |||
double new_threshold = m_threshold + adjustment;
| |||
new_threshold = MathMax(m_autotune.min_threshold,
| |||
MathMin(m_autotune.max_threshold, new_threshold));
| |||
| |||
if(MathAbs(new_threshold - m_threshold) > 0.001)
| |||
{
| |||
Print(StringFormat("[Gate:%s] Auto-tuned: %.3f -> %.3f (WR=%.2f%% PF=%.2f)",
| |||
m_name, m_threshold, new_threshold, winrate*100, profit_factor));
| |||
m_threshold = new_threshold;
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Performance Tracking |
| |||
//+------------------------------------------------------------------+
| |||
void RecordLatency(ulong latency_us)
| |||
{
| |||
// Exponential moving average
| |||
if(m_avg_latency_us == 0)
| |||
m_avg_latency_us = (double)latency_us;
| |||
else
| |||
m_avg_latency_us = m_avg_latency_us * 0.9 + (double)latency_us * 0.1;
| |||
| |||
m_total_evaluations++;
| |||
}
| |||
| |||
void RecordPass(bool passed)
| |||
{
| |||
if(passed) m_passed_count++;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Getters |
| |||
//+------------------------------------------------------------------+
| |||
string GetName() const { return m_name; }
| |||
bool IsEnabled() const { return m_enabled; }
| |||
bool IsShadowMode() const { return m_shadow_mode; }
| |||
double GetThreshold() const { return m_threshold; }
| |||
double GetDefaultThreshold() const { return m_default_threshold; }
| |||
double GetAvgLatency() const { return m_avg_latency_us; }
| |||
double GetPassRate() const
| |||
{
| |||
return m_total_evaluations > 0 ? (double)m_passed_count / m_total_evaluations : 0.0;
| |||
}
| |||
bool IsAutoTuneEnabled() const { return m_autotune.enabled; }
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Learning Interface |
| |||
//+------------------------------------------------------------------+
| |||
void UpdateThresholdFromLearning()
| |||
{
| |||
// Update threshold based on learning data
| |||
// This is called by the gate manager to refresh thresholds
| |||
if(m_autotune.enabled)
| |||
{
| |||
AutoTuneThreshold();
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Statistics |
| |||
//+------------------------------------------------------------------+
| |||
void PrintStats()
| |||
{
| |||
Print(StringFormat("[Gate:%s] Enabled=%s Evals=%I64u Passed=%I64u (%.1f%%) Latency=%.1fus Threshold=%.3f",
| |||
m_name,
| |||
m_enabled ? "YES" : "NO",
| |||
m_total_evaluations,
| |||
m_passed_count,
| |||
GetPassRate() * 100,
| |||
m_avg_latency_us,
| |||
m_threshold));
| |||
}
| |||
| |||
void ResetStats()
| |||
{
| |||
m_total_evaluations = 0;
| |||
m_passed_count = 0;
| |||
m_avg_latency_us = 0.0;
| |||
}
| |||
};
| |||
| |||
#endif // CGATEBASE_MQH
|