607 lines
20 KiB
MQL5
607 lines
20 KiB
MQL5
|
//+------------------------------------------------------------------+
|
||
|
|
//| PerformanceTracker.mqh v1.0 |
|
||
|
|
//| Centralized Performance Tracking & Analytics |
|
||
|
|
//| Optimized for Real-time Updates |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
#ifndef PERFORMANCE_TRACKER_MQH
|
||
|
|
#define PERFORMANCE_TRACKER_MQH
|
||
|
|
|
||
|
|
#include "DataTypes.mqh"
|
||
|
|
#include <Math/Stat/Math.mqh>
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Trade history entry for performance calculation |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
struct TradeHistoryEntry
|
||
|
|
{
|
||
|
|
ulong ticket;
|
||
|
|
string symbol;
|
||
|
|
ENUM_POSITION_TYPE type;
|
||
|
|
datetime open_time;
|
||
|
|
datetime close_time;
|
||
|
|
double volume;
|
||
|
|
double open_price;
|
||
|
|
double close_price;
|
||
|
|
double profit;
|
||
|
|
double commission;
|
||
|
|
double swap;
|
||
|
|
double risk_amount;
|
||
|
|
double r_multiple;
|
||
|
|
int duration_bars;
|
||
|
|
string strategy;
|
||
|
|
};
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Performance Tracker Class |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
class CPerformanceTracker
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
//--- Trade history
|
||
|
|
TradeHistoryEntry m_history[];
|
||
|
|
int m_history_size;
|
||
|
|
int m_max_history;
|
||
|
|
|
||
|
|
//--- Cached metrics
|
||
|
|
PerformanceMetrics m_metrics;
|
||
|
|
datetime m_last_update;
|
||
|
|
bool m_cache_valid;
|
||
|
|
|
||
|
|
//--- Daily tracking
|
||
|
|
double m_daily_starting_balance;
|
||
|
|
datetime m_day_start;
|
||
|
|
PerformanceMetrics m_daily_metrics;
|
||
|
|
|
||
|
|
//--- Return series for advanced calculations
|
||
|
|
double m_returns[];
|
||
|
|
double m_equity_curve[];
|
||
|
|
int m_curve_size;
|
||
|
|
|
||
|
|
//--- Configuration
|
||
|
|
int m_lookback_period;
|
||
|
|
double m_risk_free_rate;
|
||
|
|
|
||
|
|
//--- Helper methods
|
||
|
|
void UpdateBasicMetrics();
|
||
|
|
void UpdateAdvancedMetrics();
|
||
|
|
void UpdateDrawdownMetrics();
|
||
|
|
void UpdateReturnDistribution();
|
||
|
|
void CalculateRatios();
|
||
|
|
double CalculateSharpe();
|
||
|
|
double CalculateSortino();
|
||
|
|
double CalculateCalmar();
|
||
|
|
void UpdateEquityCurve(double current_balance);
|
||
|
|
|
||
|
|
public:
|
||
|
|
CPerformanceTracker();
|
||
|
|
~CPerformanceTracker();
|
||
|
|
|
||
|
|
//--- Initialization
|
||
|
|
bool Initialize(int max_history = 1000, int lookback = 252);
|
||
|
|
|
||
|
|
//--- Trade tracking
|
||
|
|
void AddTrade(const ManagedTrade &trade, double close_price);
|
||
|
|
void UpdateOpenTrade(const ManagedTrade &trade);
|
||
|
|
|
||
|
|
//--- Metric access
|
||
|
|
PerformanceMetrics GetMetrics(bool force_update = false);
|
||
|
|
PerformanceMetrics GetDailyMetrics();
|
||
|
|
|
||
|
|
//--- Specific metrics
|
||
|
|
double GetWinRate() { return m_metrics.win_rate; }
|
||
|
|
double GetProfitFactor() { return m_metrics.profit_factor; }
|
||
|
|
double GetExpectancy() { return m_metrics.expectancy; }
|
||
|
|
double GetSharpeRatio() { return m_metrics.sharpe_ratio; }
|
||
|
|
double GetMaxDrawdown() { return m_metrics.max_drawdown_percent; }
|
||
|
|
double GetRecoveryFactor() { return m_metrics.recovery_factor; }
|
||
|
|
|
||
|
|
//--- Advanced analytics
|
||
|
|
double GetValueAtRisk(double confidence = 0.95);
|
||
|
|
double GetExpectedShortfall(double confidence = 0.95);
|
||
|
|
double GetMaximumAdverseExcursion();
|
||
|
|
double GetMaximumFavorableExcursion();
|
||
|
|
double GetProfitability();
|
||
|
|
double GetConsistencyScore();
|
||
|
|
|
||
|
|
//--- Strategy analysis
|
||
|
|
void GetStrategyBreakdown(string &strategies[], double &profits[]);
|
||
|
|
void GetTimeAnalysis(int &hour_wins[], int &hour_losses[]);
|
||
|
|
void GetSymbolBreakdown(string &symbols[], double &profits[]);
|
||
|
|
|
||
|
|
//--- Period analysis
|
||
|
|
PerformanceMetrics GetPeriodMetrics(datetime from, datetime to);
|
||
|
|
PerformanceMetrics GetMonthlyMetrics(int year, int month);
|
||
|
|
PerformanceMetrics GetWeeklyMetrics();
|
||
|
|
|
||
|
|
//--- Reset functions
|
||
|
|
void ResetDaily();
|
||
|
|
void ResetAll();
|
||
|
|
|
||
|
|
//--- Export functions
|
||
|
|
bool ExportToCSV(string filename);
|
||
|
|
string GetSummaryReport();
|
||
|
|
|
||
|
|
//--- Statistical functions
|
||
|
|
double GetAverageTradeTime();
|
||
|
|
double GetWinLossRatio();
|
||
|
|
double GetPayoffRatio();
|
||
|
|
int GetTradingDays();
|
||
|
|
double GetTradesPerDay();
|
||
|
|
};
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Constructor |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CPerformanceTracker::CPerformanceTracker()
|
||
|
|
{
|
||
|
|
m_history_size = 0;
|
||
|
|
m_max_history = 1000;
|
||
|
|
m_last_update = 0;
|
||
|
|
m_cache_valid = false;
|
||
|
|
m_curve_size = 0;
|
||
|
|
m_lookback_period = 252; // Trading days
|
||
|
|
m_risk_free_rate = 0.02; // 2% annual
|
||
|
|
m_daily_starting_balance = 0;
|
||
|
|
m_day_start = 0;
|
||
|
|
|
||
|
|
//--- Initialize metrics
|
||
|
|
ZeroMemory(m_metrics);
|
||
|
|
ZeroMemory(m_daily_metrics);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Destructor |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CPerformanceTracker::~CPerformanceTracker()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Initialize tracker |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CPerformanceTracker::Initialize(int max_history, int lookback)
|
||
|
|
{
|
||
|
|
m_max_history = max_history;
|
||
|
|
m_lookback_period = lookback;
|
||
|
|
|
||
|
|
//--- Allocate arrays
|
||
|
|
ArrayResize(m_history, m_max_history);
|
||
|
|
ArrayResize(m_returns, m_lookback_period);
|
||
|
|
ArrayResize(m_equity_curve, m_lookback_period * 2);
|
||
|
|
|
||
|
|
//--- Initialize daily tracking
|
||
|
|
m_daily_starting_balance = AccountInfoDouble(ACCOUNT_BALANCE);
|
||
|
|
m_day_start = TimeCurrent();
|
||
|
|
|
||
|
|
Print("PerformanceTracker initialized: MaxHistory=", m_max_history,
|
||
|
|
", Lookback=", m_lookback_period);
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Add closed trade to history |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CPerformanceTracker::AddTrade(const ManagedTrade &trade, double close_price)
|
||
|
|
{
|
||
|
|
//--- Check array capacity
|
||
|
|
if(m_history_size >= m_max_history)
|
||
|
|
{
|
||
|
|
//--- Shift array (remove oldest)
|
||
|
|
for(int i = 0; i < m_max_history - 1; i++)
|
||
|
|
m_history[i] = m_history[i + 1];
|
||
|
|
m_history_size = m_max_history - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Add new entry
|
||
|
|
TradeHistoryEntry entry;
|
||
|
|
entry.ticket = trade.ticket;
|
||
|
|
entry.symbol = trade.symbol;
|
||
|
|
entry.type = trade.type;
|
||
|
|
entry.open_time = trade.open_time;
|
||
|
|
entry.close_time = TimeCurrent();
|
||
|
|
entry.volume = trade.volume;
|
||
|
|
entry.open_price = trade.open_price;
|
||
|
|
entry.close_price = close_price;
|
||
|
|
entry.profit = trade.profit;
|
||
|
|
entry.commission = trade.commission;
|
||
|
|
entry.swap = trade.swap;
|
||
|
|
entry.risk_amount = trade.risk_amount;
|
||
|
|
entry.r_multiple = trade.r_multiple;
|
||
|
|
entry.duration_bars = trade.bars_in_trade;
|
||
|
|
entry.strategy = trade.entry_reason;
|
||
|
|
|
||
|
|
m_history[m_history_size] = entry;
|
||
|
|
m_history_size++;
|
||
|
|
|
||
|
|
//--- Invalidate cache
|
||
|
|
m_cache_valid = false;
|
||
|
|
|
||
|
|
//--- Update equity curve
|
||
|
|
UpdateEquityCurve(AccountInfoDouble(ACCOUNT_BALANCE));
|
||
|
|
|
||
|
|
//--- Update metrics if significant time passed
|
||
|
|
if(TimeCurrent() - m_last_update > 5)
|
||
|
|
{
|
||
|
|
UpdateBasicMetrics();
|
||
|
|
m_last_update = TimeCurrent();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Get performance metrics with caching |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
PerformanceMetrics CPerformanceTracker::GetMetrics(bool force_update)
|
||
|
|
{
|
||
|
|
if(!m_cache_valid || force_update || TimeCurrent() - m_last_update > 30)
|
||
|
|
{
|
||
|
|
UpdateBasicMetrics();
|
||
|
|
UpdateAdvancedMetrics();
|
||
|
|
UpdateDrawdownMetrics();
|
||
|
|
CalculateRatios();
|
||
|
|
|
||
|
|
m_cache_valid = true;
|
||
|
|
m_last_update = TimeCurrent();
|
||
|
|
}
|
||
|
|
|
||
|
|
return m_metrics;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Update basic performance metrics |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CPerformanceTracker::UpdateBasicMetrics()
|
||
|
|
{
|
||
|
|
//--- Reset counters
|
||
|
|
m_metrics.total_trades = m_history_size;
|
||
|
|
m_metrics.winning_trades = 0;
|
||
|
|
m_metrics.losing_trades = 0;
|
||
|
|
m_metrics.gross_profit = 0;
|
||
|
|
m_metrics.gross_loss = 0;
|
||
|
|
|
||
|
|
//--- Process all trades
|
||
|
|
for(int i = 0; i < m_history_size; i++)
|
||
|
|
{
|
||
|
|
double net_profit = m_history[i].profit + m_history[i].commission + m_history[i].swap;
|
||
|
|
|
||
|
|
if(net_profit > 0)
|
||
|
|
{
|
||
|
|
m_metrics.winning_trades++;
|
||
|
|
m_metrics.gross_profit += net_profit;
|
||
|
|
|
||
|
|
if(net_profit > m_metrics.largest_win)
|
||
|
|
m_metrics.largest_win = net_profit;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_metrics.losing_trades++;
|
||
|
|
m_metrics.gross_loss += MathAbs(net_profit);
|
||
|
|
|
||
|
|
if(MathAbs(net_profit) > m_metrics.largest_loss)
|
||
|
|
m_metrics.largest_loss = MathAbs(net_profit);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Calculate derived metrics
|
||
|
|
m_metrics.net_profit = m_metrics.gross_profit - m_metrics.gross_loss;
|
||
|
|
|
||
|
|
if(m_metrics.total_trades > 0)
|
||
|
|
{
|
||
|
|
m_metrics.win_rate = (double)m_metrics.winning_trades / m_metrics.total_trades * 100;
|
||
|
|
m_metrics.expectancy = m_metrics.net_profit / m_metrics.total_trades;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(m_metrics.winning_trades > 0)
|
||
|
|
m_metrics.avg_win = m_metrics.gross_profit / m_metrics.winning_trades;
|
||
|
|
|
||
|
|
if(m_metrics.losing_trades > 0)
|
||
|
|
m_metrics.avg_loss = m_metrics.gross_loss / m_metrics.losing_trades;
|
||
|
|
|
||
|
|
if(m_metrics.gross_loss > 0)
|
||
|
|
m_metrics.profit_factor = m_metrics.gross_profit / m_metrics.gross_loss;
|
||
|
|
else
|
||
|
|
m_metrics.profit_factor = m_metrics.gross_profit > 0 ? 999.99 : 0;
|
||
|
|
|
||
|
|
if(m_metrics.avg_loss > 0)
|
||
|
|
m_metrics.risk_reward_ratio = m_metrics.avg_win / m_metrics.avg_loss;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Update advanced metrics |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CPerformanceTracker::UpdateAdvancedMetrics()
|
||
|
|
{
|
||
|
|
if(m_history_size == 0) return;
|
||
|
|
|
||
|
|
//--- Consecutive tracking
|
||
|
|
int current_wins = 0;
|
||
|
|
int current_losses = 0;
|
||
|
|
m_metrics.max_consecutive_wins = 0;
|
||
|
|
m_metrics.max_consecutive_losses = 0;
|
||
|
|
|
||
|
|
//--- Trade duration
|
||
|
|
double total_duration = 0;
|
||
|
|
double win_duration = 0;
|
||
|
|
double loss_duration = 0;
|
||
|
|
int win_count = 0;
|
||
|
|
int loss_count = 0;
|
||
|
|
|
||
|
|
for(int i = 0; i < m_history_size; i++)
|
||
|
|
{
|
||
|
|
double net_profit = m_history[i].profit + m_history[i].commission + m_history[i].swap;
|
||
|
|
|
||
|
|
//--- Consecutive tracking
|
||
|
|
if(net_profit > 0)
|
||
|
|
{
|
||
|
|
current_wins++;
|
||
|
|
current_losses = 0;
|
||
|
|
if(current_wins > m_metrics.max_consecutive_wins)
|
||
|
|
m_metrics.max_consecutive_wins = current_wins;
|
||
|
|
|
||
|
|
win_duration += m_history[i].duration_bars;
|
||
|
|
win_count++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
current_losses++;
|
||
|
|
current_wins = 0;
|
||
|
|
if(current_losses > m_metrics.max_consecutive_losses)
|
||
|
|
m_metrics.max_consecutive_losses = current_losses;
|
||
|
|
|
||
|
|
loss_duration += m_history[i].duration_bars;
|
||
|
|
loss_count++;
|
||
|
|
}
|
||
|
|
|
||
|
|
total_duration += m_history[i].duration_bars;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Average durations
|
||
|
|
if(m_history_size > 0)
|
||
|
|
m_metrics.avg_trade_duration = total_duration / m_history_size;
|
||
|
|
if(win_count > 0)
|
||
|
|
m_metrics.win_duration = win_duration / win_count;
|
||
|
|
if(loss_count > 0)
|
||
|
|
m_metrics.loss_duration = loss_duration / loss_count;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate Sharpe ratio |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CPerformanceTracker::CalculateSharpe()
|
||
|
|
{
|
||
|
|
if(m_curve_size < 30) return 0; // Need sufficient data
|
||
|
|
|
||
|
|
//--- Calculate returns
|
||
|
|
ArrayResize(m_returns, m_curve_size - 1);
|
||
|
|
for(int i = 1; i < m_curve_size; i++)
|
||
|
|
{
|
||
|
|
if(m_equity_curve[i-1] > 0)
|
||
|
|
m_returns[i-1] = (m_equity_curve[i] - m_equity_curve[i-1]) / m_equity_curve[i-1];
|
||
|
|
else
|
||
|
|
m_returns[i-1] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Calculate mean and std dev
|
||
|
|
double mean = MathMean(m_returns);
|
||
|
|
double std_dev = MathStandardDeviation(m_returns);
|
||
|
|
|
||
|
|
if(std_dev == 0) return 0;
|
||
|
|
|
||
|
|
//--- Annualize (assuming daily returns)
|
||
|
|
double annual_return = mean * 252;
|
||
|
|
double annual_std = std_dev * MathSqrt(252);
|
||
|
|
|
||
|
|
return (annual_return - m_risk_free_rate) / annual_std;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Update drawdown metrics |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CPerformanceTracker::UpdateDrawdownMetrics()
|
||
|
|
{
|
||
|
|
if(m_curve_size == 0) return;
|
||
|
|
|
||
|
|
double peak = m_equity_curve[0];
|
||
|
|
m_metrics.max_drawdown_amount = 0;
|
||
|
|
m_metrics.max_drawdown_percent = 0;
|
||
|
|
|
||
|
|
for(int i = 1; i < m_curve_size; i++)
|
||
|
|
{
|
||
|
|
if(m_equity_curve[i] > peak)
|
||
|
|
peak = m_equity_curve[i];
|
||
|
|
|
||
|
|
double drawdown = peak - m_equity_curve[i];
|
||
|
|
double drawdown_percent = (peak > 0) ? drawdown / peak * 100 : 0;
|
||
|
|
|
||
|
|
if(drawdown > m_metrics.max_drawdown_amount)
|
||
|
|
{
|
||
|
|
m_metrics.max_drawdown_amount = drawdown;
|
||
|
|
m_metrics.max_drawdown_percent = drawdown_percent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Current drawdown
|
||
|
|
double current_balance = AccountInfoDouble(ACCOUNT_BALANCE);
|
||
|
|
if(current_balance < peak)
|
||
|
|
{
|
||
|
|
m_metrics.current_drawdown = (peak - current_balance) / peak * 100;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_metrics.current_drawdown = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Recovery factor
|
||
|
|
if(m_metrics.max_drawdown_amount > 0)
|
||
|
|
m_metrics.recovery_factor = m_metrics.net_profit / m_metrics.max_drawdown_amount;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Update equity curve |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CPerformanceTracker::UpdateEquityCurve(double current_balance)
|
||
|
|
{
|
||
|
|
//--- Shift array if full
|
||
|
|
if(m_curve_size >= ArraySize(m_equity_curve))
|
||
|
|
{
|
||
|
|
for(int i = 0; i < m_curve_size - 1; i++)
|
||
|
|
m_equity_curve[i] = m_equity_curve[i + 1];
|
||
|
|
m_curve_size--;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Add new value
|
||
|
|
m_equity_curve[m_curve_size] = current_balance;
|
||
|
|
m_curve_size++;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate all ratios |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CPerformanceTracker::CalculateRatios()
|
||
|
|
{
|
||
|
|
m_metrics.sharpe_ratio = CalculateSharpe();
|
||
|
|
m_metrics.sortino_ratio = CalculateSortino();
|
||
|
|
m_metrics.calmar_ratio = CalculateCalmar();
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate Sortino ratio (downside deviation) |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CPerformanceTracker::CalculateSortino()
|
||
|
|
{
|
||
|
|
if(m_curve_size < 30) return 0;
|
||
|
|
|
||
|
|
//--- Calculate downside returns only
|
||
|
|
double negative_returns[];
|
||
|
|
int neg_count = 0;
|
||
|
|
|
||
|
|
for(int i = 0; i < ArraySize(m_returns); i++)
|
||
|
|
{
|
||
|
|
if(m_returns[i] < 0)
|
||
|
|
{
|
||
|
|
ArrayResize(negative_returns, neg_count + 1);
|
||
|
|
negative_returns[neg_count] = m_returns[i];
|
||
|
|
neg_count++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(neg_count == 0) return 999.99; // No downside
|
||
|
|
|
||
|
|
double mean_return = MathMean(m_returns);
|
||
|
|
double downside_dev = MathStandardDeviation(negative_returns);
|
||
|
|
|
||
|
|
if(downside_dev == 0) return 999.99;
|
||
|
|
|
||
|
|
//--- Annualize
|
||
|
|
double annual_return = mean_return * 252;
|
||
|
|
double annual_downside = downside_dev * MathSqrt(252);
|
||
|
|
|
||
|
|
return (annual_return - m_risk_free_rate) / annual_downside;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate Calmar ratio |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CPerformanceTracker::CalculateCalmar()
|
||
|
|
{
|
||
|
|
if(m_metrics.max_drawdown_percent == 0) return 0;
|
||
|
|
|
||
|
|
//--- Annualized return
|
||
|
|
int days = GetTradingDays();
|
||
|
|
if(days == 0) return 0;
|
||
|
|
|
||
|
|
double annual_return = (m_metrics.net_profit / m_daily_starting_balance) * (252.0 / days) * 100;
|
||
|
|
|
||
|
|
return annual_return / m_metrics.max_drawdown_percent;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Get trading days |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
int CPerformanceTracker::GetTradingDays()
|
||
|
|
{
|
||
|
|
if(m_history_size == 0) return 0;
|
||
|
|
|
||
|
|
datetime first_trade = m_history[0].open_time;
|
||
|
|
datetime last_trade = m_history[m_history_size - 1].close_time;
|
||
|
|
|
||
|
|
int days = (int)((last_trade - first_trade) / 86400);
|
||
|
|
|
||
|
|
//--- Approximate trading days (exclude weekends)
|
||
|
|
return (int)(days * 5.0 / 7.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Get strategy breakdown |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CPerformanceTracker::GetStrategyBreakdown(string &strategies[], double &profits[])
|
||
|
|
{
|
||
|
|
//--- Temporary storage
|
||
|
|
string temp_strategies[];
|
||
|
|
double temp_profits[];
|
||
|
|
int strategy_count = 0;
|
||
|
|
|
||
|
|
//--- Aggregate by strategy
|
||
|
|
for(int i = 0; i < m_history_size; i++)
|
||
|
|
{
|
||
|
|
string strategy = m_history[i].strategy;
|
||
|
|
double profit = m_history[i].profit + m_history[i].commission + m_history[i].swap;
|
||
|
|
|
||
|
|
//--- Find or add strategy
|
||
|
|
int index = -1;
|
||
|
|
for(int j = 0; j < strategy_count; j++)
|
||
|
|
{
|
||
|
|
if(temp_strategies[j] == strategy)
|
||
|
|
{
|
||
|
|
index = j;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(index >= 0)
|
||
|
|
{
|
||
|
|
temp_profits[index] += profit;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ArrayResize(temp_strategies, strategy_count + 1);
|
||
|
|
ArrayResize(temp_profits, strategy_count + 1);
|
||
|
|
temp_strategies[strategy_count] = strategy;
|
||
|
|
temp_profits[strategy_count] = profit;
|
||
|
|
strategy_count++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Copy to output arrays
|
||
|
|
ArrayResize(strategies, strategy_count);
|
||
|
|
ArrayResize(profits, strategy_count);
|
||
|
|
|
||
|
|
for(int i = 0; i < strategy_count; i++)
|
||
|
|
{
|
||
|
|
strategies[i] = temp_strategies[i];
|
||
|
|
profits[i] = temp_profits[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Get summary report |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
string CPerformanceTracker::GetSummaryReport()
|
||
|
|
{
|
||
|
|
GetMetrics(); // Ensure metrics are current
|
||
|
|
|
||
|
|
string report = "=== PERFORMANCE SUMMARY ===\n";
|
||
|
|
report += StringFormat("Total Trades: %d (Win: %d, Loss: %d)\n",
|
||
|
|
m_metrics.total_trades, m_metrics.winning_trades, m_metrics.losing_trades);
|
||
|
|
report += StringFormat("Win Rate: %.2f%%\n", m_metrics.win_rate);
|
||
|
|
report += StringFormat("Net Profit: $%.2f\n", m_metrics.net_profit);
|
||
|
|
report += StringFormat("Profit Factor: %.2f\n", m_metrics.profit_factor);
|
||
|
|
report += StringFormat("Expectancy: $%.2f\n", m_metrics.expectancy);
|
||
|
|
report += StringFormat("Sharpe Ratio: %.2f\n", m_metrics.sharpe_ratio);
|
||
|
|
report += StringFormat("Max Drawdown: %.2f%%\n", m_metrics.max_drawdown_percent);
|
||
|
|
report += StringFormat("Recovery Factor: %.2f\n", m_metrics.recovery_factor);
|
||
|
|
|
||
|
|
return report;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // PERFORMANCE_TRACKER_MQH
|