Candle shadow percent histogram 3

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

//|                            Candle shadow percent histogram 3.mq5 |

//|                         Copyright © 2019-2021, Vladimir Karputov |

//|                     https://www.mql5.com/ru/market/product/43516 |

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

#property copyright "Copyright © 2019-2021, Vladimir Karputov"

#property link      "https://www.mql5.com/ru/market/product/43516"

#property version   "3.000"

#property indicator_separate_window

#property indicator_buffers 5

#property indicator_plots   1

//--- plot Ratio

#property indicator_label1  "Ratio"

#property indicator_type1   DRAW_COLOR_HISTOGRAM2

#property indicator_color1  clrOrangeRed,clrRoyalBlue

#property indicator_style1  STYLE_SOLID

#property indicator_width1  2

//--- set limit of the indicator values

#property indicator_minimum -100

#property indicator_maximum 100

//--- input parameters

input int                  Inp_ma_period  = 5;        // Averaging period

input ENUM_MA_METHOD       Inp_ma_method  = MODE_SMA; // Smoothing type

//--- indicator buffers

double   RatioBuffer1[];

double   RatioBuffer2[];

double   RatioColors[];

double   RatioCalcBuffer1[];

double   RatioCalcBuffer2[];

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

//| Custom indicator initialization function                         |

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

int OnInit()

  {

//--- indicator buffers mapping

   SetIndexBuffer(0,RatioBuffer1,INDICATOR_DATA);

   SetIndexBuffer(1,RatioBuffer2,INDICATOR_DATA);

   SetIndexBuffer(2,RatioColors,INDICATOR_COLOR_INDEX);

   SetIndexBuffer(3,RatioCalcBuffer1,INDICATOR_CALCULATIONS);

   SetIndexBuffer(4,RatioCalcBuffer2,INDICATOR_CALCULATIONS);

//--- sets first bar from which index will be drawn

   PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,Inp_ma_period-1);

//--- set accuracy

   IndicatorSetInteger(INDICATOR_DIGITS,0);

//--- sets drawing line to empty value

   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);

//--- set the display of the symbol

   string ma_method;

   switch(Inp_ma_method)

     {

      case MODE_EMA :

         ma_method="EMA";

         break;

      case MODE_LWMA :

         ma_method="LWMA";

         break;

      case MODE_SMA :

         ma_method="SMA";

         break;

      case MODE_SMMA :

         ma_method="SMMA";

         break;

      default :

         ma_method="unknown ma";

     }

   string temp=ma_method+"("+IntegerToString(Inp_ma_period)+")";

   PlotIndexSetString(0,PLOT_LABEL,"Upper shadow "+temp+";"+"Bottom shadow "+temp+";");

   IndicatorSetString(INDICATOR_SHORTNAME,"CSPH 3"+"("+ma_method+","+IntegerToString(Inp_ma_period)+")");

//---

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

  {

   if(rates_total<Inp_ma_period-1)

      return(0);

//---

   int limit=prev_calculated-1;

   if(prev_calculated==0)// first calculation or number of bars was changed

     {

      ArrayInitialize(RatioBuffer1,0.0);

      ArrayInitialize(RatioBuffer2,0.0);

      ArrayInitialize(RatioColors,0.0);

      ArrayInitialize(RatioCalcBuffer1,0.0);

      ArrayInitialize(RatioCalcBuffer2,0.0);

      limit=0;

     }

//---

   for(int i=limit; i<rates_total; i++)

     {

      //--- high_low -> 100%

      double high_low=high[i]-low[i]; // 100%

      double upper_shadow,bottom_shadow;

      if(open[i]>close[i])

        {

         RatioColors[i]=0;

         upper_shadow=high[i]-open[i];

         bottom_shadow=close[i]-low[i];

        }

      else

        {

         RatioColors[i]=1;

         upper_shadow=high[i]-close[i];

         bottom_shadow=open[i]-low[i];

        }

      //--- high_low     -> 100%

      //--- upper_shadow -> x%

      //--- x = upper_shadow * 100 / high_low

      if(high_low==0.0)

         RatioCalcBuffer1[i]=0.0;

      else

         RatioCalcBuffer1[i]=upper_shadow * 100.0 / high_low;

      if(high_low==0.0)

         RatioCalcBuffer2[i]=0.0;

      else

         RatioCalcBuffer2[i]=-(bottom_shadow * 100.0 / high_low);

     }

//--- calculation

   switch(Inp_ma_method)

     {

      case MODE_EMA:

         CalculateEMA(rates_total,prev_calculated,0,RatioCalcBuffer1,RatioCalcBuffer2);

         break;

      case MODE_LWMA:

         CalculateLWMA(rates_total,prev_calculated,0,RatioCalcBuffer1,RatioCalcBuffer2);

         break;

      case MODE_SMMA:

         CalculateSmoothedMA(rates_total,prev_calculated,0,RatioCalcBuffer1,RatioCalcBuffer2);

         break;

      case MODE_SMA:

         CalculateSimpleMA(rates_total,prev_calculated,0,RatioCalcBuffer1,RatioCalcBuffer2);

         break;

     }

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

   return(rates_total);

  }

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

//|   simple moving average                                          |

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

void CalculateSimpleMA(int rates_total,int prev_calculated,int begin,const double &price_ratio_1[],const double &price_ratio_2[])

  {

   int i,start;

//--- first calculation or number of bars was changed

   if(prev_calculated==0)

     {

      start=Inp_ma_period+begin;

      //--- set empty value for first start bars

      for(i=0; i<start-1; i++)

        {

         RatioBuffer1[i]=0.0;

         RatioBuffer2[i]=0.0;

        }

      //--- calculate first visible value

      double first_value_ratio_1=0,first_value_ratio_2=0;

      for(i=begin; i<start; i++)

        {

         first_value_ratio_1+=price_ratio_1[i];

         first_value_ratio_2+=price_ratio_2[i];

        }

      first_value_ratio_1/=Inp_ma_period;

      first_value_ratio_2/=Inp_ma_period;

      RatioBuffer1[start-1]=first_value_ratio_1;

      RatioBuffer2[start-1]=first_value_ratio_2;

     }

   else

      start=prev_calculated-1;

//--- main loop

   for(i=start; i<rates_total && !IsStopped(); i++)

     {

      RatioBuffer1[i]=RatioBuffer1[i-1]+(price_ratio_1[i]-price_ratio_1[i-Inp_ma_period])/Inp_ma_period;

      RatioBuffer2[i]=RatioBuffer2[i-1]+(price_ratio_2[i]-price_ratio_2[i-Inp_ma_period])/Inp_ma_period;

     }

  }

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

//|  exponential moving average                                      |

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

void CalculateEMA(int rates_total,int prev_calculated,int begin,const double &price_ratio_1[],const double &price_ratio_2[])

  {

   int    i,start;

   double SmoothFactor=2.0/(1.0+Inp_ma_period);

//--- first calculation or number of bars was changed

   if(prev_calculated==0)

     {

      start=Inp_ma_period+begin;

      RatioBuffer1[begin]=price_ratio_1[begin];

      RatioBuffer2[begin]=price_ratio_2[begin];

      for(i=begin+1; i<start; i++)

        {

         RatioBuffer1[i]=price_ratio_1[i]*SmoothFactor+RatioBuffer1[i-1]*(1.0-SmoothFactor);

         RatioBuffer2[i]=price_ratio_2[i]*SmoothFactor+RatioBuffer2[i-1]*(1.0-SmoothFactor);

        }

     }

   else

      start=prev_calculated-1;

//--- main loop

   for(i=start; i<rates_total && !IsStopped(); i++)

     {

      RatioBuffer1[i]=price_ratio_1[i]*SmoothFactor+RatioBuffer1[i-1]*(1.0-SmoothFactor);

      RatioBuffer2[i]=price_ratio_2[i]*SmoothFactor+RatioBuffer2[i-1]*(1.0-SmoothFactor);

     }

  }

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

//|  linear weighted moving average                                  |

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

void CalculateLWMA(int rates_total,int prev_calculated,int begin,const double &price_ratio_1[],const double &price_ratio_2[])

  {

   int    weight=0;

   int    i,l,start;

   double sum_ratio_1=0.0,sum_ratio_2=0.0,lsum_ratio_1=0.0,lsum_ratio_2=0.0;

//--- first calculation or number of bars was changed

   if(prev_calculated<=Inp_ma_period+begin+2)

     {

      start=Inp_ma_period+begin;

      //--- set empty value for first start bars

      for(i=0; i<start; i++)

        {

         RatioBuffer1[i]=0.0;

         RatioBuffer2[i]=0.0;

        }

     }

   else

      start=prev_calculated-1;

   for(i=start-Inp_ma_period,l=1; i<start; i++,l++)

     {

      sum_ratio_1    += price_ratio_1[i]*l;

      lsum_ratio_1   += price_ratio_1[i];

      sum_ratio_2    += price_ratio_2[i]*l;

      lsum_ratio_2   += price_ratio_2[i];

      weight+=l;

     }

   RatioBuffer1[start-1]=sum_ratio_1/weight;

   RatioBuffer2[start-1]=sum_ratio_2/weight;

//--- main loop

   for(i=start; i<rates_total && !IsStopped(); i++)

     {

      sum_ratio_1    = sum_ratio_1-lsum_ratio_1+price_ratio_1[i]*Inp_ma_period;

      lsum_ratio_1   = lsum_ratio_1-price_ratio_1[i-Inp_ma_period]+price_ratio_1[i];

      sum_ratio_2    = sum_ratio_2-lsum_ratio_2+price_ratio_2[i]*Inp_ma_period;

      lsum_ratio_2   = lsum_ratio_2-price_ratio_2[i-Inp_ma_period]+price_ratio_2[i];

      RatioBuffer1[i]= sum_ratio_1/weight;

      RatioBuffer2[i]= sum_ratio_2/weight;

     }

  }

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

//|  smoothed moving average                                         |

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

void CalculateSmoothedMA(int rates_total,int prev_calculated,int begin,const double &price_ratio_1[],const double &price_ratio_2[])

  {

   int i,start;

//--- first calculation or number of bars was changed

   if(prev_calculated==0)

     {

      start=Inp_ma_period+begin;

      //--- set empty value for first start bars

      for(i=0; i<start-1; i++)

        {

         RatioBuffer1[i]=0.0;

         RatioBuffer2[i]=0.0;

        }

      //--- calculate first visible value

      double first_value_ratio_1=0,first_value_ratio_2=0;

      for(i=begin; i<start; i++)

        {

         first_value_ratio_1+=price_ratio_1[i];

         first_value_ratio_2+=price_ratio_2[i];

        }

      first_value_ratio_1/=Inp_ma_period;

      first_value_ratio_2/=Inp_ma_period;

      RatioBuffer1[start-1]=first_value_ratio_1;

      RatioBuffer2[start-1]=first_value_ratio_2;

     }

   else

      start=prev_calculated-1;

//--- main loop

   for(i=start; i<rates_total && !IsStopped(); i++)

     {

      RatioBuffer1[i]=(RatioBuffer1[i-1]*(Inp_ma_period-1)+price_ratio_1[i])/Inp_ma_period;

      RatioBuffer2[i]=(RatioBuffer2[i-1]*(Inp_ma_period-1)+price_ratio_2[i])/Inp_ma_period;

     }

  }

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