| //+------------------------------------------------------------------+
|
| //| RiskMetrics.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 <Math\Stat\Stat.mqh>
|
|
|
| //+------------------------------------------------------------------+
|
| //| Risk Metrics Class |
|
| //+------------------------------------------------------------------+
|
| class CRiskMetrics
|
| {
|
| private:
|
| // Market data
|
| string m_symbol; // Symbol
|
| ENUM_TIMEFRAMES m_timeframe; // Timeframe
|
|
|
| // Volatility metrics
|
| double m_atr; // Average True Range
|
| double m_volatility; // Current volatility (standard deviation)
|
| double m_historicalVol; // Historical volatility
|
|
|
| // Risk metrics
|
| double m_var95; // Value at Risk (95% confidence)
|
| double m_es95; // Expected Shortfall (95% confidence)
|
| double m_maxDrawdown; // Maximum drawdown
|
| double m_sharpeRatio; // Sharpe ratio
|
| double m_sortinoRatio; // Sortino ratio
|
|
|
| // Technical indicators
|
| int m_atrHandle; // ATR indicator handle
|
| int m_stdDevHandle; // Standard Deviation handle
|
|
|
| // Parameters
|
| int m_lookbackPeriod; // Lookback period for metrics
|
| int m_volatilityPeriod; // Period for volatility calculation
|
|
|
| // Internal state
|
| bool m_isInitialized; // Initialization flag
|
|
|
| // Private methods
|
| bool CalculateVolatility();
|
| bool CalculateValueAtRisk();
|
| bool CalculateExpectedShortfall();
|
| bool CalculateDrawdown();
|
| bool CalculateRatios();
|
|
|
| public:
|
| // Constructor/Destructor
|
| CRiskMetrics();
|
| ~CRiskMetrics();
|
|
|
| // Initialization
|
| bool Initialize(const string symbol, const ENUM_TIMEFRAMES timeframe,
|
| const int lookbackPeriod = 100, const int volatilityPeriod = 20);
|
| void Deinitialize();
|
|
|
| // Update methods
|
| bool UpdateVolatility();
|
| void UpdateAllMetrics();
|
|
|
| // Getters
|
| double GetCurrentVolatility() const { return m_volatility; }
|
| double GetHistoricalVolatility() const { return m_historicalVol; }
|
| double GetValueAtRisk() const { return m_var95; }
|
| double GetExpectedShortfall() const { return m_es95; }
|
| double GetMaxDrawdown() const { return m_maxDrawdown; }
|
| double GetSharpeRatio() const { return m_sharpeRatio; }
|
| double GetSortinoRatio() const { return m_sortinoRatio; }
|
| double GetATR() const { return m_atr; }
|
|
|
| // Utility methods
|
| static double CalculateStopLossPips(const string symbol, const double price,
|
| const double stopDistance, const bool isPips = true);
|
| static double CalculatePositionRisk(const double entryPrice, const double stopLoss,
|
| const double positionSize, const string symbol);
|
|
|
| // Risk assessment
|
| bool IsVolatilityTooHigh(const double maxVolatility = 0.02) const;
|
| bool IsDrawdownLimitReached(const double maxDrawdownPercent) const;
|
|
|
| // Statistical methods
|
| static double CalculateStandardDeviation(const double &values[], const int count);
|
| static double CalculateCorrelation(const double &x[], const double &y[], const int count);
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Constructor |
|
| //+------------------------------------------------------------------+
|
| CRiskMetrics::CRiskMetrics() :
|
| m_symbol(""),
|
| m_timeframe(PERIOD_CURRENT),
|
| m_atr(0.0),
|
| m_volatility(0.0),
|
| m_historicalVol(0.0),
|
| m_var95(0.0),
|
| m_es95(0.0),
|
| m_maxDrawdown(0.0),
|
| m_sharpeRatio(0.0),
|
| m_sortinoRatio(0.0),
|
| m_atrHandle(INVALID_HANDLE),
|
| m_stdDevHandle(INVALID_HANDLE),
|
| m_lookbackPeriod(100),
|
| m_volatilityPeriod(20),
|
| m_isInitialized(false)
|
| {
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Destructor |
|
| //+------------------------------------------------------------------+
|
| CRiskMetrics::~CRiskMetrics()
|
| {
|
| Deinitialize();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize risk metrics calculator |
|
| //+------------------------------------------------------------------+
|
| bool CRiskMetrics::Initialize(const string symbol, const ENUM_TIMEFRAMES timeframe,
|
| const int lookbackPeriod = 100, const int volatilityPeriod = 20)
|
| {
|
| if (m_isInitialized)
|
| return true;
|
|
|
| if (symbol == "" || lookbackPeriod <= 0 || volatilityPeriod <= 0)
|
| return false;
|
|
|
| m_symbol = symbol;
|
| m_timeframe = timeframe;
|
| m_lookbackPeriod = lookbackPeriod;
|
| m_volatilityPeriod = volatilityPeriod;
|
|
|
| // Initialize indicators
|
| m_atrHandle = iATR(m_symbol, m_timeframe, 14);
|
| m_stdDevHandle = iStdDev(m_symbol, m_timeframe, 20, 0, MODE_SMA, PRICE_CLOSE);
|
|
|
| if (m_atrHandle == INVALID_HANDLE || m_stdDevHandle == INVALID_HANDLE)
|
| {
|
| Print("Failed to initialize indicators");
|
| return false;
|
| }
|
|
|
| // Initial calculations
|
| if (!UpdateAllMetrics())
|
| {
|
| Print("Failed to calculate initial metrics");
|
| return false;
|
| }
|
|
|
| m_isInitialized = true;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Deinitialize risk metrics calculator |
|
| //+------------------------------------------------------------------+
|
| void CRiskMetrics::Deinitialize()
|
| {
|
| // Release indicators
|
| if (m_atrHandle != INVALID_HANDLE)
|
| {
|
| IndicatorRelease(m_atrHandle);
|
| m_atrHandle = INVALID_HANDLE;
|
| }
|
|
|
| if (m_stdDevHandle != INVALID_HANDLE)
|
| {
|
| IndicatorRelease(m_stdDevHandle);
|
| m_stdDevHandle = INVALID_HANDLE;
|
| }
|
|
|
| m_isInitialized = false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update volatility metrics |
|
| //+------------------------------------------------------------------+
|
| bool CRiskMetrics::UpdateVolatility()
|
| {
|
| if (!m_isInitialized)
|
| return false;
|
|
|
| // Get ATR value
|
| double atrBuffer[];
|
| if (CopyBuffer(m_atrHandle, 0, 0, 1, atrBuffer) != 1)
|
| return false;
|
|
|
| m_atr = atrBuffer[0];
|
|
|
| // Get standard deviation
|
| double stdDevBuffer[];
|
| if (CopyBuffer(m_stdDevHandle, 0, 0, 1, stdDevBuffer) != 1)
|
| return false;
|
|
|
| m_volatility = stdDevBuffer[0];
|
|
|
| // Calculate historical volatility
|
| if (!CalculateVolatility())
|
| return false;
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update all risk metrics |
|
| //+------------------------------------------------------------------+
|
| void CRiskMetrics::UpdateAllMetrics()
|
| {
|
| if (!m_isInitialized)
|
| return;
|
|
|
| // Update volatility first as it's used by other calculations
|
| UpdateVolatility();
|
|
|
| // Calculate other metrics
|
| CalculateValueAtRisk();
|
| CalculateExpectedShortfall();
|
| CalculateDrawdown();
|
| CalculateRatios();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate volatility metrics |
|
| //+------------------------------------------------------------------+
|
| bool CRiskMetrics::CalculateVolatility()
|
| {
|
| // Get close prices for volatility calculation
|
| double close[];
|
| int count = m_volatilityPeriod;
|
|
|
| if (CopyClose(m_symbol, m_timeframe, 0, count, close) != count)
|
| return false;
|
|
|
| // Calculate returns
|
| double returns[];
|
| ArrayResize(returns, count-1);
|
|
|
| for (int i = 0; i < count-1; i++)
|
| {
|
| if (close[i+1] > 0.0)
|
| returns[i] = (close[i] - close[i+1]) / close[i+1];
|
| else
|
| returns[i] = 0.0;
|
| }
|
|
|
| // Calculate standard deviation of returns (annualized)
|
| double sum = 0.0;
|
| double sumSq = 0.0;
|
|
|
| for (int i = 0; i < ArraySize(returns); i++)
|
| {
|
| sum += returns[i];
|
| sumSq += returns[i] * returns[i];
|
| }
|
|
|
| double mean = sum / ArraySize(returns);
|
| double variance = (sumSq / ArraySize(returns)) - (mean * mean);
|
|
|
| // Annualize the volatility (assuming 252 trading days)
|
| m_historicalVol = MathSqrt(variance) * MathSqrt(252.0);
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate Value at Risk (VaR) |
|
| //+------------------------------------------------------------------+
|
| bool CRiskMetrics::CalculateValueAtRisk()
|
| {
|
| // Get close prices
|
| double close[];
|
| int count = m_lookbackPeriod;
|
|
|
| if (CopyClose(m_symbol, m_timeframe, 0, count, close) != count)
|
| return false;
|
|
|
| // Calculate returns
|
| double returns[];
|
| ArrayResize(returns, count-1);
|
|
|
| for (int i = 0; i < count-1; i++)
|
| {
|
| if (close[i+1] > 0.0)
|
| returns[i] = (close[i] - close[i+1]) / close[i+1];
|
| else
|
| returns[i] = 0.0;
|
| }
|
|
|
| // Sort returns for historical simulation
|
| ArraySort(returns);
|
|
|
| // Calculate 95% VaR (5th percentile)
|
| int index = (int)MathFloor(0.05 * ArraySize(returns));
|
| m_var95 = returns[index];
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate Expected Shortfall (ES) |
|
| //+------------------------------------------------------------------+
|
| bool CRiskMetrics::CalculateExpectedShortfall()
|
| {
|
| // This is a simplified implementation
|
| // In practice, you might want to use a more sophisticated method
|
|
|
| // Get close prices
|
| double close[];
|
| int count = m_lookbackPeriod;
|
|
|
| if (CopyClose(m_symbol, m_timeframe, 0, count, close) != count)
|
| return false;
|
|
|
| // Calculate returns
|
| double returns[];
|
| ArrayResize(returns, count-1);
|
|
|
| for (int i = 0; i < count-1; i++)
|
| {
|
| if (close[i+1] > 0.0)
|
| returns[i] = (close[i] - close[i+1]) / close[i+1];
|
| else
|
| returns[i] = 0.0;
|
| }
|
|
|
| // Sort returns for historical simulation
|
| ArraySort(returns);
|
|
|
| // Calculate 95% ES (average of worst 5% returns)
|
| int varIndex = (int)MathFloor(0.05 * ArraySize(returns));
|
| double sum = 0.0;
|
|
|
| for (int i = 0; i <= varIndex; i++)
|
| {
|
| sum += returns[i];
|
| }
|
|
|
| m_es95 = sum / (varIndex + 1);
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate drawdown metrics |
|
| //+------------------------------------------------------------------+
|
| bool CRiskMetrics::CalculateDrawdown()
|
| {
|
| // This is a simplified implementation
|
| // In practice, you might want to track drawdowns over time
|
|
|
| // Get equity curve (simplified as close prices for this example)
|
| double close[];
|
| int count = m_lookbackPeriod;
|
|
|
| if (CopyClose(m_symbol, m_timeframe, 0, count, close) != count)
|
| return false;
|
|
|
| // Calculate drawdown
|
| double peak = close[0];
|
| double maxDD = 0.0;
|
|
|
| for (int i = 1; i < count; i++)
|
| {
|
| if (close[i] > peak)
|
| {
|
| peak = close[i];
|
| }
|
| else
|
| {
|
| double dd = (peak - close[i]) / peak;
|
| if (dd > maxDD)
|
| maxDD = dd;
|
| }
|
| }
|
|
|
| m_maxDrawdown = maxDD;
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate performance ratios |
|
| //+------------------------------------------------------------------+
|
| bool CRiskMetrics::CalculateRatios()
|
| {
|
| // This is a simplified implementation
|
| // In practice, you would use actual returns and risk-free rate
|
|
|
| // Get close prices
|
| double close[];
|
| int count = m_lookbackPeriod;
|
|
|
| if (CopyClose(m_symbol, m_timeframe, 0, count, close) != count)
|
| return false;
|
|
|
| // Calculate returns
|
| double returns[];
|
| ArrayResize(returns, count-1);
|
|
|
| for (int i = 0; i < count-1; i++)
|
| {
|
| if (close[i+1] > 0.0)
|
| returns[i] = (close[i] - close[i+1]) / close[i+1];
|
| else
|
| returns[i] = 0.0;
|
| }
|
|
|
| // Calculate mean return
|
| double sum = 0.0;
|
| for (int i = 0; i < ArraySize(returns); i++)
|
| {
|
| sum += returns[i];
|
| }
|
| double meanReturn = sum / ArraySize(returns);
|
|
|
| // Calculate standard deviation of returns
|
| double sumSq = 0.0;
|
| for (int i = 0; i < ArraySize(returns); i++)
|
| {
|
| double diff = returns[i] - meanReturn;
|
| sumSq += diff * diff;
|
| }
|
| double stdDev = MathSqrt(sumSq / (ArraySize(returns) - 1));
|
|
|
| // Risk-free rate (simplified as 0 for this example)
|
| double riskFreeRate = 0.0;
|
|
|
| // Calculate Sharpe ratio
|
| if (stdDev > 0.0)
|
| m_sharpeRatio = (meanReturn - riskFreeRate) / stdDev;
|
| else
|
| m_sharpeRatio = 0.0;
|
|
|
| // Calculate Sortino ratio (simplified, using downside deviation = stdDev)
|
| // In practice, you would calculate downside deviation separately
|
| if (stdDev > 0.0)
|
| m_sortinoRatio = (meanReturn - riskFreeRate) / stdDev;
|
| else
|
| m_sortinoRatio = 0.0;
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate stop loss in pips |
|
| //+------------------------------------------------------------------+
|
| double CRiskMetrics::CalculateStopLossPips(const string symbol, const double price,
|
| const double stopDistance, const bool isPips = true)
|
| {
|
| if (stopDistance <= 0.0)
|
| return 0.0;
|
|
|
| double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
|
| double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
|
|
|
| if (point == 0.0 || tickSize == 0.0)
|
| return 0.0;
|
|
|
| if (isPips)
|
| {
|
| // Convert pips to price
|
| double pipValue = point * 10.0; // Assuming 5-digit broker
|
| return stopDistance * pipValue;
|
| }
|
| else
|
| {
|
| // Already in price terms
|
| return stopDistance;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate position risk in account currency |
|
| //+------------------------------------------------------------------+
|
| double CRiskMetrics::CalculatePositionRisk(const double entryPrice, const double stopLoss,
|
| const double positionSize, const string symbol)
|
| {
|
| if (entryPrice <= 0.0 || positionSize <= 0.0)
|
| return 0.0;
|
|
|
| double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
|
| double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
|
|
|
| if (tickValue <= 0.0 || tickSize <= 0.0)
|
| return 0.0;
|
|
|
| double stopDistance = MathAbs(entryPrice - stopLoss);
|
| double riskPerLot = (stopDistance / tickSize) * tickValue;
|
|
|
| return riskPerLot * positionSize;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Check if volatility is too high |
|
| //+------------------------------------------------------------------+
|
| bool CRiskMetrics::IsVolatilityTooHigh(const double maxVolatility = 0.02) const
|
| {
|
| return (m_volatility > maxVolatility);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Check if drawdown limit is reached |
|
| //+------------------------------------------------------------------+
|
| bool CRiskMetrics::IsDrawdownLimitReached(const double maxDrawdownPercent) const
|
| {
|
| return (m_maxDrawdown >= maxDrawdownPercent / 100.0);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate standard deviation |
|
| //+------------------------------------------------------------------+
|
| double CRiskMetrics::CalculateStandardDeviation(const double &values[], const int count)
|
| {
|
| if (count <= 1)
|
| return 0.0;
|
|
|
| double sum = 0.0;
|
| double sumSq = 0.0;
|
|
|
| for (int i = 0; i < count; i++)
|
| {
|
| sum += values[i];
|
| sumSq += values[i] * values[i];
|
| }
|
|
|
| double mean = sum / count;
|
| double variance = (sumSq / count) - (mean * mean);
|
|
|
| return MathSqrt(variance);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calculate correlation between two arrays |
|
| //+------------------------------------------------------------------+
|
| double CRiskMetrics::CalculateCorrelation(const double &x[], const double &y[], const int count)
|
| {
|
| if (count <= 1)
|
| return 0.0;
|
|
|
| double sumX = 0.0, sumY = 0.0;
|
| double sumXSq = 0.0, sumYSq = 0.0;
|
| double sumXY = 0.0;
|
|
|
| for (int i = 0; i < count; i++)
|
| {
|
| sumX += x[i];
|
| sumY += y[i];
|
| sumXSq += x[i] * x[i];
|
| sumYSq += y[i] * y[i];
|
| sumXY += x[i] * y[i];
|
| }
|
|
|
| double numerator = sumXY - (sumX * sumY / count);
|
| double denominator = MathSqrt((sumXSq - (sumX * sumX / count)) * (sumYSq - (sumY * sumY / count)));
|
|
|
| if (denominator == 0.0)
|
| return 0.0;
|
|
|
| return numerator / denominator;
|
| }
|
