Navigation:Home > Content >

JB_Center_of_Gravity.mq4

Time: 2011-05-09 | Download file:JB_Center_of_Gravity.mq4

//+------------------------------------------------------------------+
//|                                         JB Center of Gravity.mq4 |
//|                                                                  |
//| Original Code from NG3110@latchess.com                           |
//| Modification written by Jьrgen Bouchй                            |
//| This is the no repainting variant of the COG indicator.          |
//|                                                                  |
//|                                         http://juergen.bouche.de |
//+------------------------------------------------------------------+
#property  copyright "ANG3110@latchess.com and Jьrgen Bouchй"
#property link       "http://juergen.bouche.de"

#property indicator_chart_window
#property indicator_buffers 5
#property indicator_color1 RoyalBlue
#property indicator_color2 LimeGreen
#property indicator_color3 LimeGreen
#property indicator_color4 Goldenrod
#property indicator_color5 Goldenrod

extern int bars_back = 240;
extern int m = 4;
extern int i = 0;
extern double kstd = 1;

double fx[], sqh[], sql[], stdh[], stdl[];
double ai[10,10], b[10], x[10], sx[20];
double sum;
int    p, n, f;
double qq, mm, tt;
int    ii, jj, kk, ll, nn;
double sq, std;

//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
   IndicatorShortName("JB Center of Gravity");
   SetIndexStyle(0, DRAW_LINE);
   SetIndexBuffer(0, fx);
   SetIndexBuffer(1, sqh);
   SetIndexBuffer(2, sql);
   SetIndexBuffer(3, stdh);
   SetIndexBuffer(4, stdl);
   
   nn = m + 1;

   return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
{
   return(0);
}
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
   int mi;

   p = bars_back; 
   sx[1] = p + 1;
   
   int iBarsToCalculate = 0;
   int iCountedBars = IndicatorCounted();
   if(iCountedBars < 0) return(-1);
   if(iCountedBars > 0) iCountedBars--;

   iBarsToCalculate = Bars - iCountedBars;
   
   for(i = 0;i < iBarsToCalculate;i++)
   {
      // +-----+ SX +-----+
      for(mi = 1; mi <= nn * 2 - 2; mi++)
      {
         sum = 0;
         for(n = i; n <= i + p; n++)
         {
            sum += MathPow(n, mi);
         }
         sx[mi + 1] = sum;
      }
      // +-----+ SYX +-----+
      for(mi = 1; mi <= nn; mi++)
      {
         sum = 0.00000;
         for(n = i; n <= i + p; n++)
         {
            if(mi == 1)
               sum += Close[n];
            else
               sum += Close[n] * MathPow(n, mi - 1);
         }
         b[mi] = sum;
      }
      // +-----+ MATRIX +-----+
      for(jj = 1; jj <= nn; jj++)
      {
         for(ii = 1; ii <= nn; ii++)
         {
            kk = ii + jj - 1;
            ai[ii, jj] = sx[kk];
         }
      }  
      // +-----+ GAUSS +-----+
      for(kk = 1; kk <= nn - 1; kk++)
      {
         ll = 0; mm = 0;
         for(ii = kk; ii <= nn; ii++)
         {
            if(MathAbs(ai[ii, kk]) > mm)
            {
               mm = MathAbs(ai[ii, kk]);
               ll = ii;
            }
         }
         if(ll == 0)
            return(0);   

         if(ll != kk)
         {
            for(jj = 1; jj <= nn; jj++)
            {
               tt = ai[kk, jj];
               ai[kk, jj] = ai[ll, jj];
               ai[ll, jj] = tt;
            }
            tt = b[kk]; b[kk] = b[ll]; b[ll] = tt;
         }  
         for(ii = kk + 1; ii <= nn; ii++)
         {
            qq = ai[ii, kk] / ai[kk, kk];
            for(jj = 1; jj <= nn; jj++)
            {
               if(jj == kk)
                  ai[ii, jj] = 0;
               else
                  ai[ii, jj] = ai[ii, jj] - qq * ai[kk, jj];
            }
            b[ii] = b[ii] - qq * b[kk];
         }
      }  
      x[nn] = b[nn] / ai[nn, nn];
      for(ii = nn - 1; ii >= 1; ii--)
      {
         tt = 0;
         for(jj = 1; jj <= nn - ii; jj++)
         {
            tt = tt + ai[ii, ii + jj] * x[ii + jj];
            x[ii] = (1 / ai[ii, ii]) * (b[ii] - tt);
         }
      }

      /*for(n = i; n <= i + p; n++)
      {
         sum = 0;
         for(kk = 1; kk <= m; kk++)
         {
            sum += x[kk + 1] * MathPow(n, kk);
         }
         fx[n] = x[1] + sum;
      }*/
      sum = 0;
      for(kk = 1; kk <= m; kk++)
      {
         sum += x[kk + 1] * MathPow(i, kk);
      }
      fx[i] = x[1] + sum;

      sq = 0.0;
      /*for(n = i;n <= i + p;n++)
      {
         sq += MathPow(Close[n] - fx[n], 2);
      }*/
      for(n = i;n <= i + p;n++)
      {
         sum = 0;
         for(kk = 1; kk <= m; kk++)
         {
            sum += x[kk + 1] * MathPow(n, kk);
         }
         sq += MathPow(Close[n] - (x[1] + sum), 2);
      }
      sq = MathSqrt(sq / (p + 1)) * kstd;
      std = iStdDev(NULL,0,p,MODE_SMA,0,PRICE_CLOSE,i) * kstd;
      /*for(n = i; n <= i + p; n++)
      {
         sqh[n] = fx[n] + sq;
         sql[n] = fx[n] - sq;
         stdh[n] = fx[n] + std;
         stdl[n] = fx[n] - std;
      }*/
      sqh[i] = fx[i] + sq;
      sql[i] = fx[i] - sq;
      stdh[i] = fx[i] + std;
      stdl[i] = fx[i] - std;
   }

   return(0);
}
//+------------------------------------------------------------------+^

Recommend