341 lines
10 KiB
MQL5
341 lines
10 KiB
MQL5
/**
|
|
* @file Stochastic - Concrete Streaming Stochastic indicator using rolling extrema, Simple Moving Average slowing, and configurable signal-line smoothing.
|
|
* @deps IndicatorBase.mqh, SMA.mqh, EMA.mqh, SMMA.mqh, LWMA.mqh, BarSeriesBuffer.mqh, RollingMin.mqh, RollingMax.mqh, EMovingAverageType.mqh
|
|
* @state Stateful (Orchestrates rolling extrema, internal moving averages, dynamic signal-line ownership, and output time-series buffers across ticks)
|
|
* @io Source struct OHLC pricing tick -> Updates rolling extrema, smoothed K, signal D, and output buffers | Request offset and line index -> Returns historical K or D double value
|
|
* @note AI-assisted code. Independently review and test in a demo environment before live production trading.
|
|
*/
|
|
|
|
#ifndef __STOCHASTIC_MQH__
|
|
#define __STOCHASTIC_MQH__
|
|
|
|
#include "IndicatorBase.mqh"
|
|
#include "SMA.mqh"
|
|
#include "EMA.mqh"
|
|
#include "SMMA.mqh"
|
|
#include "LWMA.mqh"
|
|
#include "..\\Storage\\BarSeriesBuffer.mqh"
|
|
#include "..\\Algorithms\\RollingMin.mqh"
|
|
#include "..\\Algorithms\\RollingMax.mqh"
|
|
#include "..\\Common\\EMovingAverageType.mqh"
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Stochastic |
|
|
//| |
|
|
//| PURPOSE |
|
|
//| ------- |
|
|
//| Streaming Stochastic indicator. |
|
|
//| |
|
|
//| RESPONSIBILITIES |
|
|
//| ---------------- |
|
|
//| • Maintain Stochastic configuration |
|
|
//| • Maintain rolling highest and lowest values |
|
|
//| • Calculate and smooth raw K values |
|
|
//| • Calculate configurable signal D values |
|
|
//| • Persist calculated K and D outputs |
|
|
//| |
|
|
//| NON-RESPONSIBILITIES |
|
|
//| -------------------- |
|
|
//| • Rolling extrema implementation |
|
|
//| • Moving average implementation |
|
|
//| • Circular storage implementation |
|
|
//| • MT5 lifecycle management |
|
|
//+------------------------------------------------------------------+
|
|
class Stochastic : public IndicatorBase
|
|
{
|
|
private:
|
|
|
|
int m_kPeriod;
|
|
int m_dPeriod;
|
|
int m_slowingPeriod;
|
|
EMovingAverageType m_maType;
|
|
|
|
CBarSeriesBuffer m_input;
|
|
CRollingMin m_rollingMin;
|
|
CRollingMax m_rollingMax;
|
|
|
|
SMA m_numeratorSMA;
|
|
SMA m_denominatorSMA;
|
|
IndicatorBase *m_signal;
|
|
|
|
CBarSeriesBuffer m_main;
|
|
CBarSeriesBuffer m_signalLine;
|
|
|
|
public:
|
|
|
|
static const int MAIN;
|
|
static const int SIGNAL;
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
Stochastic()
|
|
{
|
|
m_kPeriod = 0;
|
|
m_dPeriod = 0;
|
|
m_slowingPeriod = 0;
|
|
m_maType = MA_SIMPLE;
|
|
m_signal = NULL;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
~Stochastic()
|
|
{
|
|
DeInit();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Parameters |
|
|
//+------------------------------------------------------------------+
|
|
void SetParameters(const int kPeriod,
|
|
const int dPeriod,
|
|
const int slowingPeriod,
|
|
const EMovingAverageType maType)
|
|
{
|
|
m_kPeriod = kPeriod;
|
|
m_dPeriod = dPeriod;
|
|
m_slowingPeriod = slowingPeriod;
|
|
m_maType = maType;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize |
|
|
//+------------------------------------------------------------------+
|
|
virtual bool Init()
|
|
{
|
|
DeInit();
|
|
|
|
if(m_kPeriod <= 0 ||
|
|
m_dPeriod <= 0 ||
|
|
m_slowingPeriod <= 0)
|
|
{
|
|
return(false);
|
|
}
|
|
|
|
if(m_maxBarsBack == 0)
|
|
m_maxBarsBack = m_kPeriod;
|
|
|
|
if(m_maxBarsBack <= 0)
|
|
return(false);
|
|
|
|
if(!m_input.Init(m_kPeriod))
|
|
return(false);
|
|
|
|
if(!m_rollingMin.Init(m_kPeriod))
|
|
return(false);
|
|
|
|
if(!m_rollingMax.Init(m_kPeriod))
|
|
return(false);
|
|
|
|
m_numeratorSMA.SetParameters(m_slowingPeriod);
|
|
m_numeratorSMA.SetMaxBarsBack(m_maxBarsBack);
|
|
m_numeratorSMA.SetErrorValue(m_errorValue);
|
|
|
|
if(!m_numeratorSMA.Init())
|
|
return(false);
|
|
|
|
m_denominatorSMA.SetParameters(m_slowingPeriod);
|
|
m_denominatorSMA.SetMaxBarsBack(m_maxBarsBack);
|
|
m_denominatorSMA.SetErrorValue(m_errorValue);
|
|
|
|
if(!m_denominatorSMA.Init())
|
|
return(false);
|
|
|
|
switch(m_maType)
|
|
{
|
|
case MA_SIMPLE:
|
|
m_signal = new SMA;
|
|
break;
|
|
|
|
case MA_EXPONENTIAL:
|
|
m_signal = new EMA;
|
|
break;
|
|
|
|
case MA_SMOOTHED:
|
|
m_signal = new SMMA;
|
|
break;
|
|
|
|
case MA_LINEAR_WEIGHTED:
|
|
m_signal = new LWMA;
|
|
break;
|
|
|
|
default:
|
|
return(false);
|
|
}
|
|
|
|
if(CheckPointer(m_signal) != POINTER_DYNAMIC)
|
|
{
|
|
m_signal = NULL;
|
|
return(false);
|
|
}
|
|
|
|
if(m_maType == MA_SIMPLE)
|
|
((SMA*)m_signal).SetParameters(m_dPeriod);
|
|
else if(m_maType == MA_EXPONENTIAL)
|
|
((EMA*)m_signal).SetParameters(m_dPeriod);
|
|
else if(m_maType == MA_SMOOTHED)
|
|
((SMMA*)m_signal).SetParameters(m_dPeriod);
|
|
else
|
|
((LWMA*)m_signal).SetParameters(m_dPeriod);
|
|
|
|
m_signal.SetMaxBarsBack(m_maxBarsBack);
|
|
m_signal.SetErrorValue(m_errorValue);
|
|
|
|
if(!m_signal.Init())
|
|
{
|
|
DeInit();
|
|
return(false);
|
|
}
|
|
|
|
if(!m_main.Init(m_maxBarsBack))
|
|
{
|
|
DeInit();
|
|
return(false);
|
|
}
|
|
|
|
if(!m_signalLine.Init(m_maxBarsBack))
|
|
{
|
|
DeInit();
|
|
return(false);
|
|
}
|
|
|
|
return(true);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Reset |
|
|
//+------------------------------------------------------------------+
|
|
virtual void Reset()
|
|
{
|
|
m_input.Reset();
|
|
m_rollingMin.Reset();
|
|
m_rollingMax.Reset();
|
|
m_numeratorSMA.Reset();
|
|
m_denominatorSMA.Reset();
|
|
|
|
if(CheckPointer(m_signal) != POINTER_INVALID)
|
|
m_signal.Reset();
|
|
|
|
m_main.Reset();
|
|
m_signalLine.Reset();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Deinitialize |
|
|
//+------------------------------------------------------------------+
|
|
virtual void DeInit()
|
|
{
|
|
if(CheckPointer(m_signal) == POINTER_DYNAMIC)
|
|
delete m_signal;
|
|
|
|
m_signal = NULL;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Update |
|
|
//+------------------------------------------------------------------+
|
|
virtual void Update(const Source &src)
|
|
{
|
|
ESeriesEvent event = m_input.Update(src.time, src.close);
|
|
|
|
switch(event)
|
|
{
|
|
case SERIES_FIRST_SAMPLE:
|
|
m_rollingMin.Append(src.low);
|
|
m_rollingMax.Append(src.high);
|
|
break;
|
|
|
|
case SERIES_APPEND:
|
|
m_rollingMin.Append(src.low);
|
|
m_rollingMax.Append(src.high);
|
|
break;
|
|
|
|
case SERIES_REPLACE_LAST:
|
|
m_rollingMin.ReplaceLast(src.low);
|
|
m_rollingMax.ReplaceLast(src.high);
|
|
break;
|
|
|
|
case SERIES_RESET:
|
|
Reset();
|
|
|
|
m_input.Update(src.time, src.close);
|
|
m_rollingMin.Append(src.low);
|
|
m_rollingMax.Append(src.high);
|
|
break;
|
|
}
|
|
|
|
double lowest = m_rollingMin.Value();
|
|
double highest = m_rollingMax.Value();
|
|
|
|
double numerator = src.close - lowest;
|
|
double denominator = highest - lowest;
|
|
|
|
Source numeratorSource =
|
|
Source::From(numerator, src.time);
|
|
|
|
Source denominatorSource =
|
|
Source::From(denominator, src.time);
|
|
|
|
m_numeratorSMA.Update(numeratorSource);
|
|
m_denominatorSMA.Update(denominatorSource);
|
|
|
|
double numeratorAverage =
|
|
m_numeratorSMA.GetValue(0, SMA::MAIN);
|
|
|
|
double denominatorAverage =
|
|
m_denominatorSMA.GetValue(0, SMA::MAIN);
|
|
|
|
double smoothedK = m_errorValue;
|
|
|
|
if(numeratorAverage != m_errorValue &&
|
|
denominatorAverage != m_errorValue)
|
|
{
|
|
smoothedK = denominatorAverage == 0.0
|
|
? 0.0
|
|
: 100.0 * numeratorAverage / denominatorAverage;
|
|
}
|
|
|
|
double signalD = m_errorValue;
|
|
|
|
if(smoothedK != m_errorValue)
|
|
{
|
|
Source signalSource = Source::From(smoothedK, src.time);
|
|
|
|
m_signal.Update(signalSource);
|
|
signalD = m_signal.GetValue(0, 0);
|
|
}
|
|
|
|
m_main.Update(src.time, smoothedK);
|
|
m_signalLine.Update(src.time, signalD);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Value Access |
|
|
//+------------------------------------------------------------------+
|
|
virtual double GetValue(const int index,
|
|
const int lineIndex = 0) const
|
|
{
|
|
double value;
|
|
|
|
if(lineIndex == MAIN)
|
|
{
|
|
if(m_main.At(index, value))
|
|
return(value);
|
|
}
|
|
else if(lineIndex == SIGNAL)
|
|
{
|
|
if(m_signalLine.At(index, value))
|
|
return(value);
|
|
}
|
|
|
|
return(m_errorValue);
|
|
}
|
|
};
|
|
|
|
const int Stochastic::MAIN = 0;
|
|
const int Stochastic::SIGNAL = 1;
|
|
|
|
#endif // __STOCHASTIC_MQH__
|
|
//+------------------------------------------------------------------+
|