Pietro GiacobazziandDevin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
f1d1a2230f
Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
369 lines
12 KiB
Plaintext
369 lines
12 KiB
Plaintext
//+------------------------------------------------------------------+
|
|
//| PaPP_Median.mq5 |
|
|
//| PaPP v2 |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "PaPP v2"
|
|
#property version "2.00"
|
|
#property description "PaPP Median - Mediana 7 MA (3g-1y)"
|
|
#property description "Calcolo ancorato a D1 = linea uguale su ogni timeframe"
|
|
#property indicator_chart_window
|
|
#property indicator_buffers 8
|
|
#property indicator_plots 8
|
|
|
|
input int FontSize = 9;
|
|
input bool Smooth = true; // interpola tra i valori D1 -> linea morbida
|
|
input bool ShowMA = true; // mostra anche le 7 MA (oltre alla mediana)
|
|
|
|
#define ANCHOR_TF PERIOD_D1 // calcolo ancorato a D1: linea identica su ogni TF
|
|
|
|
double Buff_Median[];
|
|
double B0[],B1[],B2[],B3[],B4[],B5[],B6[];
|
|
|
|
int gDays[7] = {365,182,121,30,14,7,3};
|
|
color gCol[7] = {clrDodgerBlue,clrDeepSkyBlue,clrTurquoise,clrLimeGreen,clrOrange,clrTomato,clrRed};
|
|
int hMA[7];
|
|
int bars[7];
|
|
string _pfx = "PM_"; // oggetti pannello
|
|
string _pfx2 = "PME_"; // etichette a fine linea
|
|
|
|
//+------------------------------------------------------------------+
|
|
// scrive il valore nel buffer della MA m
|
|
void SetBuf(int m,int idx,double v)
|
|
{
|
|
switch(m)
|
|
{
|
|
case 0: B0[idx]=v; break;
|
|
case 1: B1[idx]=v; break;
|
|
case 2: B2[idx]=v; break;
|
|
case 3: B3[idx]=v; break;
|
|
case 4: B4[idx]=v; break;
|
|
case 5: B5[idx]=v; break;
|
|
case 6: B6[idx]=v; break;
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
// legge il valore corrente (barra 0) del buffer della MA m
|
|
double GetBuf(int m)
|
|
{
|
|
switch(m)
|
|
{
|
|
case 0: return B0[0];
|
|
case 1: return B1[0];
|
|
case 2: return B2[0];
|
|
case 3: return B3[0];
|
|
case 4: return B4[0];
|
|
case 5: return B5[0];
|
|
case 6: return B6[0];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
int TimeToBars(int d)
|
|
{
|
|
datetime n = TimeCurrent();
|
|
if(n==0)
|
|
{
|
|
long s = (long)d*86400L, p = PeriodSeconds(ANCHOR_TF);
|
|
return (int)MathMax(1,s/p);
|
|
}
|
|
return MathMax(1,Bars(_Symbol,ANCHOR_TF,n-d*86400,n));
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
for(int i=0;i<7;i++)
|
|
{
|
|
bars[i] = TimeToBars(gDays[i]);
|
|
hMA[i] = iMA(_Symbol,ANCHOR_TF,bars[i],0,MODE_SMA,PRICE_CLOSE);
|
|
if(hMA[i]==INVALID_HANDLE) return INIT_FAILED;
|
|
}
|
|
|
|
SetIndexBuffer(0,Buff_Median,INDICATOR_DATA);
|
|
SetIndexBuffer(1,B0,INDICATOR_DATA);
|
|
SetIndexBuffer(2,B1,INDICATOR_DATA);
|
|
SetIndexBuffer(3,B2,INDICATOR_DATA);
|
|
SetIndexBuffer(4,B3,INDICATOR_DATA);
|
|
SetIndexBuffer(5,B4,INDICATOR_DATA);
|
|
SetIndexBuffer(6,B5,INDICATOR_DATA);
|
|
SetIndexBuffer(7,B6,INDICATOR_DATA);
|
|
ArraySetAsSeries(Buff_Median,true);
|
|
ArraySetAsSeries(B0,true); ArraySetAsSeries(B1,true);
|
|
ArraySetAsSeries(B2,true); ArraySetAsSeries(B3,true);
|
|
ArraySetAsSeries(B4,true); ArraySetAsSeries(B5,true);
|
|
ArraySetAsSeries(B6,true);
|
|
|
|
//--- plot 0 = mediana (linea principale)
|
|
PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_LINE);
|
|
PlotIndexSetInteger(0,PLOT_LINE_COLOR,clrGold);
|
|
PlotIndexSetInteger(0,PLOT_LINE_WIDTH,2);
|
|
PlotIndexSetString(0,PLOT_LABEL,"PaPP Median");
|
|
PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
|
|
|
|
//--- plot 1..7 = le 7 MA
|
|
for(int p=0;p<7;p++)
|
|
{
|
|
PlotIndexSetInteger(p+1,PLOT_DRAW_TYPE,ShowMA?DRAW_LINE:DRAW_NONE);
|
|
PlotIndexSetInteger(p+1,PLOT_LINE_COLOR,gCol[p]);
|
|
PlotIndexSetInteger(p+1,PLOT_LINE_WIDTH,1);
|
|
PlotIndexSetString(p+1,PLOT_LABEL,"MA "+IntegerToString(gDays[p])+"g");
|
|
PlotIndexSetDouble(p+1,PLOT_EMPTY_VALUE,0.0);
|
|
}
|
|
|
|
IndicatorSetString(INDICATOR_SHORTNAME,"PaPP Median");
|
|
return INIT_SUCCEEDED;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
for(int i=0;i<7;i++) if(hMA[i]!=INVALID_HANDLE) IndicatorRelease(hMA[i]);
|
|
ObjectsDeleteAll(0,_pfx);
|
|
ObjectsDeleteAll(0,_pfx2);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
// d1shift = indice (serie) della barra D1 da cui leggere la SMA
|
|
double GetMA(int m,int d1shift)
|
|
{
|
|
if(d1shift<0) return 0;
|
|
double buf[1];
|
|
if(CopyBuffer(hMA[m],0,d1shift,1,buf)==1) return buf[0];
|
|
return 0;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
double Median(double &a[],int n)
|
|
{
|
|
if(n<=0) return 0;
|
|
ArraySort(a);
|
|
if((n&1)==1) return a[n/2];
|
|
return 0.5*(a[n/2-1]+a[n/2]);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
// Mediana delle 7 MA su una specifica barra D1
|
|
double MedianAtD1(int d1shift)
|
|
{
|
|
if(d1shift<0) return 0;
|
|
double vals[]; int cnt=0; ArrayResize(vals,7);
|
|
for(int m=0;m<7;m++) { double v=GetMA(m,d1shift); if(v>0) { vals[cnt]=v; cnt++; } }
|
|
ArrayResize(vals,cnt);
|
|
return Median(vals,cnt);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
// interpolazione lineare con fallback se uno dei valori manca
|
|
double Interp(double vStart,double vEnd,double frac)
|
|
{
|
|
if(vStart>0 && vEnd>0) return vStart+frac*(vEnd-vStart);
|
|
if(vEnd>0) return vEnd;
|
|
return vStart;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
// Mediana dei primi n valori di src
|
|
double MedianN(const double &src[],int n)
|
|
{
|
|
if(n<=0) return 0;
|
|
double a[]; ArrayResize(a,n);
|
|
for(int i=0;i<n;i++) a[i]=src[i];
|
|
ArraySort(a);
|
|
if((n&1)==1) return a[n/2];
|
|
return 0.5*(a[n/2-1]+a[n/2]);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
int OnCalculate(const int rates_total,
|
|
const int prev_calculated,
|
|
const datetime &time[],
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &low[],
|
|
const double &close[],
|
|
const long &tick_volume[],
|
|
const long &volume[],
|
|
const int &spread[])
|
|
{
|
|
if(rates_total<2) return 0;
|
|
ArraySetAsSeries(close,true);
|
|
ArraySetAsSeries(time,true);
|
|
|
|
//--- i dati D1 devono essere pronti, altrimenti ritenta al prossimo tick
|
|
int d1bars = Bars(_Symbol,ANCHOR_TF);
|
|
if(d1bars<2) return 0;
|
|
if(BarsCalculated(hMA[0])<=0) return 0;
|
|
|
|
//--- carica le 7 MA D1 in blocco e calcola la mediana per ogni barra D1
|
|
double med_d1[]; ArrayResize(med_d1,d1bars); ArraySetAsSeries(med_d1,true);
|
|
double cols[][7]; ArrayResize(cols,d1bars);
|
|
for(int m=0;m<7;m++)
|
|
{
|
|
double tmp[]; ArraySetAsSeries(tmp,true);
|
|
int got = CopyBuffer(hMA[m],0,0,d1bars,tmp);
|
|
if(got<=0) return 0; // non pronto: ritenta
|
|
for(int s=0;s<d1bars;s++) cols[s][m] = (s<got) ? tmp[s] : 0.0;
|
|
}
|
|
for(int s=0;s<d1bars;s++)
|
|
{
|
|
double vv[7]; int c=0;
|
|
for(int m=0;m<7;m++) if(cols[s][m]>0) { vv[c]=cols[s][m]; c++; }
|
|
med_d1[s] = MedianN(vv,c);
|
|
}
|
|
|
|
//--- range di barre grafico da (ri)calcolare:
|
|
// tutto al primo load o quando nasce una nuova barra D1, altrimenti solo oggi
|
|
static int s_lastD1 = -1;
|
|
int recalcFrom;
|
|
if(prev_calculated==0 || d1bars!=s_lastD1)
|
|
recalcFrom = rates_total-1;
|
|
else
|
|
{
|
|
datetime todayOpen = iTime(_Symbol,ANCHOR_TF,0);
|
|
recalcFrom = 0;
|
|
while(recalcFrom < rates_total-1 && time[recalcFrom] >= todayOpen) recalcFrom++;
|
|
}
|
|
s_lastD1 = d1bars;
|
|
|
|
for(int idx=recalcFrom; idx>=0; idx--)
|
|
{
|
|
int d1cur = iBarShift(_Symbol,ANCHOR_TF,time[idx],false);
|
|
if(d1cur<0 || d1cur>=d1bars)
|
|
{
|
|
Buff_Median[idx]=0;
|
|
for(int m=0;m<7;m++) SetBuf(m,idx,0.0);
|
|
continue;
|
|
}
|
|
|
|
int sj=d1cur+1; // barra D1 precedente (inizio giornata)
|
|
|
|
//--- frazione di giornata trascorsa (solo se Smooth)
|
|
double frac=0.0;
|
|
if(Smooth)
|
|
{
|
|
datetime t0 = iTime(_Symbol,ANCHOR_TF,d1cur);
|
|
datetime t1 = (d1cur>0) ? iTime(_Symbol,ANCHOR_TF,d1cur-1)
|
|
: t0 + PeriodSeconds(ANCHOR_TF);
|
|
frac = (t1>t0) ? (double)(time[idx]-t0)/(double)(t1-t0) : 0.0;
|
|
frac = MathMax(0.0,MathMin(1.0,frac));
|
|
}
|
|
|
|
//--- mediana
|
|
if(!Smooth)
|
|
Buff_Median[idx] = (sj<d1bars) ? med_d1[sj] : 0.0;
|
|
else
|
|
{
|
|
double vS = (sj<d1bars) ? med_d1[sj] : 0.0;
|
|
Buff_Median[idx] = Interp(vS,med_d1[d1cur],frac);
|
|
}
|
|
|
|
//--- le 7 MA
|
|
for(int m=0;m<7;m++)
|
|
{
|
|
double val;
|
|
if(!Smooth)
|
|
val = (sj<d1bars) ? cols[sj][m] : 0.0;
|
|
else
|
|
{
|
|
double vS2 = (sj<d1bars) ? cols[sj][m] : 0.0;
|
|
val = Interp(vS2,cols[d1cur][m],frac);
|
|
}
|
|
SetBuf(m,idx,val);
|
|
}
|
|
}
|
|
|
|
DrawInfo();
|
|
DrawTags(time[0]);
|
|
return rates_total;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
void DrawInfo()
|
|
{
|
|
double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
|
|
double median = MedianAtD1(1); // valore D1 chiuso (stabile, non-repaint)
|
|
if(median<=0) return;
|
|
|
|
int x=10,y=30,lh=FontSize+4;
|
|
ObjectsDeleteAll(0,_pfx);
|
|
|
|
Lbl("T","PaPP Median ["+EnumToString((ENUM_TIMEFRAMES)_Period)+"]",x,y,FontSize+2,clrGold,true);
|
|
y+=lh+4;
|
|
|
|
double distPct = (bid-median)/median*100;
|
|
string distS = StringFormat("%+.2f%%",distPct);
|
|
color distC = (distPct>0)?clrRed:clrLimeGreen;
|
|
Lbl("M","Median: "+DoubleToString(median,_Digits),x,y,FontSize,clrGold,false); y+=lh;
|
|
Lbl("D","Dist: "+distS,x,y,FontSize,distC,true); y+=lh+2;
|
|
|
|
//--- Dispersione MA e bande (info)
|
|
double ds=0; int dc=0;
|
|
for(int m=0;m<7;m++) { double v=GetMA(m,1); if(v>0) { ds+=MathAbs(v-median)/median*100; dc++; } }
|
|
double vol = (dc>0)?ds/dc:0;
|
|
Lbl("V","Cluster +/-"+DoubleToString(vol,3)+"%",x,y,FontSize,clrGray,false); y+=lh+2;
|
|
|
|
//--- Valori delle 7 MA (giorni : valore) con colore = linea
|
|
for(int m=0;m<7;m++)
|
|
{
|
|
double v=GetMA(m,1);
|
|
Lbl("a"+IntegerToString(m),
|
|
StringFormat("MA %3dg: %s",gDays[m],DoubleToString(v,_Digits)),
|
|
x,y,FontSize-1,(v>0)?gCol[m]:clrGray,false);
|
|
y+=lh-2;
|
|
}
|
|
y+=2;
|
|
Lbl("H","Sopra=SELL | Sotto=BUY",x,y,FontSize-1,clrGray,false);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
// etichetta di testo ancorata a (t,price); se price<=0 la rimuove
|
|
void Tag(string n,datetime t,double price,string txt,color c)
|
|
{
|
|
string o=_pfx2+n;
|
|
if(price<=0) { ObjectDelete(0,o); return; }
|
|
if(ObjectFind(0,o)<0) ObjectCreate(0,o,OBJ_TEXT,0,0,0);
|
|
ObjectSetInteger(0,o,OBJPROP_TIME,t);
|
|
ObjectSetDouble(0,o,OBJPROP_PRICE,price);
|
|
ObjectSetString(0,o,OBJPROP_TEXT," "+txt);
|
|
ObjectSetString(0,o,OBJPROP_FONT,"Consolas");
|
|
ObjectSetInteger(0,o,OBJPROP_FONTSIZE,FontSize);
|
|
ObjectSetInteger(0,o,OBJPROP_COLOR,c);
|
|
ObjectSetInteger(0,o,OBJPROP_ANCHOR,ANCHOR_LEFT);
|
|
ObjectSetInteger(0,o,OBJPROP_BACK,false);
|
|
ObjectSetInteger(0,o,OBJPROP_SELECTABLE,false);
|
|
ObjectSetInteger(0,o,OBJPROP_HIDDEN,true);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
// etichette a fine linea, nel margine vuoto a destra
|
|
void DrawTags(datetime tlast)
|
|
{
|
|
datetime tfut = tlast + 2*PeriodSeconds(_Period);
|
|
Tag("med",tfut,Buff_Median[0],"Mediana",clrGold);
|
|
for(int m=0;m<7;m++)
|
|
{
|
|
double p = ShowMA ? GetBuf(m) : 0.0;
|
|
Tag(IntegerToString(m),tfut,p,IntegerToString(gDays[m])+"g",gCol[m]);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
void Lbl(string n,string t,int x,int y,int fs,color c,bool b)
|
|
{
|
|
string o=_pfx+n;
|
|
if(ObjectFind(0,o)<0) ObjectCreate(0,o,OBJ_LABEL,0,0,0);
|
|
ObjectSetInteger(0,o,OBJPROP_XDISTANCE,x);
|
|
ObjectSetInteger(0,o,OBJPROP_YDISTANCE,y);
|
|
ObjectSetInteger(0,o,OBJPROP_CORNER,CORNER_LEFT_UPPER);
|
|
ObjectSetString(0,o,OBJPROP_TEXT,t);
|
|
ObjectSetString(0,o,OBJPROP_FONT,b?"Consolas Bold":"Consolas");
|
|
ObjectSetInteger(0,o,OBJPROP_FONTSIZE,fs);
|
|
ObjectSetInteger(0,o,OBJPROP_COLOR,c);
|
|
ObjectSetInteger(0,o,OBJPROP_BACK,false);
|
|
ObjectSetInteger(0,o,OBJPROP_SELECTABLE,false);
|
|
ObjectSetInteger(0,o,OBJPROP_HIDDEN,true);
|
|
}
|
|
//+------------------------------------------------------------------+
|