refactor: Optimized for incremental calculation

Include/MyIncludes/McGinleyDynamic_Calculator.mqh

@@ -1,6 +1,6 @@
 //+------------------------------------------------------------------+
 //|                                 McGinleyDynamic_Calculator.mqh   |
-//| Calculation engine for Standard and Heikin Ashi McGinley Dynamic.|
+//|      VERSION 3.20: Optimized for incremental calculation.        |
 //|                                        Copyright 2025, xxxxxxxx  |
 //+------------------------------------------------------------------+
 #property copyright "Copyright 2025, xxxxxxxx"
@@ -8,109 +8,31 @@
 #include <MyIncludes\HeikinAshi_Tools.mqh>
 
 //+==================================================================+
-//| CLASS: CMcGinleyFilter                                           |
-//| A stateful class to calculate one instance of a McGinley filter. |
-//+==================================================================+
-class CMcGinleyFilter
-  {
-private:
-   int               m_length;
-   double            m_last_value;
-   bool              m_is_initialized;
-
-public:
-                     CMcGinleyFilter(void) : m_length(14), m_last_value(0), m_is_initialized(false) {}
-
-   void              Init(int length);
-   double            Update(double price, const double &price_series[], int current_index);
-  };
-
-//+------------------------------------------------------------------+
-//| CMcGinleyFilter: Resets the filter's state.                      |
-//+------------------------------------------------------------------+
-void CMcGinleyFilter::Init(int length)
-  {
-   m_length = (length < 1) ? 1 : length;
-   m_is_initialized = false; // Reset initialization flag
-   m_last_value = 0;
-  }
-
-//+------------------------------------------------------------------+
-//| CMcGinleyFilter: Updates the filter with a new price value.      |
-//+------------------------------------------------------------------+
-double CMcGinleyFilter::Update(double price, const double &price_series[], int current_index)
-  {
-//--- Robust initialization with SMA on the first valid call
-   if(!m_is_initialized)
-     {
-      // Not enough data to calculate initial SMA
-      if(current_index < m_length - 1)
-         return EMPTY_VALUE;
-
-      double sum = 0;
-      for(int i = 0; i < m_length; i++)
-        {
-         sum += price_series[current_index - i];
-        }
-
-      if(m_length > 0)
-         m_last_value = sum / m_length;
-      else
-         m_last_value = price;
-
-      m_is_initialized = true;
-      return m_last_value;
-     }
-
-//--- Handle potential zero or negative previous values
-   if(m_last_value <= 0)
-     {
-      m_last_value = price;
-      return m_last_value;
-     }
-
-//--- Robust calculation with ratio clamping to prevent overflow ---
-   double ratio = price / m_last_value;
-
-// Clamp the ratio to prevent extreme 'k' values on volatile instruments
-   if(ratio > 2.0)
-      ratio = 2.0; // Cap ratio at 100% price increase
-   if(ratio < 0.5)
-      ratio = 0.5; // Cap ratio at 50% price decrease
-
-   double k = m_length * MathPow(ratio, 4);
-
-// Final guard clause to ensure the dynamic period is at least 1
-   if(k < 1.0)
-      k = 1.0;
-
-   m_last_value = m_last_value + (price - m_last_value) / k;
-   return m_last_value;
-  }
-
-//+==================================================================+
-//|                                                                  |
 //|         CLASS 1: CMcGinleyDynamicCalculator (Base Class)         |
-//|                                                                  |
 //+==================================================================+
 class CMcGinleyDynamicCalculator
   {
 protected:
    int               m_length;
+
+   //--- Persistent Buffer for Incremental Calculation
    double            m_price[];
 
-   virtual bool      PreparePriceSeries(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type);
+   //--- Updated: Accepts start_index
+   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[]);
 
 public:
                      CMcGinleyDynamicCalculator(void) {};
    virtual          ~CMcGinleyDynamicCalculator(void) {};
 
    bool              Init(int length);
-   void              Calculate(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type, double &mcginley_buffer[]);
+
+   //--- Updated: Accepts prev_calculated
+   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 &mcginley_buffer[]);
   };
 
 //+------------------------------------------------------------------+
-//| CMcGinleyDynamicCalculator: Initialization                       |
+//| Init                                                             |
 //+------------------------------------------------------------------+
 bool CMcGinleyDynamicCalculator::Init(int length)
   {
@@ -119,114 +41,171 @@ bool CMcGinleyDynamicCalculator::Init(int length)
   }
 
 //+------------------------------------------------------------------+
-//| CMcGinleyDynamicCalculator: Main Calculation Method (Shared Logic)|
+//| Main Calculation (Optimized)                                     |
 //+------------------------------------------------------------------+
-void CMcGinleyDynamicCalculator::Calculate(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type, double &mcginley_buffer[])
+void CMcGinleyDynamicCalculator::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 &mcginley_buffer[])
   {
    if(rates_total < m_length)
       return;
-   if(!PreparePriceSeries(rates_total, open, high, low, close, price_type))
+
+//--- 1. Determine Start Index
+   int start_index;
+   if(prev_calculated == 0)
+      start_index = 0;
+   else
+      start_index = prev_calculated - 1;
+
+//--- 2. Resize Buffer
+   if(ArraySize(m_price) != rates_total)
+      ArrayResize(m_price, rates_total);
+
+//--- 3. Prepare Price (Optimized)
+   if(!PreparePriceSeries(rates_total, start_index, price_type, open, high, low, close))
       return;
 
-   CMcGinleyFilter filter;
+//--- 4. Calculate McGinley Dynamic (Incremental Loop)
-   filter.Init(m_length);
+   int loop_start = MathMax(m_length, start_index);
 
-   for(int i = 0; i < rates_total; i++)
+   for(int i = loop_start; i < rates_total; i++)
      {
-      mcginley_buffer[i] = filter.Update(m_price[i], m_price, i);
+      // Initialization
+      if(i == m_length)
+        {
+         // Simple Moving Average for initialization
+         double sum = 0;
+         for(int j = 0; j < m_length; j++)
+            sum += m_price[i-j];
+         mcginley_buffer[i] = sum / m_length;
+         continue;
+        }
+
+      // Recursive calculation using persistent buffer [i-1]
+      double prev_md = mcginley_buffer[i-1];
+
+      if(prev_md <= 0) // Safety check
+        {
+         mcginley_buffer[i] = m_price[i];
+         continue;
+        }
+
+      double ratio = m_price[i] / prev_md;
+
+      // Clamp ratio
+      if(ratio > 2.0)
+         ratio = 2.0;
+      if(ratio < 0.5)
+         ratio = 0.5;
+
+      double k = m_length * MathPow(ratio, 4);
+      if(k < 1.0)
+         k = 1.0;
+
+      mcginley_buffer[i] = prev_md + (m_price[i] - prev_md) / k;
      }
   }
 
 //+------------------------------------------------------------------+
-//| CMcGinleyDynamicCalculator: Prepares the standard source price.  |
+//| Prepare Price (Standard - Optimized)                             |
 //+------------------------------------------------------------------+
-bool CMcGinleyDynamicCalculator::PreparePriceSeries(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type)
+bool CMcGinleyDynamicCalculator::PreparePriceSeries(int rates_total, int start_index, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[])
   {
-   ArrayResize(m_price, rates_total);
+// Optimized copy loop
-   switch(price_type)
+   for(int i = start_index; i < rates_total; i++)
      {
-      case PRICE_OPEN:
+      switch(price_type)
-         ArrayCopy(m_price, open, 0, 0, rates_total);
+        {
-         break;
+         case PRICE_CLOSE:
-      case PRICE_HIGH:
+            m_price[i] = close[i];
-         ArrayCopy(m_price, high, 0, 0, rates_total);
+            break;
-         break;
+         case PRICE_OPEN:
-      case PRICE_LOW:
+            m_price[i] = open[i];
-         ArrayCopy(m_price, low, 0, 0, rates_total);
+            break;
-         break;
+         case PRICE_HIGH:
-      case PRICE_MEDIAN:
+            m_price[i] = high[i];
-         for(int i=0; i<rates_total; i++)
+            break;
+         case PRICE_LOW:
+            m_price[i] = low[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;
-         break;
+            break;
-      default:
+         default:
-         ArrayCopy(m_price, close, 0, 0, rates_total);
+            m_price[i] = close[i];
-         break;
+            break;
+        }
      }
    return true;
   }
 
 //+==================================================================+
-//|                                                                  |
+//|             CLASS 2: CMcGinleyDynamicCalculator_HA (HA)          |
-//|       CLASS 2: CMcGinleyDynamicCalculator_HA (Heikin Ashi)       |
-//|                                                                  |
 //+==================================================================+
 class CMcGinleyDynamicCalculator_HA : public CMcGinleyDynamicCalculator
   {
 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, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type) override;
+   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;
   };
 
 //+------------------------------------------------------------------+
-//| CMcGinleyDynamicCalculator_HA: Prepares the HA source price.     |
+//| Prepare Price (Heikin Ashi - Optimized)                          |
 //+------------------------------------------------------------------+
-bool CMcGinleyDynamicCalculator_HA::PreparePriceSeries(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[], ENUM_APPLIED_PRICE price_type)
+bool CMcGinleyDynamicCalculator_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[])
   {
-   double ha_open[], ha_high[], ha_low[], ha_close[];
+// Resize internal HA buffers
-   ArrayResize(ha_open, rates_total);
+   if(ArraySize(m_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_OPEN:
+      ArrayResize(m_ha_open, rates_total);
-         ArrayCopy(m_price, ha_open, 0, 0, rates_total);
+      ArrayResize(m_ha_high, rates_total);
-         break;
+      ArrayResize(m_ha_low, rates_total);
-      case PRICE_HIGH:
+      ArrayResize(m_ha_close, rates_total);
-         ArrayCopy(m_price, ha_high, 0, 0, rates_total);
+     }
-         break;
+
-      case PRICE_LOW:
+//--- STRICT CALL: Use the optimized 10-param HA calculation
-         ArrayCopy(m_price, ha_low, 0, 0, rates_total);
+   m_ha_calculator.Calculate(rates_total, start_index, open, high, low, close,
-         break;
+                             m_ha_open, m_ha_high, m_ha_low, m_ha_close);
-      case PRICE_MEDIAN:
+
-         for(int i=0; i<rates_total; i++)
+//--- Copy to m_price (Optimized loop)
-            m_price[i] = (ha_high[i]+ha_low[i])/2.0;
+   for(int i = start_index; i < rates_total; i++)
-         break;
+     {
-      case PRICE_TYPICAL:
+      switch(price_type)
-         for(int i=0; i<rates_total; i++)
+        {
-            m_price[i] = (ha_high[i]+ha_low[i]+ha_close[i])/3.0;
+         case PRICE_CLOSE:
-         break;
+            m_price[i] = m_ha_close[i];
-      case PRICE_WEIGHTED:
+            break;
-         for(int i=0; i<rates_total; i++)
+         case PRICE_OPEN:
-            m_price[i] = (ha_high[i]+ha_low[i]+2*ha_close[i])/4.0;
+            m_price[i] = m_ha_open[i];
-         break;
+            break;
-      default:
+         case PRICE_HIGH:
-         ArrayCopy(m_price, ha_close, 0, 0, rates_total);
+            m_price[i] = m_ha_high[i];
-         break;
+            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;
   }
 //+------------------------------------------------------------------+
-//+------------------------------------------------------------------+