mirror of
https://github.com/softwaredevelop/mql5.git
synced 2026-07-27 20:47:44 +00:00
Toh4iem9
251 lines
11 KiB
Plaintext
251 lines
11 KiB
Plaintext
//+------------------------------------------------------------------+
|
|
//| StochasticSlow_on_Laguerre_Adaptive_RSI_Calculator.mqh |
|
|
//| Copyright 2026, xxxxxxxx|
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2026, xxxxxxxx"
|
|
#property version "1.00" // Adaptive Stochastic on Adaptive Laguerre RSI engine
|
|
#property description "Stateful calculator implementing Stochastic Slow applied directly on Adaptive Laguerre RSI."
|
|
|
|
#ifndef STOCHASTIC_SLOW_ON_LAGUERRE_ADAPTIVE_RSI_CALCULATOR_MQH
|
|
#define STOCHASTIC_SLOW_ON_LAGUERRE_ADAPTIVE_RSI_CALCULATOR_MQH
|
|
|
|
#include <MyIncludes\Laguerre_Adaptive_RSI_Calculator.mqh>
|
|
#include <MyIncludes\MovingAverage_Engine.mqh>
|
|
|
|
//+==================================================================+
|
|
//| CLASS 1: CStochasticSlowOnLaguerreAdaptiveRSICalculator |
|
|
//+==================================================================+
|
|
class CStochasticSlowOnLaguerreAdaptiveRSICalculator
|
|
{
|
|
protected:
|
|
int m_k_period;
|
|
bool m_is_ha;
|
|
|
|
//--- Composition
|
|
CLaguerreAdaptiveRSICalculator *m_adaptive_rsi_calc; // Embedded Adaptive RSI Engine
|
|
CMovingAverageCalculator *m_slowing_engine; // For Slow %K
|
|
CMovingAverageCalculator *m_signal_engine; // For Signal %D
|
|
|
|
//--- Internal Buffers
|
|
double m_rsi_buffer[]; // Stores computed Adaptive Laguerre RSI
|
|
double m_dummy_signal[]; // Required by the underlying RSI engine
|
|
double m_raw_k[]; // Stores Fast %K
|
|
|
|
//--- Helpers
|
|
double Highest(const double &array[], int period, int current_pos);
|
|
double Lowest(const double &array[], int period, int current_pos);
|
|
|
|
public:
|
|
CStochasticSlowOnLaguerreAdaptiveRSICalculator(void);
|
|
virtual ~CStochasticSlowOnLaguerreAdaptiveRSICalculator(void);
|
|
|
|
bool Init(ENUM_ADAPTIVE_METHOD method, int adaptive_period, double gamma_min, double gamma_max,
|
|
int k_period, int slowing_period, ENUM_MA_TYPE slowing_method,
|
|
int d_period, ENUM_MA_TYPE d_method, bool is_ha);
|
|
|
|
//--- Standard Calculate (Without volume data)
|
|
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 &slow_k_buffer[], double &signal_d_buffer[]);
|
|
|
|
//--- Overloaded Calculate (With Volume for VWMA support)
|
|
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[],
|
|
const long &volume[],
|
|
double &slow_k_buffer[], double &signal_d_buffer[]);
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CStochasticSlowOnLaguerreAdaptiveRSICalculator::CStochasticSlowOnLaguerreAdaptiveRSICalculator(void)
|
|
: m_adaptive_rsi_calc(NULL),
|
|
m_slowing_engine(NULL),
|
|
m_signal_engine(NULL),
|
|
m_is_ha(false)
|
|
{
|
|
m_slowing_engine = new CMovingAverageCalculator();
|
|
m_signal_engine = new CMovingAverageCalculator();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CStochasticSlowOnLaguerreAdaptiveRSICalculator::~CStochasticSlowOnLaguerreAdaptiveRSICalculator(void)
|
|
{
|
|
if(CheckPointer(m_adaptive_rsi_calc) != POINTER_INVALID)
|
|
delete m_adaptive_rsi_calc;
|
|
if(CheckPointer(m_slowing_engine) != POINTER_INVALID)
|
|
delete m_slowing_engine;
|
|
if(CheckPointer(m_signal_engine) != POINTER_INVALID)
|
|
delete m_signal_engine;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Init |
|
|
//+------------------------------------------------------------------+
|
|
bool CStochasticSlowOnLaguerreAdaptiveRSICalculator::Init(ENUM_ADAPTIVE_METHOD method, int adaptive_period, double gamma_min, double gamma_max,
|
|
int k_period, int slowing_period, ENUM_MA_TYPE slowing_method,
|
|
int d_period, ENUM_MA_TYPE d_method, bool is_ha)
|
|
{
|
|
m_k_period = (k_period < 1) ? 1 : k_period;
|
|
m_is_ha = is_ha;
|
|
|
|
if(CheckPointer(m_adaptive_rsi_calc) != POINTER_INVALID)
|
|
{
|
|
delete m_adaptive_rsi_calc;
|
|
m_adaptive_rsi_calc = NULL;
|
|
}
|
|
|
|
// Dynamic Polymorphic instantiation of the underlying Adaptive RSI Engine
|
|
if(m_is_ha)
|
|
m_adaptive_rsi_calc = new CLaguerreAdaptiveRSICalculator_HA();
|
|
else
|
|
m_adaptive_rsi_calc = new CLaguerreAdaptiveRSICalculator();
|
|
|
|
// Initialize Adaptive RSI with dummy MA settings internally (we will overwrite signal line on Stochastic level)
|
|
if(CheckPointer(m_adaptive_rsi_calc) == POINTER_INVALID ||
|
|
!m_adaptive_rsi_calc.Init(method, adaptive_period, gamma_min, gamma_max, 3, EMA, m_is_ha))
|
|
return false;
|
|
|
|
if(!m_slowing_engine.Init(slowing_period, slowing_method))
|
|
return false;
|
|
if(!m_signal_engine.Init(d_period, d_method))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Calculate (Standard - No Volume) |
|
|
//+------------------------------------------------------------------+
|
|
void CStochasticSlowOnLaguerreAdaptiveRSICalculator::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 &slow_k_buffer[], double &signal_d_buffer[])
|
|
{
|
|
int required_bars = m_k_period + m_slowing_engine.GetPeriod() + m_signal_engine.GetPeriod() + 10;
|
|
if(rates_total < required_bars)
|
|
return;
|
|
|
|
//--- Resize state buffers and enforce chronological safety
|
|
if(ArraySize(m_rsi_buffer) != rates_total)
|
|
{
|
|
ArrayResize(m_rsi_buffer, rates_total);
|
|
ArrayResize(m_dummy_signal, rates_total);
|
|
ArrayResize(m_raw_k, rates_total);
|
|
|
|
ArraySetAsSeries(m_rsi_buffer, false);
|
|
ArraySetAsSeries(m_dummy_signal, false);
|
|
ArraySetAsSeries(m_raw_k, false);
|
|
}
|
|
|
|
//--- 1. Calculate underlying Adaptive Laguerre RSI using composition
|
|
m_adaptive_rsi_calc.Calculate(rates_total, prev_calculated, price_type, open, high, low, close, m_rsi_buffer, m_dummy_signal);
|
|
|
|
int start_index = (prev_calculated > 0) ? prev_calculated - 1 : 0;
|
|
int k_start = MathMax(m_k_period, start_index);
|
|
|
|
if(k_start == m_k_period)
|
|
{
|
|
for(int i = 0; i < m_k_period; i++)
|
|
m_raw_k[i] = 50.0;
|
|
}
|
|
|
|
//--- 2. Calculate Stochastic Raw %K over Adaptive RSI values
|
|
for(int i = k_start; i < rates_total; i++)
|
|
{
|
|
double highest_rsi = Highest(m_rsi_buffer, m_k_period, i);
|
|
double lowest_rsi = Lowest(m_rsi_buffer, m_k_period, i);
|
|
double range = highest_rsi - lowest_rsi;
|
|
|
|
if(range > 0.00001)
|
|
m_raw_k[i] = (m_rsi_buffer[i] - lowest_rsi) / range * 100.0;
|
|
else
|
|
m_raw_k[i] = (i > 0) ? m_raw_k[i - 1] : 50.0;
|
|
}
|
|
|
|
//--- 3. Calculate Slow %K (Slowing of Raw %K)
|
|
m_slowing_engine.CalculateOnArray(rates_total, prev_calculated, m_raw_k, slow_k_buffer, m_k_period);
|
|
|
|
//--- 4. Calculate %D (Smoothing of Slow %K)
|
|
int d_offset = m_k_period + m_slowing_engine.GetPeriod();
|
|
m_signal_engine.CalculateOnArray(rates_total, prev_calculated, slow_k_buffer, signal_d_buffer, d_offset);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Calculate (Overloaded - With Volume for VWMA support) |
|
|
//+------------------------------------------------------------------+
|
|
void CStochasticSlowOnLaguerreAdaptiveRSICalculator::Calculate(int rates_total, int prev_calculated, ENUM_APPLIED_PRICE price_type,
|
|
const double &open[], const double &high[], const double &low[], const double &close[],
|
|
const long &volume[],
|
|
double &slow_k_buffer[], double &signal_d_buffer[])
|
|
{
|
|
int required_bars = m_k_period + m_slowing_engine.GetPeriod() + m_signal_engine.GetPeriod() + 10;
|
|
if(rates_total < required_bars)
|
|
return;
|
|
|
|
//--- Convert volume locally for VWMA
|
|
double d_vol[];
|
|
ArrayResize(d_vol, rates_total);
|
|
ArraySetAsSeries(d_vol, false);
|
|
int start_sync = (prev_calculated > 0) ? prev_calculated - 1 : 0;
|
|
for(int i = start_sync; i < rates_total; i++)
|
|
d_vol[i] = (double)volume[i];
|
|
|
|
//--- Run Standard calculation to obtain internal Raw %K on Adaptive RSI
|
|
Calculate(rates_total, prev_calculated, price_type, open, high, low, close, slow_k_buffer, signal_d_buffer);
|
|
|
|
//--- Overwrite Slow %K & Signal %D with Volume-weighted averages
|
|
m_slowing_engine.CalculateOnArray(rates_total, prev_calculated, m_raw_k, d_vol, slow_k_buffer, m_k_period);
|
|
|
|
int d_offset = m_k_period + m_slowing_engine.GetPeriod();
|
|
m_signal_engine.CalculateOnArray(rates_total, prev_calculated, slow_k_buffer, d_vol, signal_d_buffer, d_offset);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Highest Helper |
|
|
//+------------------------------------------------------------------+
|
|
double CStochasticSlowOnLaguerreAdaptiveRSICalculator::Highest(const double &array[], int period, int current_pos)
|
|
{
|
|
double res = array[current_pos];
|
|
for(int i = 1; i < period; i++)
|
|
{
|
|
if(current_pos - i < 0)
|
|
break;
|
|
if(res < array[current_pos - i])
|
|
res = array[current_pos - i];
|
|
}
|
|
return res;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Lowest Helper |
|
|
//+------------------------------------------------------------------+
|
|
double CStochasticSlowOnLaguerreAdaptiveRSICalculator::Lowest(const double &array[], int period, int current_pos)
|
|
{
|
|
double res = array[current_pos];
|
|
for(int i = 1; i < period; i++)
|
|
{
|
|
if(current_pos - i < 0)
|
|
break;
|
|
if(res > array[current_pos - i])
|
|
res = array[current_pos - i];
|
|
}
|
|
return res;
|
|
}
|
|
|
|
//+==================================================================+
|
|
//| CLASS 2: CStochasticSlowOnLaguerreAdaptiveRSICalculator_HA |
|
|
//+==================================================================+
|
|
class CStochasticSlowOnLaguerreAdaptiveRSICalculator_HA : public CStochasticSlowOnLaguerreAdaptiveRSICalculator
|
|
{
|
|
public:
|
|
CStochasticSlowOnLaguerreAdaptiveRSICalculator_HA(void)
|
|
{
|
|
m_is_ha = true;
|
|
};
|
|
};
|
|
|
|
#endif // STOCHASTIC_SLOW_ON_LAGUERRE_ADAPTIVE_RSI_CALCULATOR_MQH
|
|
//+------------------------------------------------------------------+
|