GruchaChannel

//+------------------------------------------------------------------+
//|                                                 Grucha Index.mq4 |
//|                                                   gaa1@poczta.fm |
//|                                                   www.crn.ugu.pl |
//+------------------------------------------------------------------+
#property copyright "Grzegorz Antosiewicz"
#property link      "gaa1@poczta.fm www.crn.ugu.pl"

#property indicator_chart_window
#property indicator_buffers 3

#property indicator_color1 Red
#property indicator_color2 Orange
#property indicator_color3 Orange

  extern double period = 15;
  extern double class_partitation_method = 1;
  extern bool medium_class = false;

double ExtMapBuffer1[];
double top[];
double bottom[];


int init()
  {
   IndicatorBuffers(3);
//---- indicators
   SetIndexStyle(0,DRAW_LINE);
   
   SetIndexBuffer(0,ExtMapBuffer1);
   SetIndexLabel(0,"MA");
   
   SetIndexStyle(1,DRAW_LINE,STYLE_DOT);
   SetIndexBuffer(1,top);
   SetIndexLabel(1,"TOP");
 
   
   SetIndexStyle(2,DRAW_LINE,STYLE_DOT);
   SetIndexBuffer(2,bottom);
   SetIndexLabel(2,"BOTTOM");
   


   return(0);
  }


int start()
  {
   Comment("\nIf you need MQL CODER quote to AUTOR - polish student of computer since with big experience in mql"+" \n"+
 "\n                                     mail to:\n\n>>>>>>>>>>>>   gaa1@poczta.fm    <<<<<<<<<<< " 
  +"\n\nFOR MORE FX TOOLS visit:\n \n>>>>>>>>>>>>  www.crn.ugu.pl <<<<<<<<<<<<<"
 +"\n\nLOW PRICE and HIGH QUAILTY"
 );

   int    counted_bars=IndicatorCounted();
   if (counted_bars<0) return(-1);
   if (counted_bars>0) counted_bars--;
   int   pos=(Bars+(period+5))-(counted_bars);

   int nClass = NormalizeDouble(  MathSqrt(period)*class_partitation_method,0 );
   int nPeriods=period;
   
   double nPeriod[],stdDEV[];
   ArrayResize(nPeriod, nPeriods);
   ArrayResize(stdDEV, nPeriods);
   
   double hBoard[], lBoard[];
   ArrayResize(hBoard,nClass);   
   ArrayResize(lBoard,nClass);  
   
       double sClass[0];
   double Mo[0];   
   int lClass[0];   
      
      ArrayResize(sClass,nClass);
      ArrayResize(Mo,nClass);
      ArrayResize(lClass,nClass);
      
      
      while(pos>=0)
      {

 //licze ile bedzie klas// wyrzucielm to z petli
  
 ////////////////////////////////////////////////  stad
      //zbieram cene z 30 slupkow
     
     
   for(int i_period=nPeriods-1; i_period >=0; i_period--)
   {
   nPeriod[i_period]=iClose(0,0,i_period+pos);
   //stdDEV[i_period+pos]=nPeriod[i_period] 
   
   
   }
   
      //ustalam granice klas    

   double max= nPeriod[ArrayMaximum(nPeriod,0,0)];
   double min= nPeriod[ArrayMinimum(nPeriod,0,0)];
   
   double step = (max-min)/nClass;
    
    
    //Print(max,"  ",min);  
      //granice klas
   /*
   double hBoard[], lBoard[];
   
   ArrayResize(hBoard,nClass);   
   ArrayResize(lBoard,nClass);  
   */
   
   double hB= max;
   double lB= min;
   
   int nStep = 0;
   
   while(nStep<nClass)
   {
   
   if(nStep!=0)
   {
   hB=hB-step;
   }
   
   lB=hB;
   
   hBoard[nStep]=hB+( (Point/10)*5 );
   lBoard[nStep]=lB-(step)-( (Point/10)*5 );
   
   
   //Print(nStep,"  ",hBoard[nStep],"   ",lBoard[nStep]);
   if(lBoard[nStep]<min)
   {break;}
   
   nStep++;
   }
   
   
   // dziele naklasy i oblcizam dane
   
   
      //obliczanie n klasy i mediany
   
  
   double s_tmp=0;
   int l_tmp=0;
   

     
   for(int ic= 0; ic<nClass; ic++)
   {
         s_tmp=0;
         l_tmp=0;
         
         for(int icc=0; icc<nPeriods; icc++)
         {
            if(nPeriod[icc] < hBoard[ic] && nPeriod[icc] > lBoard[ic])
            {
            s_tmp+=nPeriod[icc];
            l_tmp++;                   
            }
            sClass[ic]=s_tmp;
            lClass[ic]=l_tmp;
            
               if(l_tmp%2==0)
               {
               Mo[ic]=nPeriod[l_tmp/2];
               }
               else
               {
               Mo[ic]= (( ((nPeriod[l_tmp/2])+0.5)+((nPeriod[l_tmp/2])-0.5) )/2 );
               }        
            
            
         }
          
      //Print(lClass[ic],"   ",sClass[ic],"  ",ic);
   }
               
               
               // rangi i wynik mnozenia
            
            
             //lClass[3]=34;
            int s_ir=0;
            
            
            if( ArrayRange(lClass,0)%2==0&&medium_class )
            {
            s_ir = ArrayRange(lClass,0)/2;           
            }
            else
            {
            s_ir = ArrayMaximum(lClass);
            } 
            
            
            
            int tmp=0;
            
           
            for(int ir=0; ir<nClass; ir++)
            {
               
               
               
              sClass[ir]= ( ((ir-s_ir)%nClass) ) * lClass[ir]; 
              tmp+=sClass[ir]; 
               
              //Print(sClass[ir]); 
            }
   
            double result = (Mo[s_ir]  +  ((tmp*(step/*/nClass*/))/nPeriods) );
            
            
            ////////licze odchylenie
            
            double std=0,std_tmp1=0;
             for(int iii_period=nPeriods-1; iii_period >=0; iii_period--)
            {
            std_tmp1 = iClose(0,0,iii_period+pos)-result;
            //std_tmp1 = iii_period - 14.5;
                    
            std_tmp1 *= std_tmp1;
            std += std_tmp1;
            
             }
             
            std /= (nPeriods-1);
            std = MathSqrt(std);
            
          //  double MA=iMA(0,0,nPeriods,0,0,0,pos);
            
            double MA=result;
            
            ExtMapBuffer1[pos]= MA;
            top[pos]= MA+(MA*std);
            bottom[pos]= MA-(MA*std);

      pos--;
      }
   return(0);
  }