mirror of
https://github.com/softwaredevelop/mql5.git
synced 2026-07-27 20:47:44 +00:00
Toh4iem9
254 lines
10 KiB
Plaintext
254 lines
10 KiB
Plaintext
//+------------------------------------------------------------------+
|
|
//| Stochastic_Adaptive_on_DMI_Calculator.mqh |
|
|
//| Copyright 2026, xxxxxxxx|
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2026, xxxxxxxx"
|
|
#property version "2.30" // Upgraded with dynamic volume-weighted (VWMA) smoothing support
|
|
|
|
#ifndef STOCHASTIC_ADAPTIVE_ON_DMI_CALCULATOR_MQH
|
|
#define STOCHASTIC_ADAPTIVE_ON_DMI_CALCULATOR_MQH
|
|
|
|
#include <MyIncludes\DMI_Engine.mqh>
|
|
#include <MyIncludes\MovingAverage_Engine.mqh>
|
|
|
|
//--- Enums Definitions
|
|
#ifndef ENUM_CANDLE_SOURCE_DEFINED
|
|
#define ENUM_CANDLE_SOURCE_DEFINED
|
|
enum ENUM_CANDLE_SOURCE { CANDLE_STANDARD, CANDLE_HEIKIN_ASHI };
|
|
#endif
|
|
|
|
enum ENUM_DMI_OSC_TYPE { OSC_PDI_MINUS_NDI, OSC_NDI_MINUS_PDI };
|
|
|
|
//+==================================================================+
|
|
//| CLASS: CStochAdaptiveOnDMICalculator |
|
|
//| PURPOSE: Calculates an adaptive stochastic oscillator based on |
|
|
//| DMI output, ensuring O(1) incremental performance. |
|
|
//+==================================================================+
|
|
class CStochAdaptiveOnDMICalculator
|
|
{
|
|
protected:
|
|
// Parameters
|
|
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;
|
|
|
|
// Mathematical Engines (Stateful for O(1) recursion)
|
|
CDMIEngine *m_dmi_engine;
|
|
CMovingAverageCalculator m_slowing_engine;
|
|
CMovingAverageCalculator m_signal_engine;
|
|
|
|
// Persistent Buffers for internal states
|
|
double m_pDI[], m_nDI[];
|
|
double m_volume[]; // Persistent volume buffer to support VWMA
|
|
double m_dmi_osc[]; // DMI Oscillator Data
|
|
double m_er_buffer[]; // Efficiency Ratio of DMI
|
|
double m_nsp_buffer[]; // Dynamic Stochastic Period (Lookback)
|
|
double m_raw_k[]; // Raw Adaptive %K
|
|
|
|
// Factory Method for Engine instantiation
|
|
virtual void CreateDMIEngine();
|
|
|
|
public:
|
|
CStochAdaptiveOnDMICalculator();
|
|
virtual ~CStochAdaptiveOnDMICalculator();
|
|
|
|
bool Init(double gamma, 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);
|
|
|
|
//--- Standard Calculate (Without volume data) - Redirects to overloaded with dummy volume fallback
|
|
void Calculate(int rates_total, int prev_calculated,
|
|
const double &open[], const double &high[],
|
|
const double &low[], const double &close[],
|
|
double &out_k[], double &out_d[]);
|
|
|
|
//--- Overloaded Calculate with Volume (Specifically for VWMA support)
|
|
void Calculate(int rates_total, int prev_calculated,
|
|
const double &open[], const double &high[],
|
|
const double &low[], const double &close[],
|
|
const long &volume[],
|
|
double &out_k[], double &out_d[]);
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor & Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CStochAdaptiveOnDMICalculator::CStochAdaptiveOnDMICalculator() : m_dmi_engine(NULL) {}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
CStochAdaptiveOnDMICalculator::~CStochAdaptiveOnDMICalculator()
|
|
{
|
|
if(CheckPointer(m_dmi_engine) != POINTER_INVALID)
|
|
delete m_dmi_engine;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CStochAdaptiveOnDMICalculator::CreateDMIEngine()
|
|
{
|
|
m_dmi_engine = new CDMIEngine();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Initialization phase |
|
|
//+------------------------------------------------------------------+
|
|
bool CStochAdaptiveOnDMICalculator::Init(double gamma, 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)
|
|
{
|
|
m_dmi_p = dmi_p;
|
|
m_osc_type = osc_type;
|
|
m_er_p = er_p;
|
|
m_min_stoch_p = min_p;
|
|
m_max_stoch_p = max_p;
|
|
|
|
CreateDMIEngine();
|
|
|
|
if(CheckPointer(m_dmi_engine) == POINTER_INVALID || !m_dmi_engine.Init(m_dmi_p))
|
|
return false;
|
|
if(!m_slowing_engine.Init(slow_p, slow_ma))
|
|
return false;
|
|
if(!m_signal_engine.Init(d_p, d_ma))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Standard Calculate (OHLC) - Dummy Volume Fallback Pattern |
|
|
//+------------------------------------------------------------------+
|
|
void CStochAdaptiveOnDMICalculator::Calculate(int rates_total, int prev_calculated,
|
|
const double &open[], const double &high[],
|
|
const double &low[], const double &close[],
|
|
double &out_k[], double &out_d[])
|
|
{
|
|
long dummy_vol[];
|
|
ArrayResize(dummy_vol, rates_total);
|
|
ArrayInitialize(dummy_vol, 1);
|
|
Calculate(rates_total, prev_calculated, open, high, low, close, dummy_vol, out_k, out_d);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Overloaded Calculate (OHLC) with Volume |
|
|
//+------------------------------------------------------------------+
|
|
void CStochAdaptiveOnDMICalculator::Calculate(int rates_total, int prev_calculated,
|
|
const double &open[], const double &high[],
|
|
const double &low[], const double &close[],
|
|
const long &volume[],
|
|
double &out_k[], double &out_d[])
|
|
{
|
|
if(rates_total < m_dmi_p + m_er_p + m_max_stoch_p)
|
|
return;
|
|
|
|
if(CheckPointer(m_dmi_engine) == POINTER_INVALID)
|
|
return;
|
|
|
|
// O(1) Pointer
|
|
int start_index = (prev_calculated > 0) ? prev_calculated - 1 : 0;
|
|
|
|
// 1. Dynamic Buffer Resizing and chronological sorting safety kényszerítés
|
|
if(ArraySize(m_pDI) != rates_total)
|
|
{
|
|
ArrayResize(m_pDI, rates_total);
|
|
ArrayResize(m_nDI, rates_total);
|
|
ArrayResize(m_volume, rates_total);
|
|
ArrayResize(m_dmi_osc, rates_total);
|
|
ArrayResize(m_er_buffer, rates_total);
|
|
ArrayResize(m_nsp_buffer, rates_total);
|
|
ArrayResize(m_raw_k, rates_total);
|
|
|
|
ArraySetAsSeries(m_pDI, false);
|
|
ArraySetAsSeries(m_nDI, false);
|
|
ArraySetAsSeries(m_volume, false);
|
|
ArraySetAsSeries(m_dmi_osc, false);
|
|
ArraySetAsSeries(m_er_buffer, false);
|
|
ArraySetAsSeries(m_nsp_buffer, false);
|
|
ArraySetAsSeries(m_raw_k, false);
|
|
}
|
|
|
|
// 2. Base DMI Calculation via encapsulated Engine
|
|
m_dmi_engine.Calculate(rates_total, prev_calculated, open, high, low, close, m_pDI, m_nDI);
|
|
|
|
// 3. DMI Oscillator Line
|
|
int loop_start_dmi = MathMax(m_dmi_p, start_index);
|
|
for(int i = loop_start_dmi; i < rates_total; i++)
|
|
{
|
|
m_volume[i] = (double)volume[i]; // Copy and cast volume locally
|
|
|
|
if(m_osc_type == OSC_PDI_MINUS_NDI)
|
|
m_dmi_osc[i] = m_pDI[i] - m_nDI[i];
|
|
else
|
|
m_dmi_osc[i] = m_nDI[i] - m_pDI[i];
|
|
}
|
|
|
|
// 4. Efficiency Ratio (ER) based strictly on DMI volatility
|
|
int loop_start_er = MathMax(m_dmi_p + m_er_p, start_index);
|
|
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 volatility = 0;
|
|
for(int j = 0; j < m_er_p; j++)
|
|
volatility += MathAbs(m_dmi_osc[i - j] - m_dmi_osc[i - j - 1]);
|
|
|
|
m_er_buffer[i] = (volatility > 1.0e-9) ? direction / volatility : 0.0;
|
|
}
|
|
|
|
// 5. Adaptive Period (NSP) Calculation
|
|
// Inverse logic: High ER (Trend) = Short Period; Low ER (Chop) = Long Period
|
|
for(int i = loop_start_er; i < rates_total; i++)
|
|
{
|
|
m_nsp_buffer[i] = MathRound(m_min_stoch_p + (1.0 - m_er_buffer[i]) * (m_max_stoch_p - m_min_stoch_p));
|
|
|
|
// Safety Limit: Stochastic mathematically breaks if period < 2 (Div by Zero)
|
|
if(m_nsp_buffer[i] < 2)
|
|
m_nsp_buffer[i] = 2;
|
|
}
|
|
|
|
// 6. Raw %K on DMI Oscillator using dynamic lookback (NSP)
|
|
int stoch_start = m_dmi_p + m_er_p + m_max_stoch_p - 1;
|
|
int loop_start_k = MathMax(stoch_start, start_index);
|
|
|
|
for(int i = loop_start_k; i < rates_total; i++)
|
|
{
|
|
int current_nsp = (int)m_nsp_buffer[i];
|
|
double highest = m_dmi_osc[i];
|
|
double lowest = m_dmi_osc[i];
|
|
|
|
for(int k = 1; k < current_nsp; k++)
|
|
{
|
|
if(i-k < 0)
|
|
break; // Safety
|
|
if(m_dmi_osc[i-k] > highest)
|
|
highest = m_dmi_osc[i-k];
|
|
if(m_dmi_osc[i-k] < lowest)
|
|
lowest = m_dmi_osc[i-k];
|
|
}
|
|
|
|
double range = highest - lowest;
|
|
if(range > 1.0e-9)
|
|
m_raw_k[i] = 100.0 * (m_dmi_osc[i] - lowest) / range;
|
|
else
|
|
m_raw_k[i] = (i > 0) ? m_raw_k[i-1] : 50.0; // Flatline prevention fallback
|
|
}
|
|
|
|
// 7. Final Smoothing (Engine handles volume-weighted (VWMA) O(1) natively if volume buffer is passed)
|
|
m_slowing_engine.CalculateOnArray(rates_total, prev_calculated, m_raw_k, m_volume, out_k, stoch_start);
|
|
|
|
int d_offset = stoch_start + m_slowing_engine.GetPeriod() - 1;
|
|
m_signal_engine.CalculateOnArray(rates_total, prev_calculated, out_k, m_volume, out_d, d_offset);
|
|
}
|
|
|
|
//+==================================================================+
|
|
//| CLASS: CStochAdaptiveOnDMICalculator_HA (Heikin Ashi Support) |
|
|
//+==================================================================+
|
|
class CStochAdaptiveOnDMICalculator_HA : public CStochAdaptiveOnDMICalculator
|
|
{
|
|
protected:
|
|
virtual void CreateDMIEngine() override
|
|
{
|
|
m_dmi_engine = new CDMIEngine_HA();
|
|
}
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
#endif // STOCHASTIC_ADAPTIVE_ON_DMI_CALCULATOR_MQH |