SLAU

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

//|                                                         SLAU.mq5 | 

//|                        Copyright 2019, MetaQuotes Software Corp. | 

//|                         https://www.mql5.com/ru/users/nikolay7ko | 

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

#property copyright "Copyright 2019, Nikolay Semko" 

#property link      "https://www.mql5.com/ru/users/nikolay7ko" 

#property link      "SemkoNV@bk.ru" 

#property version   "1.03" 

#property indicator_separate_window 

#property indicator_plots   1 

#property indicator_buffers 1 



#include <Canvas\iCanvas_CB.mqh> // https://www.mql5.com/ru/code/22164 



input int N=15;               // SLE size 

input int Fut=50;             // how much bar to build in the future 

input bool profit=false;      // Evaluate profits? 



iCanvas *Canvas2=new iCanvas(0,0,0,"SubWin",0,0,2,0); 

iCanvas *Slider=new iCanvas(0,0,0,"Slider",0,60,2,0); 



int n_=N; 

double A[],F[],X[]; 

double buf[]; 

double Pr[]; 

int Size=0; 

int pre_RB=0; 

int pre_BIW=W.BarsInWind; 

bool slider=false; 

uchar _tr=0; 

int xN; 

string lang; 

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

//|                                                                  | 

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

int OnInit() 

  { 

   ArrayResize(X,n_*n_); 

   ArrayResize(A,n_); 

   ArrayResize(F,n_); 

   xN=n_*4; 

   lang=TerminalInfoString(TERMINAL_LANGUAGE); 

   return(INIT_SUCCEEDED); 

  } 

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

//| Custom indicator iteration function                              | 

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

int OnCalculate(const int rates_total, 

                const int prev_calculated, 

                const int begin, 

                const double &price[]) 

  { 

   int to_copy=rates_total-prev_calculated; 

   if(to_copy>1) // if we make the first entry or there was a delay more than the time of one bar, we initialize all the bars 

     { 

      ArrayInitialize(buf,EMPTY_VALUE); 

      Size=ArrayCopy(Pr,price); 

      if(Size!=rates_total) return 0; 

      else ArrayResize(buf,Size*n_); 

     } 

   else if(to_copy==1) {Size++; ArrayResize(Pr,Size);ArrayResize(buf,Size*n_); Pr[Size-1]=price[rates_total-1]; }  // if new bar 

   else Pr[Size-1]=price[rates_total-1];                                                                          // if new tick 

   Calc(); 

   ReDraw(); 

   return(rates_total); 

  } 

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

//| ChartEvent function                                              | 

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

void OnChartEvent(const int id, 

                  const long &lparam, 

                  const double &dparam, 

                  const string &sparam) 

  { 

   static string pre_sparam=sparam; 

   if(id==CHARTEVENT_MOUSE_MOVE) 

     { 

      if(!slider) DrawSetup(); 

      ReDraw(); 

     } 

   if(id==CHARTEVENT_CHART_CHANGE) 

     { 

      Calc(); 

      ReDraw(); 

      pre_RB=(int) W.Right_bar; 

      pre_BIW=W.BarsInWind; 

     } 

   if(sparam=="0" && pre_sparam!="0") {slider=false; ChartSetInteger(0,CHART_MOUSE_SCROLL,true);} 

   int S=W.Width/2-199; 

   if(_tr>253 && pre_sparam=="0" && sparam=="1") 

     { 

      ChartSetInteger(0,CHART_MOUSE_SCROLL,false); 

      if(Delta(S+xN,30)<50) slider=true; 

      else slider=false; 

     } 

   if(slider) 

     { 

      xN=W.MouseX-S; 

      if(xN<1) xN=1; 

      if(xN>392) xN=392; 

      int pn=n_; 

      n_=xN/8+2; 

      DrawSetup(); 

      if(pn!=n_) 

        { 

         ArrayResize(X,n_*n_); 

         ArrayResize(A,n_); 

         ArrayResize(F,n_); 

         ArrayResize(buf,Size*n_); 

         Calc(true); 

         ReDraw(); 

        } 

     } 

   pre_sparam=sparam; 

  } 

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



void Calc(bool all=false) 

  { 

   static int last_Size=0; 

   static double last_vol=0; 

   if(Size<2*n_) return; 

   if(all) last_Size=0; 

   int d=Size-last_Size; 

   if(d<0) d=Size; 

   if(d>Size-2*n_) d=Size-2*n_; 

   if(d==0) if(last_vol==Pr[Size-1]) return; else d=1; 

   for(int i=0; i<W.Left_bar; i++) 

     { 

      int adr=Size-1-i; 

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

        { 

         if((adr-j)>=0) F[j]=Pr[adr-j]; 

         for(int k=0; k<n_; k++) {int adr2=adr-k-j-1; if(adr2>=0 && adr2<ArraySize(Pr)) X[j*n_+k]=Pr[adr2];} 

        } 

      SLAU(X,F,A,n_); 

      for(int j=0; j<n_; j++) buf[ArraySize(buf)-1-i*n_-j]=A[j]; 

     } 

   last_vol=Pr[Size-1]; 

   last_Size=Size; 

  } 

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

//|                                                                  | 

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

void ReDraw() 

  { 

   Canvas.Erase(0x00FFFFFF); 

   Canvas2.Erase(0x00FFFFFF); 

   for(int i=10; i<(Canvas.m_height-10);i++) Canvas.LineHorizontal(Canvas.m_width-30,Canvas.m_width-1,i,Grad((double)(i-10)/(Canvas.m_height-20))); 

   Canvas.LineVertical(W.MouseX,0,Canvas.Height(),0xFFFF0000); 

   Canvas.LineHorizontal(0,W.Width-1,Canvas.Height()/2,0xFF808080); 

   Canvas2.LineVertical(W.MouseX,0,Canvas2.Height(),0xFFFF0000); 

   double line[]; 

   ArrayResize(line,W.BarsInWind); 

   for(int i=0;i<n_;i++) 

     { 

      for(int j=0;j<W.BarsInWind;j++) 

        { 

         line[j]=buf[ArraySize(buf)-1-(j+Floor(W.Right_bar))*n_-i]; 

        } 

      if(W.MouseX<W.Width-150 || W.MouseSubWin!=Canvas.SubWin) DrawIndicatorLine(Canvas,line,Grad((double)i/(n_-1))); 

      else if(W.MouseSubWin>=0 && W.MouseY>i*((double)W.height[W.MouseSubWin]/n_) && W.MouseY<(i+1)*((double)W.height[W.MouseSubWin]/n_)) 

        { 

         Canvas.TextPosition(W.Width/2-20,20); 

         Canvas.CurentFont("Arial",40,0,~W.Color); 

         Canvas.Comm("A"+string(i+1)); 

         DrawIndicatorLine(Canvas,line,Grad((double)i/(n_-1))); 

        } 

     } 

   for(int i=0;i<n_;i++) 

     { 

      Canvas.TextPosY=int((Canvas.m_height-20)*(double)i/(n_-1)); 

      Canvas.TextPosX=W.MouseX+10; 

      Canvas.CurentFont("Arial",18,0,ColorToARGB(Grad((double)i/(n_-1)))); 

      Canvas.LineHorizontal(Canvas.m_width-50,Canvas.m_width-32,Canvas.TextPosY+10,Grad((double)i/(n_-1))); 

      int adr=ArraySize(buf)-1-i-n_*Floor(W.MouseBar-1); 

      if(adr<0) adr=0; 

      if(adr>=ArraySize(buf)) adr=ArraySize(buf)-1; 

      if(buf[adr]>1.1e+300) Calc(true); 

      if(W.MouseX<W.Width-150 || W.MouseSubWin!=Canvas.SubWin) Canvas.Comm("a"+string(i+1)+" = "+DoubleToString(buf[adr],3)); 

      Canvas.TextPosX=Canvas.m_width-150; 

      adr=ArraySize(buf)-1-i; 

      if(adr<0) adr=0; 

      if(adr>=ArraySize(buf)) adr=ArraySize(buf)-1; 

      Canvas.Comm("a"+string(i+1)+" = "+DoubleToString(buf[adr],3)); 

     } 

   for(int j=0;j<W.BarsInWind;j++) 

     { 

      double f=0; 

      int i1=Size-2-j-Floor(W.Right_bar); 

      if(i1-n_+1>=0) for(int i=0;i<n_;i++) f+=Pr[i1-i]*buf[ArraySize(buf)-1-(j+1+Floor(W.Right_bar))*n_-i]; 

      line[j]=f; 

     } 

   DrawIndicatorLine(Canvas2,line,0xFF0000FF); 

   if(profit) 

     { 

      double sum=0,sum1=0; 

      for(int j=Size-1,j1=0;j>=2*n_+2;j--,j1++) 

        { 

         double f=0; 

         for(int i=0;i<n_;i++) f+=Pr[j-1-i]*buf[ArraySize(buf)-1-(j1+1)*n_-i]; 

         if(f<iOpen(_Symbol,_Period,j1)) sum=sum+iOpen(_Symbol,_Period,j1)-iClose(_Symbol,_Period,j1); 

         else sum=sum+iClose(_Symbol,_Period,j1)-iOpen(_Symbol,_Period,j1); 

         if(rand()<16384) sum1=sum1+iOpen(_Symbol,_Period,j1)-iClose(_Symbol,_Period,j1); 

         else sum1=sum1+iClose(_Symbol,_Period,j1)-iOpen(_Symbol,_Period,j1); 

        } 

      Canvas2.CurentFont("Tahoma",30,30,0x80FFFF00); 

      Canvas2.TextPosition(W.Width-600,50); 

      string str=(sum>0)?"Profit "+string(int(sum/_Point))+" pips ( "+string(Size-2*n_-1)+" bars, spread = 0)":"Loss "+string(int(sum/_Point))+" pips ( "+string(Size-n_)+" bars, spread = 0)"; 

      string str1=(sum1>0)?"Random profit "+string(int(sum1/_Point))+" pips ( "+string(Size-2*n_-1)+" bars, spread = 0)":"Random loss  "+string(int(sum1/_Point))+" pips ( "+string(Size-n_)+" bars, spread = 0)"; 

      Canvas2.Comm(str); 

      Canvas2.Comm(str1); 

     } 

   int cur=Floor(W.MouseBar); 

   if(cur<0) cur=0; 

   for(int b=cur+1; b<=cur+n_; b++) 

     { 

      double f=0; 

      if((Size-n_-b)>=0) for(int j=0; j<n_; j++) 

         f+=Pr[Size-1-j-b]*buf[ArraySize(buf)-1-cur*n_-j];//-n_-1-j]; 

      uint ccl=0xFFFF0000; 

      if((Size-b)>=0) if(NormalizeDouble(f,_Digits)==Pr[Size-b]) ccl=0xFF00FFFF; 

      Canvas2.FillCircle((int)Canvas2.X(double(b-1)),(int)Canvas2.Y(f),4,ccl); 

     } 

   double Future[]; 

   ArrayResize(Future,Fut+n_); 

   ArrayInitialize(Future,0); 

   ArrayCopy(Future,Pr,0,Size-1-cur-n_,n_); 

   if((cur+1)*n_+n_-1>= ArraySize(buf)) return; 

   for(int b=cur,i=0; b>cur-Fut; b--,i++) 

     { 

      double f=0; 

      for(int j=n_-1; j>=0; j--) f+=Future[j+i]*buf[ArraySize(buf)-(cur+1)*n_+j]; 

      Future[i+n_]=f; 

      Canvas2.LineD(Canvas2.X(double(b+1)),Canvas2.Y(Future[i-1+n_]),Canvas2.X(double(b)),Canvas2.Y(f),0xFFFF00FF); 

      //Canvas.Line((int)Canvas.X(double(b+1)),(int)Canvas.Y(Future[i-1+n_]),(int)Canvas.X(double(b)),(int)Canvas.Y(f),0xFF00FFFF); 

     } 

   Canvas.Update(); 

   Canvas2.Update(); 

  } 

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

//|                                                                  | 

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

void SLAU(double &x[],double &f[],double &a[],int m) 

  { 

   int k=m-1; 

   if(m>1) 

     { 

      double xx[],ff[]; 

      double g=x[0]; if(g==0) g=1.0e-100; 

      for(int i=0;i<ArraySize(x);i++) x[i]/=g; 

      for(int i=0;i<ArraySize(f);i++) f[i]/=g; 

      ArrayResize(ff,k); 

      ArrayResize(xx,k*k); 

      for(int i=0; i<k; i++) 

        { 

         ff[i]=f[0]*x[(i+1)*m]-f[i+1]*x[0]; 

         for(int j=0;j<k;j++) xx[i*k+j]=x[j+1]*x[(i+1)*m]-x[(i+1)*m+j+1]*x[0]; 

        } 

      int i=0; 

      for(;i<k; i++) if(xx[i*k]!=0) break; 

      if(i>0 && i<k) for(int j=0;j<k;j++) {double t=xx[j]; xx[j]=xx[i*k+j]; xx[i*k+j]=t;} 

      SLAU(xx,ff,a,k); 

     } 

   double sum=0; 

   for(int i=1; i<m;i++) sum+=a[n_-m+i]*x[i]; 

   if(x[0]!=0 && x[0]==x[0]) a[n_-m]=(f[0]-sum)/x[0]; else a[n_-m]=1.0/n_; 

   if(m!=n_) return; 

  } 

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



void DrawIndicatorLine(iCanvas &C,double &arr[],uint clr,int barStart=INT_MIN,int barEnd=INT_MAX,int shift=0) 

  { 

   double Min,Max=0; 

   if(ArraySize(arr)==0 || C.m_height==0) return; 

   for(int i=0; i<ArraySize(arr);i++) Max+=fabs(arr[i]); 

   Max=3*Max/ArraySize(arr); 

   Min=-Max; 

   double dy=(Max-Min)/C.m_height; 

   if(dy==0 || dy!=dy) dy=1; 

   if(barStart<W.Right_bar) barStart=Floor(W.Right_bar); 

   if(barEnd>W.Left_bar) barEnd=W.Left_bar; 

   if(W.Left_bar<=barStart) return; 

   int nn=barEnd-barStart+1; 

   barStart+=shift; 

   barEnd+=shift; 

   double x=C.X((double)barStart); 

   double pre_y; 

   if(C.SubWin==0) pre_y=C.Y(arr[0]); else pre_y=(Max-arr[0])/dy; 

   C.PixelSet(Round(x),Round(pre_y),clr); 

   x-=W.dx_pix; 

   for(int i=1; i<nn; i++,x-=W.dx_pix) 

     { 

      double y=0; 

      if(C.SubWin==0) y=C.Y(arr[i]); else y=(Max-arr[i])/dy; 

      if(fabs(y-pre_y)>1 || W.dx_pix>1) C.LineD(x,y,x+W.dx_pix,pre_y,clr); 

      else C.PixelSet(Round(x),Round(y),clr); 

      pre_y=y; 

     } 

  } 

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

//|                                                                  | 

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

void DrawSetup() 

  { 

   static int pre_N=n_; 

   static int pre_tr=-1; 

   int C=W.Width/2; 

   int h=W.MouseY-30; 

   int w=fabs(W.MouseX-C); 

   int t=255; 

   if(w<207) t=int(255*(1-(h)/100.0)); 

   else t=int(255*(1-(w-207)/50.0)); 

   if(t>255) t=255; 

   _tr=(uchar)t; 

   if(h>60 || w>257) {if(_tr!=0) {Slider.Erase(0x00FFFFFF); ; Slider.Update(); _tr=0;} return;} 

   if(n_!=pre_N) 

     { 

      pre_N=n_; 

     } 

   else if(pre_tr==_tr) return; 

   pre_tr=_tr; 

   uint clrLine=ColorToARGB(0xFF808080,_tr); 

   uint clrCir=ColorToARGB(0xFFDD8080,_tr); 

   Slider.Erase(0x00FFFFFF); ; 

   Slider.FillRectangle(Slider.m_width/2-300,5,Slider.m_width/2+300,55,ColorToARGB(W.Color,_tr)); 

   Slider.TextPosX=C-300; 

   Slider.TextPosY=17; 

   Slider.CurentFont("Century Gothic",18,20,~W.Color,_tr/255.0); 

   if (lang=="Russian") Slider.Comm(" 07<5@ !#"); else Slider.Comm("      SLE size"); 

   Slider.FillRectangle(C-199,30,C+200,30,clrLine); 

   Slider.FillCircle(C-199+xN,30,7,clrCir); 

   Slider.TextPosY=12; 

   Slider.TextPosX=C-190+xN; 

   Slider.Comm(string(n_)); 

   Slider.Update(); 

  } 



int Delta(int x,int y) {return(x-W.MouseX)*(x-W.MouseX)+(y-W.MouseY)*(y-W.MouseY);} 

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

//|                                                                  | 

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

uint Grad(double p) 

  { 

   static uint Col[6]={0xFF0000FF,0xFFFF00FF,0xFFFF0000,0xFFFFFF00,0xFF00FF00,0xFF00FFFF}; 

   if(p>0.9999) return Col[5]; 

   if(p<0.0001) return Col[0]; 

   p=p*5; 

   int nn=(int)p; 

   double k=p-nn; 

   argb c1,c2; 

   c1.clr=Col[nn]; 

   c2.clr=Col[nn+1]; 

   return ARGB(255,c1.c[2]+uchar(k*(c2.c[2]-c1.c[2])+0.5), 

               c1.c[1]+uchar(k*(c2.c[1]-c1.c[1])+0.5), 

               c1.c[0]+uchar(k*(c2.c[0]-c1.c[0])+0.5)); 

  } 

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