| //+------------------------------------------------------------------+
|
| //| OTCLearningEngine.mqh |
|
| //| Copyright 2023, OTC Escape EA |
|
| //| https://www.otc.com |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2023, OTC"
|
| #property link "https://www.otc.com"
|
| #property version "2.00"
|
| #property strict
|
|
|
| #include <Arrays\ArrayObj.mqh>
|
| #include <Files\File.mqh>
|
| #include "OTCTypes.mqh"
|
|
|
| //+------------------------------------------------------------------+
|
| //| Learning Engine for OTC Escape EA |
|
| //+------------------------------------------------------------------+
|
| class CLearningEngine : public CObject
|
| {
|
| private:
|
| CArrayObj m_trade_history; // Holds pointers to STradeRecord objects
|
| SMetricSet m_overall_metrics;
|
| SMetricSet m_metrics_buy[4];
|
| SMetricSet m_metrics_sell[4];
|
| double m_volatility_threshold;
|
| double m_trend_threshold;
|
| int m_min_trades_for_analysis;
|
| string m_data_path; // Path for saving/loading data
|
| string m_symbol;
|
| ENUM_TIMEFRAMES m_period;
|
|
|
| public:
|
| CLearningEngine(double volatility_thresh, double trend_thresh);
|
| ~CLearningEngine();
|
|
|
| void Init(string symbol, ENUM_TIMEFRAMES period);
|
| void SetMinTradesForAnalysis(int min_trades);
|
| void AddTrade(STradeRecord *trade_record);
|
| void CalculatePerformanceMetrics();
|
| int GetTotalTrades() const;
|
| E_MARKET_REGIME GetCurrentMarketRegime(double volatility, double trend_strength);
|
| bool GetOptimizedParameters(SMarketState &state);
|
|
|
| private:
|
| // Private helper methods for metric calculations
|
| void _InitMetricSet(SMetricSet &metrics);
|
| void _UpdateMetricSetWithTrade(SMetricSet &metrics, const STradeRecord *trade);
|
| void _FinalizeMetricSet(SMetricSet &metrics);
|
| void _AnalyzeClosedTrade(const STradeRecord *closed_trade);
|
|
|
| // Private helper methods for data persistence
|
| bool SaveMetrics();
|
| bool LoadMetrics();
|
| bool SaveTradeHistory();
|
| void _LoadTradeHistory();
|
| string _GetMetricsFilePath();
|
| string _GetTradeHistoryFilePath();
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Constructor |
|
| //+------------------------------------------------------------------+
|
| CLearningEngine::CLearningEngine(double volatility_thresh, double trend_thresh)
|
| {
|
| m_volatility_threshold = volatility_thresh;
|
| m_trend_threshold = trend_thresh;
|
| m_min_trades_for_analysis = 10; // Default value
|
| m_data_path = TerminalInfoString(TERMINAL_DATA_PATH) + "\\MQL5\\Files\\OTC_Escape_Data";
|
| if(FileIsExist(m_data_path) == false)
|
| {
|
| if(FolderCreate(m_data_path) == false)
|
| {
|
| PrintFormat("Failed to create data directory: %s, Error: %d", m_data_path, GetLastError());
|
| }
|
| }
|
|
|
| m_trade_history.FreeMode(true); // CArrayObj will delete the STradeRecord pointers it holds
|
|
|
|
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Destructor |
|
| //+------------------------------------------------------------------+
|
| CLearningEngine::~CLearningEngine()
|
| {
|
| SaveMetrics();
|
| SaveTradeHistory();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Add a newly opened trade to the history |
|
| //+------------------------------------------------------------------+
|
| void CLearningEngine::SetMinTradesForAnalysis(int min_trades)
|
| {
|
| m_min_trades_for_analysis = min_trades;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Add a newly opened trade to the history |
|
| //+------------------------------------------------------------------+
|
| void CLearningEngine::AddTrade(STradeRecord *trade)
|
| {
|
| if(CheckPointer(trade) == POINTER_INVALID) return;
|
| if(!m_trade_history.Add(trade))
|
| {
|
| Print("Failed to add trade to history, deleting record.");
|
| delete trade;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Analyze a closed trade and update metrics |
|
| //+------------------------------------------------------------------+
|
| void CLearningEngine::_AnalyzeClosedTrade(const STradeRecord *closed_trade)
|
| {
|
| if(CheckPointer(closed_trade) == POINTER_INVALID) return;
|
|
|
| E_MARKET_REGIME regime = closed_trade->regime;
|
| if(closed_trade->trade_direction == 0) // Buy
|
| {
|
| _UpdateMetricSetWithTrade(m_metrics_buy[regime], closed_trade);
|
| }
|
| else // Sell
|
| {
|
| _UpdateMetricSetWithTrade(m_metrics_sell[regime], closed_trade);
|
| }
|
|
|
| _UpdateMetricSetWithTrade(m_overall_metrics, closed_trade);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get current market regime |
|
| //+------------------------------------------------------------------+
|
| E_MARKET_REGIME CLearningEngine::GetCurrentMarketRegime(double volatility, double trend_strength)
|
| {
|
| bool is_volatile = volatility > m_volatility_threshold;
|
| bool is_trending = trend_strength > m_trend_threshold;
|
|
|
| if(is_volatile && is_trending) return REGIME_VOLATILE_TRENDING;
|
| if(is_volatile && !is_trending) return REGIME_VOLATILE_RANGING;
|
| if(!is_volatile && is_trending) return REGIME_QUIET_TRENDING;
|
| // Default to quiet ranging
|
| return REGIME_QUIET_RANGING;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get optimized parameters for the current market state |
|
| //+------------------------------------------------------------------+
|
| bool CLearningEngine::GetOptimizedParameters(SMarketState &market_state)
|
| {
|
| E_MARKET_REGIME regime = market_state.regime;
|
| SMetricSet &metrics_buy = m_metrics_buy[regime];
|
| SMetricSet &metrics_sell = m_metrics_sell[regime];
|
|
|
| _FinalizeMetricSet(metrics_buy);
|
| _FinalizeMetricSet(metrics_sell);
|
|
|
| // Simple logic: choose the direction with better profit factor
|
| if(metrics_buy.profit_factor > metrics_sell.profit_factor && metrics_buy.total_trades >= m_min_trades_for_analysis)
|
| {
|
| market_state.trade_direction = ORDER_TYPE_BUY;
|
| market_state.optimal_sl = metrics_buy.avg_sl;
|
| market_state.optimal_tp = metrics_buy.avg_tp;
|
| return true;
|
| }
|
| else if(metrics_sell.profit_factor > metrics_buy.profit_factor && metrics_sell.total_trades >= m_min_trades_for_analysis)
|
| {
|
| market_state.trade_direction = ORDER_TYPE_SELL;
|
| market_state.optimal_sl = metrics_sell.avg_sl;
|
| market_state.optimal_tp = metrics_sell.avg_tp;
|
| return true;
|
| }
|
|
|
| return false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize a metric set |
|
| //+------------------------------------------------------------------+
|
| void CLearningEngine::_InitMetricSet(SMetricSet &metrics)
|
| {
|
| metrics.Reset();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update a metric set with a single trade's data |
|
| //+------------------------------------------------------------------+
|
| void CLearningEngine::_UpdateMetricSetWithTrade(SMetricSet &metrics, const STradeRecord *trade)
|
| {
|
| if(CheckPointer(trade) == POINTER_INVALID) return;
|
|
|
| metrics.total_trades++;
|
| metrics.total_sl_pips += (trade->stop_loss > 0 && trade->entry_price > 0) ? MathAbs(trade->entry_price - trade->stop_loss) / _Point : 0;
|
| metrics.total_tp_pips += (trade->take_profit > 0 && trade->entry_price > 0) ? MathAbs(trade->entry_price - trade->take_profit) / _Point : 0;
|
|
|
| if(trade->profit > 0)
|
| {
|
| metrics.total_wins++;
|
| metrics.total_profit += trade->profit;
|
| }
|
| else
|
| {
|
| metrics.total_losses++;
|
| metrics.total_loss += trade->profit;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Finalize calculations for a metric set |
|
| //+------------------------------------------------------------------+
|
| void CLearningEngine::_FinalizeMetricSet(SMetricSet &metrics)
|
| {
|
| if(metrics.total_trades > 0)
|
| {
|
| metrics.win_rate = (double)metrics.total_wins / metrics.total_trades;
|
| metrics.avg_sl = (metrics.total_sl_pips > 0) ? metrics.total_sl_pips / metrics.total_trades : 0;
|
| metrics.avg_tp = (metrics.total_tp_pips > 0) ? metrics.total_tp_pips / metrics.total_trades : 0;
|
| }
|
|
|
| if(metrics.gross_loss != 0)
|
| {
|
| metrics.profit_factor = MathAbs(metrics.gross_profit / metrics.gross_loss);
|
| }
|
| else
|
| {
|
| metrics.profit_factor = (metrics.gross_profit > 0) ? 999.0 : 0.0; // High value for no losses
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate performance metrics for all regimes |
|
| //+------------------------------------------------------------------+
|
| void CLearningEngine::CalculatePerformanceMetrics()
|
| {
|
| // Reset all metrics
|
| _InitMetricSet(m_overall_metrics);
|
| for(int i = 0; i < 4; i++)
|
| {
|
| _InitMetricSet(m_metrics_buy[i]);
|
| _InitMetricSet(m_metrics_sell[i]);
|
| }
|
|
|
| // Recalculate from history
|
| int total = m_trade_history.Total();
|
| for(int i = 0; i < total; i++)
|
| {
|
| STradeRecord *trade = m_trade_history.At(i);
|
| _AnalyzeClosedTrade(trade);
|
| }
|
|
|
| // Finalize all metrics
|
| _FinalizeMetricSet(m_overall_metrics);
|
| for(int i = 0; i < 4; i++)
|
| {
|
| _FinalizeMetricSet(m_metrics_buy[i]);
|
| _FinalizeMetricSet(m_metrics_sell[i]);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get total trades from history |
|
| //+------------------------------------------------------------------+
|
| int CLearningEngine::GetTotalTrades() const
|
| {
|
| return m_trade_history.Total();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get file path for metrics |
|
| //+------------------------------------------------------------------+
|
| string CLearningEngine::_GetMetricsFilePath()
|
| {
|
| return TerminalInfoString(TERMINAL_DATA_PATH) + "\\MQL5\\Files\\" + m_symbol + "_" + EnumToString(m_period) + "_metrics.bin";
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get file path for trade history |
|
| //+------------------------------------------------------------------+
|
| string CLearningEngine::_GetTradeHistoryFilePath()
|
| {
|
| return StringFormat("%s\\%s_%s_trades.bin", m_data_path, m_symbol, EnumToString(m_period));
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Save metrics to a file |
|
| //+------------------------------------------------------------------+
|
| bool CLearningEngine::SaveMetrics()
|
| {
|
| string file_path = _GetMetricsFilePath();
|
| int handle = FileOpen(file_path, FILE_WRITE | FILE_BIN);
|
| if(handle == INVALID_HANDLE)
|
| {
|
| PrintFormat("Failed to open metrics file for writing: %s", file_path);
|
| return false;
|
| }
|
|
|
| FileWriteStruct(handle, &m_overall_metrics);
|
| for(int i = 0; i < 4; i++)
|
| {
|
| FileWriteStruct(handle, &m_metrics_buy[i]);
|
| FileWriteStruct(handle, &m_metrics_sell[i]);
|
| }
|
|
|
| FileClose(handle);
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Load metrics from a file |
|
| //+------------------------------------------------------------------+
|
| bool CLearningEngine::LoadMetrics()
|
| {
|
| string file_path = _GetMetricsFilePath();
|
| if(!FileIsExist(file_path))
|
| {
|
| // Initialize all metrics if file doesn't exist
|
| _InitMetricSet(m_overall_metrics);
|
| for(int i = 0; i < 4; i++)
|
| {
|
| _InitMetricSet(m_metrics_buy[i]);
|
| _InitMetricSet(m_metrics_sell[i]);
|
| }
|
| return true; // Not an error, just first run
|
| }
|
|
|
| int handle = FileOpen(file_path, FILE_READ | FILE_BIN);
|
| if(handle == INVALID_HANDLE)
|
| {
|
| PrintFormat("Failed to open metrics file for reading: %s", file_path);
|
| return false;
|
| }
|
|
|
| FileReadStruct(handle, &m_overall_metrics);
|
| for(int i = 0; i < 4; i++)
|
| {
|
| FileReadStruct(handle, &m_metrics_buy[i]);
|
| FileReadStruct(handle, &m_metrics_sell[i]);
|
| }
|
|
|
| FileClose(handle);
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Save trade history to a file |
|
| //+------------------------------------------------------------------+
|
| bool CLearningEngine::SaveTradeHistory()
|
| {
|
| string file_path = _GetTradeHistoryFilePath();
|
| int handle = FileOpen(file_path, FILE_WRITE | FILE_BIN);
|
| if(handle == INVALID_HANDLE)
|
| {
|
| PrintFormat("Failed to open trade history file for writing: %s", file_path);
|
| return false;
|
| }
|
|
|
| int total = m_trade_history.Total();
|
| FileWriteInteger(handle, total, INT_VALUE);
|
|
|
| for(int i = 0; i < total; i++)
|
| {
|
| STradeRecord *trade = m_trade_history.At(i);
|
| if(CheckPointer(trade) == POINTER_INVALID) continue;
|
| FileWriteStruct(handle, trade);
|
| }
|
|
|
| FileClose(handle);
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Load trade history from a file |
|
| //+------------------------------------------------------------------+
|
| void CLearningEngine::_LoadTradeHistory()
|
| {
|
| string file_path = _GetTradeHistoryFilePath();
|
| if(!FileIsExist(file_path)) return;
|
|
|
| int handle = FileOpen(file_path, FILE_READ | FILE_BIN);
|
| if(handle == INVALID_HANDLE)
|
| {
|
| PrintFormat("Failed to open trade history file for reading: %s", file_path);
|
| return;
|
| }
|
|
|
| m_trade_history.Clear();
|
| int total = (int)FileReadInteger(handle, INT_VALUE);
|
|
|
| for(int i = 0; i < total; i++)
|
| {
|
| STradeRecord *trade = new STradeRecord();
|
| if(FileReadStruct(handle, trade) > 0)
|
| {
|
| if(!m_trade_history.Add(trade))
|
| {
|
| Print("Failed to add loaded trade to history, deleting record.");
|
| delete trade;
|
| }
|
| }
|
| else
|
| {
|
| Print("Failed to read trade record from file, deleting placeholder.");
|
| delete trade;
|
| break; // Stop reading if there's an error
|
| }
|
| }
|
|
|
| FileClose(handle);
|
| }
|
|
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize the learning engine with symbol and period |
|
| //+------------------------------------------------------------------+
|
| void CLearningEngine::Init(string symbol, ENUM_TIMEFRAMES period)
|
| {
|
| m_symbol = symbol;
|
| m_period = period;
|
|
|
| // Now that we have symbol and period, load data
|
| if(!LoadMetrics())
|
| {
|
| Print("No metrics file found. Initializing new metrics.");
|
| // Initialize all metrics if file doesn't exist
|
| _InitMetricSet(m_overall_metrics);
|
| for(int i = 0; i < 4; i++)
|
| {
|
| _InitMetricSet(m_metrics_buy[i]);
|
| _InitMetricSet(m_metrics_sell[i]);
|
| }
|
| }
|
| _LoadTradeHistory();
|
| }
|
|
|
|
|
