//-------------------------------------------------------------------
// original : ANG3110
// this version : mladen
//-------------------------------------------------------------------
#property indicator_separate_window
#property indicator_buffers 4
#property indicator_color1 LightSlateGray
#property indicator_color2 DodgerBlue
#property indicator_color3 SandyBrown
#property indicator_color4 SandyBrown
#property indicator_style1 STYLE_DOT
#property indicator_width2 2
#property indicator_width3 2
#property indicator_width4 2
enum enMaTypes
{
ma_sma, // simple moving average - SMA
ma_ema, // exponential moving average - EMA
ma_dsema, // double smoothed exponential moving average - DSEMA
ma_dema, // double exponential moving average - DEMA
ma_tema, // tripple exponential moving average - TEMA
ma_smma, // smoothed moving average - SMMA
ma_lwma, // linear weighted moving average - LWMA
ma_pwma, // parabolic weighted moving average - PWMA
ma_alxma, // Alexander moving average - ALXMA
ma_vwma, // volume weighted moving average - VWMA
ma_hull, // Hull moving average
ma_tma, // triangular moving average
ma_sine, // sine weighted moving average
ma_linr, // linear regression value
ma_ie2, // IE/2
ma_nlma, // non lag moving average
ma_zlma, // zero lag moving average
ma_lead, // leader exponential moving average
ma_ssm, // super smoother
ma_smoo // smoother
};
extern int AdxmPeriod = 14;
extern int Level = 25;
extern double Smooth = 15;
extern enMaTypes SmoothType = ma_ssm;
double ADX[],ADXLa[],ADXLb[],DI[];
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
//
//
//
//
//
int init()
{
SetIndexBuffer(0,DI);
SetIndexBuffer(1,ADX);
SetIndexBuffer(2,ADXLa);
SetIndexBuffer(3,ADXLb);
SetLevelValue(0,0);
SetLevelValue(1, Level);
SetLevelValue(2,-Level);
IndicatorShortName("ADXm "+getAverageName(SmoothType)+" ("+AdxmPeriod+","+DoubleToStr(Smooth,2)+")");
return(0);
}
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
//
//
//
//
//
double work[][4];
#define zdh 0
#define zdl 1
#define zdx 2
#define slope 3
int start()
{
int i,r,counted_bars = IndicatorCounted();
if(counted_bars < 0) return(-1);
if(counted_bars > 0) counted_bars--;
double alpha = 2.0/(AdxmPeriod+1);
int limit = MathMin(Bars-counted_bars,Bars-1);
if (ArrayRange(work,0)!=Bars) ArrayResize(work,Bars);
//
//
//
//
//
if (work[limit][slope]==-1) CleanPoint(limit,ADXLa,ADXLb);
for (i=limit,r=Bars-i-1; i>=0; i--,r++)
{
if (i==Bars-1) { work[r][zdh] = 0; work[r][zdl] = 0; work[r][zdx] = 0; continue; }
double hc = iCustomMa(SmoothType,High[i] ,Smooth,i,0);
double lc = iCustomMa(SmoothType,Low[i] ,Smooth,i,1);
double cp = iCustomMa(SmoothType,Close[i+1],Smooth,i,2);
double hp = iCustomMa(SmoothType,High[i+1] ,Smooth,i,3);
double lp = iCustomMa(SmoothType,Low[i+1] ,Smooth,i,4);
double dh = MathMax(hc-hp,0);
double dl = MathMax(lp-lc,0);
if(dh==dl) {dh=0; dl=0;} else if(dh
ADX[i+1]) work[r][slope] = 1;
if (ADX[i]=Bars-3) return;
if ((second[i] != EMPTY_VALUE) && (second[i+1] != EMPTY_VALUE))
second[i+1] = EMPTY_VALUE;
else
if ((first[i] != EMPTY_VALUE) && (first[i+1] != EMPTY_VALUE) && (first[i+2] == EMPTY_VALUE))
first[i+1] = EMPTY_VALUE;
}
void PlotPoint(int i,double& first[],double& second[],double& from[])
{
if (i>=Bars-2) return;
if (first[i+1] == EMPTY_VALUE)
if (first[i+2] == EMPTY_VALUE)
{ first[i] = from[i]; first[i+1] = from[i+1]; second[i] = EMPTY_VALUE; }
else { second[i] = from[i]; second[i+1] = from[i+1]; first[i] = EMPTY_VALUE; }
else { first[i] = from[i]; second[i] = EMPTY_VALUE; }
}
//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
string methodNames[] = {"SMA","EMA","Double smoothed EMA","Double EMA","Tripple EMA","Smoothed MA","Linear weighted MA","Parabolic weighted MA","Alexander MA","Volume weghted MA","Hull MA","Triangular MA","Sine weighted MA","Linear regression","IE/2","NonLag MA","Zero lag EMA","Leader EMA","Super smoother","Smoothed"};
string getAverageName(int method)
{
int max = ArraySize(methodNames)-1;
method=MathMax(MathMin(method,max),0); return(methodNames[method]);
}
//
//
//
//
//
#define _maWorkBufferx1 5
#define _maWorkBufferx2 10
#define _maWorkBufferx3 15
#define _maWorkBufferx5 25
double iCustomMa(int mode, double price, double length, int i, int instanceNo=0)
{
int r = Bars-i-1;
length = MathMax(length,1);
switch (mode)
{
case ma_sma : return(iSma(price,length,r,instanceNo));
case ma_ema : return(iEma(price,length,r,instanceNo));
case ma_dsema : return(iDsema(price,length,r,instanceNo));
case ma_dema : return(iDema(price,length,r,instanceNo));
case ma_tema : return(iTema(price,length,r,instanceNo));
case ma_smma : return(iSmma(price,length,r,instanceNo));
case ma_lwma : return(iLwma(price,length,r,instanceNo));
case ma_pwma : return(iLwmp(price,length,r,instanceNo));
case ma_alxma : return(iAlex(price,length,r,instanceNo));
case ma_vwma : return(iWwma(price,length,r,instanceNo));
case ma_hull : return(iHull(price,length,r,instanceNo));
case ma_tma : return(iTma(price,length,r,instanceNo));
case ma_sine : return(iSineWMA(price,length,r,instanceNo));
case ma_linr : return(iLinr(price,length,r,instanceNo));
case ma_ie2 : return(iIe2(price,length,r,instanceNo));
case ma_nlma : return(iNonLagMa(price,length,r,instanceNo));
case ma_zlma : return(iZeroLag(price,length,r,instanceNo));
case ma_lead : return(iLeader(price,length,r,instanceNo));
case ma_ssm : return(iSsm(price,length,r,instanceNo));
case ma_smoo : return(iSmooth(price,length,r,instanceNo));
default : return(0);
}
}
//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
double workSma[][_maWorkBufferx2];
double iSma(double price, int period, int r, int instanceNo=0)
{
if (ArrayRange(workSma,0)!= Bars) ArrayResize(workSma,Bars); instanceNo *= 2;
//
//
//
//
//
workSma[r][instanceNo] = price;
if (r>=period)
workSma[r][instanceNo+1] = workSma[r-1][instanceNo+1]+(workSma[r][instanceNo]-workSma[r-period][instanceNo])/period;
else { workSma[r][instanceNo+1] = 0; for(int k=0; k=0; k++) workSma[r][instanceNo+1] += workSma[r-k][instanceNo];
workSma[r][instanceNo+1] /= k; }
return(workSma[r][instanceNo+1]);
}
//
//
//
//
//
double workEma[][_maWorkBufferx1];
double iEma(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workEma,0)!= Bars) ArrayResize(workEma,Bars);
//
//
//
//
//
double alpha = 2.0 / (1.0+period);
workEma[r][instanceNo] = workEma[r-1][instanceNo]+alpha*(price-workEma[r-1][instanceNo]);
return(workEma[r][instanceNo]);
}
//
//
//
//
//
double workDsema[][_maWorkBufferx2];
#define _ema1 0
#define _ema2 1
double iDsema(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workDsema,0)!= Bars) ArrayResize(workDsema,Bars); instanceNo*=2;
//
//
//
//
//
double alpha = 2.0 /(1.0+MathSqrt(period));
workDsema[r][_ema1+instanceNo] = workDsema[r-1][_ema1+instanceNo]+alpha*(price -workDsema[r-1][_ema1+instanceNo]);
workDsema[r][_ema2+instanceNo] = workDsema[r-1][_ema2+instanceNo]+alpha*(workDsema[r][_ema1+instanceNo]-workDsema[r-1][_ema2+instanceNo]);
return(workDsema[r][_ema2+instanceNo]);
}
//
//
//
//
//
double workDema[][_maWorkBufferx2];
#define _dema1 0
#define _dema2 1
double iDema(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workDema,0)!= Bars) ArrayResize(workDema,Bars); instanceNo*=2;
//
//
//
//
//
double alpha = 2.0 / (1.0+period);
workDema[r][_dema1+instanceNo] = workDema[r-1][_dema1+instanceNo]+alpha*(price -workDema[r-1][_dema1+instanceNo]);
workDema[r][_dema2+instanceNo] = workDema[r-1][_dema2+instanceNo]+alpha*(workDema[r][_dema1+instanceNo]-workDema[r-1][_dema2+instanceNo]);
return(workDema[r][_dema1+instanceNo]*2.0-workDema[r][_dema2+instanceNo]);
}
//
//
//
//
//
double workTema[][_maWorkBufferx3];
#define _tema1 0
#define _tema2 1
#define _tema3 2
double iTema(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workTema,0)!= Bars) ArrayResize(workTema,Bars); instanceNo*=3;
//
//
//
//
//
double alpha = 2.0 / (1.0+period);
workTema[r][_tema1+instanceNo] = workTema[r-1][_tema1+instanceNo]+alpha*(price -workTema[r-1][_tema1+instanceNo]);
workTema[r][_tema2+instanceNo] = workTema[r-1][_tema2+instanceNo]+alpha*(workTema[r][_tema1+instanceNo]-workTema[r-1][_tema2+instanceNo]);
workTema[r][_tema3+instanceNo] = workTema[r-1][_tema3+instanceNo]+alpha*(workTema[r][_tema2+instanceNo]-workTema[r-1][_tema3+instanceNo]);
return(workTema[r][_tema3+instanceNo]+3.0*(workTema[r][_tema1+instanceNo]-workTema[r][_tema2+instanceNo]));
}
//
//
//
//
//
double workSmma[][_maWorkBufferx1];
double iSmma(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workSmma,0)!= Bars) ArrayResize(workSmma,Bars);
//
//
//
//
//
if (r=0; k++)
{
double weight = period-k;
sumw += weight;
sum += weight*workLwma[r-k][instanceNo];
}
return(sum/sumw);
}
//
//
//
//
//
double workLwmp[][_maWorkBufferx1];
double iLwmp(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workLwmp,0)!= Bars) ArrayResize(workLwmp,Bars);
//
//
//
//
//
workLwmp[r][instanceNo] = price;
double sumw = period*period;
double sum = sumw*price;
for(int k=1; k=0; k++)
{
double weight = (period-k)*(period-k);
sumw += weight;
sum += weight*workLwmp[r-k][instanceNo];
}
return(sum/sumw);
}
//
//
//
//
//
double workAlex[][_maWorkBufferx1];
double iAlex(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workAlex,0)!= Bars) ArrayResize(workAlex,Bars);
if (period<4) return(price);
//
//
//
//
//
workAlex[r][instanceNo] = price;
double sumw = period-2;
double sum = sumw*price;
for(int k=1; k=0; k++)
{
double weight = period-k-2;
sumw += weight;
sum += weight*workAlex[r-k][instanceNo];
}
return(sum/sumw);
}
//
//
//
//
//
double workTma[][_maWorkBufferx1];
double iTma(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workTma,0)!= Bars) ArrayResize(workTma,Bars);
//
//
//
//
//
workTma[r][instanceNo] = price;
double half = (period+1.0)/2.0;
double sum = price;
double sumw = 1;
for(int k=1; k=0; k++)
{
double weight = k+1; if (weight > half) weight = period-k;
sumw += weight;
sum += weight*workTma[r-k][instanceNo];
}
return(sum/sumw);
}
//
//
//
//
//
double workSineWMA[][_maWorkBufferx1];
#define Pi 3.14159265358979323846264338327950288
double iSineWMA(double price, int period, int r, int instanceNo=0)
{
if (period<1) return(price);
if (ArrayRange(workSineWMA,0)!= Bars) ArrayResize(workSineWMA,Bars);
//
//
//
//
//
workSineWMA[r][instanceNo] = price;
double sum = 0;
double sumw = 0;
for(int k=0; k=0; k++)
{
double weight = MathSin(Pi*(k+1.0)/(period+1.0));
sumw += weight;
sum += weight*workSineWMA[r-k][instanceNo];
}
return(sum/sumw);
}
//
//
//
//
//
double workWwma[][_maWorkBufferx1];
double iWwma(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workWwma,0)!= Bars) ArrayResize(workWwma,Bars);
//
//
//
//
//
workWwma[r][instanceNo] = price;
int i = Bars-r-1;
double sumw = Volume[i];
double sum = sumw*price;
for(int k=1; k=0; k++)
{
double weight = Volume[i+k];
sumw += weight;
sum += weight*workWwma[r-k][instanceNo];
}
return(sum/sumw);
}
//
//
//
//
//
double workHull[][_maWorkBufferx2];
double iHull(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workHull,0)!= Bars) ArrayResize(workHull,Bars);
//
//
//
//
//
int HmaPeriod = MathMax(period,2);
int HalfPeriod = MathFloor(HmaPeriod/2);
int HullPeriod = MathFloor(MathSqrt(HmaPeriod));
double hma,hmw,weight; instanceNo *= 2;
workHull[r][instanceNo] = price;
//
//
//
//
//
hmw = HalfPeriod; hma = hmw*price;
for(int k=1; k=0; k++)
{
weight = HalfPeriod-k;
hmw += weight;
hma += weight*workHull[r-k][instanceNo];
}
workHull[r][instanceNo+1] = 2.0*hma/hmw;
hmw = HmaPeriod; hma = hmw*price;
for(k=1; k=0; k++)
{
weight = HmaPeriod-k;
hmw += weight;
hma += weight*workHull[r-k][instanceNo];
}
workHull[r][instanceNo+1] -= hma/hmw;
//
//
//
//
//
hmw = HullPeriod; hma = hmw*workHull[r][instanceNo+1];
for(k=1; k=0; k++)
{
weight = HullPeriod-k;
hmw += weight;
hma += weight*workHull[r-k][1+instanceNo];
}
return(hma/hmw);
}
//
//
//
//
//
double workLinr[][_maWorkBufferx1];
double iLinr(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workLinr,0)!= Bars) ArrayResize(workLinr,Bars);
//
//
//
//
//
period = MathMax(period,1);
workLinr[r][instanceNo] = price;
double lwmw = period; double lwma = lwmw*price;
double sma = price;
for(int k=1; k=0; k++)
{
double weight = period-k;
lwmw += weight;
lwma += weight*workLinr[r-k][instanceNo];
sma += workLinr[r-k][instanceNo];
}
return(3.0*lwma/lwmw-2.0*sma/period);
}
//
//
//
//
//
double workIe2[][_maWorkBufferx1];
double iIe2(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workIe2,0)!= Bars) ArrayResize(workIe2,Bars);
//
//
//
//
//
period = MathMax(period,1);
workIe2[r][instanceNo] = price;
double sumx=0, sumxx=0, sumxy=0, sumy=0;
for (int k=0; k0)
{
double sum = 0;
for (k=0; k < nlmvalues[instanceNo][_len]; k++) sum += nlmalphas[k][instanceNo]*nlmprices[r-k][instanceNo];
return( sum / nlmvalues[instanceNo][_weight]);
}
else return(0);
}