gavindiaz/mql5
1
0
Fork 0
mirror of https://github.com/softwaredevelop/mql5.git synced 2026-07-27 20:47:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor(indicators): Optimized for incremental calculation

Browse Source
This commit is contained in:
Toh4iem9
2025-12-31 18:25:35 +01:00
parent 170ff7ea15
commit 7a2e518c32
1 changed files with 57 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Include/MyIncludes/CHO_Calculator.mqh
+57 -109
View File
@@ -1,63 +1,66 @@
//+------------------------------------------------------------------+
//| CHO_Calculator.mqh |
//| Calculation engine for Standard and Heikin Ashi CHO. |
//| VERSION 3.00: Optimized for incremental calculation. |
//| Copyright 2025, xxxxxxxx |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, xxxxxxxx"
//--- Re-use the AD calculator we built previously ---
#include <MyIncludes\AD_Calculator.mqh>
#include <MyIncludes\MovingAverage_Engine.mqh>
//+==================================================================+
//| |
//| CLASS 1: CCHOCalculator (Base Class) |
//| |
//+==================================================================+
class CCHOCalculator
{
protected:
int m_fast_period;
int m_slow_period;
ENUM_MA_METHOD m_ma_method;
ENUM_APPLIED_VOLUME m_volume_type;
//--- It contains a pointer to a base AD calculator
//--- Composition: AD Calculator + 2 MA Engines
CADCalculator *m_ad_calculator;
CMovingAverageCalculator m_fast_ma_engine;
CMovingAverageCalculator m_slow_ma_engine;
//--- Persistent Buffers for Incremental Calculation
double m_adl_buffer[];
double m_fast_ma_buffer[];
double m_slow_ma_buffer[];
public:
CCHOCalculator(void);
virtual ~CCHOCalculator(void);
//--- Public methods
bool Init(int fast_p, int slow_p, ENUM_MA_METHOD ma_m, ENUM_APPLIED_VOLUME vol_t);
//--- Init now takes ENUM_MA_TYPE
bool Init(int fast_p, int slow_p, ENUM_MA_TYPE ma_m, ENUM_APPLIED_VOLUME vol_t);
int GetSlowPeriod(void) const { return m_slow_period; }
//--- CORRECTED: Added 'open' array to the signature
void Calculate(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], double &cho_buffer[]);
//--- Updated: Accepts prev_calculated
void Calculate(int rates_total, int prev_calculated, const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], ENUM_APPLIED_VOLUME volume_type, double &cho_buffer[]);
};
//+------------------------------------------------------------------+
//| CCHOCalculator: Constructor |
//| Constructor |
//+------------------------------------------------------------------+
CCHOCalculator::CCHOCalculator(void)
{
//--- The base class creates a standard AD calculator instance
m_ad_calculator = new CADCalculator();
}
//+------------------------------------------------------------------+
//| CCHOCalculator: Destructor |
//| Destructor |
//+------------------------------------------------------------------+
CCHOCalculator::~CCHOCalculator(void)
{
//--- Clean up the contained object
if(CheckPointer(m_ad_calculator) != POINTER_INVALID)
delete m_ad_calculator;
}
//+------------------------------------------------------------------+
//| CCHOCalculator: Initialization |
//| Init |
//+------------------------------------------------------------------+
bool CCHOCalculator::Init(int fast_p, int slow_p, ENUM_MA_METHOD ma_m, ENUM_APPLIED_VOLUME vol_t)
bool CCHOCalculator::Init(int fast_p, int slow_p, ENUM_MA_TYPE ma_m, ENUM_APPLIED_VOLUME vol_t)
{
m_fast_period = (fast_p < 1) ? 1 : fast_p;
m_slow_period = (slow_p < 1) ? 1 : slow_p;
@@ -69,109 +72,60 @@ bool CCHOCalculator::Init(int fast_p, int slow_p, ENUM_MA_METHOD ma_m, ENUM_APPL
m_slow_period = temp;
}
m_ma_method = ma_m;
m_volume_type = vol_t;
// Initialize MA Engines
if(!m_fast_ma_engine.Init(m_fast_period, ma_m))
return false;
if(!m_slow_ma_engine.Init(m_slow_period, ma_m))
return false;
return (CheckPointer(m_ad_calculator) != POINTER_INVALID);
}
//+------------------------------------------------------------------+
//| CCHOCalculator: Main Calculation Method |
//| Main Calculation (Optimized) |
//+------------------------------------------------------------------+
void CCHOCalculator::Calculate(int rates_total, const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], double &cho_buffer[])
void CCHOCalculator::Calculate(int rates_total, int prev_calculated, const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], ENUM_APPLIED_VOLUME volume_type, double &cho_buffer[])
{
if(rates_total < m_slow_period || CheckPointer(m_ad_calculator) == POINTER_INVALID)
return;
//--- Internal buffers
double adl[], fast_ma[], slow_ma[];
ArrayResize(adl, rates_total);
ArrayResize(fast_ma, rates_total);
ArrayResize(slow_ma, rates_total);
//--- STEP 1: Calculate ADL using the contained calculator
//--- CORRECTED: Pass the 'open' array to the AD calculator
m_ad_calculator.Calculate(rates_total, open, high, low, close, tick_volume, volume, m_volume_type, adl);
//--- STEP 2: Calculate Fast MA on ADL
for(int i = m_fast_period - 1; i < rates_total; i++)
// Resize internal buffers
if(ArraySize(m_adl_buffer) != rates_total)
{
switch(m_ma_method)
{
case MODE_EMA:
case MODE_SMMA:
if(i == m_fast_period - 1)
{
double sum=0;
for(int j=0; j<m_fast_period; j++)
sum+=adl[i-j];
fast_ma[i] = sum/m_fast_period;
}
else
{
if(m_ma_method == MODE_EMA)
{
double pr=2.0/(m_fast_period+1.0);
fast_ma[i] = adl[i]*pr + fast_ma[i-1]*(1.0-pr);
}
else
fast_ma[i] = (fast_ma[i-1]*(m_fast_period-1)+adl[i])/m_fast_period;
}
break;
case MODE_LWMA:
{double lwma_sum=0, weight_sum=0; for(int j=0; j<m_fast_period; j++) {int weight=m_fast_period-j; lwma_sum+=adl[i-j]*weight; weight_sum+=weight;} if(weight_sum>0) fast_ma[i]=lwma_sum/weight_sum;}
break;
default:
{double sum=0; for(int j=0; j<m_fast_period; j++) sum+=adl[i-j]; fast_ma[i] = sum/m_fast_period;}
break;
}
ArrayResize(m_adl_buffer, rates_total);
ArrayResize(m_fast_ma_buffer, rates_total);
ArrayResize(m_slow_ma_buffer, rates_total);
}
//--- STEP 3: Calculate Slow MA on ADL
for(int i = m_slow_period - 1; i < rates_total; i++)
{
switch(m_ma_method)
{
case MODE_EMA:
case MODE_SMMA:
if(i == m_slow_period - 1)
{
double sum=0;
for(int j=0; j<m_slow_period; j++)
sum+=adl[i-j];
slow_ma[i] = sum/m_slow_period;
}
else
{
if(m_ma_method == MODE_EMA)
{
double pr=2.0/(m_slow_period+1.0);
slow_ma[i] = adl[i]*pr + slow_ma[i-1]*(1.0-pr);
}
else
slow_ma[i] = (slow_ma[i-1]*(m_slow_period-1)+adl[i])/m_slow_period;
}
break;
case MODE_LWMA:
{double lwma_sum=0, weight_sum=0; for(int j=0; j<m_slow_period; j++) {int weight=m_slow_period-j; lwma_sum+=adl[i-j]*weight; weight_sum+=weight;} if(weight_sum>0) slow_ma[i]=lwma_sum/weight_sum;}
break;
default:
{double sum=0; for(int j=0; j<m_slow_period; j++) sum+=adl[i-j]; slow_ma[i] = sum/m_slow_period;}
break;
}
}
//--- 1. Calculate ADL (Incremental)
// The AD calculator handles its own incremental logic
m_ad_calculator.Calculate(rates_total, prev_calculated, open, high, low, close, tick_volume, volume, volume_type, m_adl_buffer);
//--- STEP 4: Calculate final Chaikin Oscillator value
for(int i = m_slow_period - 1; i < rates_total; i++)
//--- 2. Calculate Fast MA on ADL (Using Engine)
// ADL is valid from index 0
m_fast_ma_engine.CalculateOnArray(rates_total, prev_calculated, m_adl_buffer, m_fast_ma_buffer, 0);
//--- 3. Calculate Slow MA on ADL (Using Engine)
m_slow_ma_engine.CalculateOnArray(rates_total, prev_calculated, m_adl_buffer, m_slow_ma_buffer, 0);
//--- 4. Calculate CHO (Fast - Slow)
int start_index = (prev_calculated > 0) ? prev_calculated - 1 : 0;
int loop_start = MathMax(m_slow_period - 1, start_index);
if(prev_calculated == 0)
ArrayInitialize(cho_buffer, EMPTY_VALUE);
for(int i = loop_start; i < rates_total; i++)
{
cho_buffer[i] = fast_ma[i] - slow_ma[i];
if(m_fast_ma_buffer[i] != EMPTY_VALUE && m_slow_ma_buffer[i] != EMPTY_VALUE)
cho_buffer[i] = m_fast_ma_buffer[i] - m_slow_ma_buffer[i];
else
cho_buffer[i] = EMPTY_VALUE;
}
}
//+==================================================================+
//| |
//| CLASS 2: CCHOCalculator_HA (Heikin Ashi) |
//| |
//| CLASS 2: CCHOCalculator_HA (Heikin Ashi) |
//+==================================================================+
class CCHOCalculator_HA : public CCHOCalculator
{
@@ -180,26 +134,20 @@ public:
};
//+------------------------------------------------------------------+
//| CCHOCalculator_HA: Constructor |
//| |
//+------------------------------------------------------------------+
CCHOCalculator_HA::CCHOCalculator_HA(void)
{
//--- Clean up the base class's standard calculator first
if(CheckPointer(m_ad_calculator) != POINTER_INVALID)
delete m_ad_calculator;
//--- The derived class creates a Heikin Ashi AD calculator instance instead
// Use HA version of AD calculator
m_ad_calculator = new CADCalculator_HA();
}
//+==================================================================+
//| |
//| CLASS 3: CCHOCalculator_Std (Standard) |
//| |
//| CLASS 3: CCHOCalculator_Std (Standard) |
//+==================================================================+
// This is just for consistency in naming, it inherits everything from the base.
class CCHOCalculator_Std : public CCHOCalculator
{
};
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+