refactor: Uses MovingAverage_Engine for all lines

Include/MyIncludes/MACD_Calculator.mqh

@@ -1,6 +1,6 @@
 //+------------------------------------------------------------------+
 //|                                               MACD_Calculator.mqh|
-//|      VERSION 2.10: Reverted Signal Line to local calculation.    |
+//|      VERSION 3.00: Uses MovingAverage_Engine for all lines.      |
 //|                                        Copyright 2025, xxxxxxxx  |
 //+------------------------------------------------------------------+
 #property copyright "Copyright 2025, xxxxxxxx"
@@ -17,10 +17,8 @@ protected:
    //--- Engines for MACD Line
    CMovingAverageCalculator *m_fast_ma_engine;
    CMovingAverageCalculator *m_slow_ma_engine;
-
+   //--- Engine for Signal Line
-   //--- Parameters for Signal Line
+   CMovingAverageCalculator *m_signal_ma_engine;
-   int               m_signal_period;
-   ENUM_MA_METHOD    m_signal_ma_type;
 
    //--- Persistent Buffers for Incremental Calculation
    double            m_price[];
@@ -30,16 +28,13 @@ protected:
    //--- Updated: Accepts start_index
    virtual bool      PreparePriceSeries(int rates_total, int start_index, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type);
 
-   //--- Local Helper for Signal Line (Handles offset data correctly)
-   void              CalculateSignalMA(const double &source[], double &dest[], int rates_total, int start_index, int period, ENUM_MA_METHOD method, int data_start_pos);
-
 public:
                      CMACDCalculator(void);
    virtual          ~CMACDCalculator(void);
 
-   bool              Init(int fast_p, int slow_p, int signal_p, ENUM_MA_METHOD src_ma, ENUM_MA_METHOD sig_ma);
+   //--- Init now takes ENUM_MA_TYPE for all MAs
+   bool              Init(int fast_p, int slow_p, int signal_p, ENUM_MA_TYPE src_ma, ENUM_MA_TYPE sig_ma);
 
-   //--- Updated: Accepts prev_calculated
    void              Calculate(int rates_total, int prev_calculated, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type,
                                double &macd_line[], double &signal_line[], double &histogram[]);
   };
@@ -51,6 +46,7 @@ CMACDCalculator::CMACDCalculator(void)
   {
    m_fast_ma_engine = new CMovingAverageCalculator();
    m_slow_ma_engine = new CMovingAverageCalculator();
+   m_signal_ma_engine = new CMovingAverageCalculator();
   }
 
 //+------------------------------------------------------------------+
@@ -62,12 +58,14 @@ CMACDCalculator::~CMACDCalculator(void)
       delete m_fast_ma_engine;
    if(CheckPointer(m_slow_ma_engine) != POINTER_INVALID)
       delete m_slow_ma_engine;
+   if(CheckPointer(m_signal_ma_engine) != POINTER_INVALID)
+      delete m_signal_ma_engine;
   }
 
 //+------------------------------------------------------------------+
 //| Init                                                             |
 //+------------------------------------------------------------------+
-bool CMACDCalculator::Init(int fast_p, int slow_p, int signal_p, ENUM_MA_METHOD src_ma, ENUM_MA_METHOD sig_ma)
+bool CMACDCalculator::Init(int fast_p, int slow_p, int signal_p, ENUM_MA_TYPE src_ma, ENUM_MA_TYPE sig_ma)
   {
 // Ensure fast < slow
    int f_p = (fast_p < 1) ? 1 : fast_p;
@@ -79,13 +77,14 @@ bool CMACDCalculator::Init(int fast_p, int slow_p, int signal_p, ENUM_MA_METHOD
       s_p=temp;
      }
 
-   m_signal_period = (signal_p < 1) ? 1 : signal_p;
+   int sig_p = (signal_p < 1) ? 1 : signal_p;
-   m_signal_ma_type = sig_ma;
 
 // Initialize Engines
-   if(!m_fast_ma_engine.Init(f_p, (ENUM_MA_TYPE)src_ma))
+   if(!m_fast_ma_engine.Init(f_p, src_ma))
       return false;
-   if(!m_slow_ma_engine.Init(s_p, (ENUM_MA_TYPE)src_ma))
+   if(!m_slow_ma_engine.Init(s_p, src_ma))
+      return false;
+   if(!m_signal_ma_engine.Init(sig_p, sig_ma))
       return false;
 
    return true;
@@ -97,7 +96,9 @@ bool CMACDCalculator::Init(int fast_p, int slow_p, int signal_p, ENUM_MA_METHOD
 void CMACDCalculator::Calculate(int rates_total, int prev_calculated, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type,
                                 double &macd_line[], double &signal_line[], double &histogram[])
   {
-   if(rates_total < 2)
+// Minimum bars check
+   int min_bars = m_slow_ma_engine.GetPeriod() + m_signal_ma_engine.GetPeriod();
+   if(rates_total <= min_bars)
       return;
 
 //--- 1. Determine Start Index
@@ -120,8 +121,6 @@ void CMACDCalculator::Calculate(int rates_total, int prev_calculated, const doub
       return;
 
 //--- 4. Calculate Fast & Slow MAs (Delegated to Engine)
-// We pass PRICE_CLOSE because we already prepared m_price array with the correct price type!
-// The engine will copy m_price to its internal buffer.
    m_fast_ma_engine.Calculate(rates_total, prev_calculated, PRICE_CLOSE, m_price, m_price, m_price, m_price, m_fast_ma);
    m_slow_ma_engine.Calculate(rates_total, prev_calculated, PRICE_CLOSE, m_price, m_price, m_price, m_price, m_slow_ma);
 
@@ -129,7 +128,6 @@ void CMACDCalculator::Calculate(int rates_total, int prev_calculated, const doub
    int slow_period = m_slow_ma_engine.GetPeriod();
    int loop_start_macd = MathMax(slow_period - 1, start_index);
 
-// Initialize buffer on full recalc
    if(prev_calculated == 0)
       ArrayInitialize(macd_line, EMPTY_VALUE);
 
@@ -141,15 +139,19 @@ void CMACDCalculator::Calculate(int rates_total, int prev_calculated, const doub
          macd_line[i] = EMPTY_VALUE;
      }
 
-//--- 6. Calculate Signal Line (Using Local Helper)
+//--- 6. Calculate Signal Line (Using MA Engine)
 // The MACD line starts being valid at 'slow_period - 1'.
+// This is the offset we pass to the Signal Engine.
+   int macd_offset = slow_period - 1;
+
    if(prev_calculated == 0)
       ArrayInitialize(signal_line, EMPTY_VALUE);
 
-   CalculateSignalMA(macd_line, signal_line, rates_total, start_index, m_signal_period, m_signal_ma_type, slow_period - 1);
+   m_signal_ma_engine.CalculateOnArray(rates_total, prev_calculated, macd_line, signal_line, macd_offset);
 
 //--- 7. Calculate Histogram
-   int signal_start = slow_period - 1 + m_signal_period - 1;
+   int signal_period = m_signal_ma_engine.GetPeriod();
+   int signal_start = macd_offset + signal_period - 1;
    int loop_start_hist = MathMax(signal_start, start_index);
 
    if(prev_calculated == 0)
@@ -164,73 +166,11 @@ void CMACDCalculator::Calculate(int rates_total, int prev_calculated, const doub
      }
   }
 
-//+------------------------------------------------------------------+
-//| Local Helper for Signal Line Calculation                         |
-//+------------------------------------------------------------------+
-void CMACDCalculator::CalculateSignalMA(const double &source[], double &dest[], int rates_total, int start_index, int period, ENUM_MA_METHOD method, int data_start_pos)
-  {
-// The actual calculation starts 'period' bars after the data starts
-   int calc_start_pos = data_start_pos + period - 1;
-   int i = MathMax(calc_start_pos, start_index);
-
-   if(i >= rates_total)
-      return;
-
-   for(; i < rates_total; i++)
-     {
-      switch(method)
-        {
-         case MODE_EMA:
-         case MODE_SMMA:
-            if(i == calc_start_pos)
-              {
-               double sum=0;
-               for(int j=0; j<period; j++)
-                  sum+=source[i-j];
-               dest[i]=sum/period;
-              }
-            else
-              {
-               if(method==MODE_EMA)
-                 {
-                  double pr=2.0/(period+1.0);
-                  dest[i]=source[i]*pr+dest[i-1]*(1.0-pr);
-                 }
-               else
-                  dest[i]=(dest[i-1]*(period-1)+source[i])/period;
-              }
-            break;
-         case MODE_LWMA:
-           {
-            double sum=0,w_sum=0;
-            for(int j=0; j<period; j++)
-              {
-               int w=period-j;
-               sum+=source[i-j]*w;
-               w_sum+=w;
-              }
-            if(w_sum>0)
-               dest[i]=sum/w_sum;
-           }
-         break;
-         default: // SMA
-           {
-            double sum=0;
-            for(int j=0; j<period; j++)
-               sum+=source[i-j];
-            dest[i]=sum/period;
-           }
-         break;
-        }
-     }
-  }
-
 //+------------------------------------------------------------------+
 //| Prepare Price (Standard - Optimized)                             |
 //+------------------------------------------------------------------+
 bool CMACDCalculator::PreparePriceSeries(int rates_total, int start_index, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type)
   {
-// Optimized copy loop
    for(int i = start_index; i < rates_total; i++)
      {
       switch(price_type)
@@ -271,19 +211,16 @@ class CMACDCalculator_HA : public CMACDCalculator
   {
 private:
    CHeikinAshi_Calculator m_ha_calculator;
-   // Internal HA buffers
    double            m_ha_open[], m_ha_high[], m_ha_low[], m_ha_close[];
-
 protected:
    virtual bool      PreparePriceSeries(int rates_total, int start_index, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type) override;
   };
 
 //+------------------------------------------------------------------+
-//| Prepare Price (Heikin Ashi - Optimized)                          |
+//|                                                                  |
 //+------------------------------------------------------------------+
 bool CMACDCalculator_HA::PreparePriceSeries(int rates_total, int start_index, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type)
   {
-// Resize internal HA buffers
    if(ArraySize(m_ha_open) != rates_total)
      {
       ArrayResize(m_ha_open, rates_total);
@@ -291,12 +228,7 @@ bool CMACDCalculator_HA::PreparePriceSeries(int rates_total, int start_index, co
       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);
-//--- STRICT CALL: Use the optimized 10-param HA calculation
-   m_ha_calculator.Calculate(rates_total, start_index, open, high, low, close,
-                             m_ha_open, m_ha_high, m_ha_low, m_ha_close);
-
-//--- Copy to m_price (Optimized loop)
    for(int i = start_index; i < rates_total; i++)
      {
       switch(price_type)