refactor: Optimized for incremental calculation

Include/MyIncludes/MACD_Laguerre_Calculator.mqh

@@ -1,6 +1,6 @@
 //+------------------------------------------------------------------+
 //|                                     MACD_Laguerre_Calculator.mqh |
-//|      VERSION 1.12: Corrected variable name in Laguerre signal calc.|
+//|      VERSION 1.20: Optimized for incremental calculation.        |
 //|                                        Copyright 2025, xxxxxxxx  |
 //+------------------------------------------------------------------+
 #property copyright "Copyright 2025, xxxxxxxx"
@@ -8,7 +8,7 @@
 #include <MyIncludes\Laguerre_Engine.mqh>
 #include <MyIncludes\MovingAverage_Engine.mqh>
 
-//--- Universal enum for smoothing types, now including Laguerre ---
+//--- Universal enum for smoothing types
 enum ENUM_SMOOTHING_METHOD_LAGUERRE
   {
    SMOOTH_Laguerre,
@@ -26,20 +26,24 @@ protected:
    int               m_signal_period;
    ENUM_SMOOTHING_METHOD_LAGUERRE m_signal_ma_type;
 
+   //--- Engines for MACD Line
    CLaguerreEngine   *m_fast_engine;
    CLaguerreEngine   *m_slow_engine;
 
-   double            m_sig_L0_prev, m_sig_L1_prev, m_sig_L2_prev, m_sig_L3_prev;
+   //--- Engines for Signal Line (Optimization: Use dedicated engines)
+   CLaguerreEngine   *m_signal_laguerre_engine; // Used if type is Laguerre
+   CMovingAverageCalculator *m_signal_ma_engine; // Used if type is SMA/EMA...
 
    virtual CLaguerreEngine *CreateEngineInstance(void);
-   void              CalculateMA(const double &source_array[], double &dest_array[], int period, ENUM_MA_TYPE method, int start_pos);
 
 public:
                      CMACDLaguerreCalculator(void);
    virtual          ~CMACDLaguerreCalculator(void);
 
    bool              Init(double g1, double g2, double sig_g, int sig_p, ENUM_SMOOTHING_METHOD_LAGUERRE sig_type);
-   void              Calculate(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type,
+
+   //--- 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[]);
   };
 
@@ -57,20 +61,18 @@ protected:
 //+==================================================================+
 
 //+------------------------------------------------------------------+
-//|                                                                  |
+//| Constructor                                                      |
 //+------------------------------------------------------------------+
 CMACDLaguerreCalculator::CMACDLaguerreCalculator(void)
   {
    m_fast_engine = NULL;
    m_slow_engine = NULL;
-   m_sig_L0_prev = 0;
+   m_signal_laguerre_engine = NULL;
-   m_sig_L1_prev = 0;
+   m_signal_ma_engine = NULL;
-   m_sig_L2_prev = 0;
-   m_sig_L3_prev = 0;
   }
 
 //+------------------------------------------------------------------+
-//|                                                                  |
+//| Destructor                                                       |
 //+------------------------------------------------------------------+
 CMACDLaguerreCalculator::~CMACDLaguerreCalculator(void)
   {
@@ -78,16 +80,20 @@ CMACDLaguerreCalculator::~CMACDLaguerreCalculator(void)
       delete m_fast_engine;
    if(CheckPointer(m_slow_engine) != POINTER_INVALID)
       delete m_slow_engine;
+   if(CheckPointer(m_signal_laguerre_engine) != POINTER_INVALID)
+      delete m_signal_laguerre_engine;
+   if(CheckPointer(m_signal_ma_engine) != POINTER_INVALID)
+      delete m_signal_ma_engine;
   }
 
 //+------------------------------------------------------------------+
-//|                                                                  |
+//| Factory Method                                                   |
 //+------------------------------------------------------------------+
 CLaguerreEngine *CMACDLaguerreCalculator::CreateEngineInstance(void) { return new CLaguerreEngine(); }
 CLaguerreEngine *CMACDLaguerreCalculator_HA::CreateEngineInstance(void) { return new CLaguerreEngine_HA(); }
 
 //+------------------------------------------------------------------+
-//|                                                                  |
+//| Init                                                             |
 //+------------------------------------------------------------------+
 bool CMACDLaguerreCalculator::Init(double g1, double g2, double sig_g, int sig_p, ENUM_SMOOTHING_METHOD_LAGUERRE sig_type)
   {
@@ -97,11 +103,7 @@ bool CMACDLaguerreCalculator::Init(double g1, double g2, double sig_g, int sig_p
    m_signal_period = (sig_p < 1) ? 1 : sig_p;
    m_signal_ma_type = sig_type;
 
-   m_sig_L0_prev=0;
+// Create Main Engines
-   m_sig_L1_prev=0;
-   m_sig_L2_prev=0;
-   m_sig_L3_prev=0;
-
    m_fast_engine = CreateEngineInstance();
    m_slow_engine = CreateEngineInstance();
 
@@ -109,132 +111,72 @@ bool CMACDLaguerreCalculator::Init(double g1, double g2, double sig_g, int sig_p
       CheckPointer(m_slow_engine) == POINTER_INVALID || !m_slow_engine.Init(m_slow_gamma, SOURCE_PRICE))
       return false;
 
+// Create Signal Engine based on type
+   if(m_signal_ma_type == SMOOTH_Laguerre)
+     {
+      // For Signal Line, we use standard Laguerre Engine (on MACD data, not HA)
+      // Even if main calc is HA, the MACD line is already processed, so signal is just math on array.
+      m_signal_laguerre_engine = new CLaguerreEngine();
+      if(!m_signal_laguerre_engine.Init(m_signal_gamma, SOURCE_PRICE))
+         return false;
+     }
+   else
+     {
+      m_signal_ma_engine = new CMovingAverageCalculator();
+      ENUM_MA_TYPE ma_type = (ENUM_MA_TYPE)(m_signal_ma_type - 1);
+      if(!m_signal_ma_engine.Init(m_signal_period, ma_type))
+         return false;
+     }
+
    return true;
   }
 
 //+------------------------------------------------------------------+
-//|                                                                  |
+//| Main Calculation (Optimized)                                     |
 //+------------------------------------------------------------------+
-void CMACDLaguerreCalculator::Calculate(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type,
+void CMACDLaguerreCalculator::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)
       return;
 
+//--- 1. Calculate Fast and Slow Laguerre Filters (Incremental)
+// We need temp buffers for the filters
+// Optimization: We can reuse macd_line as one buffer if we are careful, but let's use temp buffers for clarity.
+// Actually, LaguerreEngine needs a destination buffer.
+// Let's use static/member buffers if we want to avoid allocation, but local arrays are fine for now as Engine handles state.
+
    double fast_filter[], slow_filter[];
-   double L0_dummy[], L1_dummy[], L2_dummy[], L3_dummy[];
+// Note: The engine resizes them.
-   m_fast_engine.CalculateFilter(rates_total, price_type, open, high, low, close, L0_dummy, L1_dummy, L2_dummy, L3_dummy, fast_filter);
+
-   m_slow_engine.CalculateFilter(rates_total, price_type, open, high, low, close, L0_dummy, L1_dummy, L2_dummy, L3_dummy, slow_filter);
+   m_fast_engine.CalculateFilter(rates_total, prev_calculated, price_type, open, high, low, close, fast_filter);
-   for(int i = 0; i < rates_total; i++)
+   m_slow_engine.CalculateFilter(rates_total, prev_calculated, price_type, open, high, low, close, slow_filter);
+
+//--- 2. Calculate MACD Line
+   int start_index = (prev_calculated > 0) ? prev_calculated - 1 : 0;
+
+   for(int i = start_index; i < rates_total; i++)
       macd_line[i] = fast_filter[i] - slow_filter[i];
 
-   switch(m_signal_ma_type)
+//--- 3. Calculate Signal Line
+   if(m_signal_ma_type == SMOOTH_Laguerre)
      {
-      case SMOOTH_Laguerre:
+      // Use Laguerre Engine on the MACD Line
-         if(rates_total > 0)
+      // We treat MACD line as 'close' price.
-           {
+      m_signal_laguerre_engine.CalculateFilter(rates_total, prev_calculated, PRICE_CLOSE,
-            signal_line[0] = macd_line[0];
+            macd_line, macd_line, macd_line, macd_line,
-            m_sig_L0_prev = macd_line[0];
+            signal_line);
-            m_sig_L1_prev = macd_line[0];
+     }
-            m_sig_L2_prev = macd_line[0];
+   else
-            m_sig_L3_prev = macd_line[0];
+     {
-           }
+      // Use MA Engine on the MACD Line
-         for(int i = 1; i < rates_total; i++)
+      m_signal_ma_engine.Calculate(rates_total, prev_calculated, PRICE_CLOSE,
-           {
+                                   macd_line, macd_line, macd_line, macd_line,
-            double L0 = (1.0 - m_signal_gamma) * macd_line[i] + m_signal_gamma * m_sig_L0_prev;
+                                   signal_line);
-            //--- CORRECTED: Use m_signal_gamma for all calculations in this block ---
-            double L1 = -m_signal_gamma * L0 + m_sig_L0_prev + m_signal_gamma * m_sig_L1_prev;
-            double L2 = -m_signal_gamma * L1 + m_sig_L1_prev + m_signal_gamma * m_sig_L2_prev;
-            double L3 = -m_signal_gamma * L2 + m_sig_L2_prev + m_signal_gamma * m_sig_L3_prev;
-            signal_line[i] = (L0 + 2.0 * L1 + 2.0 * L2 + L3) / 6.0;
-            m_sig_L0_prev = L0;
-            m_sig_L1_prev = L1;
-            m_sig_L2_prev = L2;
-            m_sig_L3_prev = L3;
-           }
-         break;
-      default:
-        {
-         ENUM_MA_TYPE ma_type = (ENUM_MA_TYPE)(m_signal_ma_type - 1);
-         CalculateMA(macd_line, signal_line, m_signal_period, ma_type, m_signal_period + 1);
-         break;
-        }
      }
 
-   for(int i = 0; i < rates_total; i++)
+//--- 4. Calculate Histogram
+   for(int i = start_index; i < rates_total; i++)
       histogram[i] = macd_line[i] - signal_line[i];
   }
-
-//+------------------------------------------------------------------+
-//|                                                                  |
-//+------------------------------------------------------------------+
-void CMACDLaguerreCalculator::CalculateMA(const double &source_array[], double &dest_array[], int period, ENUM_MA_TYPE method, int start_pos)
-  {
-   for(int i = start_pos; i < ArraySize(source_array); i++)
-     {
-      switch(method)
-        {
-         case EMA:
-         case SMMA:
-            if(i == start_pos)
-              {
-               double sum=0;
-               int count=0;
-               for(int j=0; j<period; j++)
-                 {
-                  if(source_array[i-j] != EMPTY_VALUE)
-                    {
-                     sum+=source_array[i-j];
-                     count++;
-                    }
-                 }
-               if(count > 0)
-                  dest_array[i]=sum/count;
-              }
-            else
-              {
-               if(method==EMA)
-                 {
-                  double pr=2.0/(period+1.0);
-                  dest_array[i]=source_array[i]*pr+dest_array[i-1]*(1.0-pr);
-                 }
-               else
-                  dest_array[i]=(dest_array[i-1]*(period-1)+source_array[i])/period;
-              }
-            break;
-         case LWMA:
-           {
-            double sum=0, w_sum=0;
-            for(int j=0; j<period; j++)
-              {
-               if(source_array[i-j] == EMPTY_VALUE)
-                  continue;
-               int w=period-j;
-               sum+=source_array[i-j]*w;
-               w_sum+=w;
-              }
-            if(w_sum>0)
-               dest_array[i]=sum/w_sum;
-           }
-         break;
-         default: // SMA
-           {
-            double sum=0;
-            int count=0;
-            for(int j=0; j<period; j++)
-              {
-               if(source_array[i-j] != EMPTY_VALUE)
-                 {
-                  sum+=source_array[i-j];
-                  count++;
-                 }
-              }
-            if(count > 0)
-               dest_array[i]=sum/count;
-           }
-         break;
-        }
-     }
-  }
-//+------------------------------------------------------------------+
 //+------------------------------------------------------------------+