356 lines
12 KiB
MQL5
356 lines
12 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| DrawdownManager.mqh |
|
|
//| Copyright 2025, Your Company Name |
|
|
//| https://www.yoursite.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2025, Your Company Name"
|
|
#property link "https://www.yoursite.com"
|
|
#property version "1.00"
|
|
#property strict
|
|
|
|
#include <Arrays\ArrayObj.mqh>
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Drawdown Period Structure |
|
|
//+------------------------------------------------------------------+
|
|
struct SDrawdownPeriod
|
|
{
|
|
datetime startTime; // Start time of drawdown
|
|
datetime endTime; // End time of drawdown (0 if ongoing)
|
|
double startEquity; // Equity at start of drawdown
|
|
double minEquity; // Minimum equity during drawdown
|
|
double maxDrawdown; // Maximum drawdown in account currency
|
|
double maxDrawdownPct; // Maximum drawdown in percentage
|
|
|
|
// Constructor
|
|
SDrawdownPeriod()
|
|
{
|
|
startTime = 0;
|
|
endTime = 0;
|
|
startEquity = 0.0;
|
|
minEquity = 0.0;
|
|
maxDrawdown = 0.0;
|
|
maxDrawdownPct = 0.0;
|
|
}
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Drawdown Manager Class |
|
|
//+------------------------------------------------------------------+
|
|
class CDrawdownManager
|
|
{
|
|
private:
|
|
CArrayObj* m_drawdowns; // Array of drawdown periods
|
|
SDrawdownPeriod* m_currentDD; // Current drawdown period (if any)
|
|
|
|
// Statistics
|
|
double m_equityPeak; // Peak equity value
|
|
double m_maxDrawdown; // Maximum drawdown (currency)
|
|
double m_maxDrawdownPct; // Maximum drawdown (%)
|
|
double m_avgDrawdown; // Average drawdown
|
|
int m_ddCount; // Number of drawdowns
|
|
|
|
// Parameters
|
|
double m_equity; // Current equity
|
|
bool m_isInitialized; // Initialization flag
|
|
|
|
// Private methods
|
|
void UpdateDrawdownStats();
|
|
|
|
public:
|
|
// Constructor/Destructor
|
|
CDrawdownManager();
|
|
~CDrawdownManager();
|
|
|
|
// Initialization
|
|
bool Initialize();
|
|
void Deinitialize();
|
|
|
|
// Update methods
|
|
void UpdateEquity(const double equity);
|
|
void UpdateFromHistory();
|
|
|
|
// Getters
|
|
double GetCurrentDrawdown() const;
|
|
double GetCurrentDrawdownPct() const;
|
|
double GetMaxDrawdown() const { return m_maxDrawdown; }
|
|
double GetMaxDrawdownPct() const { return m_maxDrawdownPct; }
|
|
double GetAvgDrawdown() const;
|
|
int GetDrawdownCount() const { return m_ddCount; }
|
|
bool IsInDrawdown() const { return (m_currentDD != NULL); }
|
|
bool IsInitialized() const { return m_isInitialized; }
|
|
|
|
// Risk management
|
|
bool IsDrawdownLimitReached(const double maxDrawdownPct) const;
|
|
bool IsDailyLossLimitReached(const double maxDailyLossPct) const;
|
|
|
|
// Statistics
|
|
void CalculateStatistics();
|
|
|
|
// Persistence
|
|
bool SaveToFile(const string filename);
|
|
bool LoadFromFile(const string filename);
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CDrawdownManager::CDrawdownManager() :
|
|
m_drawdowns(NULL),
|
|
m_currentDD(NULL),
|
|
m_equityPeak(0.0),
|
|
m_maxDrawdown(0.0),
|
|
m_maxDrawdownPct(0.0),
|
|
m_avgDrawdown(0.0),
|
|
m_ddCount(0),
|
|
m_equity(0.0),
|
|
m_isInitialized(false)
|
|
{
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CDrawdownManager::~CDrawdownManager()
|
|
{
|
|
Deinitialize();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize drawdown manager |
|
|
//+------------------------------------------------------------------+
|
|
bool CDrawdownManager::Initialize()
|
|
{
|
|
if (m_isInitialized)
|
|
return true;
|
|
|
|
m_drawdowns = new CArrayObj();
|
|
if (m_drawdowns == NULL)
|
|
return false;
|
|
|
|
m_equity = AccountInfoDouble(ACCOUNT_EQUITY);
|
|
m_equityPeak = m_equity;
|
|
m_currentDD = NULL;
|
|
|
|
// Load historical drawdowns if available
|
|
// LoadFromFile("drawdown_history.dat");
|
|
|
|
m_isInitialized = true;
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Deinitialize drawdown manager |
|
|
//+------------------------------------------------------------------+
|
|
void CDrawdownManager::Deinitialize()
|
|
{
|
|
if (m_drawdowns != NULL)
|
|
{
|
|
m_drawdowns.Clear();
|
|
delete m_drawdowns;
|
|
m_drawdowns = NULL;
|
|
}
|
|
|
|
if (m_currentDD != NULL)
|
|
{
|
|
delete m_currentDD;
|
|
m_currentDD = NULL;
|
|
}
|
|
|
|
m_isInitialized = false;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Update equity and check for drawdowns |
|
|
//+------------------------------------------------------------------+
|
|
void CDrawdownManager::UpdateEquity(const double equity)
|
|
{
|
|
if (!m_isInitialized)
|
|
return;
|
|
|
|
m_equity = equity;
|
|
|
|
// Check for new peak
|
|
if (m_equity > m_equityPeak)
|
|
{
|
|
// If we were in a drawdown and now reached a new peak, end the drawdown
|
|
if (m_currentDD != NULL)
|
|
{
|
|
m_currentDD.endTime = TimeCurrent();
|
|
m_drawdowns.Add(m_currentDD);
|
|
m_currentDD = NULL;
|
|
}
|
|
|
|
m_equityPeak = m_equity;
|
|
}
|
|
// Check for drawdown
|
|
else if (m_equity < m_equityPeak)
|
|
{
|
|
// Start new drawdown if not already in one
|
|
if (m_currentDD == NULL)
|
|
{
|
|
m_currentDD = new SDrawdownPeriod();
|
|
if (m_currentDD != NULL)
|
|
{
|
|
m_currentDD.startTime = TimeCurrent();
|
|
m_currentDD.startEquity = m_equityPeak;
|
|
m_currentDD.minEquity = m_equity;
|
|
m_currentDD.maxDrawdown = m_equityPeak - m_equity;
|
|
m_currentDD.maxDrawdownPct = (m_currentDD.maxDrawdown / m_equityPeak) * 100.0;
|
|
}
|
|
}
|
|
// Update existing drawdown
|
|
else
|
|
{
|
|
m_currentDD.minEquity = MathMin(m_currentDD.minEquity, m_equity);
|
|
double currentDD = m_equityPeak - m_equity;
|
|
double currentDDPct = (currentDD / m_equityPeak) * 100.0;
|
|
|
|
if (currentDD > m_currentDD.maxDrawdown)
|
|
{
|
|
m_currentDD.maxDrawdown = currentDD;
|
|
m_currentDD.maxDrawdownPct = currentDDPct;
|
|
}
|
|
}
|
|
|
|
// Update global max drawdown
|
|
if (m_currentDD != NULL && m_currentDD.maxDrawdown > m_maxDrawdown)
|
|
{
|
|
m_maxDrawdown = m_currentDD.maxDrawdown;
|
|
m_maxDrawdownPct = m_currentDD.maxDrawdownPct;
|
|
}
|
|
}
|
|
|
|
// Recalculate statistics
|
|
CalculateStatistics();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Update from account history |
|
|
//+------------------------------------------------------------------+
|
|
void CDrawdownManager::UpdateFromHistory()
|
|
{
|
|
// This would load historical drawdowns from account history
|
|
// Implementation depends on how you want to track historical drawdowns
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Get current drawdown in account currency |
|
|
//+------------------------------------------------------------------+
|
|
double CDrawdownManager::GetCurrentDrawdown() const
|
|
{
|
|
if (m_currentDD != NULL)
|
|
return m_equityPeak - m_equity;
|
|
|
|
return 0.0;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Get current drawdown as percentage of peak equity |
|
|
//+------------------------------------------------------------------
|
|
double CDrawdownManager::GetCurrentDrawdownPct() const
|
|
{
|
|
if (m_equityPeak > 0.0)
|
|
return ((m_equityPeak - m_equity) / m_equityPeak) * 100.0;
|
|
|
|
return 0.0;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Calculate average drawdown |
|
|
//+------------------------------------------------------------------
|
|
double CDrawdownManager::GetAvgDrawdown() const
|
|
{
|
|
if (m_ddCount == 0)
|
|
return 0.0;
|
|
|
|
double totalDD = 0.0;
|
|
int count = m_drawdowns.Total();
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
SDrawdownPeriod* dd = (SDrawdownPeriod*)m_drawdowns.At(i);
|
|
if (dd != NULL)
|
|
{
|
|
totalDD += dd.maxDrawdownPct;
|
|
}
|
|
}
|
|
|
|
return (count > 0) ? (totalDD / count) : 0.0;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Check if drawdown limit is reached |
|
|
//+------------------------------------------------------------------
|
|
bool CDrawdownManager::IsDrawdownLimitReached(const double maxDrawdownPct) const
|
|
{
|
|
if (maxDrawdownPct <= 0.0)
|
|
return false;
|
|
|
|
double currentDD = GetCurrentDrawdownPct();
|
|
return (currentDD >= maxDrawdownPct);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Check if daily loss limit is reached |
|
|
//+------------------------------------------------------------------
|
|
bool CDrawdownManager::IsDailyLossLimitReached(const double maxDailyLossPct) const
|
|
{
|
|
if (maxDailyLossPct <= 0.0)
|
|
return false;
|
|
|
|
// This would check the daily loss from the start of the day
|
|
// Implementation depends on how you want to track daily P/L
|
|
|
|
return false;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Calculate drawdown statistics |
|
|
//+------------------------------------------------------------------
|
|
void CDrawdownManager::CalculateStatistics()
|
|
{
|
|
int count = m_drawdowns.Total();
|
|
|
|
// Count only closed drawdowns
|
|
m_ddCount = 0;
|
|
double totalDD = 0.0;
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
SDrawdownPeriod* dd = (SDrawdownPeriod*)m_drawdowns.At(i);
|
|
if (dd != NULL && dd.endTime > 0)
|
|
{
|
|
totalDD += dd.maxDrawdownPct;
|
|
m_ddCount++;
|
|
}
|
|
}
|
|
|
|
// Calculate average drawdown
|
|
m_avgDrawdown = (m_ddCount > 0) ? (totalDD / m_ddCount) : 0.0;
|
|
|
|
// Update max drawdown if current drawdown is larger
|
|
if (m_currentDD != NULL && m_currentDD.maxDrawdown > m_maxDrawdown)
|
|
{
|
|
m_maxDrawdown = m_currentDD.maxDrawdown;
|
|
m_maxDrawdownPct = m_currentDD.maxDrawdownPct;
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Save drawdown data to file |
|
|
//+------------------------------------------------------------------
|
|
bool CDrawdownManager::SaveToFile(const string filename)
|
|
{
|
|
// Implementation depends on how you want to persist the data
|
|
return false;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Load drawdown data from file |
|
|
//+------------------------------------------------------------------
|
|
bool CDrawdownManager::LoadFromFile(const string filename)
|
|
{
|
|
// Implementation depends on how you want to load the data
|
|
return false;
|
|
}
|