diff --git a/Include/MyIncludes/Supertrend_Calculator.mqh b/Include/MyIncludes/Supertrend_Calculator.mqh index 9a57b21..2e113c4 100644 --- a/Include/MyIncludes/Supertrend_Calculator.mqh +++ b/Include/MyIncludes/Supertrend_Calculator.mqh @@ -1,12 +1,14 @@ //+------------------------------------------------------------------+ //| Supertrend_Calculator.mqh| -//| VERSION 3.20: Adapted to new ATR Calculator. | +//| VERSION 3.30: Optimized for incremental calculation. | //| Copyright 2025, xxxxxxxx | //+------------------------------------------------------------------+ #property copyright "Copyright 2025, xxxxxxxx" #include +//+==================================================================+ +//| CLASS 1: CSupertrendCalculator (Base Class) | //+==================================================================+ class CSupertrendCalculator { @@ -14,42 +16,48 @@ protected: int m_atr_period; double m_factor; CATRCalculator *m_atr_calculator; - double m_src_high[], m_src_low[], m_src_close[]; - virtual bool PrepareSourceData(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[]); + //--- Persistent Buffers for Incremental Calculation + double m_src_high[], m_src_low[], m_src_close[]; + double m_atr_buffer[]; // Internal ATR buffer + + //--- Persistent State for Supertrend Logic + double m_upper[], m_lower[], m_trend[]; + double m_segment_idx[]; // Tracks segment index for coloring + + //--- Updated: Accepts start_index + virtual bool PrepareSourceData(int rates_total, int start_index, const double &open[], const double &high[], const double &low[], const double &close[]); public: CSupertrendCalculator(void); virtual ~CSupertrendCalculator(void); bool Init(int atr_p, double factor, ENUM_CANDLE_SOURCE atr_src); - void Calculate(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[], + + //--- Updated: Accepts prev_calculated + void Calculate(int rates_total, int prev_calculated, const double &open[], const double &high[], const double &low[], const double &close[], double &st_odd[], double &color_odd[], double &st_even[], double &color_even[]); }; //+------------------------------------------------------------------+ -//| | +//| Constructor | //+------------------------------------------------------------------+ -class CSupertrendCalculator_HA : public CSupertrendCalculator +CSupertrendCalculator::CSupertrendCalculator(void) { -private: - CHeikinAshi_Calculator m_ha_calculator; -protected: - virtual bool PrepareSourceData(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[]) override; - }; - -//+==================================================================+ -//| METHOD IMPLEMENTATIONS | -//+==================================================================+ + m_atr_calculator = NULL; + } //+------------------------------------------------------------------+ -//| | +//| Destructor | //+------------------------------------------------------------------+ -CSupertrendCalculator::CSupertrendCalculator(void) { m_atr_calculator = NULL; } -CSupertrendCalculator::~CSupertrendCalculator(void) { if(CheckPointer(m_atr_calculator) != POINTER_INVALID) delete m_atr_calculator; } +CSupertrendCalculator::~CSupertrendCalculator(void) + { + if(CheckPointer(m_atr_calculator) != POINTER_INVALID) + delete m_atr_calculator; + } //+------------------------------------------------------------------+ -//| | +//| Init | //+------------------------------------------------------------------+ bool CSupertrendCalculator::Init(int atr_p, double factor, ENUM_CANDLE_SOURCE atr_src) { @@ -71,72 +79,107 @@ bool CSupertrendCalculator::Init(int atr_p, double factor, ENUM_CANDLE_SOURCE at } //+------------------------------------------------------------------+ -//| | +//| Main Calculation (Optimized) | //+------------------------------------------------------------------+ -void CSupertrendCalculator::Calculate(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[], +void CSupertrendCalculator::Calculate(int rates_total, int prev_calculated, const double &open[], const double &high[], const double &low[], const double &close[], double &st_odd[], double &color_odd[], double &st_even[], double &color_even[]) { if(rates_total <= m_atr_period || CheckPointer(m_atr_calculator) == POINTER_INVALID) return; - if(!PrepareSourceData(rates_total, 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 Buffers + if(ArraySize(m_src_high) != rates_total) + { + ArrayResize(m_src_high, rates_total); + ArrayResize(m_src_low, rates_total); + ArrayResize(m_src_close, rates_total); + ArrayResize(m_atr_buffer, rates_total); + ArrayResize(m_upper, rates_total); + ArrayResize(m_lower, rates_total); + ArrayResize(m_trend, rates_total); + ArrayResize(m_segment_idx, rates_total); + } + +//--- 3. Prepare Source Data (Optimized) + if(!PrepareSourceData(rates_total, start_index, open, high, low, close)) return; - double atr[], upper[], lower[], trend[]; - ArrayResize(atr, rates_total); - ArrayResize(upper, rates_total); - ArrayResize(lower, rates_total); - ArrayResize(trend, rates_total); +//--- 4. Calculate ATR (Incremental) + m_atr_calculator.Calculate(rates_total, prev_calculated, open, high, low, close, m_atr_buffer); - m_atr_calculator.Calculate(rates_total, open, high, low, close, atr); +//--- 5. Calculate Supertrend (Incremental Loop) + int loop_start = (start_index < 1) ? 1 : start_index; - int trend_segment_index = 1; - for(int i = 1; i < rates_total; i++) +// Initialization for first bar + if(loop_start == 1) + { + m_upper[0] = 0; + m_lower[0] = 0; + m_trend[0] = 0; + m_segment_idx[0] = 1; + } + + for(int i = loop_start; i < rates_total; i++) { double hl2 = (m_src_high[i] + m_src_low[i]) / 2.0; - double atr_val = m_factor * atr[i]; + double atr_val = m_factor * m_atr_buffer[i]; double upper_basic = hl2 + atr_val; double lower_basic = hl2 - atr_val; - if(upper_basic < upper[i-1] || m_src_close[i-1] > upper[i-1]) - upper[i] = upper_basic; + // Recursive logic using persistent buffers [i-1] + if(upper_basic < m_upper[i-1] || m_src_close[i-1] > m_upper[i-1]) + m_upper[i] = upper_basic; else - upper[i] = upper[i-1]; + m_upper[i] = m_upper[i-1]; - if(lower_basic > lower[i-1] || m_src_close[i-1] < lower[i-1]) - lower[i] = lower_basic; + if(lower_basic > m_lower[i-1] || m_src_close[i-1] < m_lower[i-1]) + m_lower[i] = lower_basic; else - lower[i] = lower[i-1]; + m_lower[i] = m_lower[i-1]; - if(i == m_atr_period) - trend[i] = (m_src_close[i] > hl2) ? 1 : -1; + // Trend Logic + if(i <= m_atr_period) + m_trend[i] = (m_src_close[i] > hl2) ? 1 : -1; else - if(i > m_atr_period) - { - if(trend[i-1] == 1 && m_src_close[i] < lower[i]) - trend[i] = -1; - else - if(trend[i-1] == -1 && m_src_close[i] > upper[i]) - trend[i] = 1; - else - trend[i] = trend[i-1]; - } - - if(trend[i] != trend[i-1] && i > 1) - trend_segment_index++; - - if(trend[i] == 1) // Uptrend { - if(trend_segment_index % 2 != 0) // Odd + if(m_trend[i-1] == 1 && m_src_close[i] < m_lower[i]) + m_trend[i] = -1; + else + if(m_trend[i-1] == -1 && m_src_close[i] > m_upper[i]) + m_trend[i] = 1; + else + m_trend[i] = m_trend[i-1]; + } + + // Segment Index Logic (Persistent) + if(m_trend[i] != m_trend[i-1]) + m_segment_idx[i] = m_segment_idx[i-1] + 1; + else + m_segment_idx[i] = m_segment_idx[i-1]; + + // Output to Buffers + int seg_idx = (int)m_segment_idx[i]; + + if(m_trend[i] == 1) // Uptrend + { + if(seg_idx % 2 != 0) // Odd { - st_odd[i] = lower[i]; + st_odd[i] = m_lower[i]; color_odd[i] = 0; st_even[i] = EMPTY_VALUE; color_even[i] = 0; } else // Even { - st_even[i] = lower[i]; + st_even[i] = m_lower[i]; color_even[i] = 0; st_odd[i] = EMPTY_VALUE; color_odd[i] = 0; @@ -144,16 +187,16 @@ void CSupertrendCalculator::Calculate(int rates_total, const double &open[], con } else // Downtrend { - if(trend_segment_index % 2 != 0) // Odd + if(seg_idx % 2 != 0) // Odd { - st_odd[i] = upper[i]; + st_odd[i] = m_upper[i]; color_odd[i] = 1; st_even[i] = EMPTY_VALUE; color_even[i] = 1; } else // Even { - st_even[i] = upper[i]; + st_even[i] = m_upper[i]; color_even[i] = 1; st_odd[i] = EMPTY_VALUE; color_odd[i] = 1; @@ -163,31 +206,59 @@ void CSupertrendCalculator::Calculate(int rates_total, const double &open[], con } //+------------------------------------------------------------------+ -//| | +//| Prepare Source Data (Standard - Optimized) | //+------------------------------------------------------------------+ -bool CSupertrendCalculator::PrepareSourceData(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[]) +bool CSupertrendCalculator::PrepareSourceData(int rates_total, int start_index, const double &open[], const double &high[], const double &low[], const double &close[]) { - ArrayResize(m_src_high, rates_total); - ArrayCopy(m_src_high, high, 0, 0, rates_total); - ArrayResize(m_src_low, rates_total); - ArrayCopy(m_src_low, low, 0, 0, rates_total); - ArrayResize(m_src_close, rates_total); - ArrayCopy(m_src_close, close, 0, 0, rates_total); +// Optimized copy loop + for(int i = start_index; i < rates_total; i++) + { + m_src_high[i] = high[i]; + m_src_low[i] = low[i]; + m_src_close[i] = close[i]; + } return true; } -//+------------------------------------------------------------------+ -//| | -//+------------------------------------------------------------------+ -bool CSupertrendCalculator_HA::PrepareSourceData(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[]) +//+==================================================================+ +//| CLASS 2: CSupertrendCalculator_HA (Heikin Ashi) | +//+==================================================================+ +class CSupertrendCalculator_HA : public CSupertrendCalculator { - double ha_open[]; - ArrayResize(ha_open, rates_total); - ArrayResize(m_src_high, rates_total); - ArrayResize(m_src_low, rates_total); - ArrayResize(m_src_close, rates_total); - m_ha_calculator.Calculate(rates_total, open, high, low, close, ha_open, m_src_high, m_src_low, m_src_close); +private: + CHeikinAshi_Calculator m_ha_calculator; + // Internal HA buffers + double m_ha_open[], m_ha_high_temp[], m_ha_low_temp[], m_ha_close_temp[]; + +protected: + virtual bool PrepareSourceData(int rates_total, int start_index, const double &open[], const double &high[], const double &low[], const double &close[]) override; + }; + +//+------------------------------------------------------------------+ +//| Prepare Source Data (Heikin Ashi - Optimized) | +//+------------------------------------------------------------------+ +bool CSupertrendCalculator_HA::PrepareSourceData(int rates_total, int start_index, const double &open[], const double &high[], const double &low[], const double &close[]) + { +// Resize internal HA buffers + if(ArraySize(m_ha_open) != rates_total) + { + ArrayResize(m_ha_open, rates_total); + ArrayResize(m_ha_high_temp, rates_total); + ArrayResize(m_ha_low_temp, rates_total); + ArrayResize(m_ha_close_temp, 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_temp, m_ha_low_temp, m_ha_close_temp); + +//--- Copy to source buffers (Optimized loop) + for(int i = start_index; i < rates_total; i++) + { + m_src_high[i] = m_ha_high_temp[i]; + m_src_low[i] = m_ha_low_temp[i]; + m_src_close[i] = m_ha_close_temp[i]; + } return true; } //+------------------------------------------------------------------+ -//+------------------------------------------------------------------+