iK_tay_v01

//+------------------------------------------------------------------+
//|                                                   iK_tay_v01.mq4 |
//|                                                      Ivan Katsko |
//+------------------------------------------------------------------+
#property copyright "Ivan Katsko"
#property link      "" 

#property indicator_separate_window                            // Îòîáðàæåíèå â îòäåëüíîì îêíå
#property indicator_buffers 7                                  // Êîëè÷åñòâî áóôåðîâ
#property indicator_color1 DeepPink                            // Öâåò ïåðâîé ëèíèè
#property indicator_color2 Purple                              // Öâåò âòîðîé ëèíèè
#property indicator_color3 Red                                 // Öâåò òðåòüåé ëèíèè
#property indicator_color4 LawnGreen                           // Öâåò ÷åðâåðòîé ëèíèè
#property indicator_color5 Gold                                // Öâåò ïÿòîé ëèíèè
#property indicator_color6 DarkBlue                            // Öâåò øåñòîé ëèíèè
#property indicator_color7 SteelBlue                           // Öâåò ñåäüìîé ëèíèè
 
extern int Discret=1;                                          // Äèñêðåòíîñòü ïîäáîðà: 1 - êàæäàÿ ïîçèöèÿ; 2 - ÷åðåç ïîçèöèþ è ò.ä.
extern double Level=10;                                        // Ìèíèìàëüíûé óðîâåíü SL/TP

int i,j,x,
    Repeat_Count=30,                                           // Êîëè÷åñòâî ïîâòîðîâ
    Action_Count,                                              // Êîëè÷åñòâî ñäåëîê
    History,                                                   // Êîëè÷.áàðîâ â ðàñ÷¸òíîé èñòîðèè
    Iteration;                                                 // Êîëè÷.èòåðàöèé
 
static datetime New_Time;

double 
       k,                                                      // Êîýô.
       Alg_Minus=-0.001,                                       // Àëãîðèòì: "ñåãîäíÿ - íå êàê â÷åðà"
       Alg_Plus = 0.001,                                       // Àëãîðèòì: "ñåãîäíÿ - êàê â÷åðà"
       Buy = 0.001,                                            // Âåëè÷èíà èíäèêàòîðà 
       Sell=-0.001,                                            // Âåëè÷èíà èíäèêàòîðà
       Scope_Up,                                               // Ðàçìàõ Ââåðõ
       Scope_Dn,                                               // Ðàçìàõ Âíèç
       Max_Alg_Minus,                                          // Ìàêñèìóì äëÿ àëãîðèòìà "ìèíóñ"
       Max_Alg_Plus,                                           // Ìàêñèìóì äëÿ àëãîðèòìà "ïëþñ"
       Max_Value=-0.1,
       YT_Alg_Minus,
       TP_Alg_Minus,
       SL_Alg_Minus,
       Set_Alg_Minus,
       YT_Alg_Plus,
       TP_Alg_Plus,
       SL_Alg_Plus,
       Set_Alg_Plus,
       Scope_Cl,                                               // Ðàçìàõ çàêðûòèÿ 
       Repeat[30,3],                                           // Ìàññèâ ïîâòîðîâ ïîâòîðèòü
       Algoritm[],                                             // Àëãîðèòì: 1 - "ñåãîäíÿ êàê â÷åðà", -1 - "ñåãîäíÿ íå êàê â÷åðà"
       Direction[],                                            // Íàïðàâëåíèå ïðèêàçà: 1 - ïîêóïêà, -1 - ïðîäàæà
       Value_TP[],                                             // Ìàññèâ - Çíà÷åíèå Òåéê Ïðîôèò äàëåå áóäåò ïåðåîïðåäåëåí ðàçìåð
       Sum_TP[],                                               // Ìàññèâ - Íàðàñòàþùåé àäàïòèâíîé ñóììû Òåéê Ïðîôèò
       Sum_na_TP[],                                            // Ìàññèâ - Íàðàñòàþùåé ñóììû Òåéê Ïðîôèò
       Im_Sum_TP[30],                                          // Ìàññèâ - ïðîìåæóòî÷íîé Íàðàñòàþùåé ñóììû Òåéê Ïðîôèò
       Spread,                                                 // Ñïðåä
       Set_YT,                                                 // Çàäàííûé ðàçìàõ "â÷åðà"
       Set_TP[],                                               // Çàäàííûé Òåéê Ïðîôèò
       Set_SL[],                                               // Çàäàííûé Ñòîï Ëîññ
       Found_TP,                                               // Íàéäåííîå çíà÷åíèå Òåéê Ïðîôèò
       Found_SL,                                               // Íàéäåííîå çíà÷åíèå Ñòîï Ëîññ
       Found_Scope_YT;                                         // Íàéäåííûé ðàçìàõ "â÷åðà"

bool 
     New_Bar=false;                                            // Ôëàã íîâîãî áàðà 

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   if (Discret<=0) 
     {
     Discret=1;                                                // Íå êîððåêòíî ââåäåí äèñêðåò
     Alert ("Äèñêðåòíîñòü óñòàíîâëåíà ðàâíîé 1");
     }
   New_Time=Time[0];                                           // Âðåìÿ òåêóùåãî áàðà
   Spread=MarketInfo(Symbol(), MODE_SPREAD)*Point;

   SetIndexBuffer(0,Set_TP);                                   // Íàçíà÷åíèå ìàññèâà Òåéê Ïðîôèò
   SetIndexStyle (0,DRAW_LINE,STYLE_SOLID,2);                  // Ñòèëü ëèíèè
   SetIndexBuffer(1,Set_SL);                                   // Íàçíà÷åíèå ìàññèâà Ñòîï Ëîññ
   SetIndexStyle (1,DRAW_LINE,STYLE_SOLID,1);                  // Ñòèëü ëèíèè
   SetIndexBuffer(2,Sum_TP);                                   // Íàçíà÷åíèå ìàññèâà ñóììà ïðîôèòà
   SetIndexStyle (2,DRAW_LINE,STYLE_SOLID,2);                  // Ñòèëü ëèíèè
   SetIndexBuffer(3,Direction);                                // Íàçíà÷åíèå ìàññèâà Íàïðàâëåíèå òîðãîâëè
   SetIndexStyle (3,DRAW_HISTOGRAM,STYLE_SOLID,4);             // Ñòèëü ëèíèè
   SetIndexBuffer(4,Algoritm);                                 // Íàçíà÷åíèå ìàññèâà àëãîðèòìà
   SetIndexStyle (4,DRAW_LINE,STYLE_SOLID,1);                  // Ñòèëü ëèíèè
   SetIndexBuffer(5,Value_TP);                                 // Íàçíà÷åíèå ìàññèâà Ïðîôèòà
   SetIndexStyle (5,DRAW_HISTOGRAM,STYLE_SOLID,2);             // Ñòèëü ëèíèè

   switch (Period())                                           // Óñòàíîâêà êîëè÷.èññëåäóåìûõ áàðîâ
      {
         case    5: History = 24; break;                       // Ïåðèîä 5-òè ìèíóòíûé 
         case   15: History = 24; break;                       // Ïåðèîä 15-òè ìèíóòíûé
         case   30: History = 24; break;                       // Ïåðèîä 30-òè ìèíóòíûé
         case   60: History = 24; break;                       // Ïåðèîä ÷àñîâîé
         case  240: History = 30; break;                       // Ïåðèîä 4-õ ÷àñîâîé
         case 1440: History = 22; break;                       // Ïåðèîä äíåâíîé
         default: Alert("Âûáåðèòå ïåðèîä îò M5 äî D1."); break;// Íåâåðíî âûáðàí ïåðèîä
      }

   return(0);
  }

//+------------------------------------------------------------------+
int start()
  {
   Fun_New_Bar();                                              // Îïðåäåëåíèå íà÷àëà íîâîãî áàðà

   for (int n=1; n<3; n++)                                     // Äëÿ äâóõ âàðèàíòîâ àëãîðèòìîâ
   {
    Fun_Sum_TP(10*Point,10*Point,10*Point,Alg_Minus);          // Èùåì ÷èñëî èòåðàöèé (ðàâíî íàèáîëüøåìó ðàçìàõó)
    
    Set_YT   =0.5*Iteration*Discret*Point;                     // Íà÷àëüíûé ðàçìàõ "â÷åðà"
    Set_SL[0]=0.5*Iteration*Discret*Point;                     // Íà÷àëüíûé Ñòîï Ëîññ
    Set_TP[0]=0.5*Iteration*Discret*Point;                     // Íà÷àëüíûé Òåéê Ïðîôèò
    
    Alg_Minus=-0.25*Set_SL[0];
    Alg_Plus = 0.25*Set_TP[0];
    if (n==1) Algoritm[0]=Alg_Minus;                           // Ïåðâûé ïðîõîä - àëãîðèòì "ñåãîäíÿ íå êàê â÷åðà"
    if (n==2) Algoritm[0]=Alg_Plus;                            // Âòîðîé ïðîõîä - àëãîðèòì "ñåãîäíÿ êàê â÷åðà"
    Repeat_Count=5+History/MathSqrt(Iteration*Discret/10);
    ArrayResize(Repeat,Repeat_Count);                          // Èçìåíåí ðàçìåð ìàññèâà
    ArrayResize(Im_Sum_TP,Repeat_Count);                       // Èçìåíåí ðàçìåð ìàññèâà
    ArrayInitialize(Im_Sum_TP,0);                              // Î÷èñòèòü ìàññèâ ñóìì
    ArrayInitialize(Repeat,0);                                 // Î÷èñòèòü ìàññèâ ïîâòîðîâ
    Action_Count=0;                                            // Îáíóëèì ñ÷åò÷èê êîëè÷åñòâà ñäåëîê
    x=0;                                                       // Ñáðîñèòü èíäåêñ ìàññèâ ïîâòîðîâ
    
    while (Action_Count<History/2                              // Ïîêà ÷èñëî ñäåëîê ìåíüøå ïîëîâèíû
           || Sum_TP[0]<0)
      {                                                        // áóäåì èñêàòü äðóãîé âàðèàíò
       Action_Count=0;                                         // Îáíóëèì ñ÷åò÷èê êîëè÷åñòâà ñäåëîê
       
       //---- Îïðåäåëÿåì îïòèìàëüíîå çíà÷åíèå "â÷åðà"
       for (j=0; j<Iteration-1; j++)
         {
          if (j==0) 
            {
             Max_Value=-0.1;
             Set_YT=0;
            }
          Set_YT += Discret*Point;
          if (Fun_Repeat(Set_YT,Set_SL[0],Set_TP[0])) continue;// Åñëè òàêîé âàðèàíò áûë - âçÿòü ñëåäóþùèé
          Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Algoritm[0]);  // Èùåì ìàêñèìàëüíîå çíà÷åíèå "â÷åðà"
          if (Max_Value<Sum_TP[0])
            {
             Max_Value=Sum_TP[0];
             Found_Scope_YT=Set_YT;
            }
         }
       Set_YT=Found_Scope_YT;                                  // Íàøëè ìàêñèìàëüíîå çíà÷åíèå "â÷åðà"
       
       //---- Îïðåäåëÿåì îïòèìàëüíîå çíà÷åíèå Ñòîï Ëîññ
       for (j=0; j<Iteration-1; j++)
         {
          if (j==0) 
            {
             Max_Value=-0.1;
             Set_SL[0]=Level*Point;                            // Íà÷èíàÿ îò ìèíèìàëüíî äîïóñòèìîãî óðîâíÿ
            }
          Set_SL[0] += Discret*Point;
          if (Fun_Repeat(Set_YT,Set_SL[0],Set_TP[0])) continue;// Åñëè òàêîé âàðèàíò áûë - âçÿòü ñëåäóþùèé
          Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Algoritm[0]);  // Ìàêñèìàëüíîå çíà÷åíèå Ñòîï Ëîññ
          if (Max_Value<Sum_TP[0])
            {
             Max_Value=Sum_TP[0];
             Found_SL=Set_SL[0];
            }
         }
       Set_SL[0]=Found_SL;                                     // Íàøëè ìàêñèìàëüíîå çíà÷åíèå Ñòîï Ëîññ
       
       //---- Îïðåäåëÿåì îïòèìàëüíîå çíà÷åíèå Òåéê Ïðîôèò
       for (j=0; j<Iteration-1; j++)
         {
          if (j==0) 
            {
             Max_Value=-0.1;
             Set_TP[0]=Level*Point;                            // Íà÷èíàÿ îò ìèíèìàëüíî äîïóñòèìîãî óðîâíÿ
            }
          Set_TP[0] += Discret*Point;
          if (Fun_Repeat(Set_YT,Set_SL[0],Set_TP[0])) continue;// Åñëè òàêîé âàðèàíò áûë - âçÿòü ñëåäóþùèé
          Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Algoritm[0]);  // Ìàêñèìàëüíîå çíà÷åíèå Òåéê Ïðîôèò
          if (Max_Value<Sum_TP[0])
            {
             Max_Value=Sum_TP[0];
             Found_TP=Set_TP[0];
            }
         }
       Set_TP[0]=Found_TP;                                     // Íàøëè ìàêñèìàëüíîå çíà÷åíèå Òåéê Ïðîôèò
       
       Alg_Minus=-0.25*Set_SL[0];
       Alg_Plus = 0.25*Set_TP[0];
       if (n==1) Algoritm[0]=Alg_Minus;                        // Ïåðâûé ïðîõîä - àëãîðèòì "ñåãîäíÿ íå êàê â÷åðà"
       if (n==2) Algoritm[0]=Alg_Plus;                         // Âòîðîé ïðîõîä - àëãîðèòì "ñåãîäíÿ êàê â÷åðà"
       
       //---- Êîëè÷åñòâî ñëåäîê çà âñå âðåìÿ íå äîëæíî áûòü ìåíüøå ïîëîâèíû âîçìîæíûõ
       Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Algoritm[0]);     // Ïîñìîòðèì ñêîëüêî ïîëó÷àåòñÿ ñäåëîê
       for (j=0; j<=History-1; j++)                            // Ïîäñ÷åò ÷èñëà ñäåëîê
         if (Direction[j]!=0) Action_Count+=1;
       if (Action_Count<History/2                              // Åñëè ÷èñëî ñäåëîê ìåíüøå ïîëîâèíû
           || Sum_TP[0]<0)
         {
          Repeat[x,0] =Set_YT;                                 // çàïîìíèòü ýòîò âàðèàí YT
          Repeat[x,1] =Set_SL[0];                              // çàïîìíèòü ýòîò âàðèàíò SL
          Repeat[x,2] =Set_TP[0];                              // çàïîìíèòü ýòîò âàðèàíò ÒÐ
          Im_Sum_TP[x]=Sum_TP[0];                              // çàïîìíèòü ýòîò âàðèàíò Sum
          x++;
         }
       if (x==Repeat_Count)                                    // íåò îïòèìàëüíûõ âàðèàíòîâ 
         {                                                     // îïðåäåëèì ëó÷øèé èç õóäøèõ
          Sum_TP[0]=Im_Sum_TP[ArrayMaximum(Im_Sum_TP)];
          Set_YT   =Repeat[ArrayMaximum(Im_Sum_TP),0];
          Set_SL[0]=Repeat[ArrayMaximum(Im_Sum_TP),1];
          Set_TP[0]=Repeat[ArrayMaximum(Im_Sum_TP),2];
          break;                                               // Çàêîí÷èòü while
         }
      }                                                        // Êîíåö while
    
    if (n==1)   
      {
       Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Alg_Minus);       // Îáíîâèì âñå
       Max_Alg_Minus=Sum_TP[0];
       YT_Alg_Minus=Set_YT;
       TP_Alg_Minus=Set_TP[0];
       SL_Alg_Minus=Set_SL[0];
       Set_Alg_Minus=Alg_Minus;
      }
    if (n==2) 
      {
       Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Alg_Plus);        //Îáíîâèì âñå
       Max_Alg_Plus =Sum_TP[0];
       YT_Alg_Plus=Set_YT;
       TP_Alg_Plus=Set_TP[0];
       SL_Alg_Plus=Set_SL[0];
       Set_Alg_Plus=Alg_Plus;
      }
   }                                                           // Êîíåö äâóõ âàðèàíòîâ àëãîðèòìîâ
   if (Max_Alg_Minus>=Max_Alg_Plus)                            // Åñëè ëó÷øèì îêàçàëñÿ àäãîðèòì "ìèíóñ"
     {
      Max_Value=Max_Alg_Minus;
      Set_YT=YT_Alg_Minus;
      for (i=0; i<History/3; i++)
        {
         Set_TP[i]=TP_Alg_Minus;
         Set_SL[i]=SL_Alg_Minus;
         if (Max_Alg_Minus>0)
           Algoritm[i]=Set_Alg_Minus;
           else
           Algoritm[i]=0;
         Alg_Minus=Set_Alg_Minus;
        }
     }
      else
     {
      Max_Value=Max_Alg_Plus;
      Set_YT=YT_Alg_Plus;
      for (i=0; i<History/3; i++)
        {
         Set_TP[i]=TP_Alg_Plus;
         Set_SL[i]=SL_Alg_Plus;
         if (Max_Alg_Plus>0)
           Algoritm[i]=Set_Alg_Plus;
           else
           Algoritm[i]=0;
         Alg_Plus=Set_Alg_Plus;
        }
     }
   
   Buy = 0.5*Set_YT;
   Sell=-0.5*Set_SL[0];
   
   Fun_Sum_TP(Set_YT,Set_SL[0],Set_TP[0],Algoritm[0]);         // Íàðèñóåì îêîí÷àòåëüíûé ãðàôèê
   return(0);
  }

//+------------------------------------------------------------------+
double Fun_Sum_TP(double set_YT,    // Ô-èÿ îïðåäåëåíèÿ íàðàñòàþùåãî çíà÷åíèÿ Òåéê Ïðîôèò
                  double set_SL,double set_TP,double algoritm) 
  {
   int i,                           // Èíäåêñ áàðà
   Count_bars;                      // Êîëè÷åñòâî ïðîñ÷èòàííûõ áàðîâ 
   
   Sum_TP[History]=0;               // Îáíóëèì ïîñëåäíèå çíà÷åíèÿ 
   Sum_na_TP[History]=0;         
   Direction[History]=0;
   Value_TP[History-1]=0;
   
   i=Bars-1;                        // Èíäåêñ ïåðâîãî 
   if (i>History-1)                 // Åñëè ìíîãî áàðîâ òî ..
      i=History-1;                  // ..ðàññ÷èòûâàòü çàäàííîå êîëè÷.
   while(i>=0)                      // Öèêë ïî áàðàì
     {
      //---- Îïðåäåëèì ðàçìàõ
      Scope_Up=(High[i] -Open[i]);  // Çíà÷åíèå Ðàçìàõà Ââåðõ íà i-îì áàðå
      Scope_Dn=(Low[i]  -Open[i]);  // Çíà÷åíèå Ðàçìàõà Âíèç íà i-îì áàðå
      Scope_Cl=(Close[i]-Open[i]);  // Çíà÷åíèå Ðàçìàõà Çàêðûòèÿ íà i-îì áàðå
      
      //---- Îïðåäåëèì êîëè÷åñòâî èòåðàöèé
      if ( Scope_Up>Iteration*Discret*Point) Iteration= (Scope_Up/Point)/Discret;
      if (-Scope_Dn>Iteration*Discret*Point) Iteration=(-Scope_Dn/Point)/Discret;
   
      //---- Îïðåäåëèì íàïðàâëåíèå ïðèêàçà
      if ((Scope_Up>=(-Scope_Dn)    // Åñëè ðàçìàõ ââåðõ áîëüøå ðàçìàõà âíèç
          && Scope_Up>=set_YT       // áîëüøå çàäàííîãî ðàçìàõà "â÷åðà"
          && algoritm==Alg_Plus)    // çàäàí àëãîðèòì "ñåãîäíÿ êàê â÷åðà"
          ||                        // ÈËÈ
          (Scope_Up<(-Scope_Dn)     // Åñëè ðàçìàõ âíèç  áîëüøå ðàçìàõà ââåðõ
          && (-Scope_Dn)>=set_YT    // áîëüøå çàäàííîãî ðàçìàõà "â÷åðà"
          && algoritm==Alg_Minus))  // çàäàí àëãîðèòì "ñåãîäíÿ íå êàê â÷åðà"
        {
         Direction[i]=Buy;          // íàäî ïîêóïàòü
        }
      if ((Scope_Up>(-Scope_Dn)     // Åñëè ðàçìàõ ââåðõ áîëüøå ðàçìàõà âíèç
          && Scope_Up>=set_YT       // áîëüøå çàäàííîãî ðàçìàõà "â÷åðà"
          && algoritm==Alg_Minus)   // çàäàí àëãîðèòì "ñåãîäíÿ íå êàê â÷åðà"
          ||                        // ÈËÈ
          (Scope_Up<(-Scope_Dn)     // Åñëè ðàçìàõ âíèç  áîëüøå ðàçìàõà ââåðõ
          && (-Scope_Dn)>=set_YT    // áîëüøå çàäàííîãî ðàçìàõà "â÷åðà"
          && algoritm==Alg_Plus))   // çàäàí àëãîðèòì "ñåãîäíÿ êàê â÷åðà"
        {
         Direction[i]=Sell;         // íàäî ïðîäàâàòü
        }
      if ((Scope_Up>=(-Scope_Dn)    // Åñëè ðàçìàõ ââåðõ áîëüøå ðàçìàõà âíèç
          && Scope_Up<set_YT)       // ìåíüøå ðàçìàõà "â÷åðà"
          ||                        // ÈËÈ
          (Scope_Up<=(-Scope_Dn)    // Åñëè ðàçìàõ âíèç  áîëüøå ðàçìàõà ââåðõ
          && (-Scope_Dn)<set_YT))   // ìåíüøå ðàçìàõà "â÷åðà"
        {
         Direction[i]=0;            // íàïðàâëåíèå íå îïðåäåëåíî
        }
      //---- Îïðåäåëèì çíà÷åíèÿ Òåéê Ïðîôèò ïðè âûèãðàøå
      if ((Direction[i+1]==Buy             // Åñëè íàäî ïîêóïàòü
          && Scope_Up>=(set_TP+Spread)     // ðàçìàõ ââåðõ áîëüøå Òåéê Ïðîôèòà + Ñïðåä
          && (-Scope_Dn)<(set_SL-Spread))  // ðàçìàõ âíèç ìåíüøå Ñòîï Ëîññà - Ñïðåä
          ||                               // ÈËÈ
         (Direction[i+1]==Sell             // Åñëè íàäî ïðîäàâàòü
          && (-Scope_Dn)>=(set_TP+Spread)  // ðàçìàõ âíèç áîëüøå Òåéê Ïðîôèòà + Ñïðåä
          && Scope_Up<(set_SL-Spread)))    // ðàçìàõ ââåðõ ìåíüøå Ñòîï Ëîññà - Ñïðåä
        Value_TP[i]=set_TP;                // ïîëó÷åí çàäàííûé Òåéê Ïðîôèò
      //---- Îïðåäåëèì çíà÷åíèÿ Òåéê Ïðîôèò ïðè ïðîèãðûøå
      if ((Direction[i+1]==Buy             // Åñëè íàäî ïîêóïàòü
          && (-Scope_Dn)>=(set_SL-Spread)) // ðàçìàõ âíèç ìåíüøå Ñòîï Ëîññà - Ñïðåä
          ||                               // ÈËÈ
         (Direction[i+1]==Sell             // Åñëè íàäî ïðîäàâàòü
          && Scope_Up>=(set_SL-Spread)))   // ðàçìàõ ââåðõ ìåíüøå Ñòîï Ëîññà - Ñïðåä
        Value_TP[i]=-set_SL;               // ïîëó÷åí çàäàííûé Òåéê Ïðîôèò
      //---- Îïðåäåëèì çíà÷åíèÿ Òåéê Ïðîôèò â äðóãèõ ñëó÷àÿõ
      if (Direction[i+1]==0) Value_TP[i]=0;// Åñëè íàïðàâëåíèå íå îïðåäåëåíî - Òåéê Ïðîôèò ðàâåí íóëþ
      if ((Direction[i+1]==Buy             // Åñëè íàäî ïîêóïàòü
          && Scope_Up<(set_TP+Spread)      // ðàçìàõ ââåðõ ìåíüøå Òåéê Ïðîôèòà + Ñïðåä
          && (-Scope_Dn)<(set_SL-Spread)   // ðàçìàõ âíèç ìåíüøå Ñòîï Ëîññà - Ñïðåä
          && Scope_Cl>=0)
          ||                               // ÈËÈ
         (Direction[i+1]==Sell             // Åñëè íàäî ïðîäàâàòü
          && (-Scope_Dn)<(set_TP+Spread)   // ðàçìàõ âíèç ìåíüøå Òåéê Ïðîôèòà + Ñïðåä
          && Scope_Up<(set_SL-Spread)      // ðàçìàõ ââåðõ ìåíüøå Ñòîï Ëîññà - Ñïðåä
          && -Scope_Cl>=0))
        Value_TP[i]=MathAbs(Scope_Cl)-Spread; // Òåéê Ïðîôèò ðàâåí çàêðûòèþ ìèíóñ ñïðåä
      if ((Direction[i+1]==Buy             // Åñëè íàäî ïîêóïàòü
          && Scope_Up<(set_TP+Spread)      // ðàçìàõ ââåðõ ìåíüøå Òåéê Ïðîôèòà + Ñïðåä
          && (-Scope_Dn)<(set_SL-Spread)   // ðàçìàõ âíèç ìåíüøå Ñòîï Ëîññà - Ñïðåä
          && Scope_Cl<0)
          ||                               // ÈËÈ
         (Direction[i+1]==Sell             // Åñëè íàäî ïðîäàâàòü
          && (-Scope_Dn)<(set_TP+Spread)   // ðàçìàõ âíèç ìåíüøå Òåéê Ïðîôèòà + Ñïðåä
          && Scope_Up<(set_SL-Spread)      // ðàçìàõ ââåðõ ìåíüøå Ñòîï Ëîññà - Ñïðåä
          && -Scope_Cl<0))
        Value_TP[i]=-(MathAbs(Scope_Cl)+Spread); // Òåéê Ïðîôèò ðàâåí çàêðûòèþ ìèíóñ ñïðåä
      //---- Îïðåäåëèì íàðàñòàþùåå çíà÷åíèå Òåéê Ïðîôèò
      k=i;
      Sum_TP[i]=Sum_TP[i+1]+Value_TP[i]/((k+10)/10);
      Sum_na_TP[i]=Sum_na_TP[i+1]+Value_TP[i];
   
     i--;                                  // Ðàñ÷¸ò èíäåêñà ñëåäóþùåãî áàðà
     }
   return(0);                              // âîçâðàùàåìîå çíà÷åíèå
  }
//+------------------------------------------------------------------+
void Fun_New_Bar()                         // Ô-èÿ îáíàðóæåíèÿ íîâîãî áàðà
  {                                             
   New_Bar=false;                          // Íîâîãî áàðà íåò
   if(New_Time!=Time[0])                   // Ñðàâíèâàåì âðåìÿ
     {
      New_Time=Time[0];                    // Òåïåðü âðåìÿ òàêîå
      New_Bar=true;                        // Ïîéìàëñÿ íîâûé áàð  
     }
  }
//+------------------------------------------------------------------+
bool Fun_Repeat(double yt,double sl,double tp ) // Ô-èÿ ñðàâíåíèÿ ñ ìàññèâîì ïîâòîðîâ
  {
   for (int X=0; X<Repeat_Count; X++)
     {
     if (Repeat[X,0]==yt &&
         Repeat[X,1]==sl &&
         Repeat[X,2]==tp) 
       return(true);
     }
   return(false);
  }