AllAbsoluteStrength_v2.3 600+.mq4
AllAbsoluteStrength_v2.3 600+.mq4 download link will appear after 10 seconds.
AllAbsoluteStrength_v2.3 600+.mq4 Programming source code.
//+------------------------------------------------------------------
// List of MAs:
// MA_Method= 0: SMA - Simple Moving Average
// MA_Method= 1: EMA - Exponential Moving Average
// MA_Method= 2: Wilder - Wilder Exponential Moving Average
// MA_Method= 3: LWMA - Linear Weighted Moving Average
// MA_Method= 4: SineWMA - Sine Weighted Moving Average
// MA_Method= 5: TriMA - Triangular Moving Average
// MA_Method= 6: LSMA - Least Square Moving Average (or EPMA, Linear Regression Line)
// MA_Method= 7: SMMA - Smoothed Moving Average
// MA_Method= 8: HMA - Hull Moving Average by Alan Hull
// MA_Method= 9: ZeroLagEMA - Zero-Lag Exponential Moving Average
// MA_Method=10: DEMA - Double Exponential Moving Average by Patrick Mulloy
// MA_Method=11: T3_basic - T3 by T.Tillson (original version)
// MA_Method=12: ITrend - Instantaneous Trendline by J.Ehlers
// MA_Method=13: Median - Moving Median
// MA_Method=14: GeoMean - Geometric Mean
// MA_Method=15: REMA - Regularized EMA by Chris Satchwell
// MA_Method=16: ILRS - Integral of Linear Regression Slope
// MA_Method=17: IE/2 - Combination of LSMA and ILRS
// MA_Method=18: TriMAgen - Triangular Moving Average generalized by J.Ehlers
// MA_Method=19: VWMA - Volume Weighted Moving Average
// MA_Method=20: JSmooth - Smoothing by Mark Jurik
// MA_Method=21: SMA_eq - Simplified SMA
// MA_Method=22: ALMA - Arnaud Legoux Moving Average
// MA_Method=23: TEMA - Triple Exponential Moving Average by Patrick Mulloy
// MA_Method=24: T3 - T3 by T.Tillson (correct version)
// MA_Method=25: Laguerre - Laguerre filter by J.Ehlers
// List of Prices:
// Price = 0 - Close
// Price = 1 - Open
// Price = 2 - High
// Price = 3 - Low
// Price = 4 - Median Price = (High+Low)/2
// Price = 5 - Typical Price = (High+Low+Close)/3
// Price = 6 - Weighted Close = (High+Low+Close*2)/4
#property indicator_separate_window
#property indicator_buffers 6
#property indicator_color1 DeepSkyBlue
#property indicator_width1 2
#property indicator_color2 Tomato
#property indicator_width2 2
#property indicator_color3 SkyBlue
#property indicator_width3 1
#property indicator_style3 2
#property indicator_color4 Coral
#property indicator_width4 1
#property indicator_style4 2
#property indicator_color5 LightGray
#property indicator_width5 1
#property indicator_style5 4
#property indicator_color6 LightGray
#property indicator_width6 1
#property indicator_style6 4
//---- indicator parameters
extern int TimeFrame = 0; // TimeFrame in min
extern int MathMode = 3; // Math method: 0-RSI;1-Stoch;2-DMI;3-MACD
extern int Price = 0; // Price = 0...6
extern int Length = 26; // Period of evaluation
extern int PreSmooth = 12; // Period of PreSmoothing
extern int Smooth = 1; // Period of smoothing
extern int Signal = 9; // Period of Signal Line
extern int MA_Method = 1; // See list above
extern int LevelsMode = 1; // Levels Mode: 0-Standard OverBought/OverSold
// 1-StdDev Bands
// 2-High/Low Channel
extern double StrengthLevel = 80; // Strength Level (ex.70)
extern double WeaknessLevel = 20; // Weakness Level (ex.30)
extern int LookBackPeriod = 20; // LookBack Period for LevelsMode=1,2
extern double UpperMultiplier = 1; // Upper Band Multiplier for LevelsMode=1
extern double LowerMultiplier = 1; // Lower Band Multiplier for LevelsMode=1
//---- indicator buffers
double Bulls[];
double Bears[];
double sigBulls[];
double sigBears[];
double strength[];
double weakness[];
double lbulls[];
double lbears[];
double bulls[];
double bears[];
//----
double tmp[][8][2], ma[8][3], mMA[2], mLo[2], smin[2], smax[2], HiArray[], LoArray[];
int draw_begin, masize;
string TF, IndicatorName, short_name, math_name, price_name, maname, zone_name;
double upsum, dnsum, _point;
datetime prevtime[8], ptime;
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int init()
{
if(TimeFrame <= Period()) TimeFrame = Period();
TF = tf(TimeFrame);
if(TF == "N/A") TimeFrame = Period();
IndicatorDigits(Digits);
//---- indicator buffers mapping
IndicatorBuffers(10);
SetIndexBuffer(0, Bulls); SetIndexStyle(0,DRAW_LINE);
SetIndexBuffer(1, Bears); SetIndexStyle(1,DRAW_LINE);
SetIndexBuffer(2,sigBulls); SetIndexStyle(2,DRAW_LINE);
SetIndexBuffer(3,sigBears); SetIndexStyle(3,DRAW_LINE);
SetIndexBuffer(4,strength); SetIndexStyle(4,DRAW_LINE);
SetIndexBuffer(5,weakness); SetIndexStyle(5,DRAW_LINE);
SetIndexBuffer(6, lbulls);
SetIndexBuffer(7, lbears);
SetIndexBuffer(8, bulls);
SetIndexBuffer(9, bears);
//---- indicator name
switch(Price)
{
case 0 : price_name = "Close" ; break;
case 1 : price_name = "Open" ; break;
case 2 : price_name = "High" ; break;
case 3 : price_name = "Low" ; break;
case 4 : price_name = "Median" ; break;
case 5 : price_name = "Typical"; break;
case 6 : price_name = "WtClose"; break;
}
switch(MathMode)
{
case 0 : math_name = "RSI" ; break;
case 1 : math_name = "Stoch"; break;
case 2 : math_name = "DMI" ; break;
case 3 : math_name = "MACD" ; break;
}
maname = averageName(MA_Method, masize);
IndicatorName = WindowExpertName();
short_name = "[" + TF + "]("+ math_name + "," + price_name + "," + Length + "," + PreSmooth + "," + Smooth + "," + Signal + "," + maname + "," + LevelsMode+")";
IndicatorShortName(IndicatorName + short_name);
draw_begin = Bars - iBars(NULL,TimeFrame)*TimeFrame/Period() + Length + PreSmooth + Smooth + Signal + LookBackPeriod;
SetIndexDrawBegin(0,draw_begin);
SetIndexDrawBegin(1,draw_begin);
SetIndexDrawBegin(2,draw_begin);
SetIndexDrawBegin(3,draw_begin);
SetIndexDrawBegin(4,draw_begin);
SetIndexDrawBegin(5,draw_begin);
SetIndexLabel(0,"Bulls");
SetIndexLabel(1,"Bears");
SetIndexLabel(2,"Signal Bulls");
SetIndexLabel(3,"Signal Bears");
SetIndexLabel(4,"Strength Line");
SetIndexLabel(5,"Weakness Line");
SetIndexEmptyValue(4,0);
SetIndexEmptyValue(5,0);
//----
ArrayResize(tmp , masize);
ArrayResize(HiArray,LookBackPeriod);
ArrayResize(LoArray,LookBackPeriod);
_point = Point*MathPow(10,Digits%2);
//---- initialization done
return(0);
}
int deinit() {Comment(""); return(0);}
//+------------------------------------------------------------------+
//| UniAbsoluteStrength_v2.3 600+ |
//+------------------------------------------------------------------+
int start()
{
int limit, i, shift, counted_bars = IndicatorCounted();
if (counted_bars > 0) limit=Bars-counted_bars-1;
if (counted_bars < 0) return(0);
if (counted_bars < 1)
{
limit = Bars-1;
for(i=limit;i>=0;i--)
{
Bulls[i] = EMPTY_VALUE;
Bears[i] = EMPTY_VALUE;
sigBulls[i] = EMPTY_VALUE;
sigBears[i] = EMPTY_VALUE;
strength[i] = 0;
weakness[i] = 0;
}
}
if(TimeFrame != Period())
{
limit = MathMax(limit,TimeFrame/Period());
for(shift = 0;shift < limit;shift++)
{
int y = iBarShift(NULL,TimeFrame,Time[shift]);
Bulls[shift] = iCustom(NULL,TimeFrame,IndicatorName,0,MathMode,Price,Length,PreSmooth,Smooth,Signal,MA_Method,LevelsMode,StrengthLevel,WeaknessLevel,LookBackPeriod,UpperMultiplier,LowerMultiplier,0,y);
Bears[shift] = iCustom(NULL,TimeFrame,IndicatorName,0,MathMode,Price,Length,PreSmooth,Smooth,Signal,MA_Method,LevelsMode,StrengthLevel,WeaknessLevel,LookBackPeriod,UpperMultiplier,LowerMultiplier,1,y);
sigBulls[shift] = iCustom(NULL,TimeFrame,IndicatorName,0,MathMode,Price,Length,PreSmooth,Smooth,Signal,MA_Method,LevelsMode,StrengthLevel,WeaknessLevel,LookBackPeriod,UpperMultiplier,LowerMultiplier,2,y);
sigBears[shift] = iCustom(NULL,TimeFrame,IndicatorName,0,MathMode,Price,Length,PreSmooth,Smooth,Signal,MA_Method,LevelsMode,StrengthLevel,WeaknessLevel,LookBackPeriod,UpperMultiplier,LowerMultiplier,3,y);
if(StrengthLevel > 0 || WeaknessLevel > 0)
{
strength[shift] = iCustom(NULL,TimeFrame,IndicatorName,0,MathMode,Price,Length,PreSmooth,Smooth,Signal,MA_Method,LevelsMode,StrengthLevel,WeaknessLevel,LookBackPeriod,UpperMultiplier,LowerMultiplier,4,y);
weakness[shift] = iCustom(NULL,TimeFrame,IndicatorName,0,MathMode,Price,Length,PreSmooth,Smooth,Signal,MA_Method,LevelsMode,StrengthLevel,WeaknessLevel,LookBackPeriod,UpperMultiplier,LowerMultiplier,5,y);
}
}
return(0);
}
else _AllAbsStrength(limit);
return(0);
}
//-----
void _AllAbsStrength(int limit)
{
double upPivot, dnPivot;
for(int shift=limit;shift>=0;shift--)
{
if(ptime != Time[shift])
{
mMA[1] = mMA[0];
mLo[1] = mLo[0];
smin[1] = smin[0];
smax[1] = smax[0];
ptime = Time[shift];
}
if(MathMode != 2) int price = Price; else price = 2;
mMA[0] = allAverages(0,price,PreSmooth,MA_Method,masize,shift);
if(shift < Bars - 2)
{
if (MathMode == 0)
{
bulls[shift] = 0.5*(MathAbs(mMA[0] - mMA[1]) + (mMA[0] - mMA[1]));
bears[shift] = 0.5*(MathAbs(mMA[0] - mMA[1]) - (mMA[0] - mMA[1]));
}
else
if (MathMode == 1)
{
double up = 0;
double dn = 10000000000;
for(int i=0;i bears[shift]) bears[shift] = 0;
else
if(bulls[shift] < bears[shift]) bulls[shift] = 0;
else {bulls[shift] = 0; bears[shift] = 0;}
}
else
if(MathMode == 3)
{
double slow = allAverages(1,price,Length,MA_Method,masize,shift);
bulls[shift] = 0.5*(MathAbs(mMA[0] - slow) + (mMA[0] - slow));
bears[shift] = 0.5*(MathAbs(mMA[0] - slow) - (mMA[0] - slow));
}
if(MathMode == 1 || MathMode == 3) int len = 1; else len = Length;
lbulls[shift] = allAveragesOnArray(2,bulls,len,MA_Method,masize,shift);
lbears[shift] = allAveragesOnArray(3,bears,len,MA_Method,masize,shift);
Bulls[shift] = allAveragesOnArray(4,lbulls,Smooth,MA_Method,masize,shift)/_point;
Bears[shift] = allAveragesOnArray(5,lbears,Smooth,MA_Method,masize,shift)/_point;
if(Signal > 0)
{
if(Signal > 1)
{
sigBulls[shift] = allAveragesOnArray(6,Bulls,Signal,MA_Method,masize,shift);
sigBears[shift] = allAveragesOnArray(7,Bears,Signal,MA_Method,masize,shift);
}
else
{
sigBulls[shift] = Bulls[shift+1];
sigBears[shift] = Bears[shift+1];
}
}
if(LevelsMode == 0)
{
if(StrengthLevel > 0) strength[shift] = StrengthLevel/100*(Bulls[shift] + Bears[shift]);
if(WeaknessLevel > 0) weakness[shift] = WeaknessLevel/100*(Bulls[shift] + Bears[shift]);
}
else
if(LevelsMode == 1 && shift < Bars - (LookBackPeriod+Length))
{
for(int j = 0; j < LookBackPeriod; j++)
{
HiArray[j] = MathMax(Bulls[shift+j],Bears[shift+j]);
LoArray[j] = MathMin(Bulls[shift+j],Bears[shift+j]);
}
if(UpperMultiplier > 0) strength[shift] = SMAOnArray(HiArray,LookBackPeriod,0) + UpperMultiplier*stdDev(HiArray,LookBackPeriod);
if(LowerMultiplier > 0) weakness[shift] = SMAOnArray(LoArray,LookBackPeriod,0) - LowerMultiplier*stdDev(LoArray,LookBackPeriod);
}
else
if(LevelsMode == 2 && shift < Bars -(LookBackPeriod + Length))
{
for(j = 0; j < LookBackPeriod; j++)
{
HiArray[j] = MathMax(Bulls[shift+j],Bears[shift+j]);
LoArray[j] = MathMin(Bulls[shift+j],Bears[shift+j]);
}
upPivot = getPivots(2,HiArray,LookBackPeriod,0);
dnPivot = getPivots(3,LoArray,LookBackPeriod,0);
smax[0] = upPivot;
smin[0] = dnPivot;
strength[shift] = smax[0] - (smax[0] - smin[0])*(1 - StrengthLevel/100);
weakness[shift] = smin[0] + (smax[0] - smin[0])*WeaknessLevel/100;
}
}
}
}
//-----
string averageName(int mode,int& arraysize)
{
string ma_name = "";
switch(mode)
{
case 1 : ma_name = "EMA" ; break;
case 2 : ma_name = "Wilder" ; break;
case 3 : ma_name = "LWMA" ; break;
case 4 : ma_name = "SineWMA" ; break;
case 5 : ma_name = "TriMA" ; break;
case 6 : ma_name = "LSMA" ; break;
case 7 : ma_name = "SMMA" ; break;
case 8 : ma_name = "HMA" ; break;
case 9 : ma_name = "ZeroLagEMA"; break;
case 10: ma_name = "DEMA" ; arraysize = 2; break;
case 11: ma_name = "T3 basic" ; arraysize = 6; break;
case 12: ma_name = "InstTrend" ; break;
case 13: ma_name = "Median" ; break;
case 14: ma_name = "GeoMean" ; break;
case 15: ma_name = "REMA" ; break;
case 16: ma_name = "ILRS" ; break;
case 17: ma_name = "IE/2" ; break;
case 18: ma_name = "TriMA_gen" ; break;
case 19: ma_name = "VWMA" ; break;
case 20: ma_name = "JSmooth" ; arraysize = 5; break;
case 21: ma_name = "SMA_eq" ; break;
case 22: ma_name = "ALMA" ; break;
case 23: ma_name = "TEMA" ; arraysize = 4; break;
case 24: ma_name = "T3" ; arraysize = 6; break;
case 25: ma_name = "Laguerre" ; arraysize = 4; break;
default: ma_name = "SMA" ; break;
}
return(ma_name);
}
double allAverages(int index,int price,int period,int mode,int arraysize,int bar)
{
double MA[3];
if(prevtime[index] != Time[bar])
{
ma[index][2] = ma[index][1];
ma[index][1] = ma[index][0];
for(int i=0;i= Bars - 2) double ema = iMA(NULL,0,1,0,0,price,bar);
else
ema = prev + 2.0/(1+per)*(iMA(NULL,0,1,0,0,price,bar) - prev);
return(ema);
}
double EMAOnArray(double price,double prev,int per,int bar)
{
if(bar >= Bars - 2) double ema = price;
else
ema = prev + 2.0/(1+per)*(price - prev);
return(ema);
}
// MA_Method=2: Wilder - Wilder Exponential Moving Average
double Wilder(int price,double prev,int per,int bar)
{
if(bar >= Bars - 2) double wilder = iMA(NULL,0,1,0,0,price,bar); //SMA(array1,per,bar);
else
wilder = prev + (iMA(NULL,0,1,0,0,price,bar) - prev)/per;
return(wilder);
}
double WilderOnArray(double price,double prev,int per,int bar)
{
if(bar >= Bars - 2) double wilder = price; //SMA(array1,per,bar);
else
wilder = prev + (price - prev)/per;
return(wilder);
}
// MA_Method=3: LWMA - Linear Weighted Moving Average
double LWMA(int price,int per,int bar)
{
double Sum = 0, Weight = 0;
for(int i = 0;i < per;i++)
{
Weight += (per - i);
Sum += iMA(NULL,0,1,0,0,price,bar+i)*(per - i);
}
if(Weight>0) double lwma = Sum/Weight; else lwma = 0;
return(lwma);
}
double LWMAOnArray(double& array[],int per,int bar)
{
double Sum = 0, Weight = 0;
for(int i=0;i0) double lwma = Sum/Weight; else lwma = 0;
return(lwma);
}
// MA_Method=4: SineWMA - Sine Weighted Moving Average
double SineWMA(int price,int per,int bar)
{
double pi = 3.1415926535;
double Sum = 0;
double Weight = 0;
for(int i = 0;i < per;i++)
{
Weight+= MathSin(pi*(i+1)/(per+1));
Sum += iMA(NULL,0,1,0,0,price,bar+i)*MathSin(pi*(i+1)/(per+1));
}
if(Weight>0) double swma = Sum/Weight;
else swma = 0;
return(swma);
}
double SineWMAOnArray(double& array[],int per,int bar)
{
double pi = 3.1415926535;
double Sum = 0;
double Weight = 0;
for(int i = 0;i < per;i++)
{
Weight+= MathSin(pi*(i+1)/(per+1));
Sum += array[bar+i]*MathSin(pi*(i+1)/(per+1));
}
if(Weight>0) double swma = Sum/Weight;
else swma = 0;
return(swma);
}
// MA_Method=5: TriMA - Triangular Moving Average
double TriMA(int price,int per,int bar)
{
double sma;
int len = MathCeil((per+1)*0.5);
double sum=0;
for(int i = 0;i < len;i++)
{
sma = SMA(price,len,bar+i);
sum += sma;
}
double trima = sum/len;
return(trima);
}
double TriMAOnArray(double& array[],int per,int bar)
{
double sma;
int len = MathCeil((per+1)*0.5);
double sum=0;
for(int i = 0;i < len;i++)
{
sma = SMAOnArray(array,len,bar+i);
sum += sma;
}
double trima = sum/len;
return(trima);
}
// MA_Method=6: LSMA - Least Square Moving Average (or EPMA, Linear Regression Line)
double LSMA(int price,int per,int bar)
{
double Sum=0;
for(int i=per; i>=1; i--) Sum += (i-(per+1)/3.0)*iMA(NULL,0,1,0,0,price,bar+per-i);
double lsma = Sum*6/(per*(per+1));
return(lsma);
}
double LSMAOnArray(double& array[],int per,int bar)
{
double Sum=0;
for(int i=per; i>=1; i--) Sum += (i-(per+1)/3.0)*array[bar+per-i];
double lsma = Sum*6/(per*(per+1));
return(lsma);
}
// MA_Method=7: SMMA - Smoothed Moving Average
double SMMA(int price,double prev,int per,int bar)
{
if(bar == Bars - per) double smma = SMA(price,per,bar);
else
if(bar < Bars - per)
{
double Sum = 0;
for(int i = 0;i < per;i++) Sum += iMA(NULL,0,1,0,0,price,bar+i+1);
smma = (Sum - prev + iMA(NULL,0,1,0,0,price,bar))/per;
}
return(smma);
}
double SMMAOnArray(double& array[],double prev,int per,int bar)
{
if(bar == Bars - per) double smma = SMAOnArray(array,per,bar);
else
if(bar < Bars - per)
{
double Sum = 0;
for(int i = 0;i < per;i++) Sum += array[bar+i+1];
smma = (Sum - prev + array[bar])/per;
}
return(smma);
}
// MA_Method=8: HMA - Hull Moving Average by Alan Hull
double HMA(int price,int per,int bar)
{
double temp[];
int len = MathSqrt(per);
ArrayResize(temp,len);
if(bar == Bars - per || per == 1) double hma = iMA(NULL,0,1,0,0,price,bar);
else
if(bar < Bars - per)
{
for(int i=0;i= Bars - lag) double zema = iMA(NULL,0,1,0,0,price,bar);
else
zema = alfa*(2*iMA(NULL,0,1,0,0,price,bar) - iMA(NULL,0,1,0,0,price,bar+lag)) + (1-alfa)*prev;
return(zema);
}
double ZeroLagEMAOnArray(double& price[],double prev,int per,int bar)
{
double alfa = 2.0/(1+per);
int lag = 0.5*(per - 1);
if(bar >= Bars - lag) double zema = price[bar];
else
zema = alfa*(2*price[bar] - price[bar+lag]) + (1-alfa)*prev;
return(zema);
}
// MA_Method=10: DEMA - Double Exponential Moving Average by Patrick Mulloy
double DEMA(int index,int num,int price,double per,double v,int bar)
{
double alpha = 2.0/(1+per);
if(bar == Bars - 2) {double dema = iMA(NULL,0,1,0,0,price,bar); tmp[num][index][0] = dema; tmp[num+1][index][0] = dema;}
else
if(bar < Bars - 2)
{
tmp[num ][index][0] = tmp[num ][index][1] + alpha*(iMA(NULL,0,1,0,0,price,bar) - tmp[num ][index][1]);
tmp[num+1][index][0] = tmp[num+1][index][1] + alpha*(tmp[num][index][0] - tmp[num+1][index][1]);
dema = tmp[num ][index][0]*(1+v) - tmp[num+1][index][0]*v;
}
return(dema);
}
double DEMAOnArray(int index,int num,double price,double per,double v,int bar)
{
double alpha = 2.0/(1+per);
if(bar == Bars - 2) {double dema = price; tmp[num][index][0] = dema; tmp[num+1][index][0] = dema;}
else
if(bar < Bars - 2)
{
tmp[num ][index][0] = tmp[num ][index][1] + alpha*(price - tmp[num ][index][1]);
tmp[num+1][index][0] = tmp[num+1][index][1] + alpha*(tmp[num][index][0] - tmp[num+1][index][1]);
dema = tmp[num ][index][0]*(1+v) - tmp[num+1][index][0]*v;
}
return(dema);
}
// MA_Method=11: T3 by T.Tillson
double T3_basic(int index,int num,int price,int per,double v,int bar)
{
double dema1, dema2;
if(bar == Bars - 2)
{
double T3 = iMA(NULL,0,1,0,0,price,bar);
for(int k=0;k<6;k++) tmp[num+k][index][0] = T3;
}
else
if(bar < Bars - 2)
{
T3 = iMA(NULL,0,1,0,0,price,bar);
dema1 = DEMAOnArray(index,num ,T3 ,per,v,bar);
dema2 = DEMAOnArray(index,num+2,dema1,per,v,bar);
T3 = DEMAOnArray(index,num+4,dema2,per,v,bar);
}
return(T3);
}
double T3_basicOnArray(int index,int num,double price,int per,double v,int bar)
{
double dema1, dema2;
if(bar == Bars - 2)
{
double T3 = price;
for(int k=0;k<6;k++) tmp[num+k][index][0] = price;
}
else
if(bar < Bars - 2)
{
dema1 = DEMAOnArray(index,num ,price,per,v,bar);
dema2 = DEMAOnArray(index,num+2,dema1,per,v,bar);
T3 = DEMAOnArray(index,num+4,dema2,per,v,bar);
}
return(T3);
}
// MA_Method=12: ITrend - Instantaneous Trendline by J.Ehlers
double ITrend(int price,double& array[],int per,int bar)
{
double alfa = 2.0/(per + 1);
if(bar < Bars - 7)
double it = (alfa - 0.25*alfa*alfa)*iMA(NULL,0,1,0,0,price,bar) + 0.5*alfa*alfa*iMA(NULL,0,1,0,0,price,bar+1)
- (alfa - 0.75*alfa*alfa)*iMA(NULL,0,1,0,0,price,bar+2) + 2*(1-alfa)*array[1] - (1-alfa)*(1-alfa)*array[2];
else
it = (iMA(NULL,0,1,0,0,price,bar) + 2*iMA(NULL,0,1,0,0,price,bar+1) + iMA(NULL,0,1,0,0,price,bar)+2)/4;
return(it);
}
double ITrendOnArray(double& price[],double& array[],int per,int bar)
{
double alfa = 2.0/(per+1);
if(bar < Bars - 7)
double it = (alfa - 0.25*alfa*alfa)*price[bar] + 0.5*alfa*alfa*price[bar+1] - (alfa - 0.75*alfa*alfa)*price[bar+2] +
2*(1-alfa)*array[1] - (1-alfa)*(1-alfa)*array[2];
else
it = (price[bar] + 2*price[bar+1] + price[bar+2])/4;
return(it);
}
// MA_Method=13: Median - Moving Median
double Median(int price,int per,int bar)
{
double array[];
ArrayResize(array,per);
for(int i=0;i 0) double median = array[num]; else median = 0.5*(array[num] + array[num+1]);
return(median);
}
double MedianOnArray(double& price[],int per,int bar)
{
double array[];
ArrayResize(array,per);
for(int i=0;i 0) double median = array[num]; else median = 0.5*(array[num] + array[num+1]);
return(median);
}
// MA_Method=14: GeoMean - Geometric Mean
double GeoMean(int price,int per,int bar)
{
if(bar < Bars - per)
{
double gmean = MathPow(iMA(NULL,0,1,0,0,price,bar),1.0/per);
for(int i = 1; i < per;i++) gmean *= MathPow(iMA(NULL,0,1,0,0,price,bar+i),1.0/per);
}
return(gmean);
}
double GeoMeanOnArray(double& price[],int per,int bar)
{
if(bar < Bars - per)
{
double gmean = MathPow(price[bar],1.0/per);
for(int i = 1; i < per;i++) gmean *= MathPow(price[bar+i],1.0/per);
}
return(gmean);
}
// MA_Method=15: REMA - Regularized EMA by Chris Satchwell
double REMA(int price,double& array[],int per,double lambda,int bar)
{
double alpha = 2.0/(per + 1);
if(bar >= Bars - 3) double rema = iMA(NULL,0,1,0,0,price,bar);
else
rema = (array[1]*(1+2*lambda) + alpha*(iMA(NULL,0,1,0,0,price,bar) - array[1]) - lambda*array[2])/(1+lambda);
return(rema);
}
double REMAOnArray(double price,double& array[],int per,double lambda,int bar)
{
double alpha = 2.0/(per + 1);
if(bar >= Bars - 3) double rema = price;
else
rema = (array[1]*(1+2*lambda) + alpha*(price - array[1]) - lambda*array[2])/(1+lambda);
return(rema);
}
// MA_Method=16: ILRS - Integral of Linear Regression Slope
double ILRS(int price,int per,int bar)
{
double sum = per*(per-1)*0.5;
double sum2 = (per-1)*per*(2*per-1)/6.0;
double sum1 = 0;
double sumy = 0;
for(int i=0;i0) double vwma = Sum/Weight;
else vwma = 0;
return(vwma);
}
double VWMAOnArray(double& array[],int per,int bar)
{
double Sum = 0;
double Weight = 0;
for(int i = 0;i < per;i++)
{
Weight+= Volume[bar+i];
Sum += array[bar+i]*Volume[bar+i];
}
if(Weight>0) double vwma = Sum/Weight;
else vwma = 0;
return(vwma);
}
// MA_Method=20: JSmooth - Smoothing by Mark Jurik
double JSmooth(int index,int num,int price,int per,double pow,int bar)
{
double beta = 0.45*(per-1)/(0.45*(per-1)+2);
double alpha = MathPow(beta,pow);
double ima = iMA(NULL,0,1,0,0,price,bar);
if(bar == Bars - 2)
{
tmp[num+4][index][0] = ima;
tmp[num+0][index][0] = ima;
tmp[num+2][index][0] = ima;
}
else
if(bar < Bars - 2)
{
tmp[num+0][index][0] = (1-alpha)*ima + alpha*tmp[num+0][index][1];
tmp[num+1][index][0] = (ima - tmp[num+0][index][0])*(1-beta) + beta*tmp[num+1][index][1];
tmp[num+2][index][0] = tmp[num+0][index][0] + tmp[num+1][index][0];
tmp[num+3][index][0] = (tmp[num+2][index][0] - tmp[num+4][index][1])*MathPow((1-alpha),2) + MathPow(alpha,2)*tmp[num+3][index][1];
tmp[num+4][index][0] = tmp[num+4][index][1] + tmp[num+3][index][0];
}
return(tmp[num+4][index][0]);
}
double JSmoothOnArray(int index,int num,double price,int per,double pow,int bar)
{
double beta = 0.45*(per-1)/(0.45*(per-1)+2);
double alpha = MathPow(beta,pow);
if(bar == Bars - 2) {tmp[num+4][index][0] = price; tmp[num+0][index][0] = price; tmp[num+2][index][0] = price;}
else
if(bar < Bars - 2)
{
tmp[num+0][index][0] = (1-alpha)*price + alpha*tmp[num+0][index][1];
tmp[num+1][index][0] = (price - tmp[num+0][index][0])*(1-beta) + beta*tmp[num+1][index][1];
tmp[num+2][index][0] = tmp[num+0][index][0] + tmp[num+1][index][0];
tmp[num+3][index][0] = (tmp[num+2][index][0] - tmp[num+4][index][1])*MathPow((1-alpha),2) + MathPow(alpha,2)*tmp[num+3][index][1];
tmp[num+4][index][0] = tmp[num+4][index][1] + tmp[num+3][index][0];
}
return(tmp[num+4][index][0]);
}
// MA_Method=21: SMA_eq - Simplified SMA
double SMA_eq(int price,double& array[],int per,int bar)
{
if(bar == Bars - per) double sma = SMA(price,per,bar);
else
if(bar < Bars - per) sma = (iMA(NULL,0,1,0,0,price,bar) - iMA(NULL,0,1,0,0,price,bar+per))/per + array[1];
return(sma);
}
double SMA_eqOnArray(double& price[],double& array[],int per,int bar)
{
if(bar == Bars - per) double sma = SMAOnArray(price,per,bar);
else
if(bar < Bars - per) sma = (price[bar] - price[bar+per])/per + array[1];
return(sma);
}
// MA_Method=22: ALMA by Arnaud Legoux / Dimitris Kouzis-Loukas / Anthony Cascino
double ALMA(int price,int per,double offset,double sigma,int bar)
{
double m = MathFloor(offset * (per - 1));
double s = per/sigma;
double w, sum =0, wsum = 0;
for (int i=0;i < per;i++)
{
w = MathExp(-((i - m)*(i - m))/(2*s*s));
wsum += w;
sum += iMA(NULL,0,1,0,0,price,bar+(per-1-i))*w;
}
if(wsum != 0) double alma = sum/wsum;
return(alma);
}
double ALMAOnArray(double& price[],int per,double offset,double sigma,int bar)
{
double m = MathFloor(offset * (per - 1));
double s = per/sigma;
double w, sum =0, wsum = 0;
for (int i=0;i < per;i++)
{
w = MathExp(-((i - m)*(i - m))/(2*s*s));
wsum += w;
sum += price[bar+(per-1-i)]*w;
}
if(wsum != 0) double alma = sum/wsum;
return(alma);
}
// MA_Method=23: TEMA - Triple Exponential Moving Average by Patrick Mulloy
double TEMA(int index,int price,int per,double v,int bar)
{
double alpha = 2.0/(per+1);
double ima = iMA(NULL,0,1,0,0,price,bar);
if(bar == Bars - 2) {tmp[0][index][0] = ima; tmp[1][index][0] = ima; tmp[2][index][0] = ima;}
else
if(bar < Bars - 2)
{
tmp[0][index][0] = tmp[0][index][1] + alpha *(ima - tmp[0][index][1]);
tmp[1][index][0] = tmp[1][index][1] + alpha *(tmp[0][index][0] - tmp[1][index][1]);
tmp[2][index][0] = tmp[2][index][1] + alpha *(tmp[1][index][0] - tmp[2][index][1]);
tmp[3][index][0] = tmp[0][index][0] + v*(tmp[0][index][0] + v*(tmp[0][index][0]-tmp[1][index][0]) - tmp[1][index][0] - v*(tmp[1][index][0] - tmp[2][index][0]));
}
return(tmp[3][index][0]);
}
double TEMAOnArray(int index,double price,int per,double v,int bar)
{
double alpha = 2.0/(per+1);
if(bar == Bars - 2) {tmp[0][index][0] = price; tmp[1][index][0] = price; tmp[2][index][0] = price;}
else
if(bar < Bars - 2)
{
tmp[0][index][0] = tmp[0][index][1] + alpha *(price - tmp[0][index][1]);
tmp[1][index][0] = tmp[1][index][1] + alpha *(tmp[0][index][0] - tmp[1][index][1]);
tmp[2][index][0] = tmp[2][index][1] + alpha *(tmp[1][index][0] - tmp[2][index][1]);
tmp[3][index][0] = tmp[0][index][0] + v*(tmp[0][index][0] + v*(tmp[0][index][0]-tmp[1][index][0]) - tmp[1][index][0] - v*(tmp[1][index][0] - tmp[2][index][0]));
}
return(tmp[3][index][0]);
}
// MA_Method=24: T3 by T.Tillson (correct version)
double T3(int index,int num,double price,int per,double v,int bar)
{
double len = MathMax((per + 5.0)/3.0-1,1), dema1, dema2;
double T3, ima = iMA(NULL,0,1,0,0,price,bar);
if(bar == Bars - 2) for(int k=0;k<6;k++) tmp[num+k][index][0] = ima;
else
if(bar < Bars - 2)
{
dema1 = DEMAOnArray(index,num ,ima ,len,v,bar);
dema2 = DEMAOnArray(index,num+2,dema1,len,v,bar);
T3 = DEMAOnArray(index,num+4,dema2,len,v,bar);
}
return(T3);
}
double T3OnArray(int index,int num,double price,int per,double v,int bar)
{
double len = MathMax((per + 5.0)/3.0 - 1,1), dema1, dema2;
if(bar == Bars - 2)
{
double T3 = price;
for(int k=0;k<6;k++) tmp[num+k][index][0] = T3;
}
else
if(bar < Bars - 2)
{
dema1 = DEMAOnArray(index,num ,price,len,v,bar);
dema2 = DEMAOnArray(index,num+2,dema1,len,v,bar);
T3 = DEMAOnArray(index,num+4,dema2,len,v,bar);
}
return(T3);
}
// MA_Method=25: Laguerre filter by J.Ehlers
double Laguerre(int index,int price,int per,int order,int bar)
{
double gamma = 1 - 10.0/(per + 9);
double ima = iMA(NULL,0,1,0,0,price,bar);
double aPrice[];
ArrayResize(aPrice,order);
for(int i=0;i= Bars - order) tmp[i][index][0] = ima;
else
{
if(i == 0) tmp[i][index][0] = (1 - gamma)*ima + gamma*tmp[i][index][1];
else
tmp[i][index][0] = -gamma * tmp[i-1][index][0] + tmp[i-1][index][1] + gamma * tmp[i][index][1];
aPrice[i] = tmp[i][index][0];
}
}
double laguerre = TriMA_genOnArray(aPrice,order,0);
return(laguerre);
}
double LaguerreOnArray(int index,double price,int per,int order,int bar)
{
double gamma = 1-10.0/(per+9);
double aPrice[];
ArrayResize(aPrice,order);
for(int i=0;i= Bars - order) tmp[i][index][0] = price;
else
{
if(i == 0) tmp[i][index][0] = (1 - gamma)*price + gamma*tmp[i][index][1];
else
tmp[i][index][0] = -gamma * tmp[i-1][index][0] + tmp[i-1][index][1] + gamma * tmp[i][index][1];
aPrice[i] = tmp[i][index][0];
}
}
double laguerre = TriMA_genOnArray(aPrice,order,0);
return(laguerre);
}
double getPivots(int type,double& price[],int size,double height)
{
if(type < 2) int len = 2*MathMax(1,size) + 1; else len = size;
int imax = 0, imin = 0;
double max = 0, min = 100000000;
for(int i=0;i max && price[i] < 1000000) {max = price[i]; imax = i;}
if((type == 1 || type == 3) && price[i] < min ) {min = price[i]; imin = i;}
}
if(type < 2)
{
if(imax == size && max - price[0] > height && max - price[len-1] > height) return(max);
if(imin == size && price[0] - min > height && price[len-1] - min > height) return(min);
}
else
{
if(type == 2) return(max);
if(type == 3) return(min);
}
return(0);
}
double stdDev(double& array[],int length)
{
double avg = 0;
for (int i=0;i