gavindiaz/mql5
1
0
Fork 0
mirror of https://github.com/softwaredevelop/mql5.git synced 2026-08-18 06:48:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor(indicators): ER Calculated on DMI (Pure Logic)

Browse Source
This commit is contained in:
Toh4iem9
2026-02-17 09:57:00 +01:00
parent a42008fe49
commit c19a57eb16
1 changed files with 54 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Include/MyIncludes/Stochastic_Adaptive_on_DMI_Calculator.mqh
+54 -82
View File
@@ -1,8 +1,7 @@
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| Stochastic_Adaptive_on_DMI_Calculator.mqh | //| Stochastic_Adaptive_on_DMI_Calculator.mqh |
//| Engine: Adaptive Stochastic applied to DMI Oscillator. | //| Engine: Adaptive Stochastic applied to DMI Oscillator. |
//| Concept: Combines DMI trend strength with Adaptive Logic. | //| VERSION 2.00: ER Calculated on DMI (Pure Logic). |
//| VERSION 1.10: Added Safe Enum Definitions (Guards) |
//| Copyright 2026, xxxxxxxx | //| Copyright 2026, xxxxxxxx |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
#property copyright "Copyright 2026, xxxxxxxx" #property copyright "Copyright 2026, xxxxxxxx"
@@ -10,25 +9,13 @@
#include <MyIncludes\DMI_Engine.mqh> #include <MyIncludes\DMI_Engine.mqh>
#include <MyIncludes\MovingAverage_Engine.mqh> #include <MyIncludes\MovingAverage_Engine.mqh>
//--- Enum for Candle Source (Safe Definition) //--- Enums Definitions
#ifndef ENUM_CANDLE_SOURCE_DEFINED #ifndef ENUM_CANDLE_SOURCE_DEFINED
#define ENUM_CANDLE_SOURCE_DEFINED #define ENUM_CANDLE_SOURCE_DEFINED
enum ENUM_CANDLE_SOURCE enum ENUM_CANDLE_SOURCE { CANDLE_STANDARD, CANDLE_HEIKIN_ASHI };
{
CANDLE_STANDARD,
CANDLE_HEIKIN_ASHI
};
#endif #endif
//--- Enum for DMI Osc Type (Safe Definition) enum ENUM_DMI_OSC_TYPE { OSC_PDI_MINUS_NDI, OSC_NDI_MINUS_PDI };
#ifndef ENUM_DMI_ADAPTIVE_OSC_TYPE_DEFINED
#define ENUM_DMI_ADAPTIVE_OSC_TYPE_DEFINED
enum ENUM_DMI_ADAPTIVE_OSC_TYPE
{
OSC_PDI_MINUS_NDI,
OSC_NDI_MINUS_PDI
};
#endif
//+==================================================================+ //+==================================================================+
//| CLASS: CStochAdaptiveOnDMICalculator | //| CLASS: CStochAdaptiveOnDMICalculator |
@@ -36,55 +23,47 @@ enum ENUM_DMI_ADAPTIVE_OSC_TYPE
class CStochAdaptiveOnDMICalculator class CStochAdaptiveOnDMICalculator
{ {
protected: protected:
//--- Components // Parameters
CDMIEngine *m_dmi_engine; int m_dmi_p;
ENUM_DMI_OSC_TYPE m_osc_type;
int m_er_p;
int m_min_stoch_p;
int m_max_stoch_p;
// Engines
CDMIEngine *m_dmi_engine;
CMovingAverageCalculator m_slowing_engine; CMovingAverageCalculator m_slowing_engine;
CMovingAverageCalculator m_signal_engine; CMovingAverageCalculator m_signal_engine;
bool m_is_ha; // Buffers
double m_pDI[], m_nDI[];
double m_dmi_osc[]; // DMI Oscillator
double m_er_buffer[]; // Efficiency Ratio of DMI
double m_nsp_buffer[]; // Dynamic Period
double m_raw_k[]; // Raw Adaptive %K
//--- Parameters // Factory Method
int m_dmi_p; virtual void CreateDMIEngine();
int m_er_p;
int m_min_stoch_p;
int m_max_stoch_p;
ENUM_DMI_ADAPTIVE_OSC_TYPE m_osc_type;
//--- Internal Buffers
double m_pDI[];
double m_nDI[];
double m_dmi_osc[]; // The "Source Price"
double m_er_buffer[]; // Efficiency Ratio
double m_nsp_buffer[]; // Dynamic Period
double m_raw_k[]; // Raw Adaptive %K
//--- Factory Method
virtual void CreateDMIEngine();
public: public:
CStochAdaptiveOnDMICalculator(); CStochAdaptiveOnDMICalculator();
virtual ~CStochAdaptiveOnDMICalculator(); virtual ~CStochAdaptiveOnDMICalculator();
bool Init(int dmi_period, int er_period, int min_stoch, int max_stoch, bool Init(int dmi_p, ENUM_DMI_OSC_TYPE osc_type, int er_p, int min_p, int max_p, int slow_p, ENUM_MA_TYPE slow_ma, int d_p, ENUM_MA_TYPE d_ma);
int slow_k, ENUM_MA_TYPE slow_ma,
int d_p, ENUM_MA_TYPE d_ma,
ENUM_DMI_ADAPTIVE_OSC_TYPE osc_type);
void Calculate(int rates_total, int prev_calculated, void Calculate(int rates_total, int prev_calculated,
const double &open[], const double &high[], const double &open[], const double &high[],
const double &low[], const double &close[], const double &low[], const double &close[],
double &out_k[], double &out_d[]); double &out_k[], double &out_d[]);
}; };
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| Constructor | //| Constructor |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
CStochAdaptiveOnDMICalculator::CStochAdaptiveOnDMICalculator() : m_dmi_engine(NULL), m_is_ha(false) CStochAdaptiveOnDMICalculator::CStochAdaptiveOnDMICalculator() : m_dmi_engine(NULL) {}
{
}
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| Destructor | //| |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
CStochAdaptiveOnDMICalculator::~CStochAdaptiveOnDMICalculator() CStochAdaptiveOnDMICalculator::~CStochAdaptiveOnDMICalculator()
{ {
@@ -93,7 +72,7 @@ CStochAdaptiveOnDMICalculator::~CStochAdaptiveOnDMICalculator()
} }
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| Factory Method (Standard) | //| |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
void CStochAdaptiveOnDMICalculator::CreateDMIEngine() void CStochAdaptiveOnDMICalculator::CreateDMIEngine()
{ {
@@ -101,25 +80,20 @@ void CStochAdaptiveOnDMICalculator::CreateDMIEngine()
} }
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| Initialization | //| Init |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
bool CStochAdaptiveOnDMICalculator::Init(int dmi_period, int er_period, int min_stoch, int max_stoch, bool CStochAdaptiveOnDMICalculator::Init(int dmi_p, ENUM_DMI_OSC_TYPE osc_type, int er_p, int min_p, int max_p, int slow_p, ENUM_MA_TYPE slow_ma, int d_p, ENUM_MA_TYPE d_ma)
int slow_k, ENUM_MA_TYPE slow_ma,
int d_p, ENUM_MA_TYPE d_ma,
ENUM_DMI_ADAPTIVE_OSC_TYPE osc_type)
{ {
m_dmi_p = dmi_period; m_dmi_p = dmi_p;
m_er_p = (er_period < 1) ? 1 : er_period;
m_min_stoch_p = (min_stoch < 2) ? 2 : min_stoch;
m_max_stoch_p = (max_stoch <= m_min_stoch_p) ? m_min_stoch_p + 1 : max_stoch;
m_osc_type = osc_type; m_osc_type = osc_type;
m_er_p = er_p;
m_min_stoch_p = min_p;
m_max_stoch_p = max_p;
CreateDMIEngine(); CreateDMIEngine();
if(!m_dmi_engine.Init(m_dmi_p)) if(!m_dmi_engine.Init(m_dmi_p))
return false; return false;
if(!m_slowing_engine.Init(slow_p, slow_ma))
// Initialize MA Engines for smoothing
if(!m_slowing_engine.Init(slow_k, slow_ma))
return false; return false;
if(!m_signal_engine.Init(d_p, d_ma)) if(!m_signal_engine.Init(d_p, d_ma))
return false; return false;
@@ -135,13 +109,12 @@ void CStochAdaptiveOnDMICalculator::Calculate(int rates_total, int prev_calculat
const double &low[], const double &close[], const double &low[], const double &close[],
double &out_k[], double &out_d[]) double &out_k[], double &out_d[])
{ {
// Safety check: DMI Period + ER Period + Smoothing
if(rates_total < m_dmi_p + m_er_p + m_max_stoch_p) if(rates_total < m_dmi_p + m_er_p + m_max_stoch_p)
return; return;
int start_index = (prev_calculated > 0) ? prev_calculated - 1 : 0; int start_index = (prev_calculated > 0) ? prev_calculated - 1 : 0;
// 1. Resize Internal Buffers // 1. Resize Buffers
if(ArraySize(m_pDI) != rates_total) if(ArraySize(m_pDI) != rates_total)
{ {
ArrayResize(m_pDI, rates_total); ArrayResize(m_pDI, rates_total);
@@ -156,8 +129,8 @@ void CStochAdaptiveOnDMICalculator::Calculate(int rates_total, int prev_calculat
m_dmi_engine.Calculate(rates_total, prev_calculated, open, high, low, close, m_pDI, m_nDI); m_dmi_engine.Calculate(rates_total, prev_calculated, open, high, low, close, m_pDI, m_nDI);
// 3. Calculate DMI Oscillator // 3. Calculate DMI Oscillator
int loop_start = MathMax(m_dmi_p, start_index); int loop_start_dmi = MathMax(m_dmi_p, start_index);
for(int i = loop_start; i < rates_total; i++) for(int i = loop_start_dmi; i < rates_total; i++)
{ {
if(m_osc_type == OSC_PDI_MINUS_NDI) if(m_osc_type == OSC_PDI_MINUS_NDI)
m_dmi_osc[i] = m_pDI[i] - m_nDI[i]; m_dmi_osc[i] = m_pDI[i] - m_nDI[i];
@@ -165,11 +138,10 @@ void CStochAdaptiveOnDMICalculator::Calculate(int rates_total, int prev_calculat
m_dmi_osc[i] = m_nDI[i] - m_pDI[i]; m_dmi_osc[i] = m_nDI[i] - m_pDI[i];
} }
// 4. Calculate Efficiency Ratio (ER) on DMI Oscillator // 4. Calculate Efficiency Ratio (ER) on DMI OSCILLATOR (Pure Logic)
int er_start = m_dmi_p + m_er_p; int loop_start_er = MathMax(m_dmi_p + m_er_p, start_index);
loop_start = MathMax(er_start, start_index);
for(int i = loop_start; i < rates_total; i++) for(int i = loop_start_er; i < rates_total; i++)
{ {
double direction = MathAbs(m_dmi_osc[i] - m_dmi_osc[i - m_er_p]); double direction = MathAbs(m_dmi_osc[i] - m_dmi_osc[i - m_er_p]);
double volatility = 0; double volatility = 0;
@@ -180,7 +152,7 @@ void CStochAdaptiveOnDMICalculator::Calculate(int rates_total, int prev_calculat
} }
// 5. Calculate Adaptive Period (NSP) // 5. Calculate Adaptive Period (NSP)
for(int i = loop_start; i < rates_total; i++) for(int i = loop_start_er; i < rates_total; i++)
{ {
m_nsp_buffer[i] = (int)MathRound(m_min_stoch_p + (1.0 - m_er_buffer[i]) * (m_max_stoch_p - m_min_stoch_p)); m_nsp_buffer[i] = (int)MathRound(m_min_stoch_p + (1.0 - m_er_buffer[i]) * (m_max_stoch_p - m_min_stoch_p));
if(m_nsp_buffer[i] < 2) if(m_nsp_buffer[i] < 2)
@@ -188,27 +160,26 @@ void CStochAdaptiveOnDMICalculator::Calculate(int rates_total, int prev_calculat
} }
// 6. Calculate Raw %K on DMI Oscillator // 6. Calculate Raw %K on DMI Oscillator
int stoch_start = er_start + m_max_stoch_p; int stoch_start = m_dmi_p + m_er_p + m_max_stoch_p - 1;
loop_start = MathMax(stoch_start, start_index); int loop_start_k = MathMax(stoch_start, start_index);
for(int i = loop_start; i < rates_total; i++) for(int i = loop_start_k; i < rates_total; i++)
{ {
int current_nsp = (int)m_nsp_buffer[i]; int current_nsp = (int)m_nsp_buffer[i];
double highest = m_dmi_osc[i]; double highest = m_dmi_osc[i];
double lowest = m_dmi_osc[i]; double lowest = m_dmi_osc[i];
// Dynamic Lookback
for(int k = 1; k < current_nsp; k++) for(int k = 1; k < current_nsp; k++)
{ {
if(i - k < 0) if(i-k < 0)
break; break;
highest = MathMax(highest, m_dmi_osc[i - k]); if(m_dmi_osc[i-k] > highest)
lowest = MathMin(lowest, m_dmi_osc[i - k]); highest = m_dmi_osc[i-k];
if(m_dmi_osc[i-k] < lowest)
lowest = m_dmi_osc[i-k];
} }
double range = highest - lowest; double range = highest - lowest;
if(range > 1.0e-9) if(range > 1.0e-9)
m_raw_k[i] = 100.0 * (m_dmi_osc[i] - lowest) / range; m_raw_k[i] = 100.0 * (m_dmi_osc[i] - lowest) / range;
else else
@@ -234,3 +205,4 @@ protected:
} }
}; };
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//+------------------------------------------------------------------+