| //+------------------------------------------------------------------+
|
| //| StEngines.mqh |
|
| //| Copyright 2026, Allan Niñal |
|
| //| https://www.allanninal.dev/mql5 |
|
| //+------------------------------------------------------------------+
|
| //| The three signal engines of Signal Trader (UT Bot, SuperTrend, |
|
| //| Range Filter), embedded so nothing else has to be installed. |
|
| //| Each is the calculation loop of the indicator moved into a class |
|
| //| that is fed ONE CLOSED BAR at a time. Range Filter uses RF.mqh. |
|
| //| A signal is reported for the bar just fed, which is always |
|
| //| closed, so nothing repaints. The Python statement of the three |
|
| //| engines is tests/reference.py. |
|
| //+------------------------------------------------------------------+
|
| // SPDX-License-Identifier: MPL-2.0
|
| // This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
|
| // distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/
|
| // Origin of the maths: UT Bot idea by Yo_adriiiiaan (from an original idea by HPotter), TradingView "UT Bot Alerts" by
|
| // QuantNomad; SuperTrend follows the widely published TradingView ATR-band script; Range Filter is an own implementation
|
| // of the published range-filter method.
|
| #ifndef ST_ENGINES_MQH
|
| #define ST_ENGINES_MQH
|
|
|
| #include "RF.mqh"
|
|
|
| #define ST_ATR_N 14 // the stop distance unit
|
|
|
| bool StAbove(const double a,const double b) { return(a-b>1e-10*MathAbs(b)); }
|
| bool StBelow(const double a,const double b) { return(b-a>1e-10*MathAbs(b)); }
|
|
|
| //--- bars fed so far plus Wilder ATR(14) (seeded with the SMA of the first 14 true ranges)
|
| class CEng
|
| {
|
| public:
|
| double o[],h[],l[],c[],atr[];
|
| int n,cap;
|
| CEng(void) { n=0; cap=0; }
|
| virtual ~CEng(void) {}
|
| void Clear(void) { n=0; cap=0; ArrayResize(o,0); ArrayResize(h,0); ArrayResize(l,0); ArrayResize(c,0); ArrayResize(atr,0); OnClear(); }
|
| virtual void OnClear(void) {}
|
| virtual void Grow(void)
|
| {
|
| if(n<cap)
|
| return;
|
| cap+=4096;
|
| ArrayResize(o,cap); ArrayResize(h,cap); ArrayResize(l,cap); ArrayResize(c,cap); ArrayResize(atr,cap);
|
| }
|
| double TR(const int k)
|
| {
|
| if(k==0)
|
| return(h[k]-l[k]);
|
| return(MathMax(h[k]-l[k],MathMax(MathAbs(h[k]-c[k-1]),MathAbs(l[k]-c[k-1]))));
|
| }
|
| //--- feed one closed bar; returns +1 buy, -1 sell, 0 none for that bar
|
| int Feed(const double O,const double H,const double L,const double C)
|
| {
|
| Grow();
|
| GrowState();
|
| int i=n;
|
| o[i]=O; h[i]=H; l[i]=L; c[i]=C;
|
| n++;
|
| if(i<ST_ATR_N-1)
|
| atr[i]=EMPTY_VALUE;
|
| else
|
| if(i==ST_ATR_N-1)
|
| {
|
| double s=0;
|
| for(int k=0; k<ST_ATR_N; k++)
|
| s+=TR(k);
|
| atr[i]=s/ST_ATR_N;
|
| }
|
| else
|
| atr[i]=(atr[i-1]*(ST_ATR_N-1)+TR(i))/ST_ATR_N;
|
| return(Step(i));
|
| }
|
| virtual void GrowState(void) {}
|
| virtual int Step(const int i) { return(0); }
|
| virtual string Describe(void) { return(""); }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| UT Bot (UTBotAlerts.mq5) |
|
| //+------------------------------------------------------------------+
|
| class CUtBot : public CEng
|
| {
|
| public:
|
| double InpKey;
|
| int InpATR;
|
| bool InpUseEMA;
|
| int InpEMA;
|
| double g_line[],g_atr[],g_ema[];
|
| CUtBot(const double key,const int atrp,const bool use_ema) { InpKey=key; InpATR=atrp; InpUseEMA=use_ema; InpEMA=200; }
|
| virtual void OnClear(void) { ArrayResize(g_line,0); ArrayResize(g_atr,0); ArrayResize(g_ema,0); }
|
| virtual void GrowState(void)
|
| {
|
| if(ArraySize(g_line)<cap)
|
| { ArrayResize(g_line,cap); ArrayResize(g_atr,cap); ArrayResize(g_ema,cap); }
|
| }
|
| virtual string Describe(void) { return(StringFormat("UT Bot %.1f/%d%s",InpKey,InpATR,InpUseEMA ? " EMA200" : "")); }
|
| virtual int Step(const int i)
|
| {
|
| //--- ATR: Wilder's smoothing of the true range, seeded with the SMA of the first InpATR values
|
| double tr=TR(i);
|
| if(i<InpATR-1)
|
| g_atr[i]=EMPTY_VALUE;
|
| else
|
| if(i==InpATR-1)
|
| {
|
| double s=0;
|
| for(int k=0; k<InpATR; k++)
|
| s+=TR(k);
|
| g_atr[i]=s/InpATR;
|
| }
|
| else
|
| g_atr[i]=(g_atr[i-1]*(InpATR-1)+tr)/InpATR;
|
| //--- EMA of the close, seeded with the SMA of the first InpEMA closes
|
| if(i<InpEMA-1)
|
| g_ema[i]=EMPTY_VALUE;
|
| else
|
| if(i==InpEMA-1)
|
| {
|
| double s=0;
|
| for(int k=0; k<InpEMA; k++)
|
| s+=c[k];
|
| g_ema[i]=s/InpEMA;
|
| }
|
| else
|
| g_ema[i]=g_ema[i-1]+2.0/(InpEMA+1)*(c[i]-g_ema[i-1]);
|
| //--- the trailing stop
|
| double prev=(i>0 ? g_line[i-1] : 0.0);
|
| if(g_atr[i]==EMPTY_VALUE)
|
| {
|
| g_line[i]=EMPTY_VALUE;
|
| return(0);
|
| }
|
| if(prev==EMPTY_VALUE)
|
| prev=0.0;
|
| double src=c[i],p1=(i>0 ? c[i-1] : src),nloss=InpKey*g_atr[i];
|
| if(src>prev && p1>prev)
|
| g_line[i]=MathMax(prev,src-nloss);
|
| else
|
| if(src<prev && p1<prev)
|
| g_line[i]=MathMin(prev,src+nloss);
|
| else
|
| g_line[i]=(src>prev ? src-nloss : src+nloss);
|
| if(i==0 || g_line[i-1]==EMPTY_VALUE)
|
| return(0);
|
| bool up=(src>g_line[i] && p1<=g_line[i-1]);
|
| bool dn=(src<g_line[i] && p1>=g_line[i-1]);
|
| if(InpUseEMA)
|
| {
|
| up=up && g_ema[i]!=EMPTY_VALUE && c[i]>g_ema[i];
|
| dn=dn && g_ema[i]!=EMPTY_VALUE && c[i]<g_ema[i];
|
| }
|
| return(up ? 1 : (dn ? -1 : 0));
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| SuperTrend (SuperTrendSignalAlerts.mq5, RMA ATR) |
|
| //+------------------------------------------------------------------+
|
| class CSuperTrend : public CEng
|
| {
|
| public:
|
| int InpATR;
|
| double InpMult;
|
| bool InpUseEMA;
|
| int InpEMA;
|
| double g_up[],g_dn[],g_trend[],g_atr[],g_ema[];
|
| CSuperTrend(const int atrp,const double mult,const bool use_ema) { InpATR=atrp; InpMult=mult; InpUseEMA=use_ema; InpEMA=200; }
|
| virtual void OnClear(void) { ArrayResize(g_up,0); ArrayResize(g_dn,0); ArrayResize(g_trend,0); ArrayResize(g_atr,0); ArrayResize(g_ema,0); }
|
| virtual void GrowState(void)
|
| {
|
| if(ArraySize(g_up)<cap)
|
| { ArrayResize(g_up,cap); ArrayResize(g_dn,cap); ArrayResize(g_trend,cap); ArrayResize(g_atr,cap); ArrayResize(g_ema,cap); }
|
| }
|
| virtual string Describe(void) { return(StringFormat("SuperTrend %d/%.1f%s",InpATR,InpMult,InpUseEMA ? " EMA200" : "")); }
|
| virtual int Step(const int i)
|
| {
|
| double tr=TR(i);
|
| g_atr[i]=EMPTY_VALUE;
|
| if(i>=InpATR-1)
|
| {
|
| if(i==InpATR-1)
|
| {
|
| double s=0;
|
| for(int k=i-InpATR+1; k<=i; k++)
|
| s+=TR(k);
|
| g_atr[i]=s/InpATR;
|
| }
|
| else
|
| g_atr[i]=(g_atr[i-1]*(InpATR-1)+tr)/InpATR;
|
| }
|
| if(i<InpEMA-1)
|
| g_ema[i]=EMPTY_VALUE;
|
| else
|
| if(i==InpEMA-1)
|
| {
|
| double s=0;
|
| for(int k=0; k<InpEMA; k++)
|
| s+=c[k];
|
| g_ema[i]=s/InpEMA;
|
| }
|
| else
|
| g_ema[i]=g_ema[i-1]+2.0/(InpEMA+1)*(c[i]-g_ema[i-1]);
|
| if(g_atr[i]==EMPTY_VALUE)
|
| {
|
| g_up[i]=EMPTY_VALUE;
|
| g_dn[i]=EMPTY_VALUE;
|
| g_trend[i]=EMPTY_VALUE;
|
| return(0);
|
| }
|
| double src=(h[i]+l[i])/2.0;
|
| double up=src-InpMult*g_atr[i];
|
| double dn=src+InpMult*g_atr[i];
|
| bool first=(i==0 || g_up[i-1]==EMPTY_VALUE);
|
| double up1=(first ? up : g_up[i-1]);
|
| double dn1=(first ? dn : g_dn[i-1]);
|
| if(i>0 && StAbove(c[i-1],up1))
|
| up=MathMax(up,up1);
|
| if(i>0 && StBelow(c[i-1],dn1))
|
| dn=MathMin(dn,dn1);
|
| double trend=(first ? 1.0 : g_trend[i-1]);
|
| if(trend==-1.0 && StAbove(c[i],dn1))
|
| trend=1.0;
|
| else
|
| if(trend==1.0 && StBelow(c[i],up1))
|
| trend=-1.0;
|
| g_up[i]=up;
|
| g_dn[i]=dn;
|
| g_trend[i]=trend;
|
| if(first)
|
| return(0);
|
| bool buy=(trend==1.0 && g_trend[i-1]==-1.0);
|
| bool sell=(trend==-1.0 && g_trend[i-1]==1.0);
|
| if(InpUseEMA)
|
| {
|
| buy=buy && g_ema[i]!=EMPTY_VALUE && c[i]>g_ema[i];
|
| sell=sell && g_ema[i]!=EMPTY_VALUE && c[i]<g_ema[i];
|
| }
|
| return(buy ? 1 : (sell ? -1 : 0));
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Range Filter (RF.mqh) |
|
| //+------------------------------------------------------------------+
|
| class CRangeFilter : public CEng
|
| {
|
| public:
|
| RFParams p;
|
| RFState s;
|
| CRangeFilter(const int period,const double mult) { p.period=period; p.mult=mult; RFInit(s); }
|
| virtual void OnClear(void) { RFInit(s); }
|
| virtual string Describe(void) { return(StringFormat("Range Filter %d/%.1f",p.period,p.mult)); }
|
| virtual int Step(const int i)
|
| {
|
| RFFeed(s,p,c[i]);
|
| return(s.ev);
|
| }
|
| };
|
|
|
| enum ENUM_ST_SOURCE
|
| {
|
| ST_SRC_UT=0, // UT Bot
|
| ST_SRC_ST=1, // SuperTrend
|
| ST_SRC_RF=2 // Range Filter
|
| };
|
|
|
| #endif
|
| //+------------------------------------------------------------------+
|
