| //+------------------------------------------------------------------+
|
| //| Exhaust.mqh |
|
| //| Copyright 2026, Allan Niñal |
|
| //| https://www.allanninal.dev/mql5 |
|
| //+------------------------------------------------------------------+
|
| //| Fibonacci-extension EXHAUSTION marker, one CLOSED bar per step |
|
| //| (no repaint), used by Harmonic Signal Alerts. |
|
| //| Spec: docs/SPEC.md ("Exhaustion marker"); tested against |
|
| //| exh_stream() in tests/reference.py. |
|
| //| |
|
| //| Swings: a pivot with `w` bars on each side (not strictly: equal |
|
| //| prices count), known `w` bars later, added in the order they are |
|
| //| confirmed to an alternating sequence (two highs in a row keep |
|
| //| the higher, two lows the lower). Whenever the sequence changes |
|
| //| and its last three points A-B-C are an impulse plus a pullback |
|
| //| (top case: A low, B high, C a higher low below B; the bottom case|
|
| //| mirrors it) a setup is armed on that bar with |
|
| //| E = C + 2.618 x (B - A). It is cancelled if price trades beyond C|
|
| //| first or after 300 bars. When price reaches E the setup is |
|
| //| touched; within 10 bars after the touch the first close beyond |
|
| //| the extreme of the previous 3 bars (top: below their lowest low) |
|
| //| is the exhaustion signal. A setup signals once; several setups |
|
| //| on one bar count once. Optional confluence: at least `conf` |
|
| //| earlier swing pivots (up to 250 bars before A) within 0.5 ATR(14)|
|
| //| of the 100 / 161.8 / 261.8 % levels. |
|
| //| The sequence is built bar by bar from confirmed pivots only, so |
|
| //| a later swing never removes a setup that was already armed. |
|
| //| Analysis marker, not a trading system: on 37 symbols, H1/H4/D1 |
|
| //| it showed no edge as a trade rule. |
|
| //+------------------------------------------------------------------+
|
| // SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0 (see LICENSE)
|
| #ifndef EXHAUST_MQH
|
| #define EXHAUST_MQH
|
|
|
| #define EX_N 128 // ring of recent bars (2 x w + 2 must stay below it)
|
| #define EX_ATRN 14
|
| #define EX_LIFE 300 // bars a setup waits for the touch
|
| #define EX_WINDOW 10 // bars after the touch in which the signal must come
|
| #define EX_REF 3 // the signal closes beyond the extreme of this many previous bars
|
| #define EX_PRIOR 250 // confluence looks this many bars before A
|
| #define EX_STOPATR 0.25 // invalidation level beyond the extreme, x ATR(14)
|
| #define EX_MAXW 30
|
|
|
| struct EXParams
|
| {
|
| int w; // pivot bars on each side (2 - EX_MAXW)
|
| int conf; // earlier swings needed near the levels (0 = not required)
|
| };
|
|
|
| struct EXSwing
|
| {
|
| int bar,conf_bar,type; // pivot bar, bar it was confirmed on, 1 high / -1 low
|
| double px;
|
| };
|
|
|
| struct EXPivot
|
| {
|
| int bar;
|
| double px;
|
| };
|
|
|
| struct EXSetup
|
| {
|
| int s; // +1 top case (E above), -1 bottom case
|
| int ab,bb,cb,armed,touch; // touch = -1 until E is reached
|
| double ap,bp,cp,e,ext;
|
| };
|
|
|
| struct EXEvent
|
| {
|
| int bar,dir; // signal bar; direction of the signal: -1 down (after a top), +1 up
|
| int ab,bb,cb,armed,touch;
|
| double ap,bp,cp,e,ext,stop;
|
| };
|
|
|
| struct EXState
|
| {
|
| int cnt; // bars fed
|
| double h[EX_N],l[EX_N],c[EX_N];
|
| EXSwing sq[3];
|
| int nsq;
|
| EXPivot pv[];
|
| int npv;
|
| EXSetup st[];
|
| int nst;
|
| int armed_total; // setups armed so far
|
| bool fired; // the last bar gave a signal: ev
|
| EXEvent ev;
|
| int last_dir,last_bar; // the latest signal (engine bar), -1 none
|
| EXEvent last;
|
| };
|
|
|
| void EXInit(EXState &s)
|
| {
|
| s.cnt=0; s.nsq=0; s.npv=0; s.nst=0; s.armed_total=0; s.fired=false; s.last_dir=0; s.last_bar=-1;
|
| ArrayResize(s.pv,0); // the reserve is given on the first growth (EXPivotIn, EXArm): a cell with the marker off holds no memory for it
|
| ArrayResize(s.st,0);
|
| }
|
|
|
| double EXH(const EXState &s,const int k) { return(s.h[k%EX_N]); }
|
| double EXL(const EXState &s,const int k) { return(s.l[k%EX_N]); }
|
| double EXC(const EXState &s,const int k) { return(s.c[k%EX_N]); }
|
|
|
| //--- ATR(14) = mean of the last 14 true ranges ending at bar k (iATR); EMPTY_VALUE before bar 13
|
| double EXAtr(const EXState &s,const int k)
|
| {
|
| if(k<EX_ATRN-1)
|
| return(EMPTY_VALUE);
|
| double sum=0;
|
| for(int i=k-EX_ATRN+1; i<=k; i++)
|
| {
|
| double t=(i==0 ? EXH(s,i)-EXL(s,i) :
|
| MathMax(EXH(s,i)-EXL(s,i),MathMax(MathAbs(EXH(s,i)-EXC(s,i-1)),MathAbs(EXL(s,i)-EXC(s,i-1)))));
|
| sum+=t;
|
| }
|
| return(sum/EX_ATRN);
|
| }
|
|
|
| //--- the sequence changed on bar b: arm a setup when A-B-C is an impulse plus a pullback
|
| void EXArm(EXState &s,const EXParams &p,const int b)
|
| {
|
| if(s.nsq<3)
|
| return;
|
| EXSwing A=s.sq[0],B=s.sq[1],C=s.sq[2];
|
| int sd=B.type;
|
| if(!(sd>0 ? (A.px<C.px && C.px<B.px) : (B.px<C.px && C.px<A.px)))
|
| return;
|
| double atr=EXAtr(s,b);
|
| if(atr==EMPTY_VALUE)
|
| return;
|
| double leg=MathAbs(B.px-A.px);
|
| if(p.conf>0)
|
| {
|
| double lv[3]={C.px+sd*1.0*leg,C.px+sd*1.618*leg,C.px+sd*2.618*leg};
|
| int near=0;
|
| for(int i=0; i<s.npv; i++)
|
| if(s.pv[i].bar>=A.bar-EX_PRIOR && s.pv[i].bar<A.bar)
|
| {
|
| double d=MathMin(MathAbs(s.pv[i].px-lv[0]),MathMin(MathAbs(s.pv[i].px-lv[1]),MathAbs(s.pv[i].px-lv[2])));
|
| if(d<=0.5*atr)
|
| near++;
|
| }
|
| if(near<p.conf)
|
| return;
|
| }
|
| int k=s.nst;
|
| ArrayResize(s.st,k+1,64);
|
| s.st[k].s=sd; s.st[k].ab=A.bar; s.st[k].bb=B.bar; s.st[k].cb=C.bar; s.st[k].armed=b; s.st[k].touch=-1;
|
| s.st[k].ap=A.px; s.st[k].bp=B.px; s.st[k].cp=C.px; s.st[k].e=C.px+sd*2.618*leg; s.st[k].ext=0;
|
| s.nst++;
|
| s.armed_total++;
|
| }
|
|
|
| //--- one confirmed pivot (type, bar j, price px) confirmed on bar b
|
| void EXPivotIn(EXState &s,const EXParams &p,const int typ,const int j,const double px,const int b)
|
| {
|
| int k=s.npv;
|
| ArrayResize(s.pv,k+1,512);
|
| s.pv[k].bar=j; s.pv[k].px=px;
|
| s.npv++;
|
| bool changed=false;
|
| if(s.nsq>0 && s.sq[s.nsq-1].type==typ)
|
| {
|
| if(typ>0 ? px>=s.sq[s.nsq-1].px : px<=s.sq[s.nsq-1].px)
|
| {
|
| s.sq[s.nsq-1].bar=j; s.sq[s.nsq-1].conf_bar=b; s.sq[s.nsq-1].px=px;
|
| changed=true;
|
| }
|
| }
|
| else
|
| if(!(s.nsq>0 && s.sq[s.nsq-1].bar==j))
|
| {
|
| if(s.nsq==3)
|
| {
|
| s.sq[0]=s.sq[1]; s.sq[1]=s.sq[2];
|
| s.nsq--;
|
| }
|
| s.sq[s.nsq].bar=j; s.sq[s.nsq].conf_bar=b; s.sq[s.nsq].px=px; s.sq[s.nsq].type=typ;
|
| s.nsq++;
|
| changed=true;
|
| }
|
| if(changed)
|
| EXArm(s,p,b);
|
| }
|
|
|
| //--- feed one CLOSED bar; true when it gave an exhaustion signal (s.ev)
|
| bool EXFeed(EXState &s,const EXParams &p,const double high,const double low,const double close)
|
| {
|
| int b=s.cnt;
|
| s.h[b%EX_N]=high; s.l[b%EX_N]=low; s.c[b%EX_N]=close;
|
| s.cnt++;
|
| s.fired=false;
|
| //--- pivot confirmed on this bar: j = b - w
|
| int j=b-p.w;
|
| if(j>=p.w)
|
| {
|
| double mh=EXH(s,j),ml=EXL(s,j);
|
| for(int i=j-p.w; i<=b; i++)
|
| {
|
| if(EXH(s,i)>mh) mh=EXH(s,i);
|
| if(EXL(s,i)<ml) ml=EXL(s,i);
|
| }
|
| if(EXH(s,j)==mh)
|
| EXPivotIn(s,p,1,j,EXH(s,j),b);
|
| if(EXL(s,j)==ml)
|
| EXPivotIn(s,p,-1,j,EXL(s,j),b);
|
| }
|
| if(s.nsq>0) // pivots older than any later A - 250 are never read again
|
| {
|
| int lo=s.sq[0].bar-EX_PRIOR,m=0;
|
| for(int i=0; i<s.npv; i++)
|
| if(s.pv[i].bar>=lo)
|
| s.pv[m++]=s.pv[i];
|
| s.npv=m;
|
| }
|
| //--- setups take this bar, in the order they were armed
|
| double atr=EXAtr(s,b);
|
| int w=0;
|
| for(int i=0; i<s.nst; i++)
|
| {
|
| EXSetup st=s.st[i];
|
| int sg=st.s;
|
| if(st.touch<0)
|
| {
|
| if(b<=st.armed)
|
| { s.st[w++]=st; continue; }
|
| if(b>st.armed+EX_LIFE || (sg>0 ? low<st.cp : high>st.cp))
|
| continue;
|
| if(sg>0 ? high>=st.e : low<=st.e)
|
| { st.touch=b; st.ext=(sg>0 ? high : low); }
|
| s.st[w++]=st;
|
| continue;
|
| }
|
| st.ext=(sg>0 ? MathMax(st.ext,high) : MathMin(st.ext,low));
|
| if(b>st.touch+EX_WINDOW)
|
| continue;
|
| double ref=(sg>0 ? EXL(s,b-1) : EXH(s,b-1));
|
| for(int q=2; q<=EX_REF; q++)
|
| ref=(sg>0 ? MathMin(ref,EXL(s,b-q)) : MathMax(ref,EXH(s,b-q)));
|
| if(sg>0 ? close<ref : close>ref)
|
| {
|
| if(!s.fired && atr!=EMPTY_VALUE)
|
| {
|
| s.fired=true;
|
| s.ev.bar=b; s.ev.dir=-sg; s.ev.ab=st.ab; s.ev.bb=st.bb; s.ev.cb=st.cb; s.ev.armed=st.armed; s.ev.touch=st.touch;
|
| s.ev.ap=st.ap; s.ev.bp=st.bp; s.ev.cp=st.cp; s.ev.e=st.e; s.ev.ext=st.ext;
|
| s.ev.stop=st.ext+sg*EX_STOPATR*atr;
|
| }
|
| continue; // a setup signals once
|
| }
|
| s.st[w++]=st;
|
| }
|
| s.nst=w;
|
| if(s.fired)
|
| {
|
| s.last=s.ev; s.last_dir=s.ev.dir; s.last_bar=b;
|
| }
|
| return(s.fired);
|
| }
|
|
|
| #endif
|
| //+------------------------------------------------------------------+
|
9249455712