Velocity normalized Indicator For MT5

Velocity normalized Indicator For MT5

The Velocity normalized Indicator For MT5 is a marvelous technical trading tool because it offers traders a superior trading experience in comparison to using momentum based indicators because with this indicator the distinction is made in its algorithm which has more leverage for providing traders with smooth momentum oscillations therefore once the trade gets the hang of using this indicator they will gradually reduce their usage of the normal momentum indicator. Momentum is a component of velocity - the speed of a trend is an essential aspect to monitor - and another benefit is that oversold and overbought zones are easily identifiable now. Furthermore, the levels of the indicator are not fixed - it uses floating levels to define its oscillations and respective oversold and overbought zones which is a great way to go about because the nature of the market and its associated velocity or smoothed out momentum are not fixed parameters.

FREE Velocity - normalized Indicator

Download the FREE Velocity - normalized Indicator for MT5.

To receive my email 100% sure: 
Put my email on your whitelist!

 

Partially Automated Trading Besides Your Day Job

Alerts In Real-Time When Divergences Occur

My Recommended MT4/MT5 Broker

 

Installing the Velocity normalized Indicator For MT5

After you downloaded the indicator via the form above you need to unzip the zip-file. Then you need to copy the file Velocity_-_normalized.mq5 into the folder MQL5\Indicators of your MT5 installation. After that please restart MT5 and then you will be able to see the indicator in the list of indicators.

Parameters of the Velocity normalized Indicator For MT5

The Velocity normalized Indicator For MT5 has 15 parameters to configure.

input ENUM_TIMEFRAMES TimeFrame       = PERIOD_CURRENT; // Time frame
input int             VelPeriod       = 32;             // Velocity period
input enPrices        VelPrice        = pr_close;       // Price to use
input enNormMethod    NormMethod      = nm_atr;         // Normalization method
input enColorOn       ColorOn         = cc_onLevels;    // Color change :
input int             MinMaxPeriod    = 50;             // Floating levels period (<= 1 to use velocity period)
input double          LevelUp         = 80.0;           // Up level %
input double          LevelDown       = 20.0;           // Down level %
input bool            alertsOn        = false;          // Turn alerts on?
input bool            alertsOnCurrent = true;           // Alert on current bar?
input bool            alertsMessage   = true;           // Display messageas on alerts?
input bool            alertsSound     = false;          // Play sound on alerts?
input bool            alertsEmail     = false;          // Send email on alerts?
input bool            alertsNotify    = false;          // Send push notification on alerts?
input bool            Interpolate     = true;           // Interpolate mtf data ?

Buffers of the Velocity normalized Indicator For MT5

The Velocity normalized Indicator For MT5 provides 8 buffers.

SetIndexBuffer(0,fill1  ,INDICATOR_DATA);
SetIndexBuffer(1,fill2  ,INDICATOR_DATA);
SetIndexBuffer(2,levelUp,INDICATOR_DATA);
SetIndexBuffer(3,levelMi,INDICATOR_DATA);
SetIndexBuffer(4,levelDn,INDICATOR_DATA);
SetIndexBuffer(5,vel    ,INDICATOR_DATA);
SetIndexBuffer(6,velc   ,INDICATOR_COLOR_INDEX);
SetIndexBuffer(7,count  ,INDICATOR_CALCULATIONS);

Main Parts Of The Code

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) lt rates_total) return(-1);
   
      //
      //
      //
      //
      //
      
      if (timeFrame!=_Period)
      {
         double result[]; datetime currTime[],nextTime[]; 
            if (_mtfHandle==INVALID_HANDLE) _mtfHandle = _mtfCall;
            if (_mtfHandle==INVALID_HANDLE)              return(0);
            if (CopyBuffer(_mtfHandle,7,0,1,result)==-1) return(0); 
      
                //
                //
                //
                //
                //
              
                #define _mtfRatio PeriodSeconds(timeFrame)/PeriodSeconds(_Period)
                int i,limit = MathMin(MathMax(prev_calculated-1,0),MathMax(rates_total-(int)result[0]*_mtfRatio-1,0));
                for (i=limit; i lt rates_total && !_StopFlag; i++ )
                {
                   if (CopyBuffer(_mtfHandle,0,time[i],1,result)==-1) break; fill1[i]   = result[0];
                   if (CopyBuffer(_mtfHandle,1,time[i],1,result)==-1) break; fill2[i]   = result[0];
                   if (CopyBuffer(_mtfHandle,2,time[i],1,result)==-1) break; levelUp[i] = result[0];
                   if (CopyBuffer(_mtfHandle,3,time[i],1,result)==-1) break; levelMi[i] = result[0];
                   if (CopyBuffer(_mtfHandle,4,time[i],1,result)==-1) break; levelDn[i] = result[0];
                   if (CopyBuffer(_mtfHandle,5,time[i],1,result)==-1) break; vel[i]     = result[0];
                   if (CopyBuffer(_mtfHandle,6,time[i],1,result)==-1) break; velc[i]    = result[0];
                   
                   //
                   //
                   //
                   //
                   //
                   
                   #define _interpolate(buff,i,k,n) buff[i-k] = buff[i]+(buff[i-n]-buff[i])*k/n
                   if (!Interpolate) continue; CopyTime(_Symbol,TimeFrame,time[i  ],1,currTime); 
                      if (i lt (rates_total-1)) { CopyTime(_Symbol,TimeFrame,time[i+1],1,nextTime); if (currTime[0]==nextTime[0]) continue; }
                      int n,k;
                         for(n=1; (i-n) gt  0 && time[i-n]  gt = currTime[0]; n++) continue;	
                         for(k=1; (i-k) gt =0 && k lt n; k++)
                         {
                            _interpolate(fill1  ,i,k,n);
                            _interpolate(fill2  ,i,k,n);
                            _interpolate(levelUp,i,k,n);
                            _interpolate(levelDn,i,k,n);
                            _interpolate(levelMi,i,k,n);
                            _interpolate(vel    ,i,k,n);
                         }                            
                }     
                if (i!=rates_total) return(0); return(rates_total);
      }

   //
   //
   //
   //
   //

   int minMaxPeriod = (MinMaxPeriod gt 0) ? MinMaxPeriod : VelPeriod;
   for (int i=(int)MathMax(prev_calculated-1,0); i lt rates_total && !_StopFlag; i++)
   {
      double price = getPrice(VelPrice,open,close,high,low,i,rates_total), div=0;
            switch (NormMethod)
            {
               case nm_atr : div = iAtr(VelPeriod,high,low,close,i); break;
               case nm_non : div = 1;                                break;
               default :     div = iDeviation(price,VelPeriod,NormMethod==nm_stc,i,rates_total);
            }                                    
            vel[i] = (div!=0) ? iMomentumS(price,VelPeriod,1,2,i,rates_total)/div : iMomentumS(price,VelPeriod,1,2,i,rates_total);
            double min = vel[i], max = vel[i];
            for (int k=1; k lt minMaxPeriod && i-k gt =0; k++)
            {
                  min = MathMin(vel[i-k],min);
                  max = MathMax(vel[i-k],max);
            }
            double range = max-min;
            levelUp[i] = min+LevelUp  *range/100.0;
            levelDn[i] = min+LevelDown*range/100.0;
            levelMi[i] = min+0.5*range;
            switch(ColorOn)
            {
               case cc_onLevels: velc[i] = (vel[i] gt levelUp[i])  ? 1 : (vel[i] lt levelDn[i])  ? 2 : 0; break;
               case cc_onMiddle: velc[i] = (vel[i] gt levelMi[i])  ? 1 : (vel[i] lt levelMi[i])  ? 2 : 0; break;
               default :         velc[i] = (i gt 0) ? (vel[i] gt vel[i-1]) ? 1 : (vel[i] lt vel[i-1]) ? 2 : 0 : 0;
            }                  
      fill1[i] = vel[i];
      fill2[i] = (vel[i] gt levelUp[i]) ? levelUp[i] : (vel[i] lt levelDn[i]) ? levelDn[i] : vel[i];
   }
   count[rates_total-1] = MathMax(rates_total-prev_calculated+1,1);
   manageAlerts(time,velc,rates_total);
   return(rates_total);
}

//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//

double iAtr(int atrPeriod, const double& high[],  const double& low[], const double& close[], int i)
{
   double atr=0;
   for (int k=0; k lt atrPeriod && i-k gt =0; k++)
      if (i-k==0)
            atr += high[i-k]+low[i-k];
      else  atr += MathMax(high[i-k],close[i-k-1])-MathMin(low[i-k],close[i-k-1]);
   return(atr/atrPeriod);
}

// 
//
//
//
//

double workDev[];
double iDeviation(double value, int length, bool isSample, int i, int bars)
{
   if (ArraySize(workDev)!=bars) ArrayResize(workDev,bars); workDev[i] = value;
                 
   //
   //
   //
   //
   //
   
      double oldMean   = value;
      double newMean   = value;
      double squares   = 0; int k;
      for (k=1; k lt length && (i-k) gt =0; k++)
      {
         newMean  = (workDev[i-k]-oldMean)/(k+1)+oldMean;
         squares += (workDev[i-k]-oldMean)*(workDev[i-k]-newMean);
         oldMean  = newMean;
      }
      return(MathSqrt(squares/MathMax(k-isSample,1)));
}

//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//

void manageAlerts(const datetime& time[], double& ttrend[], int bars)
{
   if (!alertsOn) return;
      int whichBar = bars-1; if (!alertsOnCurrent) whichBar = bars-2; datetime time1 = time[whichBar];
      if (ttrend[whichBar] != ttrend[whichBar-1])
      {
         if (ttrend[whichBar] == 1) doAlert(time1,"up");
         if (ttrend[whichBar] == 2) doAlert(time1,"down");
      }         
}   

//
//
//
//
//

void doAlert(datetime forTime, string doWhat)
{
   static string   previousAlert="nothing";
   static datetime previousTime;
   
   if (previousAlert != doWhat || previousTime != forTime) 
   {
      previousAlert  = doWhat;
      previousTime   = forTime;

      string message = timeFrameToString(_Period)+" "+_Symbol+" at "+TimeToString(TimeLocal(),TIME_SECONDS)+" velocity state changed to "+doWhat;
         if (alertsMessage) Alert(message);
         if (alertsEmail)   SendMail(_Symbol+" velocity",message);
         if (alertsNotify)  SendNotification(message);
         if (alertsSound)   PlaySound("alert2.wav");
   }
}

//------------------------------------------------------------------
//                                                                 
//------------------------------------------------------------------
//
//
//
//
//

double workMom[];
double iMomentumS(double price, double length, double powSlow, double powFast, int i, int bars)
{
   if (ArraySize(workMom)!=bars) ArrayResize(workMom,bars);  workMom[i] = price;
      
      //
      //
      //
      //
      //
      
      double suma = 0.0, sumwa=0;
      double sumb = 0.0, sumwb=0;
         for(int k=0; k lt length && (i-k) gt =0; k++)
         {
            double weight = length-k;
               suma  += workMom[i-k] * MathPow(weight,powSlow);
               sumb  += workMom[i-k] * MathPow(weight,powFast);
               sumwa += MathPow(weight,powSlow);
               sumwb += MathPow(weight,powFast);
         }
   return(sumb/sumwb-suma/sumwa);
}  


//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
//

#define priceInstances 1
double workHa[][priceInstances*4];
double getPrice(int tprice, const double& open[], const double& close[], const double& high[], const double& low[], int i,int _bars, int instanceNo=0)
{
  if (tprice gt =pr_haclose)
   {
      if (ArrayRange(workHa,0)!= _bars) ArrayResize(workHa,_bars); instanceNo*=4;
         
         //
         //
         //
         //
         //
         
         double haOpen;
         if (i gt 0)
                haOpen  = (workHa[i-1][instanceNo+2] + workHa[i-1][instanceNo+3])/2.0;
         else   haOpen  = (open[i]+close[i])/2;
         double haClose = (open[i] + high[i] + low[i] + close[i]) / 4.0;
         double haHigh  = MathMax(high[i], MathMax(haOpen,haClose));
         double haLow   = MathMin(low[i] , MathMin(haOpen,haClose));

         if(haOpen   lt haClose) { workHa[i][instanceNo+0] = haLow;  workHa[i][instanceNo+1] = haHigh; } 
         else                 { workHa[i][instanceNo+0] = haHigh; workHa[i][instanceNo+1] = haLow;  } 
                                workHa[i][instanceNo+2] = haOpen;
                                workHa[i][instanceNo+3] = haClose;
         //
         //
         //
         //
         //
         
         switch (tprice)
         {
            case pr_haclose:     return(haClose);
            case pr_haopen:      return(haOpen);
            case pr_hahigh:      return(haHigh);
            case pr_halow:       return(haLow);
            case pr_hamedian:    return((haHigh+haLow)/2.0);
            case pr_hamedianb:   return((haOpen+haClose)/2.0);
            case pr_hatypical:   return((haHigh+haLow+haClose)/3.0);
            case pr_haweighted:  return((haHigh+haLow+haClose+haClose)/4.0);
            case pr_haaverage:   return((haHigh+haLow+haClose+haOpen)/4.0);
            case pr_hatbiased:
               if (haClose gt haOpen)
                     return((haHigh+haClose)/2.0);
               else  return((haLow+haClose)/2.0);        
            case pr_hatbiased2:
               if (haClose gt haOpen)  return(haHigh);
               if (haClose lt haOpen)  return(haLow);
                                    return(haClose);        
         }
   }
   
   //
   //

 

About Me

I'm Mike Semlitsch the owner of PerfectTrendSystem.com. My trading career started in 2007. Since 2013 I have helped thousands of traders to take their trading to the next level. Many of them are now constantly profitable traders. 

The following performance was achieved by me while trading live in front of hundreds of my clients:

Connect With Me:  

This FREE Indicator Can Transform
Your Trading!

FREE Indicator + Telegram Group


Request the Ultimate Double Top/Bottom Indicator which is used by 10,000+ traders.

Results From 5 Months!
This service starts soon! Be the first who get's notified when it begins!