diff --git a/Include/MyIncludes/MADH_Calculator.mqh b/Include/MyIncludes/MADH_Calculator.mqh index 54bbac3..bf54625 100644 --- a/Include/MyIncludes/MADH_Calculator.mqh +++ b/Include/MyIncludes/MADH_Calculator.mqh @@ -1,12 +1,12 @@ //+------------------------------------------------------------------+ //| MADH_Calculator.mqh | //| Calculation engine for the John Ehlers' MADH indicator. | -//| VERSION 2.00: Optimized for incremental calculation. | +//| VERSION 3.10: Fixed pointer declaration bug. | //| Copyright 2025, xxxxxxxx | //+------------------------------------------------------------------+ #property copyright "Copyright 2025, xxxxxxxx" -#include +#include //+==================================================================+ //| CLASS 1: CMADHCalculator (Base Class) | @@ -17,18 +17,20 @@ protected: int m_short_len; int m_dom_cycle; - //--- Persistent Buffer for Incremental Calculation - double m_price[]; + //--- Engines (Pointers!) + CWindowedMACalculator *m_short_ma; + CWindowedMACalculator *m_long_ma; - // Helper function to calculate a Hann-windowed Moving Average - double CalcHWMA(int position, int period, const double &price_array[]); + //--- Persistent Buffers for MA outputs + double m_short_buffer[]; + double m_long_buffer[]; - //--- Updated: Accepts start_index - virtual bool PreparePriceSeries(int rates_total, int start_index, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[]); + //--- Factory Method for Engines + virtual void CreateEngines(void); public: - CMADHCalculator(void) {}; - virtual ~CMADHCalculator(void) {}; + CMADHCalculator(void); + virtual ~CMADHCalculator(void); bool Init(int short_len, int dom_cycle); @@ -36,6 +38,44 @@ public: void Calculate(int rates_total, int prev_calculated, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[], double &madh_buffer[]); }; +//+------------------------------------------------------------------+ +//| Constructor | +//+------------------------------------------------------------------+ +CMADHCalculator::CMADHCalculator(void) + { + m_short_ma = NULL; + m_long_ma = NULL; +// Note: CreateEngines is virtual, so calling it in constructor is risky in C++, +// but in MQL5 it calls the base version. We should call it in Init or handle it carefully. +// However, for simplicity here, we can call it, but the derived class constructor runs AFTER base. +// So the derived class will overwrite these pointers. +// Better pattern: Call CreateEngines in Init or check for NULL. +// But let's stick to the pattern used in other calculators: +// Base constructor creates base engines. Derived constructor deletes and creates derived engines. + m_short_ma = new CWindowedMACalculator(); + m_long_ma = new CWindowedMACalculator(); + } + +//+------------------------------------------------------------------+ +//| Destructor | +//+------------------------------------------------------------------+ +CMADHCalculator::~CMADHCalculator(void) + { + if(CheckPointer(m_short_ma) != POINTER_INVALID) + delete m_short_ma; + if(CheckPointer(m_long_ma) != POINTER_INVALID) + delete m_long_ma; + } + +//+------------------------------------------------------------------+ +//| Factory Method | +//+------------------------------------------------------------------+ +void CMADHCalculator::CreateEngines(void) + { +// This method is actually not needed if we handle creation in constructors properly. +// But let's keep it for clarity if we want to re-init. + } + //+------------------------------------------------------------------+ //| Init | //+------------------------------------------------------------------+ @@ -43,37 +83,21 @@ bool CMADHCalculator::Init(int short_len, int dom_cycle) { m_short_len = (short_len < 1) ? 1 : short_len; m_dom_cycle = (dom_cycle < 1) ? 1 : dom_cycle; + + int long_len = m_short_len + (int)round(m_dom_cycle / 2.0); + + if(CheckPointer(m_short_ma) == POINTER_INVALID || CheckPointer(m_long_ma) == POINTER_INVALID) + return false; + +// Initialize Engines (Hann Window, Price Source) + if(!m_short_ma.Init(m_short_len, SOURCE_PRICE)) + return false; + if(!m_long_ma.Init(long_len, SOURCE_PRICE)) + return false; + return true; } -//+------------------------------------------------------------------+ -//| Helper function to calculate a Hann-windowed Moving Average | -//+------------------------------------------------------------------+ -double CMADHCalculator::CalcHWMA(int position, int period, const double &price_array[]) - { - if(position < period - 1) - return 0.0; - - double sum = 0; - double coef_sum = 0; - -// Optimization: Pre-calculate weights in Init? -// Since period can be different (short vs long), we keep it local or use a map. -// For typical periods, local calculation is fast enough. - - for(int i = 0; i < period; i++) - { - double weight = 1.0 - cos(2 * M_PI * (i + 1.0) / (period + 1.0)); - sum += weight * price_array[position - i]; - coef_sum += weight; - } - - if(coef_sum > 0) - return sum / coef_sum; - - return 0.0; - } - //+------------------------------------------------------------------+ //| Main Calculation (Optimized) | //+------------------------------------------------------------------+ @@ -83,136 +107,61 @@ void CMADHCalculator::Calculate(int rates_total, int prev_calculated, ENUM_APPLI if(rates_total < long_len) return; -//--- 1. Determine Start Index - int start_index; - if(prev_calculated == 0) - start_index = 0; - else - start_index = prev_calculated - 1; +// Resize internal buffers + if(ArraySize(m_short_buffer) != rates_total) + { + ArrayResize(m_short_buffer, rates_total); + ArrayResize(m_long_buffer, rates_total); + } -//--- 2. Resize Buffer - if(ArraySize(m_price) != rates_total) - ArrayResize(m_price, rates_total); +// 1. Calculate Short MA (Delegated) + m_short_ma.Calculate(rates_total, prev_calculated, price_type, open, high, low, close, m_short_buffer); -//--- 3. Prepare Price (Optimized) - if(!PreparePriceSeries(rates_total, start_index, price_type, open, high, low, close)) - return; +// 2. Calculate Long MA (Delegated) + m_long_ma.Calculate(rates_total, prev_calculated, price_type, open, high, low, close, m_long_buffer); -//--- 4. Calculate MADH (Incremental Loop) +// 3. Calculate MADH (Incremental Loop) + int start_index = (prev_calculated > 0) ? prev_calculated - 1 : 0; int loop_start = MathMax(long_len - 1, start_index); for(int i = loop_start; i < rates_total; i++) { - // Step 1 & 2: Calculate the two HWMA filters - double filt1 = CalcHWMA(i, m_short_len, m_price); - double filt2 = CalcHWMA(i, long_len, m_price); + double filt1 = m_short_buffer[i]; + double filt2 = m_long_buffer[i]; - // Step 3: Calculate the final MADH value - if(filt2 != 0) + if(filt2 != 0 && filt2 != EMPTY_VALUE && filt1 != EMPTY_VALUE) { madh_buffer[i] = 100.0 * (filt1 - filt2) / filt2; } else { - madh_buffer[i] = 0; + madh_buffer[i] = 0.0; } } } -//+------------------------------------------------------------------+ -//| Prepare Price (Standard - Optimized) | -//+------------------------------------------------------------------+ -bool CMADHCalculator::PreparePriceSeries(int rates_total, int start_index, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[]) - { - for(int i = start_index; i < rates_total; i++) - { - switch(price_type) - { - case PRICE_CLOSE: - m_price[i] = close[i]; - break; - case PRICE_OPEN: - m_price[i] = open[i]; - break; - case PRICE_HIGH: - m_price[i] = high[i]; - break; - case PRICE_LOW: - m_price[i] = low[i]; - break; - case PRICE_MEDIAN: - m_price[i] = (high[i]+low[i])/2.0; - break; - case PRICE_TYPICAL: - m_price[i] = (high[i]+low[i]+close[i])/3.0; - break; - case PRICE_WEIGHTED: - m_price[i] = (high[i]+low[i]+2*close[i])/4.0; - break; - default: - m_price[i] = close[i]; - break; - } - } - return true; - } - //+==================================================================+ //| CLASS 2: CMADHCalculator_HA (Heikin Ashi) | //+==================================================================+ class CMADHCalculator_HA : public CMADHCalculator { -private: - CHeikinAshi_Calculator m_ha_calculator; - double m_ha_open[], m_ha_high[], m_ha_low[], m_ha_close[]; -protected: - virtual bool PreparePriceSeries(int rates_total, int start_index, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[]) override; +public: + CMADHCalculator_HA(void); }; //+------------------------------------------------------------------+ -//| Prepare Price (Heikin Ashi - Optimized) | +//| Constructor (HA) | //+------------------------------------------------------------------+ -bool CMADHCalculator_HA::PreparePriceSeries(int rates_total, int start_index, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[]) +CMADHCalculator_HA::CMADHCalculator_HA(void) { - if(ArraySize(m_ha_open) != rates_total) - { - ArrayResize(m_ha_open, rates_total); - ArrayResize(m_ha_high, rates_total); - ArrayResize(m_ha_low, rates_total); - ArrayResize(m_ha_close, rates_total); - } - m_ha_calculator.Calculate(rates_total, start_index, open, high, low, close, m_ha_open, m_ha_high, m_ha_low, m_ha_close); + if(CheckPointer(m_short_ma) != POINTER_INVALID) + delete m_short_ma; + if(CheckPointer(m_long_ma) != POINTER_INVALID) + delete m_long_ma; - for(int i = start_index; i < rates_total; i++) - { - switch(price_type) - { - case PRICE_CLOSE: - m_price[i] = m_ha_close[i]; - break; - case PRICE_OPEN: - m_price[i] = m_ha_open[i]; - break; - case PRICE_HIGH: - m_price[i] = m_ha_high[i]; - break; - case PRICE_LOW: - m_price[i] = m_ha_low[i]; - break; - case PRICE_MEDIAN: - m_price[i] = (m_ha_high[i]+m_ha_low[i])/2.0; - break; - case PRICE_TYPICAL: - m_price[i] = (m_ha_high[i]+m_ha_low[i]+m_ha_close[i])/3.0; - break; - case PRICE_WEIGHTED: - m_price[i] = (m_ha_high[i]+m_ha_low[i]+2*m_ha_close[i])/4.0; - break; - default: - m_price[i] = m_ha_close[i]; - break; - } - } - return true; +// Use HA Engines + m_short_ma = new CWindowedMACalculator_HA(); + m_long_ma = new CWindowedMACalculator_HA(); } //+------------------------------------------------------------------+ +//+------------------------------------------------------------------+