FOREX MT4 INDICATORS DOWNLOAD
  • Donate to the operator
  • MT4 INDICATORS A
  • MT4 INDICATORS B
  • MT4 INDICATORS C
  • MT4 INDICATORS D
  • MT4 INDICATORS E
  • MT4 INDICATORS F
  • MT4 INDICATORS G
  • MT4 INDICATORS H
  • MT4 INDICATORS I
  • MT4 INDICATORS J
  • MT4 INDICATORS K
  • MT4 INDICATORS L
  • MT4 INDICATORS M
  • MT4 INDICATORS N
  • MT4 INDICATORS O
  • MT4 INDICATORS P
  • MT4 INDICATORS Q
  • MT4 INDICATORS R
  • MT4 INDICATORS S
  • MT4 INDICATORS T
  • MT4 INDICATORS U
  • MT4 INDICATORS V
  • MT4 INDICATORS W
  • MT4 INDICATORS X
  • MT4 INDICATORS Y
  • MT4 INDICATORS Z
  • MT4 INDICATORS NUM
  • MT4 INDICATORS SIGN

Balance of market power nrp_alerts.mq4

Balance of market power nrp_alerts.mq4 FOREX MetaTrader4 Indicators Download

Balance of market power nrp_alerts.mq4 download link will appear after 10 seconds.


Icon

Balance of market power nrp_alerts.mq4

1 file(s) 14.62 KB
Download


Balance of market power nrp_alerts.mq4 Programming source code.

#property indicator_separate_window
#property indicator_buffers 5
#property indicator_color1  DeepSkyBlue
#property indicator_color2  PaleVioletRed
#property indicator_color3  PaleVioletRed
#property indicator_color4  DimGray
#property indicator_color5  DimGray
#property indicator_style4  STYLE_DOT
#property indicator_style5  STYLE_DOT
#property indicator_width1  2
#property indicator_width2  2
#property indicator_width3  2
#property indicator_level1  0

//
//
//
//
//

extern string TimeFrame          = "Current time frame";
extern double SmoothPeriod       = 90;
extern double SmoothPhase        =  0;
extern int    BandsPeriod        =  9;
extern bool   Interpolate        = true;

extern string _                  = "alerts settings";
extern bool   alertsOn           = true;
extern bool   alertsOnCurrent    = true;
extern bool   alertsMessage      = true;
extern bool   alertsSound        = false;
extern bool   alertsEmail        = false;

extern string  __                = "arrows settings";
extern bool   ShowArrows         = false;
extern string arrowsIdentifier   = "balance of power arrows1";
extern double arrowsDisplacement = 1.0;
extern color  arrowsUpColor      = Lime;
extern color  arrowsDnColor      = Orange;

//
//
//
//
//

double buff[];
double buffUc[];
double buffDc[];
double bandUp[];
double bandDn[];
double trend[];

int    timeFrame;
string indicatorFileName;
bool   returnBars;
bool   calculateValue;

//+------------------------------------------------------------------
//|                                                                  
//+------------------------------------------------------------------
//
//
//
//
//

int init()
{
   IndicatorBuffers(6);
   SetIndexBuffer(0,buff);
   SetIndexBuffer(1,buffUc);
   SetIndexBuffer(2,buffDc);
   SetIndexBuffer(3,bandUp);
   SetIndexBuffer(4,bandDn);
   SetIndexBuffer(5,trend);
   
   
      //
      //
      //
      //
      //
      
         indicatorFileName = WindowExpertName();
         calculateValue    = (TimeFrame=="calculateValue"); if (calculateValue) return(0);
         returnBars        = (TimeFrame=="returnBars");     if (returnBars)     return(0);
         timeFrame         = stringToTimeFrame(TimeFrame);
      
      //
      //
      //
      //
      //
   
      IndicatorShortName(timeFrameToString(timeFrame)+" Balance of market power ("+DoubleToStr(SmoothPeriod,2)+","+DoubleToStr(BandsPeriod,2)+")");
   return(0);
}

//
//
//
//
//

int deinit(){  if (!calculateValue && ShowArrows) deleteArrows();  return(0); }


//+------------------------------------------------------------------
//|                                                                  
//+------------------------------------------------------------------
//
//
//
//
//

int start()
{
   int i,limit,counted_bars=IndicatorCounted();
      if(counted_bars<0) return(-1);
      if(counted_bars>0) counted_bars--;
            limit = MathMin(Bars-counted_bars,Bars-1);
            if (returnBars) { buff[0] = limit+1; return(0); }

   //
   //
   //
   //
   //

   if (calculateValue || timeFrame == Period())
   {
      if (!calculateValue && trend[limit]==-1) CleanPoint(limit,buffUc,buffDc);
      for(i=limit; i>=0; i--) 
      {
         double range = MathMax(High[i]-Low[i],Point);
         double buo   = (High[i]-Open[i])/range;
         double buc   = (Close[i]-Low[i])/range;
         double buoc  = MathMax(Close[i]-Open[i],0)/range;
         double beo   = (Open[i]-Low[i])/range;
         double bec   = (High[i]-Close[i])/range;
         double beoc  = MathMax(Open[i]-Close[i],0)/range;
      
         //
         //
         //
         //
         //
         
         buff[i] = iSmooth((buo+buc+buoc)/3.0-(beo+bec+beoc)/3.0,SmoothPeriod,SmoothPhase,i);
               double avg = iSmooth(buff[i],BandsPeriod,SmoothPhase,i,1);
               double dev = iDeviation(buff,BandsPeriod,buff[i],i);
         bandUp[i] = avg+dev;
         bandDn[i] = avg-dev;
         buffUc[i] = EMPTY_VALUE;
         buffDc[i] = EMPTY_VALUE;
         trend[i]  = trend[i+1];
         
         if(buff[i] > buff[i+1]) trend[i] =  1;
         if(buff[i] < buff[i+1]) trend[i] = -1;
         if (!calculateValue) manageArrow(i);
         if (!calculateValue && trend[i]==-1) PlotPoint(i,buffUc,buffDc,buff);
                              
      }

      //
      //
      //
      //
      //
      
      manageAlerts();
      return(0);
   }      
   
   //
   //
   //
   //
   //
   
   limit = MathMax(limit,MathMin(Bars-1,iCustom(NULL,timeFrame,indicatorFileName,"returnBars",0,0)*timeFrame/Period()));
   if (trend[limit]==-1) CleanPoint(limit,buffUc,buffDc);
   for(i=limit; i>=0; i--)
   {
      int y = iBarShift(NULL,timeFrame,Time[i]);
         buff[i]   = iCustom(NULL,timeFrame,indicatorFileName,"calculateValue",SmoothPeriod,SmoothPhase,BandsPeriod,0,y);
         buffUc[i] = EMPTY_VALUE;
         buffDc[i] = EMPTY_VALUE;
         bandUp[i] = iCustom(NULL,timeFrame,indicatorFileName,"calculateValue",SmoothPeriod,SmoothPhase,BandsPeriod,3,y);
         bandDn[i] = iCustom(NULL,timeFrame,indicatorFileName,"calculateValue",SmoothPeriod,SmoothPhase,BandsPeriod,4,y);
         trend[i]  = iCustom(NULL,timeFrame,indicatorFileName,"calculateValue",SmoothPeriod,SmoothPhase,BandsPeriod,5,y);
         
         manageArrow(i);
            
         //
         //
         //
         //
         //
      
         if (!Interpolate || y==iBarShift(NULL,timeFrame,Time[i-1])) continue;

         //
         //
         //
         //
         //

         datetime time = iTime(NULL,timeFrame,y);
            for(int n = 1; i+n < Bars && Time[i+n] >= time; n++) continue;	
            for(int k = 1; k < n; k++)
            {
               buff[i+k]   = buff[i]   + (buff[i+n]   - buff[i]  )*k/n;
               bandUp[i+k] = bandUp[i] + (bandUp[i+n] - bandUp[i])*k/n;
               bandDn[i+k] = bandDn[i] + (bandDn[i+n] - bandDn[i])*k/n;
            }               
   }
   for (i=limit;i>=0;i--) if (trend[i]==-1) PlotPoint(i,buffUc,buffDc,buff);

   //
   //
   //
   //
   //
   
   manageAlerts();
   return(0);
}


//+------------------------------------------------------------------
//|                                                                  
//+------------------------------------------------------------------
//
//
//
//
//

double iDeviation(double& array[], double period, double ma, int i, bool isSample=false)
{
   double sum = 0.00;
      for(int k=0; k MathAbs(del2)) wrk[r][volty+s] = MathAbs(del1); 
               if(MathAbs(del1) < MathAbs(del2)) wrk[r][volty+s] = MathAbs(del2); 
         wrk[r][vsum+s] =	wrk[r-1][vsum+s] + (wrk[r][volty+s]-wrk[r-forBar][volty+s])*div;
         
         //
         //
         //
         //
         //
   
         wrk[r][avolty+s] = wrk[r-1][avolty+s]+(2.0/(MathMax(4.0*length,30)+1.0))*(wrk[r][vsum+s]-wrk[r-1][avolty+s]);
            if (wrk[r][avolty+s] > 0)
               double dVolty = wrk[r][volty+s]/wrk[r][avolty+s]; else dVolty = 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) wrk[r][bsmax+s] = price; else wrk[r][bsmax+s] = price - Kv*del1;
         if (del2 < 0) wrk[r][bsmin+s] = price; else wrk[r][bsmin+s] = price - Kv*del2;
	
   //
   //
   //
   //
   //
      
      double R     = 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);

         wrk[r][0+s] = price + alpha*(wrk[r-1][0+s]-price);
         wrk[r][1+s] = (price - wrk[r][0+s])*(1-beta) + beta*wrk[r-1][1+s];
         wrk[r][2+s] = (wrk[r][0+s] + R*wrk[r][1+s]);
         wrk[r][3+s] = (wrk[r][2+s] - wrk[r-1][4+s])*MathPow((1-alpha),2) + MathPow(alpha,2)*wrk[r-1][3+s];
         wrk[r][4+s] = (wrk[r-1][4+s] + wrk[r][3+s]); 

   //
   //
   //
   //
   //

   return(wrk[r][4+s]);
}


//+-------------------------------------------------------------------
//|                                                                  
//+-------------------------------------------------------------------
//
//
//
//
//

string sTfTable[] = {"M1","M5","M15","M30","H1","H4","D1","W1","MN"};
int    iTfTable[] = {1,5,15,30,60,240,1440,10080,43200};

//
//
//
//
//

int stringToTimeFrame(string tfs)
{
   tfs = stringUpperCase(tfs);
   for (int i=ArraySize(iTfTable)-1; i>=0; i--)
         if (tfs==sTfTable[i] || tfs==""+iTfTable[i]) return(MathMax(iTfTable[i],Period()));
                                                      return(Period());
}
string timeFrameToString(int tf)
{
   for (int i=ArraySize(iTfTable)-1; i>=0; i--) 
         if (tf==iTfTable[i]) return(sTfTable[i]);
                              return("");
}

//
//
//
//
//

string stringUpperCase(string str)
{
   string   s = str;

   for (int length=StringLen(str)-1; length>=0; length--)
   {
      int tchar = StringGetChar(s, length);
         if((tchar > 96 && tchar < 123) || (tchar > 223 && tchar < 256))
                     s = StringSetChar(s, length, tchar - 32);
         else if(tchar > -33 && tchar < 0)
                     s = StringSetChar(s, length, tchar + 224);
   }
   return(s);
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//
//
//
//
//

void CleanPoint(int i,double& first[],double& second[])
{
   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 (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;
      }
}

//
//
//
//
//

void manageAlerts()
{
   if (!calculateValue && alertsOn)
   {
      if (alertsOnCurrent)
           int whichBar = 0;
      else     whichBar = 1; whichBar = iBarShift(NULL,0,iTime(NULL,timeFrame,whichBar));
      if (trend[whichBar] != trend[whichBar+1])
      {
         if (trend[whichBar] == 1) doAlert(whichBar,"buy");
         if (trend[whichBar] ==-1) doAlert(whichBar,"sell");
      }         
   }
}   

//
//
//
//
//

void doAlert(int forBar, string doWhat)
{
   static string   previousAlert="nothing";
   static datetime previousTime;
   string message;
   
   if (previousAlert != doWhat || previousTime != Time[forBar]) {
       previousAlert  = doWhat;
       previousTime   = Time[forBar];

       //
       //
       //
       //
       //

       message =  StringConcatenate(Symbol()," at ",TimeToStr(TimeLocal(),TIME_SECONDS)," - ",timeFrameToString(timeFrame)+" balance of power shifted to ",doWhat);
          if (alertsMessage) Alert(message);
          if (alertsEmail)   SendMail(StringConcatenate(Symbol()," balance of power "),message);
          if (alertsSound)   PlaySound("alert2.wav");
   }
}

//
//
//
//
//

void manageArrow(int i)
{
   if (!calculateValue && ShowArrows)
   {
      deleteArrow(Time[i]);
      if (trend[i]!=trend[i+1])
      {
         if (trend[i] == 1) drawArrow(i,arrowsUpColor,241,false);
         if (trend[i] ==-1) drawArrow(i,arrowsDnColor,242,true);
      }
   }
}               

//
//
//
//
//

void drawArrow(int i,color theColor,int theCode,bool up)
{
   string name = arrowsIdentifier+":"+Time[i];
   double gap  = iATR(NULL,0,20,i);   
   
      //
      //
      //
      //
      //
      
      ObjectCreate(name,OBJ_ARROW,0,Time[i],0);
         ObjectSet(name,OBJPROP_ARROWCODE,theCode);
         ObjectSet(name,OBJPROP_COLOR,theColor);
  
         if (up)
               ObjectSet(name,OBJPROP_PRICE1,High[i] + arrowsDisplacement * gap);
         else  ObjectSet(name,OBJPROP_PRICE1,Low[i]  - arrowsDisplacement * gap);
}

//
//
//
//
//

void deleteArrows()
{
   string lookFor       = arrowsIdentifier+":";
   int    lookForLength = StringLen(lookFor);
   for (int i=ObjectsTotal()-1; i>=0; i--)
   {
      string objectName = ObjectName(i);
         if (StringSubstr(objectName,0,lookForLength) == lookFor) ObjectDelete(objectName);
   }
}

//
//
//
//
//

void deleteArrow(datetime time)
{
   string lookFor = arrowsIdentifier+":"+time; ObjectDelete(lookFor);
}

//
//
//
//
//

AMA.mq4 bb macd – ssa.mq4

Related Posts

METATRADER4B

BykovTrend_Sig alert.mq4

METATRADER4B

BuySel Alert.mq4

METATRADER4B

BUTTONS_SW_TRO_MODIFIED.mq4

METATRADER4B

BUOVB_BEOVB 1.mq4

METATRADER4B

boSugarman Signals_v3 (1).ex4

METATRADER4B

Bollinger band bars.mq4

METATRADER4B

BO_NRP.mq4

METATRADER4B

BKMGC2.ex4

METATRADER4B

BigReversalSystem_V1.0.ex4

METATRADER4B

Bigger TF Candles WeekDay KB+TT.mq4

METATRADER4B

BetterVolume 1.5 new with Alerts mod.mq4

METATRADER4B

BetterVolume 1.4+Alert.mq4

How to use this site.
  1. Subscribe YouTube
  2. Subscribe Facebook
  3. Subscribe Instagram
  4. Download MT4
  5. Watch Youtube Video
  6. Downliad Indicator and Try Trading
  7. Donate to the operator

Recent News

  • xpMA.mq4
  • XO ATR AA7 MTF TT.mq4
  • xma.mq4
  • YangTrader.ex4
  • zup_v135_all_hl_113.ex4
  • Zone.mq4
  • ZigzagFr_v1.mq4
  • ZigZag_ws_Chanel_SweetSNR.mq4
  • ZigZag_Larsen_out & alerts.mq4
  • Zig Zag Arrow.mq4
  • Zeus.mq4
  • ZeroLag Tema MACD – mtf + lines 2 (1).mq4
  • Zero lag T3.mq4
  • ZB TMA TT.mq4
  • Uni_cross-sep_alerts.mq4

Donate