MT4 Множественная регрессия: более 8 градусов с экстраполяцией

Rodrigo S. Franco 2015.04.09 14:20

Привет. Я строю этот тип регрессии.

"Iregr" тем максимальной степени 8 и не имеет экстраполяции.

Это другой код может сорта 80.

Тем не менее, нарисованной линии не равен графике (когда степень равна количеству стержней) или равно "iregr". См образ. Я думаю, что простая модификация в коде решает, но пока не нашел. Любая помощь?

Более 80 градусов, линия исчезает. Я думаю, что это ограничение массивов и переменных. Как преодолеть это?

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 LightSeaGreen
#property indicator_color2 Gold
#property indicator_color3 Gold

//-----
double reg[],reg1[],reg2[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
  SetIndexBuffer(0, reg);
  SetIndexBuffer(1, reg1);
  SetIndexBuffer(2, reg2);
  
  SetIndexStyle(0, DRAW_LINE);
  SetIndexStyle(1, DRAW_LINE);
  SetIndexStyle(2, DRAW_LINE);

  return(0);
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
{

int CogDegree=80;
int CogBars=80;
int CogNW0LW1;

#define CogDegreeMAX  200 // ComputeCOG
#define CogDegree2MAX 400  // 2*MAX
#define COGCENTR     0
#define COGRMS       1
#define COGVALUES    2
double  cogvalues[][COGVALUES];

    if (CogDegree < 1  || CogDegree > CogDegreeMAX) {
        Alert("CogDegree must be 1-", CogDegreeMAX);
//        Log(  "CogDegree must be 1-", Cog.Degree.MAX);
        CogDegree  = MathMax(1, MathMin(CogDegreeMAX, CogDegree));      }
   if (CogBars < CogDegree){
        Alert("CogBars must be ",CogDegree," or greater");
//        Log(  "CogBars must be ",Cog.Degree," or greater");
      CogBars = CogDegree;                                }
   if (CogNW0LW1 < 0 || CogNW0LW1 > 1){
      Alert("CogNW0LW1 must be 0 or 1");
//      Log(  "CogNW0LW1 must be 0 or 1");
       CogNW0LW1 = 0;        }

   int iBar;
   int   nBars = iBars(NULL,0),
      iLimit   = MathMin(nBars, iBar+CogBars);
//    if (iLimit-iBar < CogDegree)         return;  // Bad call or no bars.
//   if (!ResizeBuffer(cogvalues, nBars))  return;  // Out of memory?
    double   Bi[CogDegreeMAX];
    double  EXn[CogDegree2MAX];       int CogDegree2 = CogDegree*2;
    double  Aii[CogDegreeMAX, CogDegreeMAX];
    for(int ii = 0; ii <= CogDegree;  ii++)             Bi[ii] = 0;
    for(    ii = 0; ii <= CogDegree2; ii++)            EXn[ii] = 0;
    for(int i = iBar; i < iLimit; i++){         // Count up for maximum accuracy
      if (CogNW0LW1 == 0)   double Xn = 1; else Xn = iLimit-i;  // 1*weight
        for(ii = 0; ii <= CogDegree;  ii++, Xn *= i){ Bi[ii]  += Xn*iOpen(NULL,0,i);
                                                       EXn[ii] += Xn;         }
        for(      ; ii <= CogDegree2; ii++, Xn *= i)  EXn[ii] += Xn;
    }
    for(int jj = 0; jj <= CogDegree; jj++) {
        for(ii = 0; ii <= CogDegree; ii++) {   Aii[ii, jj] = EXn[ii + jj]; }
    }

    for(int kk = 0; kk <= CogDegree; kk++) {           // Gaussian Elimination
        int ll = kk;    double mm = MathAbs(Aii[ll, kk]);
        for(ii = kk+1; ii <= CogDegree; ii++) {        // Largest magintude.
            double tt = MathAbs(Aii[ii, kk]);
            if (tt > mm) {  ll = ii;    mm = tt;    }
        }

        if (ll != kk) {                                 // Pivot.
            for(jj = 0; jj <= CogDegree; jj++) {
                tt          = Aii[kk, jj];
                Aii[kk, jj] = Aii[ll, jj];
                Aii[ll, jj] = tt;
            }
            tt = Bi[kk]; Bi[kk] = Bi[ll]; Bi[ll] = tt;
        }
        for(ii = kk + 1; ii <= CogDegree; ii++) {      // Reduce.
            double qq; qq = Aii[ii, kk] / Aii[kk, kk];  // Aii[ii,kk]=0
            for(jj = kk+1; jj <= CogDegree; jj++) {
                Aii[ii, jj] -= qq * Aii[kk, jj];
            }
            Bi[ii] -= qq * Bi[kk];
    }   }
    double  x[CogDegreeMAX];                          // Back substitution
    x[CogDegree] = Bi[CogDegree] / Aii[CogDegree, CogDegree];
    for (ii = CogDegree-1; ii >= 0; ii--) {
        tt = Bi[ii];
        for(jj = ii+1; jj <= CogDegree; jj++){
            tt -= Aii[ii, jj] * x[jj];
        }
        x[ii] = tt/Aii[ii, ii];
    }
    // Least squares completed.  Compute residual and final values.
    double  Ews = 0, Ew = 0,     w = 1.;
    for(i = iBar; i < iLimit; i++){
        double                                              Y  = x[0];
        for(kk = 1, Xn=i; kk <= CogDegree; kk++, Xn *= i)  Y += x[kk] * Xn;
        double residual = MathMax(iHigh(NULL,0,i) - Y, Y - iLow(NULL,0,i));
        if (CogNW0LW1 == 1)   w = iLimit-i;
        Ews += w * residual*residual;   Ew += w;
    }
    double ms = Ews / Ew,   rms = MathSqrt(ms);
    for(i = iLimit-1; i >= iBar; i--){
                                                            Y  = x[0];
        for(kk = 1, Xn=i; kk <= CogDegree; kk++, Xn *= i)  Y += x[kk] * Xn;
        cogvalues[i][COGCENTR] = Y;
        cogvalues[i][COGRMS] = rms;
        reg[i+1] = Y;
        reg1[i+1] = Y + 2*rms;
        reg2[i+1] = Y - 2*rms;
    }

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