AMKA_SelfTest_V2

//+-------------------------------------------------------------------------------------+
//|                                                            AMKAandWilder_Expert.mq4 |
//|                                                                           Scriptong |
//|                                                                                     |
//+-------------------------------------------------------------------------------------+
#property copyright "Scriptong"
#property link      "scriptong@mail.ru"

//---- input parameters
extern double    Lots        = 0.1;                          // Îáúåì îòêðûâàåìîé ïîçèöèè
extern int       TakeProfit = 2000;
extern int       StopLoss = 2000;
extern double    TPKoef = 0.9;
extern double    SLKoef = 1.1;
extern int       ResultsPeriod = 11;
extern string    A3 = "Ïàðàìåòðû èíäèêàòîðà AMKA";
extern int       AMKAPeriod=9;                                             // Ïåðèîä AMKA
extern int       FastEMAPeriod=2;                   // Ïåðèîä áûñòðîé ñêîëüçÿùåé äëÿ AMKA
extern int       SlowEMAPeriod=30;                  // Ïåðèîä áûñòðîé ñêîëüçÿùåé äëÿ AMKA
extern double    PowLevel=2.0;         // Ñòåïåíü, â êîòîðóþ âîçâîäÿòñÿ ñîñòàâëÿþùèå AMKA
                                       // 2 - ñðåäíåêâàäðàòè÷íîå çíà÷åíèå, 
                                       // 3 - ñðåäíåêóáè÷åñêîå è ò. ä.
extern double    dK = 1.0;                                     // êîýôôèöèåíò äëÿ ôèëüòðà
extern bool      UseStdDev = True;      // èñïîëüçîâàòü ëè ñðåäíåêâàäðàòè÷íîå îòêëîíåíèå?
extern int       AMKAPrice = 5;                              // Öåíà ðàñ÷åòà AMKA (0 - 6)
extern string    A4 = "=====================================";
extern string    OpenOrderSound = "ok.wav";                  // Çâóê äëÿ îòêðûòèÿ ïîçèöèè
extern int       MagicNumber = 17589 ;                         // Ìàãèê ïîçèöèé ñîâåòíèêà
bool Activate, FreeMarginAlert, FatalError;
double Tick, Spread, StopLevel, MinLot, MaxLot, LotStep, CurRed, CurBlue;
datetime LastBar;
int TypeOrder, LastType, TicketOrder, Signal;
// Ïåðåìåííûå äëÿ ñàìîòåñòà
int Trade = -1,                            //Òåêóùàÿ ñäåëêà (-1 - íåò, 0 - BUY, 1 - SELL)
    ProfitSeries = 0,                               // êîëè÷åñòâî ïðîôèòíûõ ñäåëîê ïîäðÿä
    EqualProfits = 0,                               // Îáùåå êîëè÷åñòâî ïðèáûëüíûõ ñäåëîê
    CountProfits = 0,                                       // êîëè÷åñòâî ïðîôèòíûõ ñåðèé
    LossSeries = 0,                                 // êîëè÷åñòâî óáûòî÷íûõ ñäåëîê ïîäðÿä
    EqualLosses = 0,                                 // Îáùåå êîëè÷åñòâî óáûòî÷íûõ ñäåëîê
    CountLosses = 0,                                        // êîëè÷åñòâî óáûòî÷íûõ ñåðèé
    MaxLoss = 0,                               // Îáùèé ìàêñèìàëüíûé ïîòåíöèàëüíûé óáûòîê
    CurMaxProfit[],       // Ìàññèâ ïîòåíöèàëüíûõ ïðèáûëåé ïîñëåäíèõ ResultsPeriod ñäåëîê
    CurMaxLoss;                                     // Ìàêñèìàëüíûé óáûòîê òåêóùåé ñäåëêè
double OpenPrice = 0,                                     // Öåíà îòêðûòèÿ òåêóùåé ñäåëêè
       SLPrice = 0,                                  // Óðîâåíü ñòîï-ëîññà òåêóùåé ñäåëêè
       TPPrice = 0;                                     // Óðîâåíü ïðîôèòà òåêóùåé ñäåëêè
datetime TimeOrder = 0;                    // Âðåìÿ îòêðûòèÿ ïîñëåäíåé âèðòóàëüíîé ñäåëêè
// --------------------------


//+-------------------------------------------------------------------------------------+
//| Ôóíêöèÿ èíèöèàëèçàöèè ýêñïåðòà                                                      |
//+-------------------------------------------------------------------------------------+
int init()
  {
//----
   Activate = False;
// - 1 - == Ñáîð èíôîðìàöèè îá óñëîâèÿõ òîðãîâëè ========================================
   Tick = MarketInfo(Symbol(), MODE_TICKSIZE);                         // ìèíèìàëüíûé òèê
   Spread = ND(MarketInfo(Symbol(), MODE_SPREAD)*Point);                  // òåêùèé ñïðýä
   StopLevel = ND(MarketInfo(Symbol(), MODE_STOPLEVEL)*Point);  // òåêóùèé óðîâåíü ñòîïîâ
   MinLot = MarketInfo(Symbol(), MODE_MINLOT);    // ìèíèìàëüíûé ðàçðåøåííûé îáúåì ñäåëêè
   MaxLot = MarketInfo(Symbol(), MODE_MAXLOT);   // ìàêñèìàëüíûé ðàçðåøåííûé îáúåì ñäåëêè
   LotStep = MarketInfo(Symbol(), MODE_LOTSTEP);          // øàã ïðèðàùåíèÿ îáúåìà ñäåëêè
// - 1 - == Îêîí÷àíèå áëîêà =============================================================

// - 2 - == Ïðèâåäåíèå îáúåìà ñäåëêè ê äîïóñòèìîìó è ïðîâåðêà êîððåêòíîñòè îáúåìà =======
   Lots = MathRound(Lots/LotStep)*LotStep; // îêðóãëåíèå îáúåìà äî áëèæàéøåãî äîïóñòèìîãî
   if(Lots < MinLot || Lots > MaxLot) // îáúåì ñäåëêè íå ìåíüøå MinLot è íå áîëüøå MaxLot
     {
      Comment("Ïàðàìåòðîì Lots áûë çàäàí íåïðàâèëüíûé îáúåì ñäåëêè! Ñîâåòíèê îòêëþ÷åí!");
      return(0);
     }
// - 2 - == Îêîí÷àíèå áëîêà =============================================================

// - 3 - == Îáíîâëåíèå èñòîðè÷åñêèõ äàííûõ ==============================================
   CurRed = 0;
   CurBlue = 0;
   Trade = -1; ProfitSeries = 0; EqualProfits = 0; CountProfits = 0; LossSeries = 0;
   EqualLosses = 0; CountLosses = 0; TimeOrder = 0;
   MaxLoss = 0; OpenPrice = 0; SLPrice = 0; TPPrice = 0;
   ArrayResize(CurMaxProfit, ResultsPeriod+1);
   ArrayResize(CurMaxLoss, ResultsPeriod+1);
   
   Comment("Ïîäîæäèòå, ïðîèçâîäèòñÿ ñáîð äàííûõ î ðàáîòå ýêñïåðòà íà äîñòóïíîé èñòîðèè");
   for (int i = Bars-MathMax(AMKAPeriod, SlowEMAPeriod); i > 0; i--) 
     {
      GetSignal(i);
      DoTransaction(i-1);       
     }
   Comment(""); 
// - 3 - == Îêîí÷àíèå áëîêà =============================================================

   LastBar = 0;

   Activate = True; // Âñå ïðîâåðêè óñïåøíî çàâåðøåíû, âîçâîäèì ôëàã àêòèâèçàöèè ýêñïåðòà
   
//----
   return(0);
  }

//+-------------------------------------------------------------------------------------+
//| Ôóíêöèÿ äåèíèöèàëèçàöèè ýêñïåðòà                                                    |
//+-------------------------------------------------------------------------------------+
int deinit()
{
//----
   Comment("");
//----
   return(0);
}

//+-------------------------------------------------------------------------------------+
//| Ïðèâåäåíèå çíà÷åíèé ê òî÷íîñòè îäíîãî ïóíêòà                                        |
//+-------------------------------------------------------------------------------------+
double ND(double A)
{
 return(NormalizeDouble(A, Digits));
}  
 
//+-------------------------------------------------------------------------------------+
//| Ðàñøèôðîâêà ñîîáùåíèÿ îá îøèáêå                                                     |
//+-------------------------------------------------------------------------------------+
string ErrorToString(int Error)
{
 switch(Error)
   {
    case 2: return("çàôèêñèðîâàíà îáùàÿ îøèáêà, îáðàòèòåñü â òåõïîääåðæêó."); 
    case 5: return("ó âàñ ñòàðàÿ âåðñèÿ òåðìèíàëà, îáíîâèòå åå."); 
    case 6: return("íåò ñâÿçè ñ ñåðâåðîì, ïîïðîáóéòå ïåðåçàãðóçèòü òåðìèíàë."); 
    case 64: return("ñ÷åò çàáëîêèðîâàí, îáðàòèòåñü â òåõïîääåðæêó.");
    case 132: return("ðûíîê çàêðûò."); 
    case 133: return("òîðãîâëÿ çàïðåùåíà."); 
    case 149: return("çàïðåùåíî ëîêèðîâàíèå."); 
   }
}
  
//+-------------------------------------------------------------------------------------+
//| Îòêðûòèå ïîçèöèè                                                                    |
//| Âîçâðàùàåò:                                                                         |
//|   True - Ïîçèöèÿ îòêðûòà óñïåøíî                                                    |
//|   False - Îøèáêà îòêðûòèÿ                                                           |
//+-------------------------------------------------------------------------------------+
bool OpenOrder(int Type, double Price, double SL, double TP)
{
 // Áëîê ïðîâåðêè äîñòàòî÷íîñòè ñâîáîäíûõ ñðåäñòâ
 if(AccountFreeMarginCheck(Symbol(), OP_BUY, Lots) <= 0 || GetLastError() == 134) 
  {
   if(!FreeMarginAlert)
    {
     Print("Íåäîñòàòî÷íî ñðåäñòâ äëÿ îòêðûòèÿ ïîçèöèè. Free Margin = ", 
           AccountFreeMargin());
     FreeMarginAlert = True;
    } 
   return(False);  
  }
 FreeMarginAlert = False;  
 // ---------------------------------------------

 switch (Type)
   {
    case OP_BUY: string S = "BUY"; break;
    case OP_SELL: S = "SELL"; break;
    case OP_BUYSTOP: S = "BUYSTOP"; break;
    case OP_SELLSTOP: S = "SELLSTOP"; break;
    case OP_BUYLIMIT: S = "BUYLIMIT"; break;
    case OP_SELLLIMIT: S = "SELLLIMIT"; break;
   }

 if(WaitForTradeContext())  // îæèäàíèå îñâîáîæäåíèÿ òîðãîâîãî ïîòîêà
   {  
    Comment("Îòïðàâëåí çàïðîñ íà îòêðûòèå îðäåðà ", S, " ...");
    int ticket=OrderSend(Symbol(), Type, Lots, Price, 0, 
               SL, TP, NULL, MagicNumber, 0, CLR_NONE);        // îòêðûòèå ïîçèöèè
    // Ïîïûòêà îòêðûòèÿ ïîçèöèè çàâåðøèëàñü íåóäà÷åé
    if(ticket<0)
      {
       int Error = GetLastError();
       if(Error == 2 || Error == 5 || Error == 6 || Error == 64 
          || Error == 132 || Error == 133 || Error == 149)     // ñïèñîê ôàòàëüíûõ îøèáîê
         {
          Comment("Ôàòàëüíàÿ îøèáêà ïðè îòêðûòèè ïîçèöèè ò. ê. "+
                   ErrorToString(Error)+" Ñîâåòíèê îòêëþ÷åí!");
          FatalError = True;
         }
        else 
         Comment("Îøèáêà îòêðûòèÿ ïîçèöèè ", S, ": ", Error);       // íåôàòàëüíàÿ îøèáêà
       return(False);
      }
    // ---------------------------------------------
    
    // Óäà÷íîå îòêðûòèå ïîçèöèè   
    Comment("Ïîçèöèÿ ", S, " îòêðûòà óñïåøíî!"); 
    PlaySound(OpenOrderSound); 
    return(True); 
    // ------------------------
   }
  else
   {
    Comment("Âðåìÿ îæèäàíèÿ îñâîáîæäåíèÿ òîðãîâîãî ïîòîêà èñòåêëî!");
    return(False);  
   } 
}

//+-------------------------------------------------------------------------------------+
//| Îæèäàíèå òîðãîâîãî ïîòîêà. Åñëè ïîòîê ñâîáîäåí, òî ðåçóëüòàò True, èíà÷å - False    |
//+-------------------------------------------------------------------------------------+
bool WaitForTradeContext()
{
 int P = 0;
 // öèêë "ïîêà"
 while(IsTradeContextBusy() && P < 5)
   {
    P++;
    Sleep(1000);
   }
 // -------------  
 if(P == 5)
   return(False);
 return(True);    
}

//+-------------------------------------------------------------------------------------+
//| Ðàñ÷åò ïîêàçàíèé AMKA è CloseONTheLimit_Reverse                                     |
//+-------------------------------------------------------------------------------------+
void GetSignal(int Bar)
{
 Signal = 0;
// - 1 - == Ðàñ÷åò ïî èíäèêàòîðó AMKA ===================================================
 double RedDot = iCustom(Symbol(), 0, "AMKA", AMKAPeriod, FastEMAPeriod, 
                         SlowEMAPeriod, PowLevel, dK, UseStdDev, AMKAPrice, 1, Bar);
 double BlueDot = iCustom(Symbol(), 0, "AMKA", AMKAPeriod, FastEMAPeriod, 
                          SlowEMAPeriod, PowLevel, dK, UseStdDev, AMKAPrice, 2, Bar);
 if (RedDot != 0 && BlueDot == 0) 
   {
    CurRed = RedDot;
    CurBlue = 0.0;
   } 
 if (BlueDot != 0 && RedDot == 0) 
   {
    CurBlue = BlueDot;
    CurRed = 0.0;
   } 
// - 1 - == Îêîí÷àíèå áëîêà =============================================================

// - 2 - == Ñèíòåç ñèãíàëà ==============================================================
  if (CurRed != 0)
    if (ND(Open[Bar]) > ND(Close[Bar]))   // ïîñëåäíèé áàð ìåäâåæèé
      if (ND(Close[Bar]) < ND(Low[Bar+1])) // è îí âûñòóïàåò çà ãðàíèöû ïðåäûäóùåãî áàðà
        if (ND(Open[Bar+1]) < ND(Close[Bar+1])) // à âòîðîé áàð áû÷èé
          Signal = 1;
    
  if (CurBlue != 0)
    if (ND(Open[Bar]) < ND(Close[Bar]))   // ïîñëåäíèé áàð áû÷èé
      if (ND(Close[Bar]) > ND(High[Bar+1])) // è îí âûñòóïàåò çà ãðàíèöû ïðåäûäóùåãî áàðà
        if (ND(Open[Bar+1]) > ND(Close[Bar+1])) // à âòîðîé áàð ìåäâåæèé
          Signal = 2;
// - 2 - == Îêîí÷àíèå áëîêà =============================================================
}  

//+-------------------------------------------------------------------------------------+
//| Çàïèñü ïðèáûëüíîé ñäåëêè                                                            |
//+-------------------------------------------------------------------------------------+
void ProfitCount()
{
 ProfitSeries++;                                 // Óâåëè÷èâàåì êîëè÷åñòâî ñäåëîê â ñåðèè
 EqualProfits++;                        // Óâåëè÷èâàåì îáùåå êîëè÷åñòâî ïðèáûëüíûõ ñäåëîê
 if (LossSeries > 0)                                // Åñëè äî ýòîãî áûëà óáûòî÷íàÿ ñåðèÿ
   {
    CountLosses++;                                // òî óâåëè÷èâàåì êîëè÷åñòâî ñåðèé íà 1
    LossSeries = 0;       // è íà÷èíàåì çàíîâî ñ÷èòàòü ñäåëêè â ñëåäóþùåé óáûòî÷íîé ñåðèè
   } 
}

//+-------------------------------------------------------------------------------------+
//| Çàïèñü óáûòî÷íîé ñäåëêè                                                             |
//+-------------------------------------------------------------------------------------+
void LossCount()
{
 LossSeries++;                                   // Óâåëè÷èâàåì êîëè÷åñòâî ñäåëîê â ñåðèè
 EqualLosses++;                         // Óâåëè÷èâàåì îáùåå êîëè÷åñòâî ïðèáûëüíûõ ñäåëîê
 if (ProfitSeries > 0)                             // Åñëè äî ýòîãî áûëà ïðèáûëüíàÿ ñåðèÿ
   {
    CountProfits++;                               // òî óâåëè÷èâàåì êîëè÷åñòâî ñåðèé íà 1
    ProfitSeries = 0;    // è íà÷èíàåì çàíîâî ñ÷èòàòü ñäåëêè â ñëåäóþùåé ïðèáûëüíîé ñåðèè
   } 
}

//+-------------------------------------------------------------------------------------+
//| Îòáðàñûâàåì ñàìîå ñòàðîå çíà÷åíèå ìàññèâà è îñâîáîæäàåì íóëåâîé ýëåìåíò             |
//+-------------------------------------------------------------------------------------+
void ThrowOld()
{
 for (int i = ResultsPeriod; i > 0; i--)
   CurMaxProfit[i] = CurMaxProfit[i-1];
}

//+-------------------------------------------------------------------------------------+
//| Íàõîäèì ñðåäíåå èç çíà÷åíèé ýëåìåíòîâ ìàññèâà CurMaxProfit                          |
//+-------------------------------------------------------------------------------------+
int AverageProfit()
{
 double Res = 0;
 for (int i = 1; i < ResultsPeriod+1; i++)
   Res += CurMaxProfit[i];
 return(MathRound(Res/(ResultsPeriod))); 
}


//+-------------------------------------------------------------------------------------+
//| Ñîâåðøåíèå âèðòóàëüíûõ ñäåëîê                                                       |
//+-------------------------------------------------------------------------------------+
void DoTransaction(int Bar)
{
// - 1 - == Ïðîâåðêà ñðàáàòûâàíèÿ ñòîïà èëè ïðîôèòà íà ïðåäûäóùåé ñâå÷å =================
    if (Trade != -1)                                      // åñëè èìååòñÿ îòêðûòàÿ ñäåëêà
      if (Trade == 0)
        {  // Äëèííàÿ ïîçèöèÿ
         if (ND(Low[Bar+1]) <= SLPrice)                             // Ñðàáàòûâàíèå ñòîïà
           {
            Trade = -1;                                   // çàêðûâàåì âèðòóàëüíóþ ñäåëêó
            LossCount();
           }
          else 
           if (ND(High[Bar+1]) >= TPPrice)                        // ñðàáàòûâàíèå ïðîôèòà
             {
              Trade = -1;                                 // çàêðûâàåì âèðòóàëüíóþ ñäåëêó
              ProfitCount();
             }
         CurMaxProfit[0] = MathMax(CurMaxProfit[0], (High[Bar+1] - OpenPrice)/Point);    
         CurMaxLoss = MathMax(CurMaxLoss, (OpenPrice - Low[Bar+1])/Point);    
        }
       else
        { // Êîðîòêàÿ ïîçèöèÿ
         if (ND(High[Bar+1]+Spread) >= SLPrice)                     // Ñðàáàòûâàíèå ñòîïà
           {
            Trade = -1;                                   // çàêðûâàåì âèðòóàëüíóþ ñäåëêó
            LossCount();
           }
          else 
           if (ND(Low[Bar+1]+Spread) <= TPPrice)                  // ñðàáàòûâàíèå ïðîôèòà
             {
              Trade = -1;                                 // çàêðûâàåì âèðòóàëüíóþ ñäåëêó
              ProfitCount();
             }
         CurMaxProfit[0] = MathMax(CurMaxProfit[0], (OpenPrice - Low[Bar+1] - Spread)/Point);    
         CurMaxLoss = MathMax(CurMaxLoss, (High[Bar+1] + Spread - OpenPrice)/Point);    
        }    
// - 1 -  == Îêîí÷àíèå áëîêà ============================================================

// - 2 - == Èìèòàöèÿ îòêðûòèÿ äëèííîé è çàêðûòèÿ êîðîòêîé ñäåëêè ========================
    if (Signal == 1 && Trade != 0)
     {
      double Price = ND(Open[Bar]+Spread);
      if (Trade == 1)                                 // çàêðûâàåì êîðîòêóþ, åñëè èìååòñÿ
        {
         if (OpenPrice-Price >= 0)
           ProfitCount();
          else
           LossCount();
         MaxLoss = MathMax(CurMaxLoss, MaxLoss); 
        }
      Trade = 0;                                              // Îòêðûòèå äëèííîé ïîçèöèè
      TimeOrder = Time[Bar];
      OpenPrice = Price;                                          // Öåíà îòêðûòèÿ ñäåëêè
      TPPrice = ND(Price + TakeProfit*Tick);                             // Ïðîôèò ñäåëêè
      SLPrice = ND(Price - StopLoss*Tick);                                 // Ñòîï ñäåëêè
      ThrowOld();
      CurMaxProfit[0] = -(Spread/Point);// Òåêóùàÿ ìàêñèìàëüíàÿ ïðèáûëü ðàâíà ìèíóñ ñïðýä
      CurMaxLoss = Spread/Point;              // Òåêóùèé ìàêñèìàëüíûé óáûòîê ðàâåí ñïðýäó
     }
// - 2 -  == Îêîí÷àíèå áëîêà ============================================================
     
// - 3 - == Èìèòàöèÿ îòêðûòèÿ êîðîòêîé è çàêðûòèÿ äëèííîé ñäåëêè ========================
    if (Signal == 2 && Trade != 1)
     {
      Price = ND(Open[Bar]);
      if (Trade == 0)                                  // çàêðûâàåì äëèííóþ, åñëè èìååòñÿ
        {
         if (Price-OpenPrice-Spread >= 0)
           ProfitCount();
          else
           LossCount();
         MaxLoss = MathMax(CurMaxLoss, MaxLoss);  
        }
      Trade = 1;                                             // Îòêðûòèå êîðîòêîé ïîçèöèè
      TimeOrder = Time[Bar];
      OpenPrice = Price;                                          // Öåíà îòêðûòèÿ ñäåëêè
      TPPrice = ND(Price - TakeProfit*Tick);                             // Ïðîôèò ñäåëêè
      SLPrice = ND(Price + StopLoss*Tick);                                 // Ñòîï ñäåëêè
      ThrowOld();
      CurMaxProfit[0] = -(Spread/Point);// Òåêóùàÿ ìàêñèìàëüíàÿ ïðèáûëü ðàâíà ìèíóñ ñïðýä
      CurMaxLoss = Spread/Point;              // Òåêóùèé ìàêñèìàëüíûé óáûòîê ðàâåí ñïðýäó
     }
// - 3 -  == Îêîí÷àíèå áëîêà ============================================================
}

//+-------------------------------------------------------------------------------------+
//| Çàêðûâàåò âñå ïîçèöèè òèïà Type. Åñëè çàêðûòü íå óäàëîñü çàêðûòü, òî 1.             |
//| Åñëè ïðèñóòñòâóåò ïðîòèâîïîëîæíàÿ, òî âîçâðàùàåò 2.  ñëó÷àå óñïåõà 0.              |
//+-------------------------------------------------------------------------------------+
int CheckOrdersReal(int Type)
{
 for (int i = OrdersTotal()-1; i >= 0; i--)
   if(OrderSelect(i, SELECT_BY_POS))
     if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber 
        && OrderType() < 2)                                       // ïîèñê "ñâîåé" ñäåëêè
       if(OrderType() == Type)                                  // Åñëè ïîçèöèÿ òèïà Type
         {
          if (WaitForTradeContext())  
            {
             if(Type == OP_BUY)
               double Pr = ND(MarketInfo(Symbol(), MODE_BID));
              else
               Pr = ND(MarketInfo(Symbol(), MODE_ASK));
             if (!OrderClose(OrderTicket(), OrderLots(), Pr, 3))// òî ïûòàåìñÿ çàêðûòü åå
              return(1);                                 // íå óäàëîñü çàêðûòü - âåðíåì 1
            }  
           else
            return(1);//âåðíåì 1, åñëè íå óäàëîñü äîæäàòüñÿ îñâîáîæäåíèÿ òîðãîâîãî ïîòîêà
         }
        else
         return(2);          // âåðíåì 2, åñëè îòêðûòà ïîçèöèÿ, ïðîòèâîïîëîæíàÿ óêàçàííîé
 return(0);                                                   // åñëè âñå ÎÊ, òî âåðíåì 0
}  

//+-------------------------------------------------------------------------------------+
//| Çàìåíà ñòàíäàðòíîãî áëîêà "if-else"                                                 |
//+-------------------------------------------------------------------------------------+
double IF(bool Condition, double IfTrue, double IfFalse)
{
 if (Condition) return(IfTrue);    // Åñëè óñëîâèå èñòèííî, òî âîçâðàùàåì çíà÷åíèå IfTrue
 else           return(IfFalse);    // Åñëè óñëîâèå ëîæíî, òî âîçâðàùàåì çíà÷åíèå IfFalse
}  

//+-------------------------------------------------------------------------------------+
//| Ôóíêöèÿ START ýêñïåðòà                                                              |
//+-------------------------------------------------------------------------------------+
int start()
  {
// - 1 -  == Ðàçðåøåíî ëè ñîâåòíèêó ðàáîòàòü? ===========================================
   if (!Activate || FatalError)             // Îòêëþ÷àåòñÿ ðàáîòà ñîâåòíèêà, åñëè ôóíêöèÿ
    return(0);           //  init çàâåðøèëàñü ñ îøèáêîé  èëè èìåëà ìåñòî ôàòàëüíàÿ îøèáêà
// - 1 -  == Îêîí÷àíèå áëîêà ============================================================

// - 2 -  == Êîíòðîëü îòêðûòèÿ íîâîãî áàðà ==============================================
   if (LastBar == Time[0])                        //Åñëè îòêðûòèå íà äàííîì áàðå óæå áûëî
     return(0);                                                         // òî çàêàí÷èâàåì
// - 2 -  == Îêîí÷àíèå áëîêà ============================================================

// - 3 - == Ñáîð èíôîðìàöèè îá óñëîâèÿõ òîðãîâëè ========================================
   Spread = ND(MarketInfo(Symbol(), MODE_SPREAD)*Point);                  // òåêùèé ñïðýä
   StopLevel = ND(MarketInfo(Symbol(), MODE_STOPLEVEL)*Point);  // òåêóùèé óðîâåíü ñòîïîâ
// - 3 -  == Îêîí÷àíèå áëîêà ============================================================
     
// - 4 - == Ðàñ÷åò òåêóùåãî ñèãíàëà =====================================================
   GetSignal(1);                                                       // ðàñ÷åò  ñèãíàëà
   DoTransaction(0);                                                // Ïîäñ÷åò ñòàòèñòèêè
   if (CountProfits == 0)                       // Ó÷èòûâàåì íóëåâîå çíà÷åíèå çíàìåíàòåëÿ
      int PC = EqualProfits;
    else
     PC = MathRound((EqualProfits/1.0)/CountProfits);         // Ðàñ÷åò ñðåäíåãî âûèãðûøà
   if (CountLosses == 0)                        // Ó÷èòûâàåì íóëåâîå çíà÷åíèå çíàìåíàòåëÿ
     int LC = EqualLosses;
    else
     LC = MathRound((EqualLosses/1.0)/CountLosses);          // Ðàñ÷åò ñðåäíåãî ïðîèãðûøà
     
   Comment("Ñðåäíÿÿ ñåðèÿ ïðèáûëüíûõ ñäåëîê ", PC, 
           "\nÑðåäíÿÿ ñåðèÿ óáûòî÷íûõ ñäåëîê ", LC,
           "\nÒåêóùåå êîë-âî âèðòóàëüíûõ ïðèáûëüíûõ ñäåëîê ", ProfitSeries,
           "\nÒåêóùåå êîë-âî âèðòóàëüíûõ óáûòî÷íûõ ñäåëîê ", LossSeries, 
           "\nÌàêñèìàëüíûé ïîòåíöèàëüíûé óáûòîê ", MaxLoss,
           "\nÑðåäíåå çíà÷åíèå ïîòåíöèàëüíîé ïðèáûëè ", 
           AverageProfit());
// - 4 -  == Îêîí÷àíèå áëîêà ============================================================
   
   double Price = 0;
   int Type = -1;
   
// - 6 - == Îòêðûòèå äëèííîé ïîçèöèè ====================================================
   if (Signal == 1 && TimeOrder == Time[0])
     {
      int Res = CheckOrdersReal(OP_SELL);
      RefreshRates();
      if (Res == 0)                                          // åñëè íåò îòêðûòûõ ïîçèöèé
        {                                               
         Price = ND(Ask);
         if (LossSeries > 0)
           {
            int NewTP = MathRound(TPKoef*AverageProfit());
            int NewSL = SLKoef*MaxLoss;
           } 
          else
           {
            NewTP = ArrayMinimum(CurMaxProfit, ResultsPeriod, 1);
            NewSL = NewTP+2*(Spread/Point);
           } 
         double TP = ND(IF(NewTP > StopLevel/Point, Price+NewTP*Tick,
                           Price + StopLevel));
         double SL = ND(IF(NewSL > (StopLevel+Spread)/Point, Price-NewSL*Tick,
                           Price - StopLevel-Spread));
         Type = OP_BUY;
        }                    
      if (Res == 1) return(0);                      // íå óäàëîñü çàêðûòü ïðîòèâîïîëîæíóþ
     }
// - 6 -  == Îêîí÷àíèå áëîêà ============================================================
     
// - 7 - == Óñòàíîâêà îðäåðà SellStop ===================================================
   if (Signal == 2 && TimeOrder == Time[0])
     {
      Res = CheckOrdersReal(OP_BUY);
      if (Res == 0)                                          // åñëè íåò îòêðûòûõ ïîçèöèé
        {               
         RefreshRates();
         Price = ND(Bid);
         if (LossSeries > 0)
           {
            NewTP = MathRound(TPKoef*AverageProfit());
            NewSL = SLKoef*MaxLoss;
           } 
          else
           {
            NewTP = ArrayMinimum(CurMaxProfit, ResultsPeriod, 1);
            NewSL = NewTP+2*(Spread/Point);
           } 
         TP = ND(IF(NewTP > StopLevel/Point, Price-NewTP*Tick, 
                    Price - StopLevel));
         SL = ND(IF(NewSL > (StopLevel+Spread)/Point, Price+NewSL*Tick,
                    Price + StopLevel + Spread));
         Type = OP_SELL;
        }                    
      if (Res == 1) return(0);                      // íå óäàëîñü çàêðûòü ïðîòèâîïîëîæíóþ
     }
// - 7 -  == Îêîí÷àíèå áëîêà ============================================================

   if (Type >= 0)
     if (!OpenOrder(Type, Price, SL, TP))             // åñëè íå óäàëîñü óñòàíîâèòü îðäåð
        return(0);                                     // òî ïîïðîáóåì ñî ñëåäóþùèì òèêîì
        
   LastBar = Time[0];     

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