//+------------------------------------------------------------------
#property copyright "mladen"
#property link "mladenfx@gmail.com"
#property description "Ultra trend"
//+------------------------------------------------------------------
#property indicator_separate_window
#property indicator_buffers 6
#property indicator_plots 3
#property indicator_label1 "Filling"
#property indicator_type1 DRAW_FILLING
#property indicator_color1 clrLightGreen,clrWheat
#property indicator_label2 "Ultra trend +"
#property indicator_type2 DRAW_COLOR_LINE
#property indicator_color2 clrDarkGray,clrLimeGreen,clrOrange
#property indicator_width2 3
#property indicator_label3 "Ultra trend -"
#property indicator_type3 DRAW_COLOR_LINE
#property indicator_color3 clrDarkGray,clrLimeGreen,clrOrange
#property indicator_width3 1
//+------------------------------------------------------------------+
//| Custom classes |
//+------------------------------------------------------------------+
class CJurikSmooth
{
private:
int m_size;
double m_wrk[][10];
//
//---
//
public :
CJurikSmooth(void) : m_size(0) { return; }
~CJurikSmooth(void) { return; }
double CalculateValue(double price,double length,double phase,int r,int bars)
{
#define bsmax 5
#define bsmin 6
#define volty 7
#define vsum 8
#define avolty 9
if (m_size!=bars) ArrayResize(m_wrk,bars); if (ArrayRange(m_wrk,0)!=bars) return(price); m_size=bars;
if(r==0 || length<=1) { int k=0; for(; k<7; k++) m_wrk[r][k]=price; for(; k<10; k++) m_wrk[r][k]=0; return(price); }
//
//---
//
double len1 = MathMax(MathLog(MathSqrt(0.5*(length-1)))/MathLog(2.0)+2.0,0);
double pow1 = MathMax(len1-2.0,0.5);
double del1 = price - m_wrk[r-1][bsmax];
double del2 = price - m_wrk[r-1][bsmin];
int forBar = MathMin(r,10);
m_wrk[r][volty]=0;
if(MathAbs(del1) > MathAbs(del2)) m_wrk[r][volty] = MathAbs(del1);
if(MathAbs(del1) < MathAbs(del2)) m_wrk[r][volty] = MathAbs(del2);
m_wrk[r][vsum]=m_wrk[r-1][vsum]+(m_wrk[r][volty]-m_wrk[r-forBar][volty])*0.1;
//
//---
//
m_wrk[r][avolty]=m_wrk[r-1][avolty]+(2.0/(MathMax(4.0*length,30)+1.0))*(m_wrk[r][vsum]-m_wrk[r-1][avolty]);
double dVolty=(m_wrk[r][avolty]>0) ? m_wrk[r][volty]/m_wrk[r][avolty]: 0;
if(dVolty > MathPow(len1,1.0/pow1)) dVolty = MathPow(len1,1.0/pow1);
if(dVolty < 1) dVolty = 1.0;
//
//---
//
double pow2 = MathPow(dVolty, pow1);
double len2 = MathSqrt(0.5*(length-1))*len1;
double Kv = MathPow(len2/(len2+1), MathSqrt(pow2));
if(del1 > 0) m_wrk[r][bsmax] = price; else m_wrk[r][bsmax] = price - Kv*del1;
if(del2 < 0) m_wrk[r][bsmin] = price; else m_wrk[r][bsmin] = price - Kv*del2;
//
//---
//
double corr = MathMax(MathMin(phase,100),-100)/100.0 + 1.5;
double beta = 0.45*(length-1)/(0.45*(length-1)+2);
double alpha = MathPow(beta,pow2);
m_wrk[r][0] = price + alpha*(m_wrk[r-1][0]-price);
m_wrk[r][1] = (price - m_wrk[r][0])*(1-beta) + beta*m_wrk[r-1][1];
m_wrk[r][2] = (m_wrk[r][0] + corr*m_wrk[r][1]);
m_wrk[r][3] = (m_wrk[r][2] - m_wrk[r-1][4])*MathPow((1-alpha),2) + MathPow(alpha,2)*m_wrk[r-1][3];
m_wrk[r][4] = (m_wrk[r-1][4] + m_wrk[r][3]);
//
//---
//
return(m_wrk[r][4]);
#undef bsmax
#undef bsmin
#undef volty
#undef vsum
#undef avolty
}
};
//
//--- input parameters
//
input int inpUtrPeriod = 3; // Start period
input int inpProgression = 5; // Step
input int inpInstances = 30; // Instances
input int inpSmooth = 5; // Ultra trend smoothing period
input int inpSmoothPhase = 100; // Ultra trend smoothing phase
//--- buffers declarations
double fillu[],filld[],valp[],valpc[],valm[],valmc[];
CJurikSmooth _iSmooth[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//--- indicator buffers mapping
SetIndexBuffer(0,fillu,INDICATOR_DATA);
SetIndexBuffer(1,filld,INDICATOR_DATA);
SetIndexBuffer(2,valp,INDICATOR_DATA);
SetIndexBuffer(3,valpc,INDICATOR_COLOR_INDEX);
SetIndexBuffer(4,valm,INDICATOR_DATA);
SetIndexBuffer(5,valmc,INDICATOR_COLOR_INDEX);
ArrayResize(_iSmooth,inpInstances+3);
PlotIndexSetInteger(0,PLOT_SHOW_DATA,false);
//--- indicator short name
IndicatorSetString(INDICATOR_SHORTNAME,"Ultra trend ("+(string)inpUtrPeriod+","+(string)inpProgression+","+(string)inpInstances+")");
//---
return (INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Custom indicator de-initialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
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(Bars(_Symbol,_Period)<rates_total) return(prev_calculated);
int endLength=inpUtrPeriod+inpProgression*inpInstances;
int i=(int)MathMax(prev_calculated-1,1); for(; i<rates_total && !_StopFlag; i++)
{
double valueUp=0;
double valueDn=0;
for(int k=inpUtrPeriod,instance=2; k<=endLength && i>0; k+=inpProgression,instance++)
if(_iSmooth[instance].CalculateValue(close[i-1],k,inpSmoothPhase,i-1,rates_total)<_iSmooth[instance].CalculateValue(close[i],k,inpSmoothPhase,i,rates_total))
valueUp++;
else valueDn++;
valp[i] = _iSmooth[0].CalculateValue(valueUp,inpSmooth,inpSmoothPhase,i,rates_total);
valm[i] = _iSmooth[1].CalculateValue(valueDn,inpSmooth,inpSmoothPhase,i,rates_total);
valpc[i] = (valp[i]>valm[i]) ? 1 : 2;
valmc[i] = valpc[i];
fillu[i] = valp[i];
filld[i] = valm[i];
}
return (i);
}
//+------------------------------------------------------------------+
.
