453 lines
17 KiB
MQL5
453 lines
17 KiB
MQL5
|
//+------------------------------------------------------------------+
|
||
|
|
//| VolatilityManager.mqh |
|
||
|
|
//| Copyright 2025, EscapeEA Team |
|
||
|
|
//| https://www.escapeea.com |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
#property copyright "Copyright 2025, EscapeEA Team"
|
||
|
|
#property link "https://www.escapeea.com"
|
||
|
|
#property version "1.00"
|
||
|
|
#property strict
|
||
|
|
|
||
|
|
#include <Escape/Common/ErrorHandler.mqh>
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Volatility Calculation Methods |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
enum ENUM_VOLATILITY_METHOD
|
||
|
|
{
|
||
|
|
VOL_ATR, // Average True Range
|
||
|
|
VOL_STD_DEV, // Standard Deviation
|
||
|
|
VOL_PARKINSON, // Parkinson's volatility
|
||
|
|
VOL_GK, // Garman-Klass volatility
|
||
|
|
VOL_RS, // Rogers-Satchell volatility
|
||
|
|
VOL_YZ // Yang-Zhang volatility
|
||
|
|
};
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Volatility Manager Class |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
class CVolatilityManager
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
// Configuration
|
||
|
|
ENUM_TIMEFRAMES m_timeframe; // Default timeframe for calculations
|
||
|
|
int m_period; // Default period for calculations
|
||
|
|
ENUM_VOLATILITY_METHOD m_method; // Default calculation method
|
||
|
|
|
||
|
|
// State
|
||
|
|
bool m_initialized; // Initialization flag
|
||
|
|
|
||
|
|
// Cache
|
||
|
|
double m_lastValues[]; // Cache of last calculated values
|
||
|
|
datetime m_lastUpdate; // Last update time
|
||
|
|
|
||
|
|
public:
|
||
|
|
//--- Constructor/Destructor
|
||
|
|
CVolatilityManager(void);
|
||
|
|
~CVolatilityManager(void);
|
||
|
|
|
||
|
|
//--- Initialization
|
||
|
|
bool Initialize(void);
|
||
|
|
void Shutdown(void);
|
||
|
|
|
||
|
|
//--- Volatility Calculation
|
||
|
|
double GetVolatility(const string symbol, const ENUM_TIMEFRAMES timeframe, const int period,
|
||
|
|
const ENUM_VOLATILITY_METHOD method, const int shift=0);
|
||
|
|
|
||
|
|
double GetCurrentVolatility(const string symbol, const ENUM_TIMEFRAMES timeframe,
|
||
|
|
const int period, const ENUM_VOLATILITY_METHOD method);
|
||
|
|
|
||
|
|
double GetAverageVolatility(const string symbol, const ENUM_TIMEFRAMES timeframe,
|
||
|
|
const int period, const int bars, const ENUM_VOLATILITY_METHOD method);
|
||
|
|
|
||
|
|
//--- Configuration
|
||
|
|
void SetDefaultTimeframe(const ENUM_TIMEFRAMES timeframe) { m_timeframe = timeframe; }
|
||
|
|
void SetDefaultPeriod(const int period) { m_period = period; }
|
||
|
|
void SetDefaultMethod(const ENUM_VOLATILITY_METHOD method) { m_method = method; }
|
||
|
|
|
||
|
|
private:
|
||
|
|
//--- Calculation Methods
|
||
|
|
double CalculateATR(const string symbol, const int period, const int shift);
|
||
|
|
double CalculateStdDev(const string symbol, const int period, const int shift);
|
||
|
|
double CalculateParkinson(const string symbol, const int period, const int shift);
|
||
|
|
double CalculateGarmanKlass(const string symbol, const int period, const int shift);
|
||
|
|
double CalculateRogersSatchell(const string symbol, const int period, const int shift);
|
||
|
|
double CalculateYangZhang(const string symbol, const int period, const int shift);
|
||
|
|
|
||
|
|
//--- Helper Methods
|
||
|
|
void UpdateCache(const string symbol, const ENUM_TIMEFRAMES timeframe,
|
||
|
|
const int period, const ENUM_VOLATILITY_METHOD method);
|
||
|
|
string GenerateCacheKey(const string symbol, const ENUM_TIMEFRAMES timeframe,
|
||
|
|
const int period, const ENUM_VOLATILITY_METHOD method) const;
|
||
|
|
double GetCachedValue(const string key);
|
||
|
|
void SetCachedValue(const string key, const double value);
|
||
|
|
};
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Constructor |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CVolatilityManager::CVolatilityManager(void) :
|
||
|
|
m_timeframe(PERIOD_CURRENT),
|
||
|
|
m_period(14),
|
||
|
|
m_method(VOL_ATR),
|
||
|
|
m_initialized(false),
|
||
|
|
m_lastUpdate(0)
|
||
|
|
{
|
||
|
|
ArrayResize(m_lastValues, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Destructor |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CVolatilityManager::~CVolatilityManager(void)
|
||
|
|
{
|
||
|
|
Shutdown();
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Initialize the volatility manager |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CVolatilityManager::Initialize(void)
|
||
|
|
{
|
||
|
|
if(m_initialized)
|
||
|
|
return true;
|
||
|
|
|
||
|
|
// Initialize any required resources
|
||
|
|
m_initialized = true;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Shutdown the volatility manager |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CVolatilityManager::Shutdown(void)
|
||
|
|
{
|
||
|
|
if(!m_initialized)
|
||
|
|
return;
|
||
|
|
|
||
|
|
// Clean up resources
|
||
|
|
ArrayFree(m_lastValues);
|
||
|
|
m_initialized = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Get volatility using specified parameters |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CVolatilityManager::GetVolatility(const string symbol, const ENUM_TIMEFRAMES timeframe,
|
||
|
|
const int period, const ENUM_VOLATILITY_METHOD method, const int shift)
|
||
|
|
{
|
||
|
|
// Check for valid parameters
|
||
|
|
if(period <= 0)
|
||
|
|
{
|
||
|
|
CErrorHandler::HandleError(ERR_INVALID_PARAMETER, "Invalid period: " + IntegerToString(period));
|
||
|
|
return 0.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Use default values if not specified
|
||
|
|
ENUM_TIMEFRAMES tf = (timeframe == PERIOD_CURRENT) ? m_timeframe : timeframe;
|
||
|
|
int p = (period <= 0) ? m_period : period;
|
||
|
|
ENUM_VOLATILITY_METHOD m = (method == -1) ? m_method : method;
|
||
|
|
|
||
|
|
// Calculate volatility based on selected method
|
||
|
|
double volatility = 0.0;
|
||
|
|
switch(m)
|
||
|
|
{
|
||
|
|
case VOL_ATR:
|
||
|
|
volatility = CalculateATR(symbol, p, shift);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case VOL_STD_DEV:
|
||
|
|
volatility = CalculateStdDev(symbol, p, shift);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case VOL_PARKINSON:
|
||
|
|
volatility = CalculateParkinson(symbol, p, shift);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case VOL_GK:
|
||
|
|
volatility = CalculateGarmanKlass(symbol, p, shift);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case VOL_RS:
|
||
|
|
volatility = CalculateRogersSatchell(symbol, p, shift);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case VOL_YZ:
|
||
|
|
volatility = CalculateYangZhang(symbol, p, shift);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
CErrorHandler::HandleError(ERR_INVALID_PARAMETER, "Unknown volatility method: " + IntegerToString(m));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return volatility;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Get current volatility |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CVolatilityManager::GetCurrentVolatility(const string symbol, const ENUM_TIMEFRAMES timeframe,
|
||
|
|
const int period, const ENUM_VOLATILITY_METHOD method)
|
||
|
|
{
|
||
|
|
return GetVolatility(symbol, timeframe, period, method, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Get average volatility over a number of bars |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CVolatilityManager::GetAverageVolatility(const string symbol, const ENUM_TIMEFRAMES timeframe,
|
||
|
|
const int period, const int bars, const ENUM_VOLATILITY_METHOD method)
|
||
|
|
{
|
||
|
|
if(bars <= 0)
|
||
|
|
{
|
||
|
|
CErrorHandler::HandleError(ERR_INVALID_PARAMETER, "Invalid number of bars: " + IntegerToString(bars));
|
||
|
|
return 0.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
double sum = 0.0;
|
||
|
|
int count = 0;
|
||
|
|
|
||
|
|
// Calculate average volatility over the specified number of bars
|
||
|
|
for(int i = 0; i < bars; i++)
|
||
|
|
{
|
||
|
|
double vol = GetVolatility(symbol, timeframe, period, method, i);
|
||
|
|
if(vol > 0)
|
||
|
|
{
|
||
|
|
sum += vol;
|
||
|
|
count++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return (count > 0) ? sum / count : 0.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate Average True Range (ATR) |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CVolatilityManager::CalculateATR(const string symbol, const int period, const int shift)
|
||
|
|
{
|
||
|
|
double atr = iATR(symbol, m_timeframe, period, shift);
|
||
|
|
if(atr == 0)
|
||
|
|
{
|
||
|
|
CErrorHandler::HandleError(ERR_INDICATOR_CALCULATION, "Failed to calculate ATR for " + symbol);
|
||
|
|
return 0.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return atr;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate Standard Deviation |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CVolatilityManager::CalculateStdDev(const string symbol, const int period, const int shift)
|
||
|
|
{
|
||
|
|
double close[];
|
||
|
|
ArraySetAsSeries(close, true);
|
||
|
|
|
||
|
|
// Get close prices
|
||
|
|
if(CopyClose(symbol, m_timeframe, shift, period, close) != period)
|
||
|
|
{
|
||
|
|
CErrorHandler::HandleError(ERR_HISTORY_NOT_FOUND, "Failed to get close prices for " + symbol);
|
||
|
|
return 0.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Calculate mean
|
||
|
|
double sum = 0.0;
|
||
|
|
for(int i = 0; i < period; i++)
|
||
|
|
sum += close[i];
|
||
|
|
double mean = sum / period;
|
||
|
|
|
||
|
|
// Calculate variance
|
||
|
|
double variance = 0.0;
|
||
|
|
for(int i = 0; i < period; i++)
|
||
|
|
variance += MathPow(close[i] - mean, 2);
|
||
|
|
variance /= period;
|
||
|
|
|
||
|
|
// Standard deviation is the square root of variance
|
||
|
|
return MathSqrt(variance);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate Parkinson Volatility |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CVolatilityManager::CalculateParkinson(const string symbol, const int period, const int shift)
|
||
|
|
{
|
||
|
|
double high[], low[];
|
||
|
|
ArraySetAsSeries(high, true);
|
||
|
|
ArraySetAsSeries(low, true);
|
||
|
|
|
||
|
|
// Get high and low prices
|
||
|
|
if(CopyHigh(symbol, m_timeframe, shift, period, high) != period ||
|
||
|
|
CopyLow(symbol, m_timeframe, shift, period, low) != period)
|
||
|
|
{
|
||
|
|
CErrorHandler::HandleError(ERR_HISTORY_NOT_FOUND, "Failed to get price data for Parkinson");
|
||
|
|
return 0.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Calculate Parkinson volatility
|
||
|
|
double sum = 0.0;
|
||
|
|
for(int i = 0; i < period; i++)
|
||
|
|
{
|
||
|
|
if(high[i] > 0 && low[i] > 0)
|
||
|
|
sum += MathLog(high[i] / low[i]) * MathLog(high[i] / low[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
return MathSqrt(sum / (4 * period * MathLog(2)));
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate Garman-Klass Volatility |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CVolatilityManager::CalculateGarmanKlass(const string symbol, const int period, const int shift)
|
||
|
|
{
|
||
|
|
double open[], high[], low[], close[];
|
||
|
|
ArraySetAsSeries(open, true);
|
||
|
|
ArraySetAsSeries(high, true);
|
||
|
|
ArraySetAsSeries(low, true);
|
||
|
|
ArraySetAsSeries(close, true);
|
||
|
|
|
||
|
|
// Get price data
|
||
|
|
if(CopyOpen(symbol, m_timeframe, shift, period, open) != period ||
|
||
|
|
CopyHigh(symbol, m_timeframe, shift, period, high) != period ||
|
||
|
|
CopyLow(symbol, m_timeframe, shift, period, low) != period ||
|
||
|
|
CopyClose(symbol, m_timeframe, shift, period, close) != period)
|
||
|
|
{
|
||
|
|
CErrorHandler::HandleError(ERR_HISTORY_NOT_FOUND, "Failed to get price data for Garman-Klass");
|
||
|
|
return 0.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Calculate Garman-Klass volatility
|
||
|
|
double sum = 0.0;
|
||
|
|
for(int i = 0; i < period; i++)
|
||
|
|
{
|
||
|
|
if(open[i] > 0 && high[i] > 0 && low[i] > 0 && close[i] > 0)
|
||
|
|
{
|
||
|
|
double u = MathLog(high[i] / open[i]);
|
||
|
|
double d = MathLog(low[i] / open[i]);
|
||
|
|
double c = MathLog(close[i] / open[i]);
|
||
|
|
sum += 0.511 * (u - d) * (u - d) - 0.019 * (c * (u + d) - 2 * u * d) - 0.383 * c * c;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return MathSqrt(sum / period);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate Rogers-Satchell Volatility |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CVolatilityManager::CalculateRogersSatchell(const string symbol, const int period, const int shift)
|
||
|
|
{
|
||
|
|
double open[], high[], low[], close[];
|
||
|
|
ArraySetAsSeries(open, true);
|
||
|
|
ArraySetAsSeries(high, true);
|
||
|
|
ArraySetAsSeries(low, true);
|
||
|
|
ArraySetAsSeries(close, true);
|
||
|
|
|
||
|
|
// Get price data
|
||
|
|
if(CopyOpen(symbol, m_timeframe, shift, period, open) != period ||
|
||
|
|
CopyHigh(symbol, m_timeframe, shift, period, high) != period ||
|
||
|
|
CopyLow(symbol, m_timeframe, shift, period, low) != period ||
|
||
|
|
CopyClose(symbol, m_timeframe, shift, period, close) != period)
|
||
|
|
{
|
||
|
|
CErrorHandler::HandleError(ERR_HISTORY_NOT_FOUND, "Failed to get price data for Rogers-Satchell");
|
||
|
|
return 0.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Calculate Rogers-Satchell volatility
|
||
|
|
double sum = 0.0;
|
||
|
|
for(int i = 0; i < period; i++)
|
||
|
|
{
|
||
|
|
if(open[i] > 0 && high[i] > 0 && low[i] > 0 && close[i] > 0)
|
||
|
|
{
|
||
|
|
double u = MathLog(high[i] / open[i]);
|
||
|
|
double d = MathLog(low[i] / open[i]);
|
||
|
|
double c = MathLog(close[i] / open[i]);
|
||
|
|
sum += u * (u - c) + d * (d - c);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return MathSqrt(sum / period);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate Yang-Zhang Volatility |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CVolatilityManager::CalculateYangZhang(const string symbol, const int period, const int shift)
|
||
|
|
{
|
||
|
|
double open[], close[];
|
||
|
|
ArraySetAsSeries(open, true);
|
||
|
|
ArraySetAsSeries(close, true);
|
||
|
|
|
||
|
|
// Get open and close prices
|
||
|
|
if(CopyOpen(symbol, m_timeframe, shift, period, open) != period ||
|
||
|
|
CopyClose(symbol, m_timeframe, shift-1, period+1, close) != period+1)
|
||
|
|
{
|
||
|
|
CErrorHandler::HandleError(ERR_HISTORY_NOT_FOUND, "Failed to get price data for Yang-Zhang");
|
||
|
|
return 0.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Calculate Yang-Zhang volatility
|
||
|
|
double sum_var = 0.0;
|
||
|
|
double sum_mean = 0.0;
|
||
|
|
|
||
|
|
for(int i = 0; i < period; i++)
|
||
|
|
{
|
||
|
|
if(open[i] > 0 && close[i] > 0 && close[i+1] > 0)
|
||
|
|
{
|
||
|
|
double o = MathLog(open[i] / close[i+1]);
|
||
|
|
double c = MathLog(close[i] / open[i]);
|
||
|
|
double u = MathLog(high[i] / open[i]);
|
||
|
|
double d = MathLog(low[i] / open[i]);
|
||
|
|
|
||
|
|
double rs = u * (u - c) + d * (d - c);
|
||
|
|
double o_c = o * o;
|
||
|
|
double c_c = c * c;
|
||
|
|
|
||
|
|
sum_var += 0.511 * rs - 0.019 * (c * (u + d) - 2 * u * d) - 0.383 * c_c;
|
||
|
|
sum_mean += o_c;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
double k = 0.34 / (1.34 + (period + 1) / (period - 1));
|
||
|
|
return MathSqrt(sum_var / period + k * sum_mean / (period - 1));
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Update the cache with latest values |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CVolatilityManager::UpdateCache(const string symbol, const ENUM_TIMEFRAMES timeframe,
|
||
|
|
const int period, const ENUM_VOLATILITY_METHOD method)
|
||
|
|
{
|
||
|
|
// Implementation for caching would go here
|
||
|
|
// This is a placeholder for actual caching logic
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Generate a cache key |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
string CVolatilityManager::GenerateCacheKey(const string symbol, const ENUM_TIMEFRAMES timeframe,
|
||
|
|
const int period, const ENUM_VOLATILITY_METHOD method) const
|
||
|
|
{
|
||
|
|
return symbol + "_" + IntegerToString(timeframe) + "_" + IntegerToString(period) + "_" + IntegerToString(method);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Get a value from cache |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CVolatilityManager::GetCachedValue(const string key)
|
||
|
|
{
|
||
|
|
// Implementation for getting cached values would go here
|
||
|
|
// This is a placeholder for actual caching logic
|
||
|
|
return 0.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Set a value in cache |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CVolatilityManager::SetCachedValue(const string key, const double value)
|
||
|
|
{
|
||
|
|
// Implementation for setting cached values would go here
|
||
|
|
// This is a placeholder for actual caching logic
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|