expert

//+------------------------------------------------------------------+
//|                                                       expert.mq4 |
//|                                                    Denis Janulis |
//|                                                  denis.j@mits.lv |
//+------------------------------------------------------------------+
#property copyright "Denis Janulis"
#property link      "denis.j@mits.lv"

#import "dpnn.dll"                                         // DPNN.DLL - ïîäêëþ÷àåì ñåòü
//--------------------------------------------------------------------
extern double MinW = 0.00100200;                           // êðèòåðèé ñëàáîñòè íåéðîíîâ.     Åñëè 0, òî æèâóò âå÷íî     
extern double LifeTime = 500;                              // âðåìÿ æèçíè íåéðîíîâ (â áàðàõ). Åñëè 0, òî æèâóò âå÷íî
extern double MinTV = 0.2;                                 // Ïîðîã êîíôëèêòîâ
extern double MaxTV = 0.95;                                // Ïîðîã èíäèâèäóàëüíîñòè
//--------------------------------------------------------------------
                                                           // Îñíîâíûå íåîáõîäèìûå ôóíêöèè ðàáîòû ñ ñåòüþ                                                          
    double CreateNet(string NN, int InputVectorSize,       // Ñîçäàåò ñåòü ñ êîëè÷åñòâîì íåéðîíîâ âî âõîäíîì âåêòîðå <i>. 
                     double MinTV, double MaxTV,           // è âîçâðàùàåò íîìåð ñåòè, ïîä êîòîðûì ñîçäàëàñü
                     double MW , int NL);          
    int    DestroyNet(string NN);                          // Óíè÷òîæàåò ñåòü <NetName>, âîçâðàùàåò êîëè÷åñòâî îñòàâøèõñÿ ñåòåé
    double TrainNet(string NetName,double& iX[],int T,datetime sT);    // Îáó÷àåò ñåòü íà ïðèìåðå Õ[InputVectorSize] c îòâåòîì Ò
    double GetPredict(string NetName,double& iX[],datetime sT);        // Âîçâðàùàåò ïðåäñêàçàíèå ñåòè 0<=Out<=1
    void   Shrink(string NetName);                         // ÏÎÊÀ ÓÏÐÀÂËßÅÒÑß ÂÐÓ×ÍÓÞ!!! - íàäî çàïóñêàòü ïîñëå îáó÷åíèÿ
    void   WReset(string NetName);                         // (A) - ÏÎÊÀ ÓÏÐÀÂËßÅÒÑß ÂÐÓ×ÍÓÞ!!! - íàäî çàïóñêàòü ïîñëå îáó÷åíèÿ
    void   AEqual(string NetName);                         // (A) - ÏÎÊÀ ÓÏÐÀÂËßÅÒÑß ÂÐÓ×ÍÓÞ!!! - íàäî çàïóñêàòü ïîñëå îáó÷åíèÿ
    void   CW(string NetName);                             // (w) - ÏÎÊÀ ÓÏÐÀÂËßÅÒÑß ÂÐÓ×ÍÓÞ!!! - íàäî çàïóñêàòü ïîñëå îáó÷åíèÿ                        
    int SizeOfNet(string NetName);                         // Âîçâðàùàåò êîëè÷åñâî Ãàóññîâñêèõ íåéðîíîâ
    void KillWeaks(string NetName); 
    void KillOlds(string NetName,datetime sT);
//-------------------------------------------------------------------
int InputVectorSize = 24;                                  // Ðàçìåðíîñòü âõîäíîãî âåêòîðà
double X[24];                                              // Âõîäíîé âåêòîð ñåòè
//-------------------------------------------------------------------
extern int    n = 10;                                      // Ïàðàìåòðû äëÿ "ó÷èòåëÿ" ñì. èíäèêàòîð djama
extern int    p = 2;                                       
extern int    q = 2;
extern bool   allowTrailingStop   = true;                  // Ðàçðåøàåì òðàëû
extern bool   allowPostTraining   = true;                  // Ðàçðåøàåì äîîáó÷åíèå
extern int    StopLoss            =   50;                   
extern int    TakeProfit          =  400;
extern int    TrailingStop = 150;
extern int    HistoryBars         = 1000;                  // Íà ñêîëüêèõ áàðàõ ïðîâîäèòü ïðåäâàðèòåëüíîå îáó÷åíèå
extern int    Repetitions         =    5;                  // Ñêîëüêî ðàç ïðîãíÿòü îáó÷åíèå ñåòè ????                                            
extern int    Activation_n = 100;                          // Ïàðàìåòðû äëÿ "àêòèâàöèîííîé ôóíêéèè" ñì. èíäèêàòîð djama   
extern int    Activation_p = 2;                            
extern int    Activation_q = 30;                    
extern double ActivationMax = 0.95;
extern double ActivationMin = 0.6;
extern double ActivationK  = 15000;  

       double ActivationBuy;
       double ActivationSell; 
//--------------------------------------------------------------------
       double Lots                =  0.1;
       int    MinMargin           =  200;   // Ìèíèìàëüíàÿ ìàðæà
     datetime prevtime            =    0;
       double Out;                          // Ðåçóëüòàò ðàáîòû ñåòåé 
bool existent = false;                                 
//********************************************************************
void BuildX(int FinishBar)                  // Ìîäóëü ñîáèðàåò è ïîäãîòàâëèâàåò äàííûå äëÿ çàãðóçêè â ñåòü
 {                                          // FinishBar - Ñ êàêîãî áàðà ñíèìàòü çíà÷åíèÿ.
 int B = InputVectorSize;
 double rD[24][24];
 double Min[24];
 double Max[24];
 if (FinishBar > Bars)
    { 
     Print("MaxBars Error = ",Bars);
     return;
    }
 for (int i=B-1;i>=0;i--)
      {
      rD[i][0] = iMA(NULL,0,2,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,2,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][1] = iMA(NULL,0,4,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,4,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][2] = iMA(NULL,0,6,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,6,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][3] = iMA(NULL,0,8,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,8,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][4] = iMA(NULL,0,10,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,10,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][5] = iMA(NULL,0,12,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,12,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][6] = iMA(NULL,0,14,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,14,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][7] = iMA(NULL,0,16,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,16,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][8] = iMA(NULL,0,18,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,18,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][9] = iMA(NULL,0,20,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,20,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][10] = iMA(NULL,0,22,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,22,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][11] = iMA(NULL,0,24,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,24,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][12] = iMA(NULL,0,26,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,26,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][13] = iMA(NULL,0,28,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,28,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][14] = iMA(NULL,0,30,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,30,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][15] = iMA(NULL,0,32,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,32,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][16] = iMA(NULL,0,34,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,34,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][17] = iMA(NULL,0,36,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,36,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][18] = iMA(NULL,0,38,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,38,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][19] = iMA(NULL,0,40,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,40,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][20] = iMA(NULL,0,42,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,42,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][21] = iMA(NULL,0,44,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,44,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][22] = iMA(NULL,0,46,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,46,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      rD[i][23] = iMA(NULL,0,48,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,48,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
      }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  for (int n = 0; n <= B-1; n++)                      // Îïðåäåëÿåì ìèíèìàëüíûå è ìàêñèìàëüíûå âåëè÷èíû
  {
   Min[n] = rD[0][n];
   Max[n] = rD[0][n];
   for ( i = 0; i <= B-1; i++)
   {
   if (rD[i][n] > Max[n]) Max[n] = rD[i][n];
   if (rD[i][n] < Min[n]) Min[n] = rD[i][n];
   }
  } 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  for ( n = 0; n <= B-1; n++)                                              // Íîðìèðóåò âõîäíîé âåêòîð íà 1
  {
    if (Max[n]== Min[n]) 
        {
         for ( i = 0; i <= B-1; i++) X[i] = Max[n];
         return;
        }
 X[n] = (rD[0][n] - Min[n])/(Max[n]-Min[n]);                               // Âõîäíîé âåêòîð, íîðìèðîâàííûé íà 1    
  }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
  
return;   
 }
//-------------------------------------------------------------------------------------------------------------------
int BuildT(int i)                                                          // Òóò ïîëó÷àåì ïðàâèëüíûé îòâåò ïî ïåðåêóïëåííîñòè 
{                                                                          // èëè ïåðåïðîäàííîñòè
  int T= 0;

  double Previous = djama(n,p,q,i+1);    
  double Current = djama(n,p,q,i);
  double Next = djama(n,p,q,i-1);
  
  if ((Current > Previous) && (Current > Next)) T = -1;
  if ((Current < Previous) && (Current < Next)) T =  1;  
  return (T);
}
//*******************************************************************************************************************
int Create(string NetName,int InputVectorSize)                             // Ñîçäàåò ñåòü ñ èìåíåì <NetName> è âõîäíûì âåêòîðîì ðàçìåðà
{                                                                          // InputVectorSize. Âûâîäèò íîìåð ñåòè (òóò îí æå îáùåå êîëè÷åñòâî
 int NeuronLife = Period()*60*LifeTime;                                    // ñåòåé) â áèáëèîòåêå. 
 int Out =  CreateNet(NetName,InputVectorSize,MinTV,MaxTV,MinW,NeuronLife);     
return(Out);
}
//-------------------------------------------------------------------------------------------------------------------
int Destroy(string NetName)                                                // Óíè÷òîæàåò ñåòü ñ èìåíåì <NetName> è âîçâðàùàåò îáùåå
{                                                                          // êîëè÷åñòâî ñåòåé îñòàâøèõñÿ â áèáëèîòåêå
return(DestroyNet(NetName));
}
//-------------------------------------------------------------------------------------------------------------------
double Train(string NetName,double& iX[],int T)                            // Ïîäàåò â ñåòü <NetName> âåêòîð X è îòâåò T äëÿ îáó÷åíèÿ íà ïðèìåðå i
{                                                                          // Âîçâðàùàåò Out cåòè
 double Out =  TrainNet(NetName,iX,T,iTime(Symbol(),0,1));                                    // Out=1, ñåòü äîáàâèëà íîâûé îáðàç. Out =2 - ñåòü ðàñïîçíàëà îáðàç è ïîäïðàâèëàñü.
return(Out);
} 

//-------------------------------------------------------------------------------------------------------------------
double Predict(string NetName)                                             // Ïîäàåò â ñåòü <NetName> âåòîð X äëÿ ïðåäñêàçàíèÿ    
{ 
 BuildX(1);                                       
 double Out =  GetPredict(NetName,X,iTime(Symbol(),0,1));                                      // Âîçâðàùàåò Out cåòè
return(Out);
}
//--------------------------------------------------------------------------------------------------------------------
double PostTraining(string NetName,int ST)
{
 int T = BuildT(2);                                                        // Ñ÷èòûâàåì ïðàâèëüíûé îòâåò
    if (T == ST)                                                           // Îáó÷àåì òîëüêî íà òîì ïðèìåðå, êîòîðûé ïîäõîäèò äëÿ îáó÷åíèÿ
     {
      BuildX(2);                                                           // Ôîðìèðóåì âõîäíîé îáó÷àþùèé âåêòîð
      Train(NetName,X,T);                                                  // Îáó÷àåì ñåòü íà êîíêðåòíîì ïðèìåðå
      Print("New neurons amount: ",SizeOfNet("OverBought")," ; ",SizeOfNet("OverSold"));
     } 
return (0);
}     
//-------------------------------------------------------------------------------------------------------------------
double InitialTraining(string NetName,int HistoryBars,int ST)              // Ðóêîâîäèò çàãðóçêîé äàííûõ â ñåòü äëÿ ïåðâè÷íîãî îáó÷åíèÿ
{                                                                          // çà ïåðèîä HistoryBars
  for ( int i = HistoryBars-1; i > 6; i--)                                 // ïî áàðàì
   {
    int T = BuildT(i);                                                     // Ñ÷èòûâàåì ïðàâèëüíûé îòâåò
    if (T == ST)                                                           // Îáó÷àåì òîëüêî íà òîì ïðèìåðå, êîòîðûé ïîäõîäèò äëÿ îáó÷åíèÿ
     {
      BuildX(i);                                                           // Ôîðìèðóåì âõîäíîé îáó÷àþùèé âåêòîð
      Train(NetName,X,T);                                                  // Îáó÷àåì ñåòü íà êîíêðåòíîì ïðèìåðå
     } 
    } 
return (0);
}
//-------------------------------------------------------------------------------------------------------------------
int init()
{
 NetInitialTraining();  
} 
//********************************************************************
int start()
  {
if (AccountFreeMargin() < MinMargin) return(0); 
if(prevtime == Time[0]) return(0);
   prevtime = Time[0];
//-------------------------------------------------------------------
if (allowPostTraining)
{
 if (LifeTime > 0) KillOlds("OverBought",iTime(Symbol(),0,1));          // Óáèâàåì ñòàðûå íåéðîíû 
 PostTraining("OverBought",-1);                                         // Äîîáó÷àåì ïî õîäó äåëà 
 Shrink("OverBought");                                                  // Ìîäåðíèçèðóåì ñåòü
 //AEqual("OverBought");                                                // Óñòàíàâëèâàåì âñå A =1
 CW("OverBought");                                                      // Ðàññ÷èòûâàåì âåñà
 KillWeaks("OverBought");                                               // Óáèâàåì ñëàáûå íåéðîíû
 CW("OverBought");                                                      // Ðàññ÷èòûâàåì âåñà
 
 if (LifeTime > 0) KillOlds("OverSold",iTime(Symbol(),0,1));            // Óáèâàåì ñòàðûå íåéðîíû 
 PostTraining("OverSold",1);                                            // Äîîáó÷àåì ïî õîäó äåëà
 //AEqual("OverSold");                                                  // Óñòàíàâëèâàåì âñå A =1
 Shrink("OverSold");                                                    // Ìîäåðíèçèðóåì ñåòü
 CW("OverSold");                                                        // Ðàññ÷èòûâàåì âåñà
 KillWeaks("OverSold");                                                 // Óáèâàåì ñëàáûå íåéðîíû
 CW("OverSold");                                                        // Ðàññ÷èòûâàåì âåñà
}
//--------------------------------------------------------------------
double OverBought = Predict("OverBought");
double OverSold   = Predict("OverSold");
Out = (OverBought - OverSold)/(OverBought+OverSold);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Activation(1);
CheckForClose();
if (allowTrailingStop) CheckForTrailingStop();
CheckForOpen();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 return(0);
  }
//+------------------------------------------------------------------+
int deinit()
{
if (!IsOptimization())
{
 Print("Destroying net=>",Destroy ("OverBought"));                           // Óáèâàåì, ÷òî ïîðîäèëè
 Print("Destroying net=>",Destroy ("OverSold"));                             // Óáèâàåì, ÷òî ïîðîäèëè
 }
}

//-------------------------------------------------------------------------------------
void CheckForOpen()
{
double SL = 0;
double TP = 0;
//-----------------------------------------
 if ( Out < (-1)*ActivationBuy)
     {
      SL = Ask - StopLoss*Point;
      TP = Ask + TakeProfit*Point;
      OpenPosition(0,SL,TP,0);
      Print("OverSoldSignal= ",Out);
     }
//-----------------------------------------
 if (Out > ActivationSell)
      {
       SL = Bid + StopLoss*Point;
       TP = Bid - TakeProfit*Point;
       OpenPosition(1,SL,TP,1);
       Print("OutBoughtSignal= ",Out);
      }
//-----------------------------------------
return(0);
}
///////////////////////////////////////////////////////////////////////////////
void CheckForClose()
{
if (Out < (-1)*ActivationBuy) ClosePosition(1);
if (Out > ActivationSell) ClosePosition(0);
return(0);
}
//------------------------------------------
double Activation(int i )
{
double t = (djama(Activation_n,Activation_p,Activation_q,i)-djama(Activation_n,Activation_p,Activation_q,i+Activation_n))/Activation_n;

//~~~~ActivationBuy 
 double M = (ActivationMin-ActivationMax)/(-ActivationK);
 if (t <= 0) ActivationBuy = ActivationMax;
 if (t >= M) ActivationBuy = ActivationMin;
 if ((t > 0) && (t < M)) ActivationBuy = -ActivationK*t+ActivationMax;
//~~~~ActivationSell
 M = (ActivationMin-ActivationMax)/(-ActivationK);
 if (t >= 0) ActivationSell = ActivationMax;
 if (t <= -M) ActivationSell = ActivationMin;
 if ((t < 0) && (t > -M)) ActivationSell = ActivationK*t+ActivationMax;
return(t); 
}
//-------------------------------------------
void NetInitialTraining()
{
int  Size0 = 0;
int  Size1 = 0;

    Print("Net Created with number: ",Create("OverBought",24)); // Ñîçäàåì ñåòü äëÿ ñèãíàëîâ Sell
    Print("Net Created with number: ",Create("OverSold",24));   // Ñîçäàåì ñåòü äëÿ ñèãíàëîâ Buy

//~~
    Print("Initial training started ...");
    for (int R = 1; R <= Repetitions; R++)                                  // Ïðîöåññ ïåðâè÷íîãî îáó÷åíèÿ 
    {                                                                       // íà èñòîðè÷åñêèõ äàííûõ    
     WReset("OverBought");                                                  // Îáíóëÿåì çíà÷åíèÿ À
     InitialTraining("OverBought",HistoryBars,-1);                          // Ïðîãîíÿåì îáó÷åíèå 
     Shrink("OverBought");                                                  // Ìîäåðíèçèðóåì ñåòü
     AEqual("OverBought");                                                  // Óñòàíàâëèâàåì âñå A =1
     CW("OverBought");                                                      // Ðàññ÷èòûâàåì âåñà
     KillWeaks("OverBought");                                               // Óáèâàåì ñëàáûå íåéðîíû
     CW("OverBought");                                                      // Ðàññ÷èòûâàåì âåñà
         
     WReset("OverSold");                                                    // Îáíóëÿåì çíà÷åíèÿ À
     InitialTraining("OverSold",HistoryBars,1);                             // Ïðîãîíÿåì îáó÷åíèå 
     AEqual("OverSold");                                                    // Óñòàíàâëèâàåì âñå A =1
     Shrink("OverSold");                                                    // Ìîäåðíèçèðóåì ñåòü
     CW("OverSold");                                                        // Ðàññ÷èòûâàåì âåñà
     KillWeaks("OverSold");                                                 // Óáèâàåì ñëàáûå íåéðîíû
     CW("OverSold");                                                        // Ðàññ÷èòûâàåì âåñà
          
     Print("Cycle ",R," completed. Neurons: ",SizeOfNet("OverBought")," ; ",SizeOfNet("OverSold"));
     if ((SizeOfNet("OverBought") == Size0) && (SizeOfNet("OverSold") == Size1)) break;
     Size0 = SizeOfNet("OverBought");
     Size1 = SizeOfNet("OverSold");
    }
     Print("Initial training completed.");
}
//-------------------------------------------------------------+
double djama(int n, int p, int q, int i)
{
 return(iCustom(Symbol(),0,"djama",n,p,q,0,i));
} 
//-------------------------------------------------------------+
bool OpenPosition(int cmd, double SL, double TP,int MN)
{
bool OpenPosition = false;
static int MaxTries = 5;
static int OrderInterval = 10;
static int ticket = 0;
if (Positions(0,MN) >= 1 || Positions(1,MN) >= 1) return;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
double Lots = 0.1;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    for (int try=1;try<=MaxTries;try++)
      {
       switch(cmd)
        {
        case 0 : ticket=OrderSend(Symbol(),cmd,Lots,NormalizeDouble(Ask,4),5,NormalizeDouble(SL,4),NormalizeDouble(TP,4),DoubleToStr(MN,0),MN,Blue);          break; // OP_BUY
        case 1 : ticket=OrderSend(Symbol(),cmd,Lots,NormalizeDouble(Bid,4),5,NormalizeDouble(SL,4),NormalizeDouble(TP,4),DoubleToStr(MN,0),MN,Red);           break; // OP_SELL    
        } 
       if (ticket>0)
         {
         OpenPosition = true;
         Print("Opened ",cmd," try N",try," SL ",SL," TP ",TP, " Magic Number: ", MN);
         break;
         }
       Sleep(10000);
       Print("Cannot open ",cmd," try N",try," SL ",SL," TP ",TP);
     } 
return(OpenPosition);         
}
//*******************************************************************
bool ClosePosition(int p)
{
bool ClosePosition;
int MaxTries = 5;
for(int i=0;i<OrdersTotal();i++)
  {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)        break;
      if((OrderSymbol()!=Symbol()) || (OrderType() != p)) continue;
 
    for (int try=1;try<=5;try++)
          {
           if ((p == 0) && (OrderType()==OP_BUY))  ClosePosition = OrderClose(OrderTicket(),OrderLots(),Bid,3,Black);
           if ((p == 1) && (OrderType()==OP_SELL)) ClosePosition = OrderClose(OrderTicket(),OrderLots(),Ask,3,Black);
           if (ClosePosition == true)
            {
             if ( p == 0) Print("Position :",OrderTicket(), "closed  at ",Bid," MN ",OrderMagicNumber()); 
             if ( p == 1) Print("Position :",OrderTicket(), "closed  at ",Ask," MN ",OrderMagicNumber()); 
             break;
            }
           if ( p == 0) Print("Cannot close long position at price, try N ",try," => Bid = ",Bid," ERROR = ",GetLastError());
           if ( p == 1) Print("Cannot close short position at price, try N ",try," => Ask = ",Ask," ERROR = ",GetLastError());
           Sleep(10000);
          } // try
   } //i       
return(ClosePosition);         
}
//**********************************************************************
void CheckForTrailingStop()
{

for(int i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)        break;
      if(OrderSymbol()!=Symbol()) continue;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
      if((OrderType()==OP_BUY))
        {
         if(Bid-OrderOpenPrice()>Point*TrailingStop)
           {
            if(OrderStopLoss()<Bid-Point*TrailingStop)
              {
              for (int try=1;try<=5;try++)
               {
                if(OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green))
                 { 
                  Print("Position :",OrderTicket()," modified StopLoss to ", OrderStopLoss(), " at try ", try);
                  break;
                 }
               }  
             }
           }   
        }
      if((OrderType()==OP_SELL))
        {
         if((OrderOpenPrice()-Ask)>(Point*TrailingStop))
            {
             if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0))
                {
                 for (try=1;try<=5;try++)
                  {
                   if(OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red))
                   {
                    Print("Position :",OrderTicket()," modified StopLoss to ", OrderStopLoss(), " at try ", try);
                    break;
                   }
                  } 
                }
            }
                 
        }
 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~      
     }        
 return(0);
}
//*******************************************************************
int Positions(int d, int mn)                 //Âîçâðàùàåò êîëè÷åñòâî îòêðûòûõ
{                                            //ïîçèöèé 
   int buys=0,sells=0,positions;
//----
   for(int i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
      if(OrderSymbol()==Symbol())
        {
      if(OrderMagicNumber() == mn || mn == 0)
       {  
         if(OrderType()==OP_BUY)  buys++;
         if(OrderType()==OP_SELL) sells++;  
       }  
        }
     }
  switch (d)
     {
     case 0 : positions = buys;         break;
     case 1 : positions = sells;        break;
     case 3 : positions = buys +sells;  break;
     }
return(positions);
}