RegressionPolynomial

//+------------------------------------------------------------------+
//|                                   Copyright © 2012, Ivan Kornilov|
//|                                         RegressionPolynomial.mq4 |
//|                                   excelf@gmail.com, skype: excelf|
//+------------------------------------------------------------------+

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 DeepSkyBlue
#property indicator_color2 OrangeRed

extern int history = 10000;
extern int period  = 55;
extern int signal  = 5;
extern int degree  = 2;
extern int price   = 0;
extern bool drowArrow=true;

double Line[];
double Signal[];
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
  {
   SetIndexStyle(0,DRAW_LINE,DRAW_LINE,2);
   SetIndexStyle(1,DRAW_LINE,DRAW_LINE,2);
   SetIndexBuffer(0,Line);
   SetIndexBuffer(1,Signal);
   IndicatorDigits(Digits);
   IndicatorShortName("RegressionPolynomial ("+period+", "+degree+", "+history+")");
   if(period<2) 
     {
      period=2;
     }
   deleteAllArrow();
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start() 
  {
   int counted_bars = IndicatorCounted();
   if(counted_bars < 0)  return(-1);
   if(counted_bars > 0)   counted_bars--;
   int limit = Bars - counted_bars;
   if(counted_bars==0) limit-=1+period+1;
     
   for(int shift=limit; shift>=0; shift--)
     {
      if(degree==1) 
        {
         Line[shift]=regression_LRMA(period,shift,price);
           } else if(degree==2) {
         Line[shift]=regression_QRMA(period,shift,price);
           } else {
         Line[shift]=regression_regressionPolynomial(shift,period,degree,price);
        }
     }
   for(shift=limit; shift>=0; shift--)
     {
      Signal[shift]=iMAOnArray(Line,Bars,signal,0,0,shift);
      if(drowArrow) 
        {
         if(Signal[shift]<Line[shift] && Signal[shift+1]>Line[shift+1]) 
           {
            addArrow(1,shift);
              } else if(Signal[shift]>Line[shift] && Signal[shift+1]<Line[shift+1]) {
            addArrow(-1,shift);
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double regression_QRMA(int period,int shift,int price) 
  {
   double lwma= iMA(NULL,0,period,0,MODE_LWMA,price,shift);
   double sma = iMA(NULL,0,period,0,MODE_SMA,price,shift);
   double qwma= ma_qwma(period,shift,price);
   double value=3.0*sma+qwma *(10-15/(period+2))-lwma *(12-15/(period+2));
   return(value);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double ma_qwma(int period,int shift,int price) 
  {
   double sum=0;
   int j,i;
   for(j=shift,i=1;j<shift+period; j++,i++) 
     {
      sum+=switch_getPrice(price,j)*MathPow(period-i+1,2);
     }
   double value=6.0/(period *(period+1) *(2*period+1));
   return(value*sum);
  }

double a[10,10];
double b[10];
double x[10];
double sx[20];
int n;
int i;
int k;
double t;
int degree1;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double regression_regressionPolynomial(int shift,int period,int degree,int priceCase) 
  {
   sx[1]=period+1;
   degree1=degree+1;

   for(i=1;i<=degree1*2-2; i++) 
     {
      sx[i+1]=0;
      for(n=0;n<=period; n++)
        {
         sx[i+1]+=MathPow(n,i);
        }
     }
   double t;
   for(i=1; i<=degree1; i++)
     {
      b[i]=0;
      for(n=0; n<=period; n++)
        {
         if(i==1) 
           {
            b[i]+=switch_getPrice(priceCase,n+shift);
              } else {
            b[i]+=switch_getPrice(priceCase,n+shift)*MathPow(n,i-1);
           }
        }
     }

   for(int j = 1;j <= degree1; j++)
     {
      for(i = 1; i <= degree1; i++)
        {
         k=i+j-1;
         a[i,j]=sx[k];
        }
     }

   for(k=1; k<=degree1-1; k++)
     {
      int l=0;
      double mm=0;
      for(i=k; i<=degree1; i++)
        {
         if(MathAbs(a[i,k])>mm)
           {
            mm= MathAbs(a[i,k]);
            l = i;
           }
        }
      if(l==0) 
        {
         return(0);
        }
      if(l!=k)
        {
         for(j=1; j<=degree1; j++)
           {
            t = a[k,j];
            a[k, j] = a[l, j];
            a[l, j] = t;
           }
         t=b[k];
         b[k] = b[l];
         b[l] = t;
        }
      double div=0;
      for(i=k+1;i<=degree1; i++)
        {
         div=a[i,k]/a[k,k];
         for(j=1;j<=degree1; j++)
           {
            if(j==k) 
              {
               a[i,j]=0;
                 } else {
               a[i,j]=a[i,j]-div*a[k,j];
              }
           }
         b[i]=b[i]-div*b[k];
        }
     }

   x[degree1]=b[degree1]/a[degree1,degree1];
   for(i=degree;i>=1; i--)
     {
      t = 0;
      for(j=1;j<=degree1-i; j++)
        {
         t = t+a[i,i+j] * x[i+j];
         x[i]=(1/a[i,i]) *(b[i]-t);
        }
     }

   double value=x[1];
   for(i=1;k<=degree; i++)
     {
      value+=x[i+1] *MathPow(n,i);
     }
   return(value);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double regression_LRMA(int period,int shift,int price)
  {
   return(3*iMA(NULL,0,period,0,MODE_LWMA,price,shift)-2*iMA(NULL,0,period,0,MODE_SMA,price,shift));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double switch_getPrice(int price,int shift) 
  {
   switch(price) 
     {
      case 0:
         return(Close[shift]);
      case 1:
         return(Open[shift]);
      case 2:
         return(High[shift]);
      case 3:
         return(Low[shift]);
      case 4:
         return((High[shift]+Low[shift])/2);
      case 5:
         return((High[shift]+Low[shift]+Close[shift])/3);
      case 6:
         return((High[shift]+Low[shift]+Close[shift]+Close[shift])/4);
      default:
         return(Close[shift]);
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void addArrow(int signal,int i) 
  {
   string name=StringConcatenate("arrow_",TimeToStr(Time[i],TIME_DATE|TIME_MINUTES));
   ObjectDelete(name);
   if(signal==1) 
     {
      ObjectCreate(name,OBJ_ARROW,0,Time[i],Open[i],0,0,0,0);
      ObjectSet(name,OBJPROP_ARROWCODE,225);
      ObjectSet(name,OBJPROP_COLOR,DeepSkyBlue);
        } else if(signal==-1) {
      ObjectCreate(name,OBJ_ARROW,0,Time[i],Open[i],0,0,0,0);
      ObjectSet(name,OBJPROP_ARROWCODE,226);
      ObjectSet(name,OBJPROP_COLOR,OrangeRed);
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int deinit() 
  {
   deleteAllArrow();
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void deleteAllArrow() 
  {
   string name;
   for(int i=ObjectsTotal(); i>=0;i--) 
     {
      name=ObjectName(i);
      if(StringFind(name,"arrow_",0)==0) 
        {
         ObjectDelete(name);
        }
     }
  }
//+------------------------------------------------------------------+