refactor(indicators): Fixed pointer declaration bug

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 <MyIncludes\HeikinAshi_Tools.mqh>
+#include <MyIncludes\Windowed_MA_Calculator.mqh>
 
 //+==================================================================+
 //|             CLASS 1: CMADHCalculator (Base Class)                |
@@ -17,18 +17,20 @@ protected:
    int               m_short_len;
    int               m_dom_cycle;
 
-   //--- Persistent Buffer for Incremental Calculation
+   //--- Engines (Pointers!)
-   double            m_price[];
+   CWindowedMACalculator *m_short_ma;
+   CWindowedMACalculator *m_long_ma;
 
-   // Helper function to calculate a Hann-windowed Moving Average
+   //--- Persistent Buffers for MA outputs
-   double            CalcHWMA(int position, int period, const double &price_array[]);
+   double            m_short_buffer[];
+   double            m_long_buffer[];
 
-   //--- Updated: Accepts start_index
+   //--- Factory Method for Engines
-   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[]);
+   virtual void      CreateEngines(void);
 
 public:
-                     CMADHCalculator(void) {};
+                     CMADHCalculator(void);
-   virtual          ~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
+// Resize internal buffers
-   int start_index;
+   if(ArraySize(m_short_buffer) != rates_total)
-   if(prev_calculated == 0)
+     {
-      start_index = 0;
+      ArrayResize(m_short_buffer, rates_total);
-   else
+      ArrayResize(m_long_buffer, rates_total);
-      start_index = prev_calculated - 1;
+     }
 
-//--- 2. Resize Buffer
+// 1. Calculate Short MA (Delegated)
-   if(ArraySize(m_price) != rates_total)
+   m_short_ma.Calculate(rates_total, prev_calculated, price_type, open, high, low, close, m_short_buffer);
-      ArrayResize(m_price, rates_total);
 
-//--- 3. Prepare Price (Optimized)
+// 2. Calculate Long MA (Delegated)
-   if(!PreparePriceSeries(rates_total, start_index, price_type, open, high, low, close))
+   m_long_ma.Calculate(rates_total, prev_calculated, price_type, open, high, low, close, m_long_buffer);
-      return;
 
-//--- 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 = m_short_buffer[i];
-      double filt1 = CalcHWMA(i, m_short_len, m_price);
+      double filt2 = m_long_buffer[i];
-      double filt2 = CalcHWMA(i, long_len, m_price);
 
-      // Step 3: Calculate the final MADH value
+      if(filt2 != 0 && filt2 != EMPTY_VALUE && filt1 != EMPTY_VALUE)
-      if(filt2 != 0)
         {
          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:
+public:
-   CHeikinAshi_Calculator m_ha_calculator;
+                     CMADHCalculator_HA(void);
-   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;
   };
 
 //+------------------------------------------------------------------+
-//| 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)
+   if(CheckPointer(m_short_ma) != POINTER_INVALID)
-     {
+      delete m_short_ma;
-      ArrayResize(m_ha_open, rates_total);
+   if(CheckPointer(m_long_ma) != POINTER_INVALID)
-      ArrayResize(m_ha_high, rates_total);
+      delete m_long_ma;
-      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);
 
-   for(int i = start_index; i < rates_total; i++)
+// Use HA Engines
-     {
+   m_short_ma = new CWindowedMACalculator_HA();
-      switch(price_type)
+   m_long_ma = new CWindowedMACalculator_HA();
-        {
-         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;
   }
 //+------------------------------------------------------------------+
+//+------------------------------------------------------------------+