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);
  }



Sample





Analysis



Market Information Used:

Series array that contains open time of each bar
Series array that contains the highest prices of each bar
Series array that contains open prices of each bar
Series array that contains the lowest prices of each bar
Series array that contains close prices for each bar


Indicator Curves created:



Indicators Used:



Custom Indicators Used:

Order Management characteristics:

Other Features:

It issuies visual alerts to the screen