LaguerreFilter_v1
Download scriptThis tool is designed to provide traders with a smoother, more refined view of price action by filtering out the "noise" often found in volatile markets. Based on technical principles from specialized cybernetics analysis, it aims to identify underlying trends without the significant delays that typically plague standard moving averages.
How the Logic Works
The script processes market data using a sophisticated multi-stage calculation known as a Laguerre Filter. Here is a breakdown of how it functions for the user:
1. Data Foundation (Price Point) Instead of looking at just the closing price, the logic begins by identifying the midpoint of each candle (the average between the High and Low). This provides a more balanced "center" for the calculation to follow.
2. The Filtering Process (The Laguerre Layers) The tool doesn't simply average the prices; it passes them through a series of four interconnected mathematical layers (referred to as L0 through L3).
- Each layer takes the current price and blends it with the results of the previous calculation.
- By cascading the data through these four steps, the script "smooths" the jagged edges of price movement. This allows it to distinguish between a temporary price spike and a genuine change in market direction.
3. Trend & Reference Comparison The script produces two distinct visual outputs on your chart:
- The Filter: This is the primary smoothed line. It represents the processed trend, designed to follow the price closely while remaining fluid.
- The FIR (Finite Impulse Response): This serves as a direct reference point, showing a weighted average of the raw prices over a short period.
Key Settings and Visuals
The primary lever for this tool is the Gamma value. By adjusting this, you can control the responsiveness of the filter:
- A higher Gamma typically makes the filter react more quickly to new price movements.
- A lower Gamma results in a smoother, slower line that ignores more market volatility.
Summary for the Trader
The goal of this script is to provide clarity. By using the Laguerre Filter instead of standard indicators, you are looking at a "cleaned" version of the market trend. It helps traders see where the price is actually heading by stripping away the minor fluctuations that can often lead to false signals in fast-moving markets.
//+------------------------------------------------------------------+
//| LaguerreFilter.mq4 |
//| |
//| Laguerre Filter |
//| |
//| Algorithm taken from book |
//| "Cybernetics Analysis for Stock and Futures" |
//| by John F. Ehlers |
//| |
//| contact@mqlsoft.com |
//| http://www.mqlsoft.com/ |
//+------------------------------------------------------------------+
#property copyright "Coded by Witold Wozniak"
#property link "www.mqlsoft.com"
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 Blue
extern double Gamma = 0.8;
double Filter[];
double FIR[];
double L0[];
double L1[];
double L2[];
double L3[];
int buffers = 0;
int drawBegin = 0;
int init() {
drawBegin = 4;
initBuffer(Filter, "Laguerre Filter", DRAW_LINE);
initBuffer(FIR, "FIR", DRAW_LINE);
initBuffer(L0);
initBuffer(L1);
initBuffer(L2);
initBuffer(L3);
IndicatorBuffers(buffers);
IndicatorShortName("Laguerre Filter [" + DoubleToStr(Gamma, 2) + "]");
return (0);
}
int start() {
if (Bars <= drawBegin) return (0);
int countedBars = IndicatorCounted();
if (countedBars < 0) return (-1);
if (countedBars > 0) countedBars--;
int s, limit = Bars - countedBars - 1;
for (s = limit; s >= 0; s--) {
L0[s] = (1.0 - Gamma) * P(s) + Gamma * L0[s + 1];
L1[s] = -Gamma * L0[s] + L0[s + 1] + Gamma * L1[s + 1];
L2[s] = -Gamma * L1[s] + L1[s + 1] + Gamma * L2[s + 1];
L3[s] = -Gamma * L2[s] + L2[s + 1] + Gamma * L3[s + 1];
Filter[s] = (L0[s] + 2.0 * L1[s] + 2.0 * L2[s] + L3[s]) / 6.0;
FIR[s] = (P(s) + 2.0 * P(s + 1) + 2.0 * P(s + 2) + P(s + 3)) / 6.0;
if (s > Bars - 4) {
L0[s] = P(s);
L1[s] = P(s);
L2[s] = P(s);
L3[s] = P(s);
Filter[s] = P(s);
}
}
return (0);
}
double P(int index) {
return ((High[index] + Low[index]) / 2.0);
}
void initBuffer(double array[], string label = "", int type = DRAW_NONE, int arrow = 0, int style = EMPTY, int width = EMPTY, color clr = CLR_NONE) {
SetIndexBuffer(buffers, array);
SetIndexLabel(buffers, label);
SetIndexEmptyValue(buffers, EMPTY_VALUE);
SetIndexDrawBegin(buffers, drawBegin);
SetIndexShift(buffers, 0);
SetIndexStyle(buffers, type, style, width);
SetIndexArrow(buffers, arrow);
buffers++;
}
Comments