Unusial_Volume_Price_Movement

ÿþ//+------------------------------------------------------------------+

//|                                Unusial_Volume_Price_Movement.mq5 |

//|                        Copyright 2018, MetaQuotes Software Corp. |

//|                                                 https://mql5.com |

//+------------------------------------------------------------------+

#property copyright "Copyright 2018, MetaQuotes Software Corp."

#property link      "https://mql5.com"

#property version   "1.00"

#property description "Unusial Volume Price Movement indicator"

#property indicator_chart_window

#property indicator_buffers 3

#property indicator_plots   2

//--- plot UP

#property indicator_label1  "Break Up"

#property indicator_type1   DRAW_ARROW

#property indicator_color1  clrGreen

#property indicator_style1  STYLE_SOLID

#property indicator_width1  1

//--- plot DN

#property indicator_label2  "Break Down"

#property indicator_type2   DRAW_ARROW

#property indicator_color2  clrRed

#property indicator_style2  STYLE_SOLID

#property indicator_width2  1

//--- enums

enum ENUM_CALC_METHOD

  {

   CALC_METHOD_PT,   // Points

   CALC_METHOD_PRC   // Percentage

  };

//--- input parameters

input uint              InpPeriodAvg      =  25;               // Average range

input double            InpMultiplierVol  =  2.0;              // Volume multiplier

input ENUM_CALC_METHOD  InpMethod         =  CALC_METHOD_PT;   // Calculation method

input uint              InpPeriodPrice    =  25;               // Price period

input double            InpValue          =  0.0;              // Value

//--- indicator buffers

double         BufferUP[];

double         BufferDN[];

double         BufferVol[];

//--- global variables

double         multiplier;

double         value;

int            period_avg;

int            period_price;

//+------------------------------------------------------------------+

//| Custom indicator initialization function                         |

//+------------------------------------------------------------------+

int OnInit()

  {

//--- set global variables

   period_avg=int(InpPeriodAvg<1 ? 1 : InpPeriodAvg);

   period_price=int(InpPeriodPrice<1 ? 1 : InpPeriodPrice);

   multiplier=(InpMultiplierVol<0 ? 0 : InpMultiplierVol);

   value=(InpValue<0 ? 0 : InpValue);

//--- indicator buffers mapping

   SetIndexBuffer(0,BufferUP,INDICATOR_DATA);

   SetIndexBuffer(1,BufferDN,INDICATOR_DATA);

   SetIndexBuffer(2,BufferVol,INDICATOR_CALCULATIONS);

//--- setting a code from the Wingdings charset as the property of PLOT_ARROW

   PlotIndexSetInteger(0,PLOT_ARROW,233);

   PlotIndexSetInteger(1,PLOT_ARROW,234);

//--- setting indicator parameters

   IndicatorSetString(INDICATOR_SHORTNAME,"Unusial Volume Price Movement ("+(string)period_avg+","+DoubleToString(multiplier,1)+","+(string)period_price+","+DoubleToString(value,1)+")");

   IndicatorSetInteger(INDICATOR_DIGITS,Digits());

//--- setting buffer arrays as timeseries

   ArraySetAsSeries(BufferUP,true);

   ArraySetAsSeries(BufferDN,true);

   ArraySetAsSeries(BufferVol,true);

//---

   return(INIT_SUCCEEDED);

  }

//+------------------------------------------------------------------+

//| 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[])

  {

//--- #AB0=>2:0 <0AA82>2 1CD5@>2 :0: B09<A5@89

   ArraySetAsSeries(high,true);

   ArraySetAsSeries(low,true);

   ArraySetAsSeries(close,true);

   ArraySetAsSeries(tick_volume,true);

//--- @>25@:0 :>;8G5AB20 4>ABC?=KE 10@>2

   if(rates_total<fmax(period_price,4) || Point()==0) return 0;

//--- @>25@:0 8 @0AGQB :>;8G5AB20 ?@>AG8BK205<KE 10@>2

   int limit=rates_total-prev_calculated;

   if(limit>1)

     {

      limit=rates_total-period_price-2;

      ArrayInitialize(BufferUP,EMPTY_VALUE);

      ArrayInitialize(BufferDN,EMPTY_VALUE);

     }

//--- >43>B>2:0 40==KE

   for(int i=limit; i>=0 && !IsStopped(); i--)

      BufferVol[i]=(double)tick_volume[i];



//---  0AGQB 8=48:0B>@0

   for(int i=limit; i>=0 && !IsStopped(); i--)

     {

      double avg_vol=GetSMA(rates_total,i,period_avg,BufferVol);

      BufferUP[i]=BufferDN[i]=EMPTY_VALUE;

      if(BufferVol[i]<avg_vol*multiplier)

         BufferUP[i]=BufferDN[i]=EMPTY_VALUE;

      else

        {

         int bl=Lowest(period_price,i+1);

         int bh=Highest(period_price,i+1);

         if(bl==WRONG_VALUE || bh==WRONG_VALUE)

            continue;

         double bottom=low[bl];

         double top=high[bh];

         if(bottom==0 || top==0)

            continue;



         if(InpMethod==CALC_METHOD_PT)

           {

            top+=value*Point();

            bottom-=value*Point();

           }

         else

           {

            top+=top*value/100.0;

            bottom-=bottom*value/100.0;

           }



         if(close[i]>top)

           {

            BufferUP[i]=low[i];

            BufferDN[i]=EMPTY_VALUE;

           }

         else

           {

            if(close[i]<bottom)

              {

               BufferDN[i]=high[i];

               BufferUP[i]=EMPTY_VALUE;

              }

            else

              {

               BufferUP[i]=BufferDN[i]=EMPTY_VALUE;

              }

           }

        }

     }



//--- return value of prev_calculated for next call

   return(rates_total);

  }

//+------------------------------------------------------------------+

//| Simple Moving Average                                            |

//+------------------------------------------------------------------+

double GetSMA(const int rates_total,const int index,const int period,const double &price[],const bool as_series=true)

  {

//---

   double result=0.0;

//--- check position

   bool check_index=(as_series ? index<=rates_total-period-1 : index>=period-1);

   if(period<1 || !check_index)

      return 0;

//--- calculate value

   for(int i=0; i<period; i++)

      result+=(as_series ? price[index+i]: price[index-i]);

//---

   return(result/period);

  }

//+------------------------------------------------------------------+

//| >72@0I05B 8=45:A <0:A8<0;L=>3> 7=0G5=8O B09<A5@88 High          |

//+------------------------------------------------------------------+

int Highest(const int count,const int start,const bool as_series=true)

  {

   double array[];

   ArraySetAsSeries(array,as_series);

   return(CopyHigh(NULL,PERIOD_CURRENT,start,count,array)==count ? ArrayMaximum(array)+start : WRONG_VALUE);

  }

//+------------------------------------------------------------------+

//| >72@0I05B 8=45:A <8=8<0;L=>3> 7=0G5=8O B09<A5@88 Low            |

//+------------------------------------------------------------------+

int Lowest(const int count,const int start,const bool as_series=true)

  {

   double array[];

   ArraySetAsSeries(array,as_series);

   return(CopyLow(NULL,PERIOD_CURRENT,start,count,array)==count ? ArrayMinimum(array)+start : WRONG_VALUE);

  }

//+------------------------------------------------------------------+