mirror of
https://github.com/softwaredevelop/mql5.git
synced 2026-07-27 20:47:44 +00:00
Toh4iem9
242 lines
10 KiB
Plaintext
242 lines
10 KiB
Plaintext
//+------------------------------------------------------------------+
|
|
//| MovingAverage_Ribbon_MTF_Calculator.mqh|
|
|
//| VERSION 2.20: Fixed uninitialized buffer bug on W1. |
|
|
//| Copyright 2025, xxxxxxxx |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2025, xxxxxxxx"
|
|
|
|
#include <MyIncludes\MovingAverage_Engine.mqh>
|
|
|
|
//+==================================================================+
|
|
//| HELPER CLASS: CSingleMAMTFCalculator |
|
|
//| Handles the logic, state, and buffers for ONE MTF line. |
|
|
//+==================================================================+
|
|
class CSingleMAMTFCalculator
|
|
{
|
|
private:
|
|
CMovingAverageCalculator *m_calculator;
|
|
|
|
//--- MTF Settings
|
|
ENUM_TIMEFRAMES m_timeframe;
|
|
bool m_is_mtf;
|
|
|
|
//--- Persistent State for MTF Calculation
|
|
double m_htf_buffer[]; // Stores HTF MA values between ticks
|
|
int m_htf_prev_calc; // Tracks how many HTF bars are already calculated
|
|
|
|
public:
|
|
CSingleMAMTFCalculator(void);
|
|
~CSingleMAMTFCalculator(void);
|
|
|
|
bool Init(ENUM_TIMEFRAMES tf, int period, ENUM_MA_TYPE type, bool is_ha);
|
|
|
|
void Calculate(int rates_total, int prev_calculated, const datetime &time[], ENUM_APPLIED_PRICE price_type,
|
|
const double &open[], const double &high[], const double &low[], const double &close[],
|
|
double &output_buffer[]);
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| CSingleMAMTFCalculator Implementation |
|
|
//+------------------------------------------------------------------+
|
|
CSingleMAMTFCalculator::CSingleMAMTFCalculator(void) : m_calculator(NULL), m_htf_prev_calc(0) {}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
CSingleMAMTFCalculator::~CSingleMAMTFCalculator(void)
|
|
{
|
|
if(CheckPointer(m_calculator) != POINTER_INVALID)
|
|
delete m_calculator;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CSingleMAMTFCalculator::Init(ENUM_TIMEFRAMES tf, int period, ENUM_MA_TYPE type, bool is_ha)
|
|
{
|
|
m_timeframe = (tf == PERIOD_CURRENT) ? (ENUM_TIMEFRAMES)Period() : tf;
|
|
m_is_mtf = (m_timeframe > Period());
|
|
|
|
if(m_timeframe < Period())
|
|
return false;
|
|
|
|
if(is_ha)
|
|
m_calculator = new CMovingAverageCalculator_HA();
|
|
else
|
|
m_calculator = new CMovingAverageCalculator();
|
|
|
|
if(CheckPointer(m_calculator) == POINTER_INVALID || !m_calculator.Init(period, type))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CSingleMAMTFCalculator::Calculate(int rates_total, int prev_calculated, const datetime &time[], ENUM_APPLIED_PRICE price_type,
|
|
const double &open[], const double &high[], const double &low[], const double &close[],
|
|
double &output_buffer[])
|
|
{
|
|
if(CheckPointer(m_calculator) == POINTER_INVALID)
|
|
return;
|
|
|
|
// CRITICAL FIX: Initialize buffer with EMPTY_VALUE on full recalc.
|
|
if(prev_calculated == 0)
|
|
{
|
|
ArrayInitialize(output_buffer, EMPTY_VALUE);
|
|
m_htf_prev_calc = 0;
|
|
}
|
|
|
|
//--- MTF MODE ---
|
|
if(m_is_mtf)
|
|
{
|
|
int htf_rates = (int)SeriesInfoInteger(_Symbol, m_timeframe, SERIES_BARS_COUNT);
|
|
if(htf_rates < m_calculator.GetPeriod())
|
|
return;
|
|
|
|
datetime htf_time[];
|
|
double htf_open[], htf_high[], htf_low[], htf_close[];
|
|
|
|
// Fetch Data (Full history copy for safety, optimized math follows)
|
|
if(CopyTime(_Symbol, m_timeframe, 0, htf_rates, htf_time) <= 0 ||
|
|
CopyOpen(_Symbol, m_timeframe, 0, htf_rates, htf_open) <= 0 ||
|
|
CopyHigh(_Symbol, m_timeframe, 0, htf_rates, htf_high) <= 0 ||
|
|
CopyLow(_Symbol, m_timeframe, 0, htf_rates, htf_low) <= 0 ||
|
|
CopyClose(_Symbol, m_timeframe, 0, htf_rates, htf_close) <= 0)
|
|
return;
|
|
|
|
if(ArraySize(m_htf_buffer) != htf_rates)
|
|
ArrayResize(m_htf_buffer, htf_rates);
|
|
|
|
// Incremental HTF Calculation
|
|
// Step back 1 bar to ensure open candle updates
|
|
int htf_calc_start = (m_htf_prev_calc > 0) ? m_htf_prev_calc - 1 : 0;
|
|
|
|
m_calculator.Calculate(htf_rates, htf_calc_start, price_type, htf_open, htf_high, htf_low, htf_close, m_htf_buffer);
|
|
m_htf_prev_calc = htf_rates;
|
|
|
|
// Mapping Logic (The Staircase)
|
|
// CRITICAL: Set HTF buffer as SERIES to match iBarShift (0 = Newest)
|
|
ArraySetAsSeries(htf_time, true);
|
|
ArraySetAsSeries(m_htf_buffer, true);
|
|
ArraySetAsSeries(time, false); // Ensure standard indexing
|
|
ArraySetAsSeries(output_buffer, false); // Ensure standard indexing
|
|
|
|
int limit = (prev_calculated > 0) ? prev_calculated - 1 : 0;
|
|
|
|
for(int i = limit; i < rates_total; i++)
|
|
{
|
|
int htf_shift = iBarShift(_Symbol, m_timeframe, time[i], false);
|
|
|
|
if(htf_shift >= 0 && htf_shift < htf_rates)
|
|
output_buffer[i] = m_htf_buffer[htf_shift];
|
|
else
|
|
output_buffer[i] = EMPTY_VALUE;
|
|
}
|
|
|
|
// Restore HTF buffer to non-series for next calculation cycle
|
|
ArraySetAsSeries(m_htf_buffer, false);
|
|
ArraySetAsSeries(htf_time, false);
|
|
}
|
|
//--- CURRENT TF MODE ---
|
|
else
|
|
{
|
|
m_calculator.Calculate(rates_total, prev_calculated, price_type, open, high, low, close, output_buffer);
|
|
}
|
|
}
|
|
|
|
|
|
//+==================================================================+
|
|
//| MAIN CLASS: CMovingAverageRibbonMTFCalculator |
|
|
//| Manages the 4 instances of the helper class. |
|
|
//+==================================================================+
|
|
class CMovingAverageRibbonMTFCalculator
|
|
{
|
|
protected:
|
|
// Composition: 4 independent instances
|
|
CSingleMAMTFCalculator *m_ma1, *m_ma2, *m_ma3, *m_ma4;
|
|
|
|
public:
|
|
CMovingAverageRibbonMTFCalculator(void);
|
|
virtual ~CMovingAverageRibbonMTFCalculator(void);
|
|
|
|
bool Init(ENUM_TIMEFRAMES tf1, int p1, ENUM_MA_TYPE t1,
|
|
ENUM_TIMEFRAMES tf2, int p2, ENUM_MA_TYPE t2,
|
|
ENUM_TIMEFRAMES tf3, int p3, ENUM_MA_TYPE t3,
|
|
ENUM_TIMEFRAMES tf4, int p4, ENUM_MA_TYPE t4,
|
|
bool is_ha);
|
|
|
|
void Calculate(int rates_total, int prev_calculated, const datetime &time[], ENUM_APPLIED_PRICE price_type,
|
|
const double &open[], const double &high[], const double &low[], const double &close[],
|
|
double &ma1_buffer[], double &ma2_buffer[], double &ma3_buffer[], double &ma4_buffer[]);
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| CMovingAverageRibbonMTFCalculator Implementation |
|
|
//+------------------------------------------------------------------+
|
|
CMovingAverageRibbonMTFCalculator::CMovingAverageRibbonMTFCalculator(void)
|
|
{
|
|
m_ma1 = NULL;
|
|
m_ma2 = NULL;
|
|
m_ma3 = NULL;
|
|
m_ma4 = NULL;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
CMovingAverageRibbonMTFCalculator::~CMovingAverageRibbonMTFCalculator(void)
|
|
{
|
|
if(CheckPointer(m_ma1) != POINTER_INVALID)
|
|
delete m_ma1;
|
|
if(CheckPointer(m_ma2) != POINTER_INVALID)
|
|
delete m_ma2;
|
|
if(CheckPointer(m_ma3) != POINTER_INVALID)
|
|
delete m_ma3;
|
|
if(CheckPointer(m_ma4) != POINTER_INVALID)
|
|
delete m_ma4;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CMovingAverageRibbonMTFCalculator::Init(ENUM_TIMEFRAMES tf1, int p1, ENUM_MA_TYPE t1,
|
|
ENUM_TIMEFRAMES tf2, int p2, ENUM_MA_TYPE t2,
|
|
ENUM_TIMEFRAMES tf3, int p3, ENUM_MA_TYPE t3,
|
|
ENUM_TIMEFRAMES tf4, int p4, ENUM_MA_TYPE t4,
|
|
bool is_ha)
|
|
{
|
|
m_ma1 = new CSingleMAMTFCalculator();
|
|
m_ma2 = new CSingleMAMTFCalculator();
|
|
m_ma3 = new CSingleMAMTFCalculator();
|
|
m_ma4 = new CSingleMAMTFCalculator();
|
|
|
|
if(CheckPointer(m_ma1) == POINTER_INVALID || !m_ma1.Init(tf1, p1, t1, is_ha) ||
|
|
CheckPointer(m_ma2) == POINTER_INVALID || !m_ma2.Init(tf2, p2, t2, is_ha) ||
|
|
CheckPointer(m_ma3) == POINTER_INVALID || !m_ma3.Init(tf3, p3, t3, is_ha) ||
|
|
CheckPointer(m_ma4) == POINTER_INVALID || !m_ma4.Init(tf4, p4, t4, is_ha))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CMovingAverageRibbonMTFCalculator::Calculate(int rates_total, int prev_calculated, const datetime &time[], ENUM_APPLIED_PRICE price_type,
|
|
const double &open[], const double &high[], const double &low[], const double &close[],
|
|
double &ma1_buffer[], double &ma2_buffer[], double &ma3_buffer[], double &ma4_buffer[])
|
|
{
|
|
if(CheckPointer(m_ma1) == POINTER_INVALID)
|
|
return;
|
|
|
|
// Delegate with prev_calculated
|
|
m_ma1.Calculate(rates_total, prev_calculated, time, price_type, open, high, low, close, ma1_buffer);
|
|
m_ma2.Calculate(rates_total, prev_calculated, time, price_type, open, high, low, close, ma2_buffer);
|
|
m_ma3.Calculate(rates_total, prev_calculated, time, price_type, open, high, low, close, ma3_buffer);
|
|
m_ma4.Calculate(rates_total, prev_calculated, time, price_type, open, high, low, close, ma4_buffer);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//+------------------------------------------------------------------+
|