refactor: Corrected state management for stability

Include/MyIncludes/Laguerre_Engine.mqh

@@ -1,14 +1,12 @@
 //+------------------------------------------------------------------+
 //|                                             Laguerre_Engine.mqh  |
-//|      Core calculation engine for the Laguerre filter series.     |
+//|      VERSION 1.10: Corrected state management for stability.     |
-//|      Can be applied to Price or Momentum.                        |
 //|                                        Copyright 2025, xxxxxxxx  |
 //+------------------------------------------------------------------+
 #property copyright "Copyright 2025, xxxxxxxx"
 
 #include <MyIncludes\HeikinAshi_Tools.mqh>
 
-// NEW: Enum to select the data source
 enum ENUM_INPUT_SOURCE { SOURCE_PRICE, SOURCE_MOMENTUM };
 
 //+==================================================================+
@@ -19,6 +17,9 @@ protected:
    ENUM_INPUT_SOURCE m_source_type;
    double            m_price[];
 
+   //--- State variables for the recursive filter (CRITICAL FIX) ---
+   double            m_L0_prev, m_L1_prev, m_L2_prev, m_L3_prev;
+
    virtual bool      PreparePriceSeries(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[]);
 
 public:
@@ -31,22 +32,42 @@ public:
    void              GetPriceBuffer(double &dest_array[]);
   };
 
+//+==================================================================+
+//|                 METHOD IMPLEMENTATIONS                           |
+//+==================================================================+
+
+//+------------------------------------------------------------------+
+//|                                                                  |
 //+------------------------------------------------------------------+
 bool CLaguerreEngine::Init(double gamma, ENUM_INPUT_SOURCE source_type)
   {
    m_gamma = fmax(0.0, fmin(1.0, gamma));
    m_source_type = source_type;
+
+//--- Reset state variables on initialization ---
+   m_L0_prev = 0;
+   m_L1_prev = 0;
+   m_L2_prev = 0;
+   m_L3_prev = 0;
+
    return true;
   }
 
+//+------------------------------------------------------------------+
+//|                                                                  |
 //+------------------------------------------------------------------+
 void CLaguerreEngine::GetPriceBuffer(double &dest_array[])
   {
    int size = ArraySize(m_price);
-   ArrayResize(dest_array, size);
+   if(size > 0)
-   ArrayCopy(dest_array, m_price, 0, 0, size);
+     {
+      ArrayResize(dest_array, size);
+      ArrayCopy(dest_array, m_price, 0, 0, size);
+     }
   }
 
+//+------------------------------------------------------------------+
+//|                                                                  |
 //+------------------------------------------------------------------+
 void CLaguerreEngine::CalculateFilter(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[],
                                       double &L0_buffer[], double &L1_buffer[], double &L2_buffer[], double &L3_buffer[], double &filt_buffer[])
@@ -62,24 +83,40 @@ void CLaguerreEngine::CalculateFilter(int rates_total, ENUM_APPLIED_PRICE price_
    ArrayResize(L3_buffer, rates_total);
    ArrayResize(filt_buffer, rates_total);
 
-   double L0_prev = m_price[0], L1_prev = m_price[0], L2_prev = m_price[0], L3_prev = m_price[0];
+//--- Robust initialization on first run ---
-   L0_buffer[0] = m_price[0];
+   if(m_L0_prev == 0 && m_L1_prev == 0) // A simple check for first run
-   L1_buffer[0] = m_price[0];
-   L2_buffer[0] = m_price[0];
-   L3_buffer[0] = m_price[0];
-   filt_buffer[0] = m_price[0];
-
-   for(int i = 1; i < rates_total; i++)
      {
-      L0_buffer[i] = (1.0 - m_gamma) * m_price[i] + m_gamma * L0_prev;
+      m_L0_prev = m_price[0];
-      L1_buffer[i] = -m_gamma * L0_buffer[i] + L0_prev + m_gamma * L1_prev;
+      m_L1_prev = m_price[0];
-      L2_buffer[i] = -m_gamma * L1_buffer[i] + L1_prev + m_gamma * L2_prev;
+      m_L2_prev = m_price[0];
-      L3_buffer[i] = -m_gamma * L2_buffer[i] + L2_prev + m_gamma * L3_prev;
+      m_L3_prev = m_price[0];
+     }
+
+   for(int i = 0; i < rates_total; i++)
+     {
+      // For the very first bar, output is just the price
+      if(i == 0)
+        {
+         L0_buffer[i] = m_price[i];
+         L1_buffer[i] = m_price[i];
+         L2_buffer[i] = m_price[i];
+         L3_buffer[i] = m_price[i];
+        }
+      else
+        {
+         L0_buffer[i] = (1.0 - m_gamma) * m_price[i] + m_gamma * m_L0_prev;
+         L1_buffer[i] = -m_gamma * L0_buffer[i] + m_L0_prev + m_gamma * m_L1_prev;
+         L2_buffer[i] = -m_gamma * L1_buffer[i] + m_L1_prev + m_gamma * m_L2_prev;
+         L3_buffer[i] = -m_gamma * L2_buffer[i] + m_L2_prev + m_gamma * m_L3_prev;
+        }
+
       filt_buffer[i] = (L0_buffer[i] + 2.0 * L1_buffer[i] + 2.0 * L2_buffer[i] + L3_buffer[i]) / 6.0;
-      L0_prev = L0_buffer[i];
+
-      L1_prev = L1_buffer[i];
+      //--- Update state variables for the next iteration ---
-      L2_prev = L2_buffer[i];
+      m_L0_prev = L0_buffer[i];
-      L3_prev = L3_buffer[i];
+      m_L1_prev = L1_buffer[i];
+      m_L2_prev = L2_buffer[i];
+      m_L3_prev = L3_buffer[i];
      }
   }