47a5ef338b
- Replaced standard library signal modules with custom implementations to allow for named patterns and improved voting. - Added new input parameters for module weights, allowing for optimization of individual signal contributions. - Enhanced the management of trades with new options for breakeven and management cut. - Introduced a mechanism for dynamic ranking of signal weights based on historical performance. - Improved initialization logic to ensure proper registration of filters and handling of trading conditions. - Added detailed logging for trading permissions and account status during initialization.
175 lines
8.2 KiB
MQL5
175 lines
8.2 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| SignalRegime.mqh |
|
|
//| AnimateDread |
|
|
//| |
|
|
//| WHICH GAME IS BEING PLAYED: trending, consolidating, or mean- |
|
|
//| reverting. A classic module in the ordinary shape - it votes |
|
|
//| 0..100, names its pattern, and the journal ranks it like any |
|
|
//| other. |
|
|
//| |
|
|
//| WHY THIS AND NOT MORE WYCKOFF. Wyckoff answers "where are we in |
|
|
//| a campaign" - events, phases, springs. That is structure. This |
|
|
//| answers a blunter and more useful question first: does price |
|
|
//| here travel, or does it come back? Those demand opposite trades |
|
|
//| from the same indicator reading, which is why an ensemble of |
|
|
//| oscillators and trend modules voting together can be right about |
|
|
//| everything and still lose: in a trend the oscillators are wrong, |
|
|
//| in a range the trend modules are. |
|
|
//| |
|
|
//| TWO MEASURES, BOTH FROM CLOSES, BOTH SCALE-FREE. |
|
|
//| |
|
|
//| EFFICIENCY RATIO (Kaufman): net distance divided by the path |
|
|
//| length walked to get there. |
|
|
//| ER = |C[t] - C[t-n]| / SUM |C[i] - C[i-1]| |
|
|
//| 1.0 is a straight line, 0.0 is thrashing that ends where it |
|
|
//| began. It needs no volatility estimate and no threshold that |
|
|
//| means different things on different symbols - a ratio of two |
|
|
//| distances in the same units cancels the instrument entirely. |
|
|
//| |
|
|
//| VARIANCE RATIO: the variance of q-bar returns against q times the |
|
|
//| variance of 1-bar returns. |
|
|
//| VR = Var(q-bar) / (q * Var(1-bar)) |
|
|
//| A random walk gives 1.0 because variance scales with time. Above |
|
|
//| 1 the moves compound - trending. Below 1 they cancel - mean |
|
|
//| reverting. This is the sharper of the two: ER says "is there a |
|
|
//| trend", VR says "does this market CONTINUE or REVERSE", which is |
|
|
//| the question an entry actually rests on. |
|
|
//| |
|
|
//| ⚠ IT DOES NOT VOTE IN CONSOLIDATION, deliberately. Neither the |
|
|
//| trend patterns nor the reversion patterns have an edge when the |
|
|
//| market is doing neither, and a module that always finds something |
|
|
//| to say is a module whose vote means nothing. Returning 0/0 is a |
|
|
//| real answer here, and the standard library counts it as one. |
|
|
//+------------------------------------------------------------------+
|
|
#ifndef WARRIOR_SIGNALREGIME_MQH
|
|
#define WARRIOR_SIGNALREGIME_MQH
|
|
|
|
#include "..\Expert\WarriorSignal.mqh"
|
|
|
|
class CSignalRegime : public CWarriorSignal
|
|
{
|
|
protected:
|
|
int m_erPeriod; // bars for the efficiency ratio
|
|
int m_vrPeriod; // bars for the variance ratio
|
|
int m_vrQ; // the q in VR(q)
|
|
int m_maPeriod; // the reference the trend is measured against
|
|
double m_erTrend; // ER at or above this is a trend
|
|
double m_erChop; // ER at or below this is consolidation
|
|
double m_vrRevert; // VR at or below this is mean reverting
|
|
|
|
int m_pattern_0; // trend, long
|
|
int m_pattern_1; // trend, short
|
|
int m_pattern_2; // mean reversion, long
|
|
int m_pattern_3; // mean reversion, short
|
|
|
|
double Sma(const int shift, const int period) const;
|
|
|
|
public:
|
|
CSignalRegime(void);
|
|
~CSignalRegime(void) {}
|
|
|
|
void ErPeriod(const int v) { m_erPeriod = v; }
|
|
void VrPeriod(const int v) { m_vrPeriod = v; }
|
|
void MaPeriod(const int v) { m_maPeriod = v; }
|
|
void Pattern_0(const int v) { m_pattern_0 = v; }
|
|
void Pattern_1(const int v) { m_pattern_1 = v; }
|
|
void Pattern_2(const int v) { m_pattern_2 = v; }
|
|
void Pattern_3(const int v) { m_pattern_3 = v; }
|
|
virtual void ApplyPatternWeight(int pattern, int weight)
|
|
{
|
|
if(pattern == 0) m_pattern_0 = weight;
|
|
if(pattern == 1) m_pattern_1 = weight;
|
|
if(pattern == 2) m_pattern_2 = weight;
|
|
if(pattern == 3) m_pattern_3 = weight;
|
|
}
|
|
//--- Published so the neural module can read the regime as context rather than recompute it.
|
|
double ER(const int shift = 1) const { return EfficiencyRatio(shift, m_erPeriod); }
|
|
double VR(const int shift = 1) const { return VarianceRatio(shift, m_vrPeriod, m_vrQ); }
|
|
|
|
virtual bool ValidationSettings(void) override;
|
|
virtual int LongCondition(void) override;
|
|
virtual int ShortCondition(void) override;
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
CSignalRegime::CSignalRegime(void) : m_erPeriod(20), m_vrPeriod(60), m_vrQ(5), m_maPeriod(50),
|
|
m_erTrend(0.35), m_erChop(0.15), m_vrRevert(0.85),
|
|
m_pattern_0(60), m_pattern_1(60),
|
|
m_pattern_2(50), m_pattern_3(50)
|
|
{
|
|
m_id = "REGIME";
|
|
m_pattern_count = 4;
|
|
m_used_series = USE_SERIES_CLOSE;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
bool CSignalRegime::ValidationSettings(void)
|
|
{
|
|
if(!CWarriorSignal::ValidationSettings())
|
|
return false;
|
|
if(m_erPeriod < 5 || m_vrPeriod < 20 || m_vrQ < 2 || m_vrPeriod < m_vrQ * 4)
|
|
{
|
|
//--- VR(q) needs several non-overlapping q-blocks to estimate a variance at all; with fewer
|
|
//--- than four the ratio is noise with a decimal point.
|
|
Print("CSignalRegime: periods are too short for a stable variance ratio");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
double CSignalRegime::Sma(const int shift, const int period) const
|
|
{
|
|
double s = 0.0;
|
|
for(int i = 0; i < period; i++)
|
|
s += Close(shift + i);
|
|
return s / period;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
int CSignalRegime::LongCondition(void)
|
|
{
|
|
const int idx = StartIndex();
|
|
const double er = EfficiencyRatio(idx, m_erPeriod);
|
|
const double vr = VarianceRatio(idx, m_vrPeriod, m_vrQ);
|
|
const double c = Close(idx);
|
|
const double ma = Sma(idx, m_maPeriod);
|
|
|
|
//--- TRENDING AND UP. ER says the path is efficient, the reference says which way.
|
|
if(er >= m_erTrend && c > ma)
|
|
{
|
|
m_active_pattern = "Pattern_0";
|
|
m_active_direction = "Buy";
|
|
return m_pattern_0;
|
|
}
|
|
//--- MEAN REVERTING AND BELOW THE REFERENCE. VR below 1 says moves cancel; being under the mean
|
|
//--- is then a reason to buy rather than a reason to worry. This is the exact setup where the
|
|
//--- trend modules are wrong, which is the whole point of separating the two regimes.
|
|
if(vr <= m_vrRevert && er <= m_erChop && c < ma)
|
|
{
|
|
m_active_pattern = "Pattern_2";
|
|
m_active_direction = "Buy";
|
|
return m_pattern_2;
|
|
}
|
|
return 0;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
int CSignalRegime::ShortCondition(void)
|
|
{
|
|
const int idx = StartIndex();
|
|
const double er = EfficiencyRatio(idx, m_erPeriod);
|
|
const double vr = VarianceRatio(idx, m_vrPeriod, m_vrQ);
|
|
const double c = Close(idx);
|
|
const double ma = Sma(idx, m_maPeriod);
|
|
|
|
if(er >= m_erTrend && c < ma)
|
|
{
|
|
m_active_pattern = "Pattern_1";
|
|
m_active_direction = "Sell";
|
|
return m_pattern_1;
|
|
}
|
|
if(vr <= m_vrRevert && er <= m_erChop && c > ma)
|
|
{
|
|
m_active_pattern = "Pattern_3";
|
|
m_active_direction = "Sell";
|
|
return m_pattern_3;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif // WARRIOR_SIGNALREGIME_MQH
|