refactor: Reverted to Full Recalc for consistency

Include/MyIncludes/MAMA_Calculator.mqh

@@ -1,23 +1,34 @@
 //+------------------------------------------------------------------+
 //|                                              MAMA_Calculator.mqh |
-//|      Calculation engine for the John Ehlers' MAMA and FAMA.      |
+//|      VERSION 1.20: Reverted to Full Recalc for consistency.      |
 //|                                        Copyright 2025, xxxxxxxx  |
 //+------------------------------------------------------------------+
 #property copyright "Copyright 2025, xxxxxxxx"
 
 #include <MyIncludes\HeikinAshi_Tools.mqh>
 
-//+==================================================================+
-//|                                                                  |
-//|             CLASS 1: CMAMACalculator (Base Class)                |
-//|                                                                  |
 //+==================================================================+
 class CMAMACalculator
   {
 protected:
    double            m_fast_limit;
    double            m_slow_limit;
+
+   //--- Buffers
    double            m_price[];
+   // We keep internal buffers as members to avoid reallocation,
+   // but we will overwrite them every time.
+   double            m_smooth_buf[];
+   double            m_detrender_buf[];
+   double            m_I1_buf[], m_Q1_buf[];
+   double            m_jI_buf[], m_jQ_buf[];
+   double            m_I2_buf[], m_Q2_buf[];
+   double            m_Re_buf[], m_Im_buf[];
+   double            m_period_buf[];
+   double            m_smooth_period_buf[];
+   double            m_phase_buf[];
+   double            m_mama_buf[];
+   double            m_fama_buf[];
 
    virtual bool      PreparePriceSeries(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[]);
 
@@ -26,6 +37,8 @@ public:
    virtual          ~CMAMACalculator(void) {};
 
    bool              Init(double fast_limit, double slow_limit);
+
+   //--- Reverted: No prev_calculated needed
    void              Calculate(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[],
                                double &mama_buffer[], double &fama_buffer[]);
   };
@@ -42,211 +55,226 @@ bool CMAMACalculator::Init(double fast_limit, double slow_limit)
 void CMAMACalculator::Calculate(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[],
                                 double &mama_buffer[], double &fama_buffer[])
   {
-   if(rates_total < 50) // MAMA needs a significant warmup period
+   if(rates_total < 50)
       return;
+
+//--- Always Full Recalculation
+
+//--- Resize Internal Buffers
+   if(ArraySize(m_price) != rates_total)
+     {
+      ArrayResize(m_price, rates_total);
+      ArrayResize(m_smooth_buf, rates_total);
+      ArrayResize(m_detrender_buf, rates_total);
+      ArrayResize(m_I1_buf, rates_total);
+      ArrayResize(m_Q1_buf, rates_total);
+      ArrayResize(m_jI_buf, rates_total);
+      ArrayResize(m_jQ_buf, rates_total);
+      ArrayResize(m_I2_buf, rates_total);
+      ArrayResize(m_Q2_buf, rates_total);
+      ArrayResize(m_Re_buf, rates_total);
+      ArrayResize(m_Im_buf, rates_total);
+      ArrayResize(m_period_buf, rates_total);
+      ArrayResize(m_smooth_period_buf, rates_total);
+      ArrayResize(m_phase_buf, rates_total);
+      ArrayResize(m_mama_buf, rates_total);
+      ArrayResize(m_fama_buf, rates_total);
+     }
+
+// Initialize buffers with 0 (important for full recalc)
+   ArrayInitialize(m_smooth_buf, 0);
+   ArrayInitialize(m_detrender_buf, 0);
+   ArrayInitialize(m_I1_buf, 0);
+   ArrayInitialize(m_Q1_buf, 0);
+   ArrayInitialize(m_jI_buf, 0);
+   ArrayInitialize(m_jQ_buf, 0);
+   ArrayInitialize(m_I2_buf, 0);
+   ArrayInitialize(m_Q2_buf, 0);
+   ArrayInitialize(m_Re_buf, 0);
+   ArrayInitialize(m_Im_buf, 0);
+   ArrayInitialize(m_period_buf, 0);
+   ArrayInitialize(m_smooth_period_buf, 0);
+   ArrayInitialize(m_phase_buf, 0);
+// MAMA/FAMA init with price later
+
    if(!PreparePriceSeries(rates_total, price_type, open, high, low, close))
       return;
 
-// --- State variables for full recalculation loop ---
+//--- Main Loop (From 0 to Total)
-   double smooth=0, detrender=0, I1=0, Q1=0;
-   double jI=0, jQ=0, I2=0, Q2=0, Re=0, Im=0;
-   double period=0, smooth_period=0, phase=0, delta_phase=0;
-
-   double I1_p[7]= {0}, Q1_p[7]= {0}, detrender_p[7]= {0}, smooth_p[5]= {0};
-   double I2_p[2]= {0}, Q2_p[2]= {0};
-   double Re_p[2]= {0}, Im_p[2]= {0};
-   double period_p[2]= {0}, smooth_period_p[2]= {0};
-   double phase_p[2]= {0};
-   double mama_prev=0, fama_prev=0;
-
-// --- Full recalculation loop for stability ---
    for(int i = 0; i < rates_total; i++)
      {
-      // Shift history
+      // Initialization for first few bars
-      for(int k=6; k>0; k--)
+      if(i < 7)
-        {
-         I1_p[k]=I1_p[k-1];
-         Q1_p[k]=Q1_p[k-1];
-         detrender_p[k]=detrender_p[k-1];
-        }
-      for(int k=4; k>0; k--)
-        {
-         smooth_p[k]=smooth_p[k-1];
-        }
-      I2_p[1]=I2_p[0];
-      Q2_p[1]=Q2_p[0];
-      Re_p[1]=Re_p[0];
-      Im_p[1]=Im_p[0];
-      period_p[1]=period_p[0];
-      smooth_period_p[1]=smooth_period_p[0];
-      phase_p[1]=phase_p[0];
-
-      // --- Calculation starts after a few bars ---
-      if(i > 5)
-        {
-         // 1. Smoothing
-         smooth = (4*m_price[i] + 3*m_price[i-1] + 2*m_price[i-2] + m_price[i-3]) / 10.0;
-         smooth_p[0] = smooth;
-
-         // 2. Detrender (Band-pass filter)
-         detrender = (0.0962*smooth_p[0] + 0.5769*smooth_p[2] - 0.5769*smooth_p[4] - 0.0962*smooth_p[0]) * (0.075*period_p[1] + 0.54);
-         detrender_p[0] = detrender;
-
-         // 3. InPhase and Quadrature components
-         Q1 = (0.0962*detrender_p[0] + 0.5769*detrender_p[2] - 0.5769*detrender_p[4] - 0.0962*detrender_p[6]) * (0.075*period_p[1] + 0.54);
-         I1 = detrender_p[3];
-         I1_p[0] = I1;
-         Q1_p[0] = Q1;
-
-         // 4. Phase advance
-         jI = (0.0962*I1_p[0] + 0.5769*I1_p[2] - 0.5769*I1_p[4] - 0.0962*I1_p[6]) * (0.075*period_p[1] + 0.54);
-         jQ = (0.0962*Q1_p[0] + 0.5769*Q1_p[2] - 0.5769*Q1_p[4] - 0.0962*Q1_p[6]) * (0.075*period_p[1] + 0.54);
-
-         // 5. Phasor addition and smoothing
-         I2 = I1 - jQ;
-         Q2 = Q1 + jI;
-         I2 = 0.2*I2 + 0.8*I2_p[1];
-         Q2 = 0.2*Q2 + 0.8*Q2_p[1];
-         I2_p[0] = I2;
-         Q2_p[0] = Q2;
-
-         // 6. Homodyne Discriminator
-         Re = I2*I2_p[1] + Q2*Q2_p[1];
-         Im = I2*Q2_p[1] - Q2*I2_p[1];
-         Re = 0.2*Re + 0.8*Re_p[1];
-         Im = 0.2*Im + 0.8*Im_p[1];
-         Re_p[0] = Re;
-         Im_p[0] = Im;
-
-         // 7. Cycle Period Measurement
-         if(Im!=0.0 && Re!=0.0)
-            period = 360.0 / (atan(Im/Re) * 180.0/M_PI);
-         if(period > 1.5*period_p[1])
-            period = 1.5*period_p[1];
-         if(period < 0.67*period_p[1])
-            period = 0.67*period_p[1];
-         if(period < 6)
-            period = 6;
-         if(period > 50)
-            period = 50;
-         period = 0.2*period + 0.8*period_p[1];
-         smooth_period = 0.33*period + 0.67*smooth_period_p[1];
-         period_p[0] = period;
-         smooth_period_p[0] = smooth_period;
-
-         // 8. Delta Phase
-         if(I1 != 0.0)
-            phase = atan(Q1/I1) * 180.0/M_PI;
-         delta_phase = phase_p[1] - phase;
-         if(delta_phase < 1.0)
-            delta_phase = 1.0;
-         phase_p[0] = phase;
-
-         // 9. Adaptive Alpha
-         double alpha = m_fast_limit / delta_phase;
-         if(alpha < m_slow_limit)
-            alpha = m_slow_limit;
-
-         // 10. MAMA and FAMA Calculation
-         mama_buffer[i] = alpha * m_price[i] + (1.0 - alpha) * mama_prev;
-         fama_buffer[i] = 0.5 * alpha * mama_buffer[i] + (1.0 - 0.5 * alpha) * fama_prev;
-        }
-      else
         {
+         m_mama_buf[i] = m_price[i];
+         m_fama_buf[i] = m_price[i];
          mama_buffer[i] = m_price[i];
          fama_buffer[i] = m_price[i];
+         continue;
         }
 
-      mama_prev = mama_buffer[i];
+      // 1. Smoothing
-      fama_prev = fama_buffer[i];
+      m_smooth_buf[i] = (4*m_price[i] + 3*m_price[i-1] + 2*m_price[i-2] + m_price[i-3]) / 10.0;
+
+      // 2. Detrender
+      double period_prev = m_period_buf[i-1];
+      m_detrender_buf[i] = (0.0962*m_smooth_buf[i] + 0.5769*m_smooth_buf[i-2] - 0.5769*m_smooth_buf[i-4] - 0.0962*m_smooth_buf[i-6]) * (0.075*period_prev + 0.54);
+
+      // 3. InPhase and Quadrature
+      m_Q1_buf[i] = (0.0962*m_detrender_buf[i] + 0.5769*m_detrender_buf[i-2] - 0.5769*m_detrender_buf[i-4] - 0.0962*m_detrender_buf[i-6]) * (0.075*period_prev + 0.54);
+      m_I1_buf[i] = m_detrender_buf[i-3];
+
+      // 4. Phase advance
+      m_jI_buf[i] = (0.0962*m_I1_buf[i] + 0.5769*m_I1_buf[i-2] - 0.5769*m_I1_buf[i-4] - 0.0962*m_I1_buf[i-6]) * (0.075*period_prev + 0.54);
+      m_jQ_buf[i] = (0.0962*m_Q1_buf[i] + 0.5769*m_Q1_buf[i-2] - 0.5769*m_Q1_buf[i-4] - 0.0962*m_Q1_buf[i-6]) * (0.075*period_prev + 0.54);
+
+      // 5. Phasor addition
+      double I2 = m_I1_buf[i] - m_jQ_buf[i];
+      double Q2 = m_Q1_buf[i] + m_jI_buf[i];
+
+      m_I2_buf[i] = 0.2*I2 + 0.8*m_I2_buf[i-1];
+      m_Q2_buf[i] = 0.2*Q2 + 0.8*m_Q2_buf[i-1];
+
+      // 6. Homodyne Discriminator
+      double Re = m_I2_buf[i]*m_I2_buf[i-1] + m_Q2_buf[i]*m_Q2_buf[i-1];
+      double Im = m_I2_buf[i]*m_Q2_buf[i-1] - m_Q2_buf[i]*m_I2_buf[i-1];
+
+      m_Re_buf[i] = 0.2*Re + 0.8*m_Re_buf[i-1];
+      m_Im_buf[i] = 0.2*Im + 0.8*m_Im_buf[i-1];
+
+      // 7. Cycle Period
+      double period = 0;
+      if(m_Im_buf[i]!=0.0 && m_Re_buf[i]!=0.0)
+         period = 360.0 / (atan(m_Im_buf[i]/m_Re_buf[i]) * 180.0/M_PI);
+
+      if(period > 1.5*m_period_buf[i-1])
+         period = 1.5*m_period_buf[i-1];
+      if(period < 0.67*m_period_buf[i-1])
+         period = 0.67*m_period_buf[i-1];
+      if(period < 6)
+         period = 6;
+      if(period > 50)
+         period = 50;
+
+      m_period_buf[i] = 0.2*period + 0.8*m_period_buf[i-1];
+      m_smooth_period_buf[i] = 0.33*m_period_buf[i] + 0.67*m_smooth_period_buf[i-1];
+
+      // 8. Delta Phase
+      double phase = 0;
+      if(m_I1_buf[i] != 0.0)
+         phase = atan(m_Q1_buf[i]/m_I1_buf[i]) * 180.0/M_PI;
+
+      double delta_phase = m_phase_buf[i-1] - phase;
+      if(delta_phase < 1.0)
+         delta_phase = 1.0;
+      m_phase_buf[i] = phase;
+
+      // 9. Adaptive Alpha
+      double alpha = m_fast_limit / delta_phase;
+      if(alpha < m_slow_limit)
+         alpha = m_slow_limit;
+
+      // 10. MAMA and FAMA
+      m_mama_buf[i] = alpha * m_price[i] + (1.0 - alpha) * m_mama_buf[i-1];
+      m_fama_buf[i] = 0.5 * alpha * m_mama_buf[i] + (1.0 - 0.5 * alpha) * m_fama_buf[i-1];
+
+      mama_buffer[i] = m_mama_buf[i];
+      fama_buffer[i] = m_fama_buf[i];
      }
   }
 
 //+------------------------------------------------------------------+
 bool CMAMACalculator::PreparePriceSeries(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[])
   {
-   ArrayResize(m_price, rates_total);
+// Full copy
-   switch(price_type)
+   for(int i = 0; i < rates_total; i++)
      {
-      case PRICE_CLOSE:
+      switch(price_type)
-         ArrayCopy(m_price, close, 0, 0, rates_total);
+        {
-         break;
+         case PRICE_CLOSE:
-      case PRICE_OPEN:
+            m_price[i] = close[i];
-         ArrayCopy(m_price, open, 0, 0, rates_total);
+            break;
-         break;
+         case PRICE_OPEN:
-      case PRICE_HIGH:
+            m_price[i] = open[i];
-         ArrayCopy(m_price, high, 0, 0, rates_total);
+            break;
-         break;
+         case PRICE_HIGH:
-      case PRICE_LOW:
+            m_price[i] = high[i];
-         ArrayCopy(m_price, low, 0, 0, rates_total);
+            break;
-         break;
+         case PRICE_LOW:
-      case PRICE_MEDIAN:
+            m_price[i] = low[i];
-         for(int i=0; i<rates_total; i++)
+            break;
+         case PRICE_MEDIAN:
             m_price[i] = (high[i]+low[i])/2.0;
-         break;
+            break;
-      case PRICE_TYPICAL:
+         case PRICE_TYPICAL:
-         for(int i=0; i<rates_total; i++)
             m_price[i] = (high[i]+low[i]+close[i])/3.0;
-         break;
+            break;
-      case PRICE_WEIGHTED:
+         case PRICE_WEIGHTED:
-         for(int i=0; i<rates_total; i++)
+            m_price[i] = (high[i]+low[i]+2*close[i])/4.0;
-            m_price[i] = (high[i]+low[i]+close[i]+close[i])/4.0;
+            break;
-         break;
+         default:
-      default:
+            m_price[i] = close[i];
-         return false;
+            break;
+        }
      }
    return true;
   }
-//+------------------------------------------------------------------+
+
-//|                                                                  |
+//+==================================================================+
-//+------------------------------------------------------------------+
 class CMAMACalculator_HA : public CMAMACalculator
   {
 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, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[]) override;
   };
-//+------------------------------------------------------------------+
+
-//|                                                                  |
 //+------------------------------------------------------------------+
 bool CMAMACalculator_HA::PreparePriceSeries(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[])
   {
-   double ha_open[], ha_high[], ha_low[], ha_close[];
+   if(ArraySize(m_ha_open) != rates_total)
-   ArrayResize(ha_open, rates_total);
-   ArrayResize(ha_high, rates_total);
-   ArrayResize(ha_low, rates_total);
-   ArrayResize(ha_close, rates_total);
-   m_ha_calculator.Calculate(rates_total, open, high, low, close, ha_open, ha_high, ha_low, ha_close);
-   ArrayResize(m_price, rates_total);
-   switch(price_type)
      {
-      case PRICE_CLOSE:
+      ArrayResize(m_ha_open, rates_total);
-         ArrayCopy(m_price, ha_close, 0, 0, rates_total);
+      ArrayResize(m_ha_high, rates_total);
-         break;
+      ArrayResize(m_ha_low, rates_total);
-      case PRICE_OPEN:
+      ArrayResize(m_ha_close, rates_total);
-         ArrayCopy(m_price, ha_open, 0, 0, rates_total);
+     }
-         break;
+
-      case PRICE_HIGH:
+// Full Recalc for HA
-         ArrayCopy(m_price, ha_high, 0, 0, rates_total);
+   m_ha_calculator.Calculate(rates_total, 0, open, high, low, close,
-         break;
+                             m_ha_open, m_ha_high, m_ha_low, m_ha_close);
-      case PRICE_LOW:
+
-         ArrayCopy(m_price, ha_low, 0, 0, rates_total);
+   for(int i = 0; i < rates_total; i++)
-         break;
+     {
-      case PRICE_MEDIAN:
+      switch(price_type)
-         for(int i=0; i<rates_total; i++)
+        {
-            m_price[i] = (ha_high[i]+ha_low[i])/2.0;
+         case PRICE_CLOSE:
-         break;
+            m_price[i] = m_ha_close[i];
-      case PRICE_TYPICAL:
+            break;
-         for(int i=0; i<rates_total; i++)
+         case PRICE_OPEN:
-            m_price[i] = (ha_high[i]+ha_low[i]+ha_close[i])/3.0;
+            m_price[i] = m_ha_open[i];
-         break;
+            break;
-      case PRICE_WEIGHTED:
+         case PRICE_HIGH:
-         for(int i=0; i<rates_total; i++)
+            m_price[i] = m_ha_high[i];
-            m_price[i] = (ha_high[i]+ha_low[i]+ha_close[i]+ha_close[i])/4.0;
+            break;
-         break;
+         case PRICE_LOW:
-      default:
+            m_price[i] = m_ha_low[i];
-         return false;
+            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;
   }