From 5afefc51d3d50fc5592a367cf368bd36f129df18 Mon Sep 17 00:00:00 2001 From: Toh4iem9 Date: Sun, 7 Dec 2025 13:27:44 +0100 Subject: [PATCH] refactor: Optimized for incremental calculation --- Include/MyIncludes/ALMA_Calculator.mqh | 217 ++++++++++++++----------- 1 file changed, 124 insertions(+), 93 deletions(-) diff --git a/Include/MyIncludes/ALMA_Calculator.mqh b/Include/MyIncludes/ALMA_Calculator.mqh index f890c2f..37ac82b 100644 --- a/Include/MyIncludes/ALMA_Calculator.mqh +++ b/Include/MyIncludes/ALMA_Calculator.mqh @@ -1,6 +1,6 @@ //+------------------------------------------------------------------+ //| ALMA_Calculator.mqh | -//| Calculation engine for Standard and Heikin Ashi ALMA. | +//| VERSION 3.10: Optimized for incremental calculation. | //| Copyright 2025, xxxxxxxx | //+------------------------------------------------------------------+ #property copyright "Copyright 2025, xxxxxxxx" @@ -8,9 +8,7 @@ #include //+==================================================================+ -//| | //| CLASS 1: CALMACalculator (Base Class) | -//| | //+==================================================================+ class CALMACalculator { @@ -19,24 +17,25 @@ protected: double m_alma_offset; double m_alma_sigma; - //--- Internal buffer for the selected source price + //--- Persistent Buffer for Incremental Calculation double m_price[]; - //--- Virtual method for preparing the price series. Base class handles standard prices. - virtual bool PreparePriceSeries(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[]); + //--- 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: CALMACalculator(void) {}; virtual ~CALMACalculator(void) {}; - //--- Public methods bool Init(int period, double offset, double sigma); int GetPeriod(void) const { return m_alma_period; } - void Calculate(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[], double &alma_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 &alma_buffer[]); }; //+------------------------------------------------------------------+ -//| CALMACalculator: Initialization | +//| Init | //+------------------------------------------------------------------+ bool CALMACalculator::Init(int period, double offset, double sigma) { @@ -47,33 +46,60 @@ bool CALMACalculator::Init(int period, double offset, double sigma) } //+------------------------------------------------------------------+ -//| CALMACalculator: Main Calculation Method (Shared Logic) | +//| Main Calculation (Optimized) | //+------------------------------------------------------------------+ -void CALMACalculator::Calculate(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[], double &alma_buffer[]) +void CALMACalculator::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 &alma_buffer[]) { if(rates_total < m_alma_period) return; -//--- STEP 1: Prepare the source price array (delegated to virtual method) - if(!PreparePriceSeries(rates_total, price_type, open, high, low, close)) +//--- 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; -//--- STEP 2: Core ALMA calculation using the prepared m_price[] array +//--- 4. Calculate ALMA (Incremental Loop) double m = m_alma_offset * (m_alma_period - 1.0); double s = (double)m_alma_period / m_alma_sigma; - for(int i = m_alma_period - 1; i < rates_total; i++) +// Pre-calculate weights (Optimization) +// Since weights depend only on period/offset/sigma, we could cache them in Init. +// But for simplicity and robustness, we calc inside loop or use a local array. +// Let's use a local array for weights to avoid re-calculating exp() inside the inner loop. + double weights[]; + ArrayResize(weights, m_alma_period); + for(int j=0; j 0) @@ -84,102 +110,107 @@ void CALMACalculator::Calculate(int rates_total, ENUM_APPLIED_PRICE price_type, } //+------------------------------------------------------------------+ -//| CALMACalculator: Prepares the standard source price series. | +//| Prepare Price (Standard - Optimized) | //+------------------------------------------------------------------+ -bool CALMACalculator::PreparePriceSeries(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[]) +bool CALMACalculator::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); - - switch(price_type) +// Optimized copy loop + for(int i = start_index; i < rates_total; i++) { - case PRICE_OPEN: - ArrayCopy(m_price, open, 0, 0, rates_total); - break; - case PRICE_HIGH: - ArrayCopy(m_price, high, 0, 0, rates_total); - break; - case PRICE_LOW: - ArrayCopy(m_price, low, 0, 0, rates_total); - break; - case PRICE_MEDIAN: - for(int i = 0; i < rates_total; i++) - m_price[i] = (high[i] + low[i]) / 2.0; - break; - case PRICE_TYPICAL: - for(int i = 0; i < rates_total; i++) - m_price[i] = (high[i] + low[i] + close[i]) / 3.0; - break; - case PRICE_WEIGHTED: - for(int i = 0; i < rates_total; i++) - m_price[i] = (high[i] + low[i] + 2 * close[i]) / 4.0; - break; - default: // PRICE_CLOSE - ArrayCopy(m_price, close, 0, 0, rates_total); - break; + switch(price_type) + { + case PRICE_CLOSE: + m_price[i] = close[i]; + break; + case PRICE_OPEN: + m_price[i] = open[i]; + break; + case PRICE_HIGH: + m_price[i] = high[i]; + break; + case PRICE_LOW: + m_price[i] = low[i]; + break; + case PRICE_MEDIAN: + m_price[i] = (high[i]+low[i])/2.0; + break; + case PRICE_TYPICAL: + m_price[i] = (high[i]+low[i]+close[i])/3.0; + break; + case PRICE_WEIGHTED: + m_price[i] = (high[i]+low[i]+2*close[i])/4.0; + break; + default: + m_price[i] = close[i]; + break; + } } return true; } //+==================================================================+ -//| | //| CLASS 2: CALMACalculator_HA (Heikin Ashi) | -//| | //+==================================================================+ class CALMACalculator_HA : public CALMACalculator { private: - CHeikinAshi_Calculator m_ha_calculator; // Instance of the HA calculator tool + CHeikinAshi_Calculator m_ha_calculator; + // Internal HA buffers + double m_ha_open[], m_ha_high[], m_ha_low[], m_ha_close[]; protected: - //--- Overridden method to prepare Heikin Ashi price series - virtual bool PreparePriceSeries(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[]) 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; }; //+------------------------------------------------------------------+ -//| CALMACalculator_HA: Prepares the Heikin Ashi source price series.| +//| Prepare Price (Heikin Ashi - Optimized) | //+------------------------------------------------------------------+ -bool CALMACalculator_HA::PreparePriceSeries(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[]) +bool CALMACalculator_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[]) { -//--- Intermediate buffers for HA candles - double ha_open[], ha_high[], ha_low[], ha_close[]; - ArrayResize(ha_open, rates_total); - ArrayResize(ha_high, rates_total); - ArrayResize(ha_low, rates_total); - ArrayResize(ha_close, rates_total); - -//--- Calculate the HA candles first - m_ha_calculator.Calculate(rates_total, open, high, low, close, ha_open, ha_high, ha_low, ha_close); - -//--- Now, populate the m_price array from the calculated HA candles - ArrayResize(m_price, rates_total); - switch(price_type) +// Resize internal HA buffers + if(ArraySize(m_ha_open) != rates_total) { - case PRICE_OPEN: - ArrayCopy(m_price, ha_open, 0, 0, rates_total); - break; - case PRICE_HIGH: - ArrayCopy(m_price, ha_high, 0, 0, rates_total); - break; - case PRICE_LOW: - ArrayCopy(m_price, ha_low, 0, 0, rates_total); - break; - case PRICE_MEDIAN: - for(int i = 0; i < rates_total; i++) - m_price[i] = (ha_high[i] + ha_low[i]) / 2.0; - break; - case PRICE_TYPICAL: - for(int i = 0; i < rates_total; i++) - m_price[i] = (ha_high[i] + ha_low[i] + ha_close[i]) / 3.0; - break; - case PRICE_WEIGHTED: - for(int i = 0; i < rates_total; i++) - m_price[i] = (ha_high[i] + ha_low[i] + 2 * ha_close[i]) / 4.0; - break; - default: // PRICE_CLOSE - ArrayCopy(m_price, ha_close, 0, 0, rates_total); - break; + ArrayResize(m_ha_open, rates_total); + ArrayResize(m_ha_high, rates_total); + ArrayResize(m_ha_low, rates_total); + ArrayResize(m_ha_close, rates_total); + } + +//--- 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) + { + case PRICE_CLOSE: + m_price[i] = m_ha_close[i]; + break; + case PRICE_OPEN: + m_price[i] = m_ha_open[i]; + break; + case PRICE_HIGH: + m_price[i] = m_ha_high[i]; + 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; } //+------------------------------------------------------------------+ -//+------------------------------------------------------------------+