//+------------------------------------------------------------------+ 
// #Chaos Semafor             \?
// Knowledge of the ancients (??
//______________________o0o___(_)___o0o_____
//___ard777________________2009_?                  
//+------------------------------------------------------------------+
#property indicator_chart_window 
#property indicator_buffers (6+9)
#property indicator_color1 SpringGreen 
#property indicator_color2 OrangeRed  
#property indicator_color3 DarkOrange 
#property indicator_color4 Maroon 
#property indicator_color5 Yellow 
#property indicator_color6 Magenta 

#property indicator_color7 White 
#property indicator_color8 White 
#property indicator_color9 DodgerBlue
#property indicator_color10 DodgerBlue
#property indicator_color11 Lime
#property indicator_color12 Red

#property indicator_width1 5
#property indicator_width2 5
#property indicator_width3 3
#property indicator_width4 3
#property indicator_width5 1
#property indicator_width6 1


#property indicator_width7 5
#property indicator_width8 5
#property indicator_width9 3
#property indicator_width10 3
#property indicator_width11 2
#property indicator_width12 2

//---- input parameters 

string   Dev_Step_1="1,1"; //1,3
string   Dev_Step_2="1,1"; //8,5
string   Dev_Step_3="1,1";//13,8
int Symbol_1_Kod=111;//78;//251;
int Symbol_2_Kod=174;//78;//82;
int Symbol_3_Kod=108;//78;//82;

//+---- 
extern double Period1                  =77;//144
extern double Period2                  =31;//62    SEE LInE 321
//extern double Period3=9;
extern int    maxBars                  = 1400;

extern string _____           ="";
extern bool   Box_Alerts               = true;
extern bool   Email_Alerts             = false;
extern bool   Sound_Alerts             = true;

extern bool   Alert_Lv1                = true;
extern bool   Alert_Lv2                = false;
//extern bool   Alert_Lv3    = true;
extern string Alert_Lv1_High_SoundFile = "air_raid.wav";  //any soundfile
extern string Alert_Lv1_Low_SoundFile  = "air_raid.wav";
extern string Alert_Lv2_High_SoundFile = "air_raid.wav";
extern string Alert_Lv2_Low_SoundFile  = "air_raid.wav";
//extern string Alert_Lv3_High_SoundFile       =  "Level3_Effect37.wav";
//extern string Alert_Lv3_Low_SoundFile        =  "Level3_Effect37.wav";

//---- buffers 
double FP_BuferUp[];
double FP_BuferDn[];
double NP_BuferUp[];
double NP_BuferDn[];
//double HP_BuferUp[];
//double HP_BuferDn[];

double FP_BuferUpLatest[];
double FP_BuferDnLatest[];
double NP_BuferUpLatest[];
double NP_BuferDnLatest[];
//double HP_BuferUpLatest[];
//double HP_BuferDnLatest[];

double trendlv1[];
double trendlv2[];
double trendlv3[];

int F_Period;
int N_Period;
//int H_Period;
int Dev1;
int Stp1;
int Dev2;
int Stp2;
//int Dev3;
//int Stp3;
//+--------- TRO MODIFICATION ---------------------------------------+ 
string symbol,tChartPeriod,tShortName;
int    digits,period;

bool Trigger1,Trigger2;//,Trigger3;

int OldBars=-1;

color tColor=Yellow;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
struct STR_POINT
  {
   datetime          dt;
   double            pr;
  };
//+------------------------------------------------------------------+ 
//| Custom indicator initialization function                         | 
//+------------------------------------------------------------------+ 
int init()
  {
//+--------- TRO MODIFICATION ---------------------------------------+  
   period       = Period();
   tChartPeriod =  TimeFrameToString(period);
   symbol       =  Symbol();
   digits       =  Digits;

   tShortName="tbb"+symbol+tChartPeriod;

   if(Period1>0) F_Period=MathCeil(Period1*Period()); else F_Period=0;
   if(Period2>0) N_Period=MathCeil(Period2*Period()); else N_Period=0;
   //if(Period3>0) H_Period=MathCeil(Period3*Period()); else H_Period=0;

   if(Period1>0)
     {
      SetIndexStyle(0,DRAW_ARROW);
      SetIndexArrow(0,Symbol_1_Kod);
      SetIndexBuffer(0,FP_BuferUp);
      SetIndexEmptyValue(0,0.0);
      SetIndexLabel(0,"b0-LG-FP_BufferUp");

      SetIndexStyle(1,DRAW_ARROW);
      SetIndexArrow(1,Symbol_1_Kod);
      SetIndexBuffer(1,FP_BuferDn);
      SetIndexEmptyValue(1,0.0);
      SetIndexLabel(1,"b1-LG-FP_BufferDn");
     }

   if(Period2>0)
     {
      SetIndexStyle(2,DRAW_ARROW);
      SetIndexArrow(2,Symbol_2_Kod);
      SetIndexBuffer(2,NP_BuferUp);
      SetIndexEmptyValue(2,0.0);
      SetIndexLabel(2,"b2-SM-NP_BuferUp");
      
      SetIndexStyle(3,DRAW_ARROW);
      SetIndexArrow(3,Symbol_2_Kod);
      SetIndexBuffer(3,NP_BuferDn);
      SetIndexEmptyValue(3,0.0);
      SetIndexLabel(3,"b3-SM-NP_BuferDn");
     }
/*
   if(Period3>0)
     {
      SetIndexStyle(4,DRAW_ARROW);
      SetIndexArrow(4,Symbol_3_Kod);
      SetIndexBuffer(4,HP_BuferUp);
      SetIndexEmptyValue(4,0.0);

      SetIndexStyle(5,DRAW_ARROW);
      SetIndexArrow(5,Symbol_3_Kod);
      SetIndexBuffer(5,HP_BuferDn);
      SetIndexEmptyValue(5,0.0);
     }
*/
      SetIndexLabel(4,"");
      SetIndexLabel(5,"");
      
//latest
   if(Period1>0)
     {
      SetIndexStyle(0+6,DRAW_ARROW);
      SetIndexArrow(0+6,Symbol_1_Kod);
      SetIndexBuffer(0+6,FP_BuferUpLatest);
      SetIndexEmptyValue(0+6,0.0);
      SetIndexLabel(0+6,"");
      
      SetIndexStyle(1+6,DRAW_ARROW);
      SetIndexArrow(1+6,Symbol_1_Kod);
      SetIndexBuffer(1+6,FP_BuferDnLatest);
      SetIndexEmptyValue(1+6,0.0);
      SetIndexLabel(1+6,"");
     }

   if(Period2>0)
     {
      SetIndexStyle(2+6,DRAW_ARROW);
      SetIndexArrow(2+6,Symbol_2_Kod);
      SetIndexBuffer(2+6,NP_BuferUpLatest);
      SetIndexEmptyValue(2+6,0.0);
      SetIndexLabel(2+6,"");

      SetIndexStyle(3+6,DRAW_ARROW);
      SetIndexArrow(3+6,Symbol_2_Kod);
      SetIndexBuffer(3+6,NP_BuferDnLatest);
      SetIndexEmptyValue(3+6,0.0);
      SetIndexLabel(3+6,"");
     }
/*
   if(Period3>0)
     {
      SetIndexStyle(4+6,DRAW_ARROW);
      SetIndexArrow(4+6,Symbol_3_Kod);
      SetIndexBuffer(4+6,HP_BuferUpLatest);
      SetIndexEmptyValue(4+6,0.0);

      SetIndexStyle(5+6,DRAW_ARROW);
      SetIndexArrow(5+6,Symbol_3_Kod);
      SetIndexBuffer(5+6,HP_BuferDnLatest);
      SetIndexEmptyValue(5+6,0.0);
     }
 */  
   SetIndexLabel(4+6,"");
   SetIndexLabel(5+6,"");
   
   SetIndexBuffer(12 ,trendlv1);  SetIndexLabel(12,"b12-LG-trendlv1");
   SetIndexBuffer(13,trendlv2);   SetIndexLabel(13,"b13-SM-trendlv2");
   SetIndexLabel(8+6,"");
   
   int CDev=0;
   int CSt=0;
   int Mass[];
   int C=0;
   if(IntFromStr(Dev_Step_1,C,Mass)==1)
     {
      Stp1=Mass[1];
      Dev1=Mass[0];
     }

   if(IntFromStr(Dev_Step_2,C,Mass)==1)
     {
      Stp2=Mass[1];
      Dev2=Mass[0];
     }

/*   if(IntFromStr(Dev_Step_3,C,Mass)==1)
     {
      Stp3=Mass[1];
      Dev3=Mass[0];
     }
*/
   DeleteAllLines();
   return(0);
  }
//+------------------------------------------------------------------+ 
//| Custor indicator deinitialization function                       | 
//+------------------------------------------------------------------+ 
int deinit()
  {
//---- 

//---- 
   return(0);
  }
//+------------------------------------------------------------------+ 
//| Custom indicator iteration function                              | 
//+------------------------------------------------------------------+ 
int start()
  {

//+-----   
   if(Bars!=OldBars) { Trigger1=True; Trigger2=True;}// Trigger3=True;}
 
 //NEW RK
   int limit;
   int counted_bars=IndicatorCounted();
   if(counted_bars<0) return(-1);
   if(counted_bars>0) counted_bars--;
   limit  = fmin(Bars-counted_bars,Bars-1);
   SetIndexDrawBegin(0,  (maxBars<=0?0:Bars-maxBars+1));
   SetIndexDrawBegin(1,  (maxBars<=0?0:Bars-maxBars+1));
   SetIndexDrawBegin(2,  (maxBars<=0?0:Bars-maxBars+1));
   SetIndexDrawBegin(3,  (maxBars<=0?0:Bars-maxBars+1));
  // SetIndexDrawBegin(4,  (maxBars<=0?0:Bars-maxBars+1));
  // SetIndexDrawBegin(5,  (maxBars<=0?0:Bars-maxBars+1));
   SetIndexDrawBegin(0+6,(maxBars<=0?0:Bars-maxBars+1));
   SetIndexDrawBegin(1+6,(maxBars<=0?0:Bars-maxBars+1));
   SetIndexDrawBegin(2+6,(maxBars<=0?0:Bars-maxBars+1));
   SetIndexDrawBegin(3+6,(maxBars<=0?0:Bars-maxBars+1));
  // SetIndexDrawBegin(4+6,(maxBars<=0?0:Bars-maxBars+1));
  // SetIndexDrawBegin(5+6,(maxBars<=0?0:Bars-maxBars+1));
   
   //if ( limit > maxBars )
   //{
   //   limit = maxBars;
   //} 
      
   int i;   //used for trends
 //end RK
 
   if(Period1>0) CountZZ(FP_BuferUp,FP_BuferDn,Period1,Dev1,Stp1);
   if(Period2>0) CountZZ(NP_BuferUp,NP_BuferDn,Period2,Dev2,Stp2);
   //if(Period3>0) CountZZ(HP_BuferUp,HP_BuferDn,Period3,Dev3,Stp3);
   STR_POINT upF[2],upN[2],upH[2];
   Lines(0,upF,FP_BuferUp);
   Lines(2,upN,NP_BuferUp);
   //Lines(4,upH,HP_BuferUp);

   DrawLine(0,upF,STYLE_DASH,C'108,138,137');
   DrawLine(2,upN,STYLE_DASHDOT,C'108,138,137');
  // DrawLine(4,upH,STYLE_DASHDOTDOT,C'108,138,137');

   STR_POINT dnF[2],dnN[2],dnH[2];
   Lines(1,dnF,FP_BuferDn);
   Lines(3,dnN,NP_BuferDn);
  // Lines(5,dnH,HP_BuferDn);

   DrawLine(1,dnF,STYLE_DASH,C'148,87,137');
   if(!LineSame(dnF,dnN))
      DrawLine(3,dnN,STYLE_DASHDOT,C'148,87,137');
  // if(!LineSame(dnN,dnH))
  //    DrawLine(5,dnH,STYLE_DASHDOTDOT,C'148,87,137');

   // NEW RK
               {     
         
                     trendlv1[i]   = trendlv1[i+1];
                     trendlv2[i]   = trendlv2[i+1];
                    // trendlv3[i]   = trendlv3[i+1];
           
               
               {
               
                        if (FP_BuferUp[0]!=0) trendlv1[i] =  1;
                        if (FP_BuferDn[0]!=0) trendlv1[i] = -1;
                        if (NP_BuferUp[0]!=0) trendlv2[i] =  1;
                        if (NP_BuferDn[0]!=0) trendlv2[i] = -1;
                        //if (HP_BuferUp[0]!=0) trendlv3[i] =  1;
                        //if (HP_BuferDn[0]!=0) trendlv3[i] = -1;  
               }
           return(0);
       }    
// end new

     {
      if(OldBars==-1)
        {
         for(int c=Bars-1;c>=0;c--)
           {
            FP_BuferUpLatest[c]=0;
            FP_BuferDnLatest[c]=0;
            NP_BuferUpLatest[c]=0;
            NP_BuferDnLatest[c]=0;
           // HP_BuferUpLatest[c]=0;
           // HP_BuferDnLatest[c]=0;
           }
        }
      else
        {
         for(c=OldBars-1;c>=0;c--)
           {
            FP_BuferUpLatest[c]=0;
            FP_BuferDnLatest[c]=0;
            NP_BuferUpLatest[c]=0;
            NP_BuferDnLatest[c]=0;
           // HP_BuferUpLatest[c]=0;
           // HP_BuferDnLatest[c]=0;
           }
        }
     }
 
               
               
               
   string alert_level;   string alert_message;

   alert_message=symbol+"  "+tChartPeriod+" at "+DoubleToStr(Close[0],digits);

   if(Trigger1 && Alert_Lv1)
     {
      if(FP_BuferUp[1]!=0)
        {
         Trigger1=False; alert_level=" ZZS: Level 1 Low;  ";
         if(Box_Alerts) Alert(alert_level,alert_message);
         if(Email_Alerts) SendMail(alert_level,alert_message);
         if(Sound_Alerts) PlaySound(Alert_Lv1_Low_SoundFile);
        }
     
      if(FP_BuferDn[1]!=0)
        {
         Trigger1=False; alert_level=" ZZS: Level 1 High; ";
         if(Box_Alerts) Alert(alert_level,alert_message);
         if(Email_Alerts) SendMail(alert_level,alert_message);
         if(Sound_Alerts) PlaySound(Alert_Lv1_High_SoundFile);
        
        }
     }

   if(Trigger2 && Alert_Lv2)
     {
      if(NP_BuferUp[1]!=0)
        {
         Trigger2=False; alert_level=" ZZS: Level 2 Low;  ";
         if(Box_Alerts) Alert(alert_level,alert_message);
         if(Email_Alerts) SendMail(alert_level,alert_message);
         if(Sound_Alerts) PlaySound(Alert_Lv2_Low_SoundFile);
        }
      if(NP_BuferDn[1]!=0)
        {
         Trigger2=False; alert_level=" ZZS: Level 2 High; ";
         if(Box_Alerts) Alert(alert_level,alert_message);
         if(Email_Alerts) SendMail(alert_level,alert_message);
         if(Sound_Alerts) PlaySound(Alert_Lv2_High_SoundFile);
        }
     }
/*
   if(Trigger3 && Alert_Lv3)
     {
      if(HP_BuferUp[0]!=0)
        {
         Trigger3=False; alert_level=" ZZS: Level 3 Low;  ";
         if(Box_Alerts) Alert(alert_level,alert_message);
         if(Email_Alerts) SendMail(alert_level,alert_message);
         if(Sound_Alerts) PlaySound(Alert_Lv3_Low_SoundFile);
        }
      if(HP_BuferDn[0]!=0)
        {
         Trigger3=False; alert_level=" ZZS: Level 3 High; ";
         if(Box_Alerts) Alert(alert_level,alert_message);
         if(Email_Alerts) SendMail(alert_level,alert_message);
         if(Sound_Alerts) PlaySound(Alert_Lv3_High_SoundFile);
        }
     }
*/
   OldBars=Bars;

   if(Period()>=PERIOD_M30)
     {
      //double SupplyStrongP1 = iCustom(Symbol(),Period(),"II_SupDemMOD_Summary",2,0);
      //double SupplyStrongP2 = iCustom(Symbol(),Period(),"II_SupDemMOD_Summary",3,0);

      //double SupplyStrongP1Upper = iCustom(Symbol(),Period(),"II_SupDemMOD_Summary",4,0);
      //double SupplyStrongP2Upper = iCustom(Symbol(),Period(),"II_SupDemMOD_Summary",5,0);

      //double DemandStrongP1 = iCustom(Symbol(),Period(),"II_SupDemMOD_Summary",6,0);
      //double DemandStrongP2 = iCustom(Symbol(),Period(),"II_SupDemMOD_Summary",7,0);

      //double DemandStrongP1Lower = iCustom(Symbol(),Period(),"II_SupDemMOD_Summary",8,0);
      //double DemandStrongP2Lower = iCustom(Symbol(),Period(),"II_SupDemMOD_Summary",9,0);

//      int q;
      //if(OldBars>50) {for(q=0;q<50;q++){if(FP_BuferUp[q]!=0)break;} FP_BuferUpLatest[q]=FP_BuferUp[q];}
      //if(OldBars>50) {for(q=0;q<50;q++){if(FP_BuferDn[q]!=0)break;} FP_BuferDnLatest[q]=FP_BuferDn[q];}

      //if(OldBars>50) {for(q=0;q<50;q++){if(NP_BuferUp[q]!=0)break;} NP_BuferUpLatest[q]=NP_BuferUp[q];}
      //if(OldBars>50) {for(q=0;q<50;q++){if(NP_BuferDn[q]!=0)break;} NP_BuferDnLatest[q]=NP_BuferDn[q];}
/*
      if(OldBars>50)
        {
         for(q=0;q<50;q++){if(HP_BuferUp[q]!=0)break;}
         //if(!((DemandStrongP1>=HP_BuferUp[q] && HP_BuferUp[q]<=DemandStrongP2) || (DemandStrongP1Lower>=HP_BuferUp[q] && HP_BuferUp[q]<=DemandStrongP2Lower)))
            HP_BuferUpLatest[q]=HP_BuferUp[q];;
        }
      if(OldBars>50)
        {
         for(q=0;q<50;q++){if(HP_BuferDn[q]!=0)break;}
         //if(!((SupplyStrongP1>=HP_BuferDn[q] && HP_BuferDn[q]<=SupplyStrongP2) || (SupplyStrongP1Upper>=HP_BuferDn[q] && HP_BuferDn[q]<=SupplyStrongP2Upper)))
            HP_BuferDnLatest[q]=HP_BuferDn[q];
        }
 */    }

//+----- 
   return(0);
  }
//+-----  
bool LineSame(STR_POINT  &line1[],STR_POINT  &line2[])
  {
   return line1[0].dt==line2[0].dt && line1[1].dt==line2[1].dt && line1[0].pr==line2[0].pr && line1[1].pr==line2[1].pr;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string TimeFrameToString(int tf)
  {
   string tfs;
   switch(tf)
     {
      case PERIOD_M1:  tfs="M1"; break;
      case PERIOD_M5:  tfs="M5"; break;
      case PERIOD_M15: tfs="M15"; break;
      case PERIOD_M30: tfs="M30"; break;
      case PERIOD_H1:  tfs="H1"; break;
      case PERIOD_H4:  tfs="H4"; break;
      case PERIOD_D1:  tfs="D1"; break;
      case PERIOD_W1:  tfs="W1"; break;
      case PERIOD_MN1: tfs="MN";
     }
   return(tfs);
  }
//+------------------------------------------------------------------+  
int CountZZ(double &ExtMapBuffer[],double &ExtMapBuffer2[],int ExtDepth,int ExtDeviation,int ExtBackstep)
  {
   int    shift,back,lasthighpos,lastlowpos;
   double val,res;
   double curlow,curhigh,lasthigh,lastlow;

   for(shift=Bars-ExtDepth; shift>=0; shift--)
     {
      val=Low[Lowest(NULL,0,MODE_LOW,ExtDepth,shift)];
      if(val==lastlow) val=0.0;
      else
        {
         lastlow=val;
         if((Low[shift]-val)>(ExtDeviation*Point)) val=0.0;
         else
           {
            for(back=1; back<=ExtBackstep; back++)
              {
               res=ExtMapBuffer[shift+back];
               if((res!=0) && (res>val)) ExtMapBuffer[shift+back]=0.0;
              }
           }
        }

      ExtMapBuffer[shift]=val;
      //--- high
      val=High[Highest(NULL,0,MODE_HIGH,ExtDepth,shift)];
      if(val==lasthigh) val=0.0;
      else
        {
         lasthigh=val;
         if((val-High[shift])>(ExtDeviation*Point)) val=0.0;
         else
           {
            for(back=1; back<=ExtBackstep; back++)
              {
               res=ExtMapBuffer2[shift+back];
               if((res!=0) && (res<val)) ExtMapBuffer2[shift+back]=0.0;
              }
           }
        }
      ExtMapBuffer2[shift]=val;
     }
// final cutting 
   lasthigh=-1; lasthighpos=-1;
   lastlow=-1;  lastlowpos=-1;

   for(shift=Bars-ExtDepth; shift>=0; shift--)
     {
      curlow=ExtMapBuffer[shift];
      curhigh=ExtMapBuffer2[shift];
      if((curlow==0) && (curhigh==0)) continue;
      //---
      if(curhigh!=0)
        {
         if(lasthigh>0)
           {
            if(lasthigh<curhigh) ExtMapBuffer2[lasthighpos]=0;
            else ExtMapBuffer2[shift]=0;
           }
         //---
         if(lasthigh<curhigh || lasthigh<0)
           {
            lasthigh=curhigh;
            lasthighpos=shift;
           }
         lastlow=-1;
        }
      //----
      if(curlow!=0)
        {
         if(lastlow>0)
           {
            if(lastlow>curlow) ExtMapBuffer[lastlowpos]=0;
            else ExtMapBuffer[shift]=0;
           }
         //---
         if((curlow<lastlow) || (lastlow<0))
           {
            lastlow=curlow;
            lastlowpos=shift;
           }
         lasthigh=-1;
        }
     }

   for(shift=Bars-1; shift>=0; shift--)
     {
      if(shift>=Bars-ExtDepth) ExtMapBuffer[shift]=0.0;
      else
        {
         res=ExtMapBuffer2[shift];
         if(res!=0.0) ExtMapBuffer2[shift]=res;
        }
     }
   return(0);  //added by rk
  }
//+------------------------------------------------------------------+   
int Str2Massive(string VStr,int &M_Count,int &VMass[])
  {
   int val=StrToInteger(VStr);
   if(val>0)
     {
      M_Count++;
      int mc=ArrayResize(VMass,M_Count);
      if(mc==0)return(-1);
      VMass[M_Count-1]=val;
      return(1);
     }
   else return(0);
  }
//+------------------------------------------------------------------+   
int IntFromStr(string ValStr,int &M_Count,int &VMass[])
  {

   if(StringLen(ValStr)==0) return(-1);
   string SS=ValStr;
   int NP=0;
   string CS;
   M_Count=0;
   ArrayResize(VMass,M_Count);
   while(StringLen(SS)>0)
     {
      NP=StringFind(SS,",");
      if(NP>0)
        {
         CS=StringSubstr(SS,0,NP);
         SS=StringSubstr(SS,NP+1,StringLen(SS));
        }
      else
        {
         if(StringLen(SS)>0)
           {
            CS=SS;
            SS="";
           }
        }
      if(Str2Massive(CS,M_Count,VMass)==0)
        {
         return(-2);
        }
     }
   return(1);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int LinearRegression(double &p[],int &t[],int rows,double &a,double &b,double &SquarePoor[])
  {
   int m;
   double Lxx=0.0,Lxy=0.0,xa=0.0,ya=0.0;
   for(m=0; m<rows; m++)
     {
      xa += t[m];
      ya += p[m];
     }
   xa /= rows;                                     // X平均值
   ya /= rows;                                     // Y平均值
   for(m=0; m<rows; m++)
     {
      Lxx+=((t[m]-xa) *(t[m]-xa));                 // Lxx = Sum((X - Xa)平方)
      Lxy+=((t[m]-xa) *(p[m]-ya));                 // Lxy = Sum((X - Xa)(Y - Ya))
     }
   if(Lxx==0) Lxx=0.0000000001;
   b= Lxy/Lxx;                                     // b = Lxy / Lxx
   a = ya-b * xa;                                  // a = Ya - b*Xa

                                                   // 方差分析
   SquarePoor[0]=SquarePoor[1]=0.0;
   for(m=0; m<rows; m++)
     {
      Lxy=a+b*t[m];
      SquarePoor[0]+=((Lxy-ya) *(Lxy-ya)); // U(回归平方和)
      SquarePoor[1]+=((p[m]-Lxy) *(p[m]-Lxy)); // Q(剩余平方和)
     }
   SquarePoor[2]=SquarePoor[0];                  // 回归方差
   if(rows!=2)
      SquarePoor[3]=SquarePoor[1]/(rows-2);     // 剩余方差
   return 0;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Lines(int id,STR_POINT &points[],double &buffer[])
  {
   double p[];
   int t[];
   ArrayResize(p,ArraySize(points));
   ArrayResize(t,ArraySize(points));

   int getPoints=0;
   int ignoreCount=1;
   for(int i=0;i<Bars;i++)
     {
      if(i>2000)
         break;
      if(buffer[i]!=0 && (ignoreCount--)<=0)
        {
         p[getPoints]=buffer[i];
         t[getPoints]=i;

         if(++getPoints>=ArraySize(points))
            break;
        }
     }

   double SquarePoor[4];
   double a,b;
   LinearRegression(p,t,ArraySize(points),a,b,SquarePoor);
//Print("point1=",p[0],",",t[0]);
//Print("point2=",p[1],",",t[1]);
//Print(a,",",b,",",SquarePoor[0],",",SquarePoor[1],",",SquarePoor[3],",",SquarePoor[3]);

   points[0].dt = Time[t[ArraySize(points)-1]];
   points[1].dt = Time[t[0]];
   points[0].pr = b*(t[ArraySize(points)-1])+a;
   points[1].pr = b*t[0]+a;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawLine(int id,STR_POINT &points[],int ls,color clr)
  {
   return;
   string c_name="Chaos-Line-Id-"+id;
   ObjectDelete(0,c_name);
   ObjectCreate(0,c_name,OBJ_TREND,0,points[0].dt,points[0].pr,points[1].dt,points[1].pr);
   ObjectSetInteger(0,c_name,OBJPROP_COLOR,clr);
   ObjectSetInteger(0,c_name,OBJPROP_BACK,true);
   ObjectSetInteger(0,c_name,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,c_name,OBJPROP_WIDTH,1);
   ObjectSetInteger(0,c_name,OBJPROP_STYLE,ls);
   ObjectSetInteger(0,c_name,OBJPROP_RAY,true);
  }
//+------------------------------------------------------------------+
void DeleteAllLines()
  {
   for(int i=ObjectsTotal(0,-1,OBJ_TREND)-1; i>=0; i--)
     {
      string name=ObjectName(0,i,-1,OBJ_TREND);
      if(StringFind(name,"Chaos-")==0)
         ObjectDelete(0,name);
     }
  }
//+------------------------------------------------------------------+