gavindiaz/mql5
1
0
Fork 0
mirror of https://github.com/softwaredevelop/mql5.git synced 2026-08-06 09:07:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Corrected state management for stability

Browse Source
This commit is contained in:
Toh4iem9
2025-11-23 10:28:04 +01:00
parent c19d7a36e7
commit d3b1d2daa9
1 changed files with 58 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Include/MyIncludes/Laguerre_Engine.mqh
+58 -21
View File
@@ -1,14 +1,12 @@
//+------------------------------------------------------------------+
//| Laguerre_Engine.mqh |
//| Core calculation engine for the Laguerre filter series. |
//| Can be applied to Price or Momentum. |
//| VERSION 1.10: Corrected state management for stability. |
//| Copyright 2025, xxxxxxxx |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, xxxxxxxx"
#include <MyIncludes\HeikinAshi_Tools.mqh>
// NEW: Enum to select the data source
enum ENUM_INPUT_SOURCE { SOURCE_PRICE, SOURCE_MOMENTUM };
//+==================================================================+
@@ -19,6 +17,9 @@ protected:
ENUM_INPUT_SOURCE m_source_type;
double m_price[];
//--- State variables for the recursive filter (CRITICAL FIX) ---
double m_L0_prev, m_L1_prev, m_L2_prev, m_L3_prev;
virtual bool PreparePriceSeries(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[]);
public:
@@ -31,22 +32,42 @@ public:
void GetPriceBuffer(double &dest_array[]);
};
//+==================================================================+
//| METHOD IMPLEMENTATIONS |
//+==================================================================+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CLaguerreEngine::Init(double gamma, ENUM_INPUT_SOURCE source_type)
{
m_gamma = fmax(0.0, fmin(1.0, gamma));
m_source_type = source_type;
//--- Reset state variables on initialization ---
m_L0_prev = 0;
m_L1_prev = 0;
m_L2_prev = 0;
m_L3_prev = 0;
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CLaguerreEngine::GetPriceBuffer(double &dest_array[])
{
int size = ArraySize(m_price);
ArrayResize(dest_array, size);
ArrayCopy(dest_array, m_price, 0, 0, size);
if(size > 0)
{
ArrayResize(dest_array, size);
ArrayCopy(dest_array, m_price, 0, 0, size);
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CLaguerreEngine::CalculateFilter(int rates_total, ENUM_APPLIED_PRICE price_type, const double &open[], const double &high[], const double &low[], const double &close[],
double &L0_buffer[], double &L1_buffer[], double &L2_buffer[], double &L3_buffer[], double &filt_buffer[])
@@ -62,24 +83,40 @@ void CLaguerreEngine::CalculateFilter(int rates_total, ENUM_APPLIED_PRICE price_
ArrayResize(L3_buffer, rates_total);
ArrayResize(filt_buffer, rates_total);
double L0_prev = m_price[0], L1_prev = m_price[0], L2_prev = m_price[0], L3_prev = m_price[0];
L0_buffer[0] = m_price[0];
L1_buffer[0] = m_price[0];
L2_buffer[0] = m_price[0];
L3_buffer[0] = m_price[0];
filt_buffer[0] = m_price[0];
for(int i = 1; i < rates_total; i++)
//--- Robust initialization on first run ---
if(m_L0_prev == 0 && m_L1_prev == 0) // A simple check for first run
{
L0_buffer[i] = (1.0 - m_gamma) * m_price[i] + m_gamma * L0_prev;
L1_buffer[i] = -m_gamma * L0_buffer[i] + L0_prev + m_gamma * L1_prev;
L2_buffer[i] = -m_gamma * L1_buffer[i] + L1_prev + m_gamma * L2_prev;
L3_buffer[i] = -m_gamma * L2_buffer[i] + L2_prev + m_gamma * L3_prev;
m_L0_prev = m_price[0];
m_L1_prev = m_price[0];
m_L2_prev = m_price[0];
m_L3_prev = m_price[0];
}
for(int i = 0; i < rates_total; i++)
{
// For the very first bar, output is just the price
if(i == 0)
{
L0_buffer[i] = m_price[i];
L1_buffer[i] = m_price[i];
L2_buffer[i] = m_price[i];
L3_buffer[i] = m_price[i];
}
else
{
L0_buffer[i] = (1.0 - m_gamma) * m_price[i] + m_gamma * m_L0_prev;
L1_buffer[i] = -m_gamma * L0_buffer[i] + m_L0_prev + m_gamma * m_L1_prev;
L2_buffer[i] = -m_gamma * L1_buffer[i] + m_L1_prev + m_gamma * m_L2_prev;
L3_buffer[i] = -m_gamma * L2_buffer[i] + m_L2_prev + m_gamma * m_L3_prev;
}
filt_buffer[i] = (L0_buffer[i] + 2.0 * L1_buffer[i] + 2.0 * L2_buffer[i] + L3_buffer[i]) / 6.0;
L0_prev = L0_buffer[i];
L1_prev = L1_buffer[i];
L2_prev = L2_buffer[i];
L3_prev = L3_buffer[i];
//--- Update state variables for the next iteration ---
m_L0_prev = L0_buffer[i];
m_L1_prev = L1_buffer[i];
m_L2_prev = L2_buffer[i];
m_L3_prev = L3_buffer[i];
}
}