cci_on_stepchannel_v1

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

//|                                           CCI_on StepChannel.mq5 |

//| CCI on StepChannel v1.03                  Copyright 2015, fxborg |

//|                                   http://fxborg-labo.hateblo.jp/ |

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

#property copyright "Copyright 2015, fxborg"

#property link      "http://fxborg-labo.hateblo.jp/"

#property version   "1.03"

#include <MovingAverages.mqh>

//---

#property indicator_buffers 17

#property indicator_plots   4

#property indicator_separate_window

#property indicator_type1 DRAW_LINE

#property indicator_type2 DRAW_COLOR_HISTOGRAM

#property indicator_type3 DRAW_LINE

#property indicator_type4 DRAW_LINE

//---

#property indicator_color1 DimGray

#property indicator_label1 "CCI"

#property indicator_width1 1

#property indicator_style1 STYLE_SOLID

#property indicator_color2 DarkGray,DodgerBlue,DeepPink

#property indicator_label2 "CCI"

#property indicator_width2 2

#property indicator_style2 STYLE_SOLID

#property indicator_color3 Gray

#property indicator_width3 1

#property indicator_style3 STYLE_DOT

#property indicator_color4 Gray

#property indicator_width4 1

#property indicator_style4 STYLE_DOT



//--- input parameters

input double InpScaleFactor=2.25; // Scale factor

input int    InpMaPeriod=3;       // Smooth Period

input int    InpVolatilityPeriod=70; //  Volatility Period

input int InpCCIPeriod=32; // CCI Period

//---

int    InpFastPeriod=int(InpVolatilityPeriod/7); //  Fast Period

int    InpMode=2; //  1:Simple Mode 2:hybrid Mode

ENUM_MA_METHOD InpMaMethod=MODE_SMMA; // Ma Method 



//---- will be used as indicator buffers

double UpperBuffer[];

double MiddleBuffer[];

double LowerBuffer[];

//---

double UpperMaBuffer[];

double MiddleMaBuffer[];

double LowerMaBuffer[];

//---

double CCI_Hist_Buffer[];

double CCI_Buffer[];

double CCI_Color_Buffer[];

double CCI_Top_Buffer[];

double CCI_Btm_Buffer[];

//---

double BaseBuffer[];

//---

double HighBuffer[];

double LowBuffer[];

double CloseBuffer[];

double StdDevBuffer[];

double StdDevCalcBuffer[];

//---- declaration of global variables

int min_rates_total;

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

//| Custom indicator initialization function                         |

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

int OnInit()

  {

//---- Initialization of variables of data calculation starting point

   min_rates_total=1+InpFastPeriod+InpVolatilityPeriod+InpMaPeriod+InpMaPeriod+1+InpCCIPeriod+int(InpCCIPeriod/3)+1;

//--- indicator buffers mapping

//--- indicator buffers

   SetIndexBuffer(0,CCI_Buffer,INDICATOR_DATA);

   SetIndexBuffer(1,CCI_Hist_Buffer,INDICATOR_DATA);

   SetIndexBuffer(2,CCI_Color_Buffer,INDICATOR_COLOR_INDEX);

   SetIndexBuffer(3,CCI_Top_Buffer,INDICATOR_DATA);

   SetIndexBuffer(4,CCI_Btm_Buffer,INDICATOR_DATA);

   SetIndexBuffer(5,BaseBuffer,INDICATOR_CALCULATIONS);

   SetIndexBuffer(6,MiddleMaBuffer,INDICATOR_CALCULATIONS);

   SetIndexBuffer(7,UpperMaBuffer,INDICATOR_CALCULATIONS);

   SetIndexBuffer(8,LowerMaBuffer,INDICATOR_CALCULATIONS);

//---

   SetIndexBuffer(9,UpperBuffer,INDICATOR_CALCULATIONS);

   SetIndexBuffer(10,MiddleBuffer,INDICATOR_CALCULATIONS);

   SetIndexBuffer(11,LowerBuffer,INDICATOR_CALCULATIONS);

   SetIndexBuffer(12,HighBuffer,INDICATOR_CALCULATIONS);

   SetIndexBuffer(13,LowBuffer,INDICATOR_CALCULATIONS);

   SetIndexBuffer(14,CloseBuffer,INDICATOR_CALCULATIONS);

   SetIndexBuffer(15,StdDevBuffer,INDICATOR_CALCULATIONS);

   SetIndexBuffer(16,StdDevCalcBuffer,INDICATOR_CALCULATIONS);

//---

   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(2,PLOT_EMPTY_VALUE,EMPTY_VALUE);

   PlotIndexSetDouble(3,PLOT_EMPTY_VALUE,EMPTY_VALUE);

   PlotIndexSetDouble(4,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(5,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(6,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(7,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(8,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(9,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(10,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(11,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(12,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(13,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(14,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(15,PLOT_EMPTY_VALUE,0);

   PlotIndexSetDouble(16,PLOT_EMPTY_VALUE,0);

//---

   PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,min_rates_total);

   PlotIndexSetInteger(1,PLOT_DRAW_BEGIN,min_rates_total);

   PlotIndexSetInteger(2,PLOT_DRAW_BEGIN,min_rates_total);

   PlotIndexSetInteger(3,PLOT_DRAW_BEGIN,min_rates_total);

   PlotIndexSetInteger(4,PLOT_DRAW_BEGIN,min_rates_total);

//---

   string short_name="CCI on StepChannel";

//---

   IndicatorSetString(INDICATOR_SHORTNAME,short_name);

//---

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

  {

//---

   int i,j,first;

//--- check for bars count

   if(rates_total<=min_rates_total)

      return(0);

//---

   MathSrand(int(TimeLocal()));

//--- indicator buffers

   ArraySetAsSeries(CCI_Buffer,false);

   ArraySetAsSeries(CCI_Hist_Buffer,false);

   ArraySetAsSeries(CCI_Color_Buffer,false);

   ArraySetAsSeries(CCI_Top_Buffer,false);

   ArraySetAsSeries(CCI_Btm_Buffer,false);

   ArraySetAsSeries(UpperMaBuffer,false);

   ArraySetAsSeries(LowerMaBuffer,false);

   ArraySetAsSeries(MiddleMaBuffer,false);

   ArraySetAsSeries(UpperBuffer,false);

   ArraySetAsSeries(LowerBuffer,false);

   ArraySetAsSeries(MiddleBuffer,false);

   ArraySetAsSeries(HighBuffer,false);

   ArraySetAsSeries(LowBuffer,false);

   ArraySetAsSeries(CloseBuffer,false);

   ArraySetAsSeries(StdDevBuffer,false);

   ArraySetAsSeries(BaseBuffer,false);

//--- rate data

   ArraySetAsSeries(high,false);

   ArraySetAsSeries(low,false);

   ArraySetAsSeries(close,false);

   ArraySetAsSeries(time,false);

//---

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

//| Set Median Buffeer                                 |

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

   int calc_span=int(InpCCIPeriod/3);

//---

   first=InpFastPeriod+InpVolatilityPeriod+InpMaPeriod+InpMaPeriod+InpCCIPeriod+calc_span;

   if(first+1<prev_calculated)

      first=prev_calculated-2;

   else

     {

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

        {

         MiddleBuffer[i]=close[i];

         HighBuffer[i]=high[i];

         LowBuffer[i]=low[i];

         CCI_Buffer[i]=0;

         CCI_Top_Buffer[i]=EMPTY_VALUE;

         CCI_Btm_Buffer[i]=EMPTY_VALUE;

        }

     }

//---

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

     {

      StdDevBuffer[i]=calcStdDev(close,InpFastPeriod,i);

      //---

      double h,l,c,hsum=0.0,lsum=0.0,csum=0.0;

      //---

      for(j=0;j<InpMaPeriod;j++)

        {

         hsum += high[i-j];

         lsum += low[i-j];

         csum += close[i-j];

        }

      //---

      h=hsum/InpMaPeriod;

      l=lsum/InpMaPeriod;

      c=csum/InpMaPeriod;

      //--- Base Volatility

      double sd=0.0;

      for(j=(i-InpVolatilityPeriod+1);j<=i;j++)

         sd+=StdDevBuffer[j];

      //--- Ma Buffer

      double v=sd/InpVolatilityPeriod;

      BaseBuffer[i]=v;

      double base=v*InpScaleFactor;

      //--- Hybrid Mode

      if((h-base)>HighBuffer[i-1]) HighBuffer[i]=h;

      else if(h+base<HighBuffer[i-1]) HighBuffer[i]=h+base;

      else HighBuffer[i]=HighBuffer[i-1];

      //---

      if(l+base<LowBuffer[i-1]) LowBuffer[i]=l;

      else if((l-base)>LowBuffer[i-1]) LowBuffer[i]=l-base;

      else LowBuffer[i]=LowBuffer[i-1];

      //---

      if((c-base/2)>CloseBuffer[i-1]) CloseBuffer[i]=c-base/2;

      else if(c+base/2<CloseBuffer[i-1]) CloseBuffer[i]=c+base/2;

      else CloseBuffer[i]=CloseBuffer[i-1];

      //---

      MiddleBuffer[i]=(HighBuffer[i]+LowBuffer[i]+CloseBuffer[i]*2)/4;

      UpperBuffer[i]=HighBuffer[i] + base/2;

      LowerBuffer[i]=LowBuffer[i]  - base/2;

      //---

      hsum=0.0;

      lsum=0.0;

      csum=0.0;

      //---

      for(j=0;j<InpMaPeriod;j++)

        {

         hsum += UpperBuffer[i-j];

         lsum += LowerBuffer[i-j];

         csum += MiddleBuffer[i-j];

        }

      //---

      UpperMaBuffer[i]=hsum/InpMaPeriod;

      LowerMaBuffer[i]=lsum/InpMaPeriod;

      MiddleMaBuffer[i]=csum/InpMaPeriod;

      //---

      calc_CCI(high,low,close,i);

     }

//----    

   return(rates_total);

  }

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

//|                                                                  |

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

void calc_CCI(const double  &high[],const double  &low[],const double  &close[],int i)

  {

   int calc_span=int(InpCCIPeriod/3);

   int j;

   double sum=0;

   for(j=0;j<InpCCIPeriod;j++)

     {

      double p=(high[i-j]+low[i-j]+close[i-j])/3;

      sum+=MathAbs(p-MiddleMaBuffer[i]);

     }

//---

   sum*=0.015/InpCCIPeriod;

   if(sum==0.0)

      CCI_Buffer[i]=0.0;

   else

     {

      double p=(high[i]+low[i]+close[i])/3;

      CCI_Buffer[i]=(p-MiddleMaBuffer[i])/sum;

     }

   CCI_Hist_Buffer[i]=CCI_Buffer[i];

//---

   if(0<CCI_Buffer[i]) CCI_Color_Buffer[i]=1.0;

   else if(0>CCI_Buffer[i]) CCI_Color_Buffer[i]=2.0;

   else  CCI_Color_Buffer[i]=0.0;

//---

   double dmax=-9999999.9;

   double dmin=9999999.9;

   for(j=1;j<calc_span;j++)

     {

      if(dmax<CCI_Buffer[i-j])dmax=CCI_Buffer[i-j];

      if(dmin>CCI_Buffer[i-j])dmin=CCI_Buffer[i-j];

     }

   CCI_Top_Buffer[i-1]=dmax>0?dmax:EMPTY_VALUE;

   CCI_Btm_Buffer[i-1]=dmin<0?dmin:EMPTY_VALUE;

   CCI_Top_Buffer[i]=CCI_Top_Buffer[i-1];

   CCI_Btm_Buffer[i]=CCI_Btm_Buffer[i-1];

  }

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

//|                                                                  |

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

double calcStdDev(const double  &close[],int span,int i)

  {

   if(i<span-1)   return 0.0;



   if(i==span-1)

      StdDevCalcBuffer[i]=SimpleMA(i,span,close);

   else

      StdDevCalcBuffer[i]=SmoothedMA(i,span,StdDevCalcBuffer[i-1],close);

//---

   double sum=0.0;

   for(int j=0;j<span;j++)

      sum+=MathPow(close[i-j]-StdDevCalcBuffer[i],2);

   return MathSqrt(sum/span);

  }

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