chiki2bum2/Market_State_Board
Watch
1
0
Fork
You've already forked Market_State_Board
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Market_State_Board/Include/MarketStateBoard_MDM_PATCH19.mqh

573 lines
20 KiB
MQL5
Raw Permalink Blame History

//+------------------------------------------------------------------+
//| MarketStateBoard_MDM.mqh |
//| PATCH-19 - MDM News Dynamic |
//+------------------------------------------------------------------+
// Post-Base analytical layer: Base State -> Market Dynamics -> Final State.
// Types: CONTINUATION / DAMPENING / REVERSAL / UNRESOLVED.
// Strength: WEAK / STRONG / VERY STRONG / EXTREME.
// Numeric modifier is internal; it is not a probability/confidence/signal.
// FINAL invariants: Response > Event; session is context only; conflicts are
// unresolved rather than averaged away; weak/strong reversal cannot zero-cross.
// PATCH-19 News Dynamic: calendar information includes Actual/Forecast/Previous/
// Revised Previous, event importance/sector/type, surprise/revision/expectation
// shift and response phase. For CLOSED bars the full evaluated candle window is
// eligible; CURRENT bars are clamped to server-now so no future event is read.
// This include uses only primitive trend-direction codes (+1/-1/0) and does not
// access g_state[].
enum MSB_MDM_Type
{
MDM_CONTINUATION,
MDM_DAMPENING,
MDM_REVERSAL,
MDM_UNRESOLVED,
MDM_DATA_UNAVAILABLE
};
enum MSB_MDM_Strength
{
MDM_STRENGTH_NONE,
MDM_WEAK,
MDM_STRONG,
MDM_VERY_STRONG,
MDM_EXTREME
};
enum MSB_MDM_NewsPhase
{
MDM_NEWS_NONE,
MDM_NEWS_RELEASE_SHOCK,
MDM_NEWS_INITIAL_RESPONSE,
MDM_NEWS_CONFIRMED_RESPONSE
};
enum MSB_MDM_Authority
{
MDM_AUTH_NONE,
MDM_AUTH_DAMPEN_ONLY,
MDM_AUTH_MAGNITUDE_ADJUST,
MDM_AUTH_ZERO_CROSS_ALLOWED
};
struct MSB_MDM_Input
{
bool valid;
ENUM_TIMEFRAMES tf;
datetime selectedTime;
datetime evaluationEnd;
bool currentBar;
string symbol;
string baseCurrency;
string profitCurrency;
double open, high, low, close;
double previousOpen, previousHigh, previousLow, previousClose;
double range, bodyRatio, closeLocation, rangeAtrRatio, volumeRatio;
double compositeScore;
bool compositeValid;
int trendDirection; // +1 UP, -1 DOWN, 0 FLAT/other
double trendQuality;
bool trendValid;
};
struct MSB_MDM_State
{
bool valid;
MSB_MDM_Type type;
MSB_MDM_Strength strength;
MSB_MDM_Authority authority;
int direction;
double modifier;
int evidenceCount;
int continuationEvidence;
int dampeningEvidence;
int reversalEvidence;
bool sessionActive;
bool liquidityEvent;
bool participationEvent;
bool volatilityEvent;
bool newsEvent;
MSB_MDM_NewsPhase newsPhase;
int newsImportance;
int newsEventCount;
double newsSurprise;
double newsRevision;
double newsExpectationShift;
double newsShock;
string newsEventName;
string newsEventCode;
datetime newsEventTime;
bool newsHighImpact;
int newsEventType;
int newsSector;
int newsImpact;
bool responseConfirmed;
bool conflict;
string diagnostic;
};
MSB_MDM_Input MDM_InvalidInput()
{
MSB_MDM_Input x;
x.valid=false; x.tf=PERIOD_CURRENT; x.selectedTime=0; x.evaluationEnd=0; x.currentBar=false;
x.symbol=""; x.baseCurrency=""; x.profitCurrency="";
x.open=x.high=x.low=x.close=0.0;
x.previousOpen=x.previousHigh=x.previousLow=x.previousClose=0.0;
x.range=x.bodyRatio=x.closeLocation=x.rangeAtrRatio=x.volumeRatio=0.0;
x.compositeScore=0.0; x.compositeValid=false;
x.trendDirection=0; x.trendQuality=0.0; x.trendValid=false;
return x;
}
MSB_MDM_State MDM_InvalidState()
{
MSB_MDM_State m;
m.valid=false; m.type=MDM_DATA_UNAVAILABLE;
m.strength=MDM_STRENGTH_NONE; m.authority=MDM_AUTH_NONE;
m.direction=0; m.modifier=0.0; m.evidenceCount=0;
m.continuationEvidence=0; m.dampeningEvidence=0; m.reversalEvidence=0;
m.sessionActive=false; m.liquidityEvent=false; m.participationEvent=false;
m.volatilityEvent=false; m.newsEvent=false;
m.newsPhase=MDM_NEWS_NONE; m.newsImportance=0; m.newsEventCount=0;
m.newsSurprise=0.0; m.newsRevision=0.0; m.newsExpectationShift=0.0;
m.newsShock=0.0; m.newsEventName=""; m.newsEventCode=""; m.newsEventTime=0;
m.newsHighImpact=false; m.newsEventType=0; m.newsSector=0; m.newsImpact=0; m.responseConfirmed=false;
m.conflict=false; m.diagnostic="DATA UNAVAILABLE";
return m;
}
bool MDM_Finite(double v)
{
return (v==v) && (v<DBL_MAX) && (v>-DBL_MAX);
}
double MDM_Clamp(double v,double lo,double hi)
{
return MathMax(lo,MathMin(hi,v));
}
int MDM_StrengthRank(MSB_MDM_Strength s)
{
switch(s)
{
case MDM_WEAK: return 1;
case MDM_STRONG: return 2;
case MDM_VERY_STRONG: return 3;
case MDM_EXTREME: return 4;
default: return 0;
}
}
int MDM_Sign(double v)
{
if(v>0.0) return 1;
if(v<0.0) return -1;
return 0;
}
bool MDM_IsActiveSession(datetime t)
{
MqlDateTime dt;
TimeToStruct(t,dt);
// Trade-server-time activity windows are context only; they do not create
// bullish/bearish direction.
return ((dt.hour>=7 && dt.hour<11) ||
(dt.hour>=13 && dt.hour<17) ||
(dt.hour>=17 && dt.hour<21));
}
int MDM_PriceResponse(const MSB_MDM_Input &x)
{
if(!x.valid || x.range<=0.0) return 0;
int priorDir=MDM_Sign(x.previousClose-x.previousOpen);
int curDir=MDM_Sign(x.close-x.open);
if(curDir==0) return 0;
if(curDir>0 && x.closeLocation>=0.70) return 1;
if(curDir<0 && x.closeLocation<=0.30) return -1;
if(priorDir!=0 && curDir==-priorDir) return curDir;
return curDir;
}
int MDM_ImportanceRank(ENUM_CALENDAR_EVENT_IMPORTANCE importance)
{
switch(importance)
{
case CALENDAR_IMPORTANCE_HIGH: return 3;
case CALENDAR_IMPORTANCE_MODERATE: return 2;
case CALENDAR_IMPORTANCE_LOW: return 1;
default: return 0;
}
}
double MDM_NewsRelativeDiff(double a,double b)
{
if(!MDM_Finite(a) || !MDM_Finite(b)) return 0.0;
double denom=MathMax(MathMax(MathAbs(a),MathAbs(b)),1.0);
return MDM_Clamp(MathAbs(a-b)/denom,0.0,1.0);
}
bool MDM_CalendarCurrencyRelevant(const MqlCalendarEvent &event,const string &base,const string &profit)
{
MqlCalendarCountry country;
if(!CalendarCountryById(event.country_id,country)) return false;
if(base!="" && StringFind(country.currency,base)>=0) return true;
if(profit!="" && StringFind(country.currency,profit)>=0) return true;
// Preserve the project's XAUUSD focus even if symbol currency metadata is unavailable.
if(base=="" && profit=="" && StringFind("USD","USD")>=0) return (StringFind(country.currency,"USD")>=0);
return false;
}
int MDM_NewsCacheSlot(ENUM_TIMEFRAMES tf)
{
switch(tf)
{
case PERIOD_M1: return 0;
case PERIOD_M5: return 1;
case PERIOD_M15: return 2;
case PERIOD_M30: return 3;
case PERIOD_H1: return 4;
case PERIOD_H4: return 5;
case PERIOD_D1: return 6;
case PERIOD_W1: return 7;
case PERIOD_MN1: return 8;
default: return -1;
}
}
void MDM_CalendarShock(const MSB_MDM_Input &x,MSB_MDM_State &m)
{
static datetime cacheSelected[9];
static datetime cacheEnd[9];
static bool cacheCurrent[9];
static string cacheBase[9];
static string cacheProfit[9];
static MSB_MDM_State cacheState[9];
int slot=MDM_NewsCacheSlot(x.tf);
if(slot>=0 && cacheSelected[slot]==x.selectedTime &&
cacheEnd[slot]==x.evaluationEnd && cacheCurrent[slot]==x.currentBar &&
cacheBase[slot]==x.baseCurrency && cacheProfit[slot]==x.profitCurrency)
{
m.newsEvent=cacheState[slot].newsEvent;
m.newsPhase=cacheState[slot].newsPhase;
m.newsImportance=cacheState[slot].newsImportance;
m.newsEventCount=cacheState[slot].newsEventCount;
m.newsSurprise=cacheState[slot].newsSurprise;
m.newsRevision=cacheState[slot].newsRevision;
m.newsExpectationShift=cacheState[slot].newsExpectationShift;
m.newsShock=cacheState[slot].newsShock;
m.newsEventName=cacheState[slot].newsEventName;
m.newsEventCode=cacheState[slot].newsEventCode;
m.newsEventTime=cacheState[slot].newsEventTime;
m.newsHighImpact=cacheState[slot].newsHighImpact;
m.newsEventType=cacheState[slot].newsEventType;
m.newsSector=cacheState[slot].newsSector;
m.newsImpact=cacheState[slot].newsImpact;
return;
}
m.newsEvent=false;
m.newsPhase=MDM_NEWS_NONE;
m.newsImportance=0;
m.newsEventCount=0;
m.newsSurprise=0.0;
m.newsRevision=0.0;
m.newsExpectationShift=0.0;
m.newsShock=0.0;
m.newsEventName="";
m.newsEventCode="";
m.newsEventTime=0;
m.newsHighImpact=false;
m.newsEventType=0;
m.newsSector=0;
m.newsImpact=0;
if(x.selectedTime<=0) return;
datetime from=x.selectedTime-30*60;
datetime to=x.evaluationEnd;
if(to<=x.selectedTime) to=x.selectedTime;
if(x.currentBar)
{
datetime now=TimeTradeServer();
if(now<=0) now=TimeCurrent();
if(now>0) to=MathMin(to,now);
}
if(to<from) return;
// Calendar functions use trade-server time. Query both symbol currencies when
// available; duplicates are harmless because we select the strongest event.
string currencies[2];
currencies[0]=x.baseCurrency;
currencies[1]=x.profitCurrency;
if(currencies[0]=="" && currencies[1]=="") currencies[0]="USD";
double bestShock=0.0;
for(int pass=0;pass<2;pass++)
{
string currency=currencies[pass];
if(currency=="") continue;
if(pass==1 && currencies[1]==currencies[0]) continue;
MqlCalendarValue values[];
int n=CalendarValueHistory(values,from,to,NULL,currency);
if(n<=0) continue;
for(int i=0;i<n;i++)
{
if(values[i].time<from || values[i].time>to) continue;
if(!values[i].HasActualValue()) continue;
MqlCalendarEvent event;
if(!CalendarEventById(values[i].event_id,event)) continue;
if(!MDM_CalendarCurrencyRelevant(event,x.baseCurrency,x.profitCurrency) &&
!(x.baseCurrency=="" && x.profitCurrency=="" && currency=="USD")) continue;
double actual=values[i].GetActualValue();
if(!MDM_Finite(actual)) continue;
bool hasForecast=values[i].HasForecastValue();
bool hasPrevious=values[i].HasPreviousValue();
bool hasRevised=values[i].HasRevisedValue();
double forecast=hasForecast ? values[i].GetForecastValue() : 0.0;
double previous=hasPrevious ? values[i].GetPreviousValue() : 0.0;
double revised=hasRevised ? values[i].GetRevisedValue() : 0.0;
double surprise=hasForecast ? MDM_NewsRelativeDiff(actual,forecast) : 0.0;
double change=hasPrevious ? MDM_NewsRelativeDiff(actual,previous) : 0.0;
double revision=(hasRevised && hasPrevious) ? MDM_NewsRelativeDiff(revised,previous) : 0.0;
double expectation=(hasForecast && hasPrevious) ? MDM_NewsRelativeDiff(forecast,previous) : 0.0;
int importance=MDM_ImportanceRank(event.importance);
if(importance<=0) continue;
// Materiality is information-content based, not a directional forecast.
// A high-importance event remains relevant even when its surprise is small.
double material=MathMax(surprise,revision);
if(material<=0.0 && expectation<=0.0) material=MathMin(change,0.25);
// Importance determines relevance, but does not fabricate surprise.
// A high-impact event with no measurable information change is retained
// only as context when Actual/Forecast/Previous are present, not as shock.
double shock=(double)importance/3.0 * MDM_Clamp(material*2.0,0.0,1.0);
if(shock<=0.05) continue;
datetime eventEnd=x.evaluationEnd;
if(eventEnd<=values[i].time) eventEnd=values[i].time+1;
int age=(int)(eventEnd-values[i].time);
MSB_MDM_NewsPhase phase=MDM_NEWS_CONFIRMED_RESPONSE;
if(age<=5*60) phase=MDM_NEWS_RELEASE_SHOCK;
else if(age<=30*60) phase=MDM_NEWS_INITIAL_RESPONSE;
m.newsEventCount++;
if(shock>bestShock)
{
bestShock=shock;
m.newsEvent=true;
m.newsImportance=importance;
m.newsSurprise=surprise;
m.newsRevision=revision;
m.newsExpectationShift=expectation;
m.newsShock=shock;
m.newsEventName=event.name;
m.newsEventCode=event.event_code;
m.newsEventTime=values[i].time;
m.newsPhase=phase;
m.newsHighImpact=(importance>=3);
m.newsEventType=(int)event.type;
m.newsSector=(int)event.sector;
m.newsImpact=(int)values[i].impact_type;
}
}
}
if(slot>=0)
{
cacheSelected[slot]=x.selectedTime;
cacheEnd[slot]=x.evaluationEnd;
cacheCurrent[slot]=x.currentBar;
cacheBase[slot]=x.baseCurrency;
cacheProfit[slot]=x.profitCurrency;
cacheState[slot]=MDM_InvalidState();
cacheState[slot].newsEvent=m.newsEvent;
cacheState[slot].newsPhase=m.newsPhase;
cacheState[slot].newsImportance=m.newsImportance;
cacheState[slot].newsEventCount=m.newsEventCount;
cacheState[slot].newsSurprise=m.newsSurprise;
cacheState[slot].newsRevision=m.newsRevision;
cacheState[slot].newsExpectationShift=m.newsExpectationShift;
cacheState[slot].newsShock=m.newsShock;
cacheState[slot].newsEventName=m.newsEventName;
cacheState[slot].newsEventCode=m.newsEventCode;
cacheState[slot].newsEventTime=m.newsEventTime;
cacheState[slot].newsHighImpact=m.newsHighImpact;
cacheState[slot].newsEventType=m.newsEventType;
cacheState[slot].newsSector=m.newsSector;
cacheState[slot].newsImpact=m.newsImpact;
}
}
MSB_MDM_State MDM_Compute(const MSB_MDM_Input &x)
{
MSB_MDM_State m=MDM_InvalidState();
if(!x.valid || !x.compositeValid || !MDM_Finite(x.compositeScore) ||
x.compositeScore<-1.0 || x.compositeScore>1.0 || x.range<=0.0 ||
!MDM_Finite(x.closeLocation) || !MDM_Finite(x.rangeAtrRatio) ||
!MDM_Finite(x.volumeRatio)) return m;
m.valid=true;
m.sessionActive=MDM_IsActiveSession(x.selectedTime);
int baseDir=MDM_Sign(x.compositeScore);
int responseDir=MDM_PriceResponse(x);
MDM_CalendarShock(x,m);
// Liquidity-response proxy: sweep previous extreme and close back inside.
bool sweepUp=(x.high>x.previousHigh && x.close<x.previousHigh);
bool sweepDn=(x.low<x.previousLow && x.close>x.previousLow);
m.liquidityEvent=(sweepUp || sweepDn);
int sweepDir=0;
if(sweepUp && !sweepDn) sweepDir=-1;
if(sweepDn && !sweepUp) sweepDir=1;
m.participationEvent=(x.volumeRatio>=1.30);
m.volatilityEvent=(x.rangeAtrRatio>=1.30);
// Response > event. The candle response establishes the primary dynamic
// direction; event families can only add one reinforcing point each.
if(baseDir!=0 && responseDir==baseDir) m.continuationEvidence++;
if(baseDir!=0 && responseDir==-baseDir) m.reversalEvidence++;
if(baseDir!=0 && responseDir==0) m.dampeningEvidence++;
if(sweepDir!=0 && baseDir!=0)
{
if(sweepDir==-baseDir) m.reversalEvidence++;
else m.continuationEvidence++;
}
if(m.participationEvent && responseDir==baseDir && baseDir!=0)
m.continuationEvidence++;
if(m.volatilityEvent && responseDir==-baseDir && baseDir!=0)
m.reversalEvidence++;
if(m.newsEvent && responseDir==baseDir && baseDir!=0)
m.continuationEvidence++;
if(m.newsEvent && responseDir==-baseDir && baseDir!=0)
m.reversalEvidence++;
// Trend is confirmation only and never establishes direction.
if(x.trendValid && x.trendQuality>=0.70 && baseDir!=0)
{
if((baseDir>0 && x.trendDirection>0) ||
(baseDir<0 && x.trendDirection<0)) m.continuationEvidence++;
else if((baseDir>0 && x.trendDirection<0) ||
(baseDir<0 && x.trendDirection>0)) m.reversalEvidence++;
}
// Weak base + simultaneous compression/low participation = dampening.
if(baseDir!=0 && MathAbs(x.compositeScore)<0.30 &&
x.volumeRatio<0.70 && x.rangeAtrRatio<0.70)
m.dampeningEvidence++;
int c=m.continuationEvidence, r=m.reversalEvidence, d=m.dampeningEvidence;
m.evidenceCount=c+r+d;
m.responseConfirmed=(responseDir!=0);
// Contradictory branches are not averaged away.
if(c>0 && r>0 && MathAbs(c-r)<2)
{
m.conflict=true; m.type=MDM_UNRESOLVED; m.strength=MDM_WEAK;
m.authority=MDM_AUTH_DAMPEN_ONLY; m.direction=baseDir; m.modifier=0.0;
m.diagnostic="CONFLICT / UNRESOLVED";
return m;
}
if(r>0 && r>c && r>=d)
{
m.type=MDM_REVERSAL; m.direction=-baseDir;
if(r>=4 && (m.liquidityEvent || m.newsEvent || m.volatilityEvent)) m.strength=MDM_EXTREME;
else if(r>=3) m.strength=MDM_VERY_STRONG;
else if(r>=2) m.strength=MDM_STRONG;
else m.strength=MDM_WEAK;
}
else if(c>0 && c>r && c>=d)
{
m.type=MDM_CONTINUATION; m.direction=baseDir;
if(c>=4 && (m.participationEvent || m.volatilityEvent || m.newsEvent)) m.strength=MDM_EXTREME;
else if(c>=3) m.strength=MDM_VERY_STRONG;
else if(c>=2) m.strength=MDM_STRONG;
else m.strength=MDM_WEAK;
}
else if(d>0)
{
m.type=MDM_DAMPENING; m.direction=baseDir;
if(d>=3) m.strength=MDM_VERY_STRONG;
else if(d>=2) m.strength=MDM_STRONG;
else m.strength=MDM_WEAK;
}
else
{
m.type=MDM_UNRESOLVED; m.strength=MDM_WEAK; m.authority=MDM_AUTH_NONE;
m.direction=baseDir; m.modifier=0.0; m.diagnostic="NO COHERENT DYNAMIC";
return m;
}
if(m.type==MDM_REVERSAL)
{
if(m.strength==MDM_WEAK) m.authority=MDM_AUTH_DAMPEN_ONLY;
else if(m.strength==MDM_STRONG) m.authority=MDM_AUTH_MAGNITUDE_ADJUST;
else m.authority=MDM_AUTH_ZERO_CROSS_ALLOWED;
}
else if(m.type==MDM_CONTINUATION) m.authority=MDM_AUTH_MAGNITUDE_ADJUST;
else if(m.type==MDM_DAMPENING) m.authority=MDM_AUTH_DAMPEN_ONLY;
else m.authority=MDM_AUTH_NONE;
if(m.type==MDM_CONTINUATION)
{
if(m.strength==MDM_WEAK) m.modifier=0.15*baseDir;
else if(m.strength==MDM_STRONG) m.modifier=0.30*baseDir;
else if(m.strength==MDM_VERY_STRONG) m.modifier=0.45*baseDir;
else m.modifier=0.60*baseDir;
}
else if(m.type==MDM_DAMPENING)
{
if(m.strength==MDM_WEAK) m.modifier=-0.15*baseDir;
else if(m.strength==MDM_STRONG) m.modifier=-0.30*baseDir;
else if(m.strength==MDM_VERY_STRONG) m.modifier=-0.45*baseDir;
else m.modifier=-0.60*baseDir;
}
else if(m.type==MDM_REVERSAL)
{
if(m.strength==MDM_WEAK) m.modifier=-0.15*baseDir;
else if(m.strength==MDM_STRONG) m.modifier=-0.35*baseDir;
else if(m.strength==MDM_VERY_STRONG) m.modifier=-0.70*baseDir;
else m.modifier=-1.00*baseDir;
}
m.modifier=MDM_Clamp(m.modifier,-1.0,1.0);
m.diagnostic="PATCH-19 NEWS DYNAMIC / MDM";
return m;
}
double MDM_ApplyToBase(const MSB_MDM_State &m,double baseScore)
{
if(!m.valid || !MDM_Finite(baseScore) || baseScore<-1.0 || baseScore>1.0)
return baseScore;
if(m.type==MDM_UNRESOLVED || m.type==MDM_DATA_UNAVAILABLE) return baseScore;
if(m.type==MDM_CONTINUATION)
{
double mag=MathAbs(baseScore);
mag=MDM_Clamp(mag+(1.0-mag)*MathAbs(m.modifier),0.0,1.0);
return (baseScore>=0.0 ? mag : -mag);
}
if(m.type==MDM_DAMPENING)
{
double mag=MathAbs(baseScore);
mag=MDM_Clamp(mag*(1.0-MathAbs(m.modifier)),0.0,1.0);
return (baseScore>=0.0 ? mag : -mag);
}
// Weak/strong reversal may damp only. Very-strong/extreme may cross zero.
if(m.authority!=MDM_AUTH_ZERO_CROSS_ALLOWED)
{
double mag=MathAbs(baseScore)*(1.0-MathAbs(m.modifier));
return (baseScore>=0.0 ? mag : -mag);
}
return MDM_Clamp(baseScore+m.modifier,-1.0,1.0);
}
Reference in a new issue View git blame Copy permalink