Gerenciamento de pedidos - É simples

18 fevereiro 2016, 11:36
Andrey Khatimlianskii
0
740

1. Introdução


Todo expert de transações possui um bloco de controle de posições abertas. Ele é a busca entre todos os pedidos no interior de um ciclo, escolhendo a sua "própria" posição através do símbolo e do valor do MagicNumber, e então modificando ou fechando a mesma. Esses blocos possuem aparência bastante semelhante, e frequentemente cumprem as mesmas funções. É por este motivo que esta parte repetida do código pode ser transferida do expert para a função. Isso irá simplificar significativamente a escrita de experts e tornar os códigos dos experts muito mais enxutos.

Primeiramente vamos dividir a tarefa em três estágios, que são diferentes em cumplicidade e funções. Esses três estágios irão se correlacionar com três tipos de experts:

  • Experts que podem abrir apenas uma posição por vez
  • Experts que podem abrir uma posição de cada tipo por vez (por exemplo, uma posição longa e uma curta)
  • Experts que podem abrir qualquer quantidade de posições simultaneamente

2. Uma posição


Há muitas estratégias que utilizam apenas uma posição aberta. O seus blocos de controle são bastante simples, mas ainda assim a sua escrita exige tempo e atenção.

Vamos examinar um expert simples, cujo sinal de abertura é a intersecção das linhas MACD (linha de sinal e linha básica), e simplificar o seu bloco de controle. Essa é a sua aparência anterior:

extern int  _MagicNumber = 1122;
 
int start()
{
    //---- Memorize indicator values for further analysis
    double MACD_1 = iMACD(Symbol(), 0, 12, 26, 9, PRICE_CLOSE,
                          MODE_MAIN, 1 );
    double MACD_2 = iMACD(Symbol(), 0, 12, 26, 9, PRICE_CLOSE,
                          MODE_MAIN, 2 );
 
    int _GetLastError = 0, _OrdersTotal = OrdersTotal();
    //---- search among all open positions
    for ( int z = _OrdersTotal - 1; z >= 0; z -- )
    {
// if an error occurs at finding the position, go to the next one
        if ( !OrderSelect( z, SELECT_BY_POS ) )
        {
          _GetLastError = GetLastError();
          Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",
                _GetLastError );
            continue;
        }
 
// if the position was opened not for the current symbol, 
// skip it
        if ( OrderSymbol() != Symbol() ) continue;
 
// if MagicNumber does not equal to _MagicNumber, skip 
// this position
        if ( OrderMagicNumber() != _MagicNumber ) continue;
 
        //---- if BUY position is opened,
        if ( OrderType() == OP_BUY )
        {
            //---- if MACD meets zero line top-down,
            if(NormalizeDouble(MACD_1, Digits + 1) <  0.0 && 
               NormalizeDouble( MACD_2, Digits + 1) >= 0.0)
            {
                //---- close the position
                if(!OrderClose( OrderTicket(), OrderLots(), 
                   Bid, 5, Green))
                {
                   _GetLastError = GetLastError();
                   Alert("Error OrderClose № ", _GetLastError);
                   return(-1);
                }
            }
// if signal has not changed, exit: it's too early for 
// opening a new position
            else
            { return(0); }
        }
        //---- if SELL position is opened,
        if ( OrderType() == OP_SELL )
        {
            //---- if MACD meets zero line bottom-up,
            if(NormalizeDouble(MACD_1, Digits + 1) >  0.0 && 
               NormalizeDouble(MACD_2, Digits + 1 ) <= 0.0)
            {
              //---- close the position
              if(!OrderClose( OrderTicket(), OrderLots(), 
                 Ask, 5, Red))
              {
                _GetLastError = GetLastError();
                Alert( "Error OrderClose № ", _GetLastError );
                return(-1);
              }
            }
// if signal has not changed, exit: it's too early to open 
// a new position
            else return(0);
        }
    }
 
//+------------------------------------------------------------------+
//| if execution has reached this point, this means no open position |
//| check whether it is possible to open a position                  |
//+------------------------------------------------------------------+
 
    //---- if MACD meets zero line bottom-up,
    if ( NormalizeDouble( MACD_1, Digits + 1 ) >  0.0 && 
          NormalizeDouble( MACD_2, Digits + 1 ) <= 0.0    )
    {
        //---- open a BUY position
        if(OrderSend( Symbol(), OP_BUY, 0.1, Ask, 5, 0.0, 0.0, 
           "MACD_test", _MagicNumber, 0, Green ) < 0)
        {
            _GetLastError = GetLastError();
            Alert( "Error OrderSend № ", _GetLastError );
            return(-1);
        }
        return(0);
    }
    //---- if MACD meets zero line top-down,
    if(NormalizeDouble( MACD_1, Digits + 1 ) <  0.0 && 
          NormalizeDouble( MACD_2, Digits + 1 ) >= 0.0)
    {
        //---- open a SELL position
        if(OrderSend( Symbol(), OP_SELL, 0.1, Bid, 5, 0.0, 0.0,
           "MACD_test", 
              _MagicNumber, 0, Red ) < 0 )
        {
            _GetLastError = GetLastError();
            Alert( "Error OrderSend № ", _GetLastError );
            return(-1);
        }
        return(0);
    }
 
    return(0);
}

Agora nós temos que escrever uma função capaz de substituir o bloco de controle de posições. A função deve realizar buscas entre todos os pedidos, encontrar o pedido necessário e memorizar todas as suas características em variáveis globais. Ele ficará parecido com isto:

int _Ticket = 0, _Type = 0; double _Lots = 0.0, 
_OpenPrice = 0.0, _StopLoss = 0.0;
double _TakeProfit = 0.0; datetime _OpenTime = -1; 
double _Profit = 0.0, _Swap = 0.0;
double _Commission = 0.0; string _Comment = ""; 
datetime _Expiration = -1;
 
void OneOrderInit( int magic )
{
    int _GetLastError, _OrdersTotal = OrdersTotal();
 
    _Ticket = 0; _Type = 0; _Lots = 0.0; _OpenPrice = 0.0; 
_StopLoss = 0.0;
    _TakeProfit = 0.0; _OpenTime = -1; _Profit = 0.0; 
_Swap = 0.0;
    _Commission = 0.0; _Comment = ""; _Expiration = -1;
 
    for ( int z = _OrdersTotal - 1; z >= 0; z -- )
    {
        if ( !OrderSelect( z, SELECT_BY_POS ) )
        {
          _GetLastError = GetLastError();
          Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #", 
                _GetLastError );
          continue;
        }
        if(OrderMagicNumber() == magic && OrderSymbol() == 
           Symbol())
        {
          _Ticket    = OrderTicket();
          _Type      = OrderType();
          _Lots      = NormalizeDouble( OrderLots(), 1 );
          _OpenPrice = NormalizeDouble( OrderOpenPrice(), Digits);
          _StopLoss = NormalizeDouble( OrderStopLoss(), Digits);
          _TakeProfit = NormalizeDouble( OrderTakeProfit(), Digits);
          _OpenTime   = OrderOpenTime();
          _Profit     = NormalizeDouble( OrderProfit(), 2 );
          _Swap       = NormalizeDouble( OrderSwap(), 2 );
          _Commission = NormalizeDouble( OrderCommission(), 2 );
          _Comment    = OrderComment();
          _Expiration = OrderExpiration();
          return;
        }
    }
}

Como você pode ver, é bastante fácil: há 11 variáveis, e cada uma delas armazena o valor de uma característica de posição (# do bilhete, tipo, tamanho do lote, etc). Essas variáveis são "zeroizadas" no momento da inicialização da função. Isso é necessário porque as variáveis são declaradas a nível global, e não são "zeroizadas" no momento da chamada da função. Mas nós não precisamos de informações relativas ao tick anterior, todos os dados devem ser recentes. Em seguida, é realizada uma busca padrão entre todas as posições abertas e, caso o símbolo e o valor do MagicNumber coincidam com aqueles procurados, as características são memorizadas nas variáveis correspondentes.


Agora vamos anexar essa função ao nosso expert advisor:


extern int  _MagicNumber = 1122;
 
#include <OneOrderControl.mq4>
 
int start()
{
    int _GetLastError = 0;
    
// Memorize parameters of the open position (if available)
    OneOrderInit( _MagicNumber );
 
    //---- Memorize indicator values for further analysis
    double MACD_1 = iMACD(Symbol(), 0, 12, 26, 9, PRICE_CLOSE, 
                          MODE_MAIN, 1 );
    double MACD_2 = iMACD(Symbol(), 0, 12, 26, 9, PRICE_CLOSE, 
                          MODE_MAIN, 2 );
 
    // Now, instead of searching in positions, just see whether 
    // there is an open position:
    if ( _Ticket > 0 )
    {
        //---- if a BUY position is opened,
        if ( _Type == OP_BUY )
        {
            //---- if MACD meets zero line top-down,
            if(NormalizeDouble( MACD_1, Digits + 1 ) <  0.0 && 
               NormalizeDouble( MACD_2, Digits + 1 ) >= 0.0)
            {
                //---- close position
                if(!OrderClose( _Ticket, _Lots, Bid, 5, Green))
                {
                  _GetLastError = GetLastError();
                  Alert( "Error OrderClose № ", _GetLastError);
                  return(-1);
                }
            }
            // if signal has not changed, exit: it's too early 
            // to open a new position
            else return(0);
        }
        //---- if a SELL position is opened,
        if ( _Type == OP_SELL )
        {
            //---- if MACD meets zero line bottom-up,
            if(NormalizeDouble( MACD_1, Digits + 1 ) >  0.0 && 
               NormalizeDouble( MACD_2, Digits + 1 ) <= 0.0)
            {
                //---- close the position
                if(!OrderClose( _Ticket, _Lots, Ask, 5, Red))
                {
                    _GetLastError = GetLastError();
                    Alert( "Error OrderClose № ", _GetLastError);
                    return(-1);
                }
            }
            // if signal has not changed, exit: it's too early 
            // to open a new position
            else return(0);
        }
    }
    // if there is no position opened by the expert 
    // ( _Ticket == 0 )
    // if MACD meets zero line bottom-up,
    if(NormalizeDouble( MACD_1, Digits + 1 ) >  0.0 && 
       NormalizeDouble( MACD_2, Digits + 1 ) <= 0.0)
    {
        //---- open a BUY position
        if(OrderSend(Symbol(), OP_BUY, 0.1, Ask, 5, 0.0, 0.0,
           "CrossMACD", _MagicNumber, 0, Green ) < 0)
        {
            _GetLastError = GetLastError();
            Alert( "Error OrderSend № ", _GetLastError );
            return(-1);
        }
        return(0);
    }
    //---- if MACD meets zero line top-down,
    if ( NormalizeDouble( MACD_1, Digits + 1 ) <  0.0 && 
          NormalizeDouble( MACD_2, Digits + 1 ) >= 0.0    )
    {
        //---- open a SELL position
        if(OrderSend(Symbol(), OP_SELL, 0.1, Bid, 5, 0.0, 0.0,
           "CrossMACD", 
              _MagicNumber, 0, Red ) < 0 )
        {
            _GetLastError = GetLastError();
            Alert( "Error OrderSend № ", _GetLastError );
            return(-1);
        }
        return(0);
    }
 
    return(0);
}

Como você pode ver, agora o código do expert está muito mais compacto e legível por humanos. Este é o caso mais simples.


Agora vamos cumprir a próxima tarefa.

3. Uma posição de cada tipo


Nós precisamos de um expert mais complexo para implementar a outra função. Ele precisa abrir várias posições de tipos diferentes e trabalhar com elas. Abaixo temos o algoritmo do expert:

  • quando ele é inicializado, o expert deve fazer dois pedidos pendentes: BuyStop no nível de Ask+20 pontos e um SellStop no nível de Bid+20 pontos;
  • caso um dos pedidos for acionado, outro precisa ser deletado;
  • a posição aberta deve ser acompanhada de um limite móvel; e
  • após a posição ter sido fechada por StopLoss ou TakeProfit, voltar ao início, ou seja, fazer dois pedidos pendentes novamente.

O código do expert é fornecido abaixo:


extern int    _MagicNumber = 1123;

extern double Lot          = 0.1;
extern int    StopLoss     = 60;
// distance to StopLoss in points (0 - disable)
extern int    TakeProfit=100;
// distance to TakeProfit in points (0 - disable)
extern int    TrailingStop=50;
// Trailing Stop in points (0 - disable)

extern int    Luft=20;
// distance to the level at which the pending order was placed

int start()
  {
// Variables, in which tickets of orders of each type will be 
// memorized
   int BuyStopOrder=0,SellStopOrder=0,BuyOrder=0,SellOrder=0;
   int _GetLastError=0,_OrdersTotal=OrdersTotal();
// search in all open positions and memorize, positions of which 
// type have already been opened:
   for(int z=_OrdersTotal-1; z>=0; z --)
     {
      // if an error occurs at searching for a position, go 
      // to the next one
      if(!OrderSelect(z,SELECT_BY_POS))
        {
         _GetLastError=GetLastError();
         Print("OrderSelect(",z,", SELECT_BY_POS) - Error #",_GetLastError);
         continue;
        }

      // if the position was opened not for the current symbol, skip it
      if(OrderSymbol()!=Symbol()) continue;

      // if the MagicNumber is not equal to _MagicNumber, skip this 
      // position
      if(OrderMagicNumber()!=_MagicNumber) continue;

      // depending on the position type, change value of the 
      // variable:
      switch(OrderType())
        {
         case OP_BUY:      BuyOrder      = OrderTicket(); break;
         case OP_SELL:     SellOrder     = OrderTicket(); break;
         case OP_BUYSTOP:  BuyStopOrder  = OrderTicket(); break;
         case OP_SELLSTOP: SellStopOrder = OrderTicket(); break;
        }
     }

//---- If we have both pending orders, quit, 
//---- we have to wait until one of them triggers
   if( BuyStopOrder > 0 && SellStopOrder > 0 ) return(0);

// search in all open positions for the second time - now 
// we will work with them:
   _OrdersTotal=OrdersTotal();
   for(z=_OrdersTotal-1; z>=0; z --)
     {
      // if an error occurs in searching a position, go to 
      // the next one
      if(!OrderSelect(z,SELECT_BY_POS))
        {
         _GetLastError=GetLastError();
         Print("OrderSelect(",z,", SELECT_BY_POS) - Error #",_GetLastError);
         continue;
        }

      // if the position was opened not for the current symbol,
      // skip it
      if(OrderSymbol()!=Symbol()) continue;

      // if the MagicNumber does not equal to _MagicNumber, 
      // skip this position
      if(OrderMagicNumber()!=_MagicNumber) continue;

      // depending on the position type, change the variable 
      // value:
      switch(OrderType())
        {
         //---- if there is an open BUY position,
         case OP_BUY:
           {
            // if the SellStop order has not been deleted 
            // yet, delete it:
            if(SellStopOrder>0)
              {
               if(!OrderDelete(SellStopOrder))
                 {
                  Alert("OrderDelete Error #",GetLastError());
                  return(-1);
                 }
              }
            // check whether the StopLoss should be moved:
            // if the size of Trailing Stop is not very small,
            if(TrailingStop>MarketInfo(Symbol(),
               MODE_STOPLEVEL))
              {
               // if the profit exceeds the TrailingStop 
               // points,
               if(NormalizeDouble(Bid-OrderOpenPrice(),Digits)>NormalizeDouble(TrailingStop*Point,Digits))
                 {
                  // if the new StopLoss level exceeds 
                  // the current level of that for the 
                  // position
                  // (or if the position does not have 
                  // a StopLoss),
                  if(NormalizeDouble(Bid-TrailingStop*Point,Digits)>OrderStopLoss() || OrderStopLoss()<=0.0)
                    {
                     //---- modify the order
                     if(!OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(Bid-TrailingStop*Point,Digits),OrderTakeProfit(),OrderExpiration()))
                       {
                        Alert("OrderModify Error #",GetLastError());
                        return(-1);
                       }
                    }
                 }
              }
            // if there is an open position, quit, there 
            // is nothing to do
            return(0);
           }
         // The next block is absolutely the same as the 
         // block processing a BUY position,
         // this is why we do not comment on it...
         case OP_SELL:
           {
            if(BuyStopOrder>0)
              {
               if(!OrderDelete(BuyStopOrder))
                 {
                  Alert("OrderDelete Error #",GetLastError());
                  return(-1);
                 }
              }
            if(TrailingStop>MarketInfo(Symbol(),
               MODE_STOPLEVEL))
              {
               if(NormalizeDouble(OrderOpenPrice()-Ask,Digits)>NormalizeDouble(TrailingStop*Point,Digits))
                 {
                  if(NormalizeDouble(Ask+TrailingStop*Point,Digits)<OrderStopLoss() || OrderStopLoss()<=0.0)
                    {
                     if(!OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(Ask+TrailingStop*Point,Digits),OrderTakeProfit(),OrderExpiration()))
                       {
                        Alert("OrderModify Error #",GetLastError());
                        return(-1);
                       }
                    }
                 }
              }
            return(0);
           }
        }
     }

//+------------------------------------------------------------------+
//| If execution has reached this point, it means there are no       |
//| pending orders or open positions                                 |
//+------------------------------------------------------------------+
//---- Place BuyStop and SellStop:
   double _OpenPriceLevel,_StopLossLevel,_TakeProfitLevel;
   _OpenPriceLevel=NormalizeDouble(Ask+Luft*Point,Digits);

   if(StopLoss>0)
     { _StopLossLevel=NormalizeDouble(_OpenPriceLevel-StopLoss*Point,Digits); }
   else
     { _StopLossLevel=0.0; }

   if(TakeProfit>0)
     { _TakeProfitLevel=NormalizeDouble(_OpenPriceLevel+TakeProfit*Point,Digits); }
   else
     { _TakeProfitLevel=0.0; }

   if(OrderSend(Symbol(),OP_BUYSTOP,Lot,_OpenPriceLevel,5,_StopLossLevel,_TakeProfitLevel,"",_MagicNumber)<0)
     {
      Alert("OrderSend Error #",GetLastError());
      return(-1);
     }

   _OpenPriceLevel=NormalizeDouble(Bid-Luft*Point,Digits);

   if(StopLoss>0)
     { _StopLossLevel=NormalizeDouble(_OpenPriceLevel+StopLoss*Point,Digits); }
   else
     { _StopLossLevel=0.0; }

   if(TakeProfit>0)
     { _TakeProfitLevel=NormalizeDouble(_OpenPriceLevel-TakeProfit*Point,Digits); }
   else
     { _TakeProfitLevel=0.0; }

   if(OrderSend(Symbol(),OP_SELLSTOP,Lot,_OpenPriceLevel,
      5,_StopLossLevel,_TakeProfitLevel,"",_MagicNumber)<0)
     {
      Alert("OrderSend Error #",GetLastError());
      return(-1);
     }
   return(0);
  }

Vamos agora escrever a função que simplificaria o bloco de controle de posições abertas. Ela deve encontrar um pedido de cada tipo e armazenar as suas características em variáveis globais. Ela ficará parecido com isto:


 
// global variables in which order characteristics will be stored:
int _BuyTicket = 0, _SellTicket = 0, _BuyStopTicket = 0;
int _SellStopTicket = 0, _BuyLimitTicket = 0, _SellLimitTicket = 0;
 
double _BuyLots = 0.0, _SellLots = 0.0, _BuyStopLots = 0.0; 
double _SellStopLots = 0.0, _BuyLimitLots = 0.0, 
_SellLimitLots = 0.0;
 
double _BuyOpenPrice = 0.0, _SellOpenPrice = 0.0, 
_BuyStopOpenPrice = 0.0;
double _SellStopOpenPrice = 0.0, _BuyLimitOpenPrice = 0.0, 
_SellLimitOpenPrice = 0.0;
 
double _BuyStopLoss = 0.0, _SellStopLoss = 0.0, _BuyStopStopLoss = 0.0;
double _SellStopStopLoss = 0.0, _BuyLimitStopLoss = 0.0, _SellLimitStopLoss = 0.0;
 
double _BuyTakeProfit = 0.0, _SellTakeProfit = 0.0, 
_BuyStopTakeProfit = 0.0;
double _SellStopTakeProfit = 0.0, _BuyLimitTakeProfit = 0.0,
 _SellLimitTakeProfit = 0.0;
 
datetime _BuyOpenTime = -1, _SellOpenTime = -1, 
_BuyStopOpenTime = -1;
datetime _SellStopOpenTime = -1, _BuyLimitOpenTime = -1, 
_SellLimitOpenTime = -1;
 
double _BuyProfit = 0.0, _SellProfit = 0.0, _BuySwap = 0.0, 
_SellSwap = 0.0;
double _BuyCommission = 0.0, _SellCommission = 0.0;
 
string _BuyComment = "", _SellComment = "", _BuyStopComment = ""; 
string _SellStopComment = "", _BuyLimitComment = "", 
_SellLimitComment = "";
 
datetime _BuyStopExpiration = -1, _SellStopExpiration = -1;
datetime _BuyLimitExpiration = -1, _SellLimitExpiration = -1;
 
void OneTypeOrdersInit( int magic )
{
// zeroizing of variables:
    _BuyTicket = 0; _SellTicket = 0; _BuyStopTicket = 0;
    _SellStopTicket = 0; _BuyLimitTicket = 0; _SellLimitTicket = 0;
 
    _BuyLots = 0.0; _SellLots = 0.0; _BuyStopLots = 0.0; 
    _SellStopLots = 0.0; _BuyLimitLots = 0.0; _SellLimitLots = 0.0;
 
    _BuyOpenPrice = 0.0; _SellOpenPrice = 0.0; _BuyStopOpenPrice = 0.0;
    _SellStopOpenPrice = 0.0; _BuyLimitOpenPrice = 0.0; 
_SellLimitOpenPrice = 0.0;
 
    _BuyStopLoss = 0.0; _SellStopLoss = 0.0; _BuyStopStopLoss = 0.0;
    _SellStopStopLoss = 0.0; _BuyLimitStopLoss = 0.0; 
_SellLimitStopLoss = 0.0;
 
    _BuyTakeProfit = 0.0; _SellTakeProfit = 0.0; 
_BuyStopTakeProfit = 0.0;
    _SellStopTakeProfit = 0.0; _BuyLimitTakeProfit = 0.0; 
_SellLimitTakeProfit = 0.0;
 
    _BuyOpenTime = -1; _SellOpenTime = -1; _BuyStopOpenTime = -1;
    _SellStopOpenTime = -1; _BuyLimitOpenTime = -1; 
_SellLimitOpenTime = -1;
 
    _BuyProfit = 0.0; _SellProfit = 0.0; _BuySwap = 0.0; 
_SellSwap = 0.0;
    _BuyCommission = 0.0; _SellCommission = 0.0;
 
    _BuyComment = ""; _SellComment = ""; _BuyStopComment = ""; 
    _SellStopComment = ""; _BuyLimitComment = ""; 
_SellLimitComment = "";
 
    _BuyStopExpiration = -1; _SellStopExpiration = -1;
    _BuyLimitExpiration = -1; _SellLimitExpiration = -1;
 
    int _GetLastError = 0, _OrdersTotal = OrdersTotal();
    for ( int z = _OrdersTotal - 1; z >= 0; z -- )
    {
        if ( !OrderSelect( z, SELECT_BY_POS ) )
        {
          _GetLastError = GetLastError();
          Print("OrderSelect(", z, ",SELECT_BY_POS) - Error #", 
                _GetLastError );
          continue;
        }
        if ( OrderMagicNumber() == magic && OrderSymbol() == 
            Symbol() )
        {
          switch ( OrderType() )
          {
            case OP_BUY:
             _BuyTicket     = OrderTicket();
             _BuyLots       = NormalizeDouble( OrderLots(), 1 );
             _BuyOpenPrice  = NormalizeDouble( OrderOpenPrice(),
                                               Digits );
             _BuyStopLoss   = NormalizeDouble( OrderStopLoss(), 
                                               Digits );
             _BuyTakeProfit = NormalizeDouble( OrderTakeProfit(),
                                               Digits );
             _BuyOpenTime   = OrderOpenTime();
             _BuyProfit     = NormalizeDouble( OrderProfit(), 2 );
             _BuySwap       = NormalizeDouble( OrderSwap(), 2 );
             _BuyCommission = NormalizeDouble( OrderCommission(),
                                               2 );
             _BuyComment    = OrderComment();
             break;
           case OP_SELL:
             _SellTicket     = OrderTicket();
             _SellLots       = NormalizeDouble( OrderLots(), 1 );
             _SellOpenPrice  = NormalizeDouble( OrderOpenPrice(),
                                                Digits );
             _SellStopLoss   = NormalizeDouble( OrderStopLoss(),
                                                Digits );
             _SellTakeProfit = NormalizeDouble( OrderTakeProfit(),
                                                Digits );
             _SellOpenTime   = OrderOpenTime();
             _SellProfit     = NormalizeDouble( OrderProfit(), 2 );
             _SellSwap       = NormalizeDouble( OrderSwap(), 2 );
             _SellCommission = NormalizeDouble( OrderCommission(),
                                                2 );
             _SellComment    = OrderComment();
             break;
           case OP_BUYSTOP:
             _BuyStopTicket     = OrderTicket();
             _BuyStopLots       = NormalizeDouble( OrderLots(), 1 );
             _BuyStopOpenPrice  = NormalizeDouble( OrderOpenPrice(),
                                                   Digits );
             _BuyStopStopLoss   = NormalizeDouble( OrderStopLoss(),
                                                   Digits );
             _BuyStopTakeProfit = NormalizeDouble( OrderTakeProfit(),
                                                   Digits );
             _BuyStopOpenTime   = OrderOpenTime();
             _BuyStopComment    = OrderComment();
             _BuyStopExpiration = OrderExpiration();
             break;
          case OP_SELLSTOP:
             _SellStopTicket     = OrderTicket();
             _SellStopLots       = NormalizeDouble( OrderLots(), 1 );
             _SellStopOpenPrice  = NormalizeDouble( OrderOpenPrice(),
                                                    Digits );
             _SellStopStopLoss   = NormalizeDouble( OrderStopLoss(),
                                                    Digits );
             _SellStopTakeProfit = NormalizeDouble( OrderTakeProfit(),
                                                    Digits );
             _SellStopOpenTime   = OrderOpenTime();
             _SellStopComment    = OrderComment();
             _SellStopExpiration = OrderExpiration();
             break;
          case OP_BUYLIMIT:
             _BuyLimitTicket     = OrderTicket();
             _BuyLimitLots       = NormalizeDouble( OrderLots(), 1 );
             _BuyLimitOpenPrice  = NormalizeDouble( OrderOpenPrice(),
                                                    Digits );
             _BuyLimitStopLoss   = NormalizeDouble( OrderStopLoss(),
                                                    Digits );
             _BuyLimitTakeProfit = NormalizeDouble( OrderTakeProfit(),
                                                    Digits );
             _BuyLimitOpenTime   = OrderOpenTime();
             _BuyLimitComment    = OrderComment();
             _BuyLimitExpiration = OrderExpiration();
             break;
           case OP_SELLLIMIT:
             _SellLimitTicket     = OrderTicket();
             _SellLimitLots       = NormalizeDouble( OrderLots(), 1 );
             _SellLimitOpenPrice  = NormalizeDouble( OrderOpenPrice(),
                                                     Digits );
             _SellLimitStopLoss   = NormalizeDouble( OrderStopLoss(),
                                                     Digits );
             _SellLimitTakeProfit = NormalizeDouble( OrderTakeProfit(),
                                                     Digits );
             _SellLimitOpenTime   = OrderOpenTime();
             _SellLimitComment    = OrderComment();
             _SellLimitExpiration = OrderExpiration();
             break;
            }
        }
    }
}

Agora vamos anexar a função ao expert:


extern int    _MagicNumber = 1123;
 
extern double Lot          = 0.1;
extern int    StopLoss     = 60;    
// distance to StopLoss in points (0 - disable)
extern int    TakeProfit   = 100;   
// distance to TakeProfit in points (0 - disable)
extern int    TrailingStop = 50;    
// Trailing Stop in points (0 - disable)
 
extern int    Luft         = 20;    
// distance to the placing level of the pending order
 
#include <OneTypeOrdersControl.mq4>
 
int start()
{
    int _GetLastError = 0;
 
    //---- Memorize parameters of open positions (if available)
    OneTypeOrdersInit( _MagicNumber );
 
    //---- If we have both pending orders, quit, 
    //---- we have to wait until one of them triggers
    if ( _BuyStopTicket > 0 && _SellStopTicket > 0 ) return(0);
 
    //---- if there is an open BUY position,
    if ( _BuyTicket > 0 )
    {
        //---- if the SellStop has not been deleted yet, delete it:
        if ( _SellStopTicket > 0 )
        {
            if ( !OrderDelete( _SellStopTicket ) )
            {
                Alert( "OrderDelete Error #", GetLastError() );
                return(-1);
            }
        }
        //---- check whether the StopLoss should be moved:
        //---- if the Trailing Stop size is not too small,
        if ( TrailingStop > MarketInfo( Symbol(), 
             MODE_STOPLEVEL ) )
        {
//---- if the profit on the position exceeds TrailingStop points,
            if ( NormalizeDouble( Bid - _BuyOpenPrice, Digits ) > 
                  NormalizeDouble( TrailingStop*Point, Digits ) )
            {
//---- if the new level of StopLoss exceeds that of the current 
//     position
//---- (or if the position does not have a StopLoss),
                if(NormalizeDouble( Bid - TrailingStop*Point, 
                   Digits ) > _BuyStopLoss
                   || _BuyStopLoss <= 0.0 )
                {
                    //---- modify the order
                    if ( !OrderModify( _BuyTicket, _BuyOpenPrice, 
                          NormalizeDouble( Bid - TrailingStop*Point,
                          Digits ), 
                          _BuyTakeProfit, 0 ) )
                    {
                        Alert( "OrderModify Error #", 
                               GetLastError() );
                        return(-1);
                    }
                }                    
            }
        }
//---- if there is an open position, quit, there is nothing to do
        return(0);
    }
 
//---- The block below is absolutely similar to that processing 
//     the BUY position,
//---- this is why we do not comment on it...
    if ( _SellTicket > 0 )
    {
        if ( _BuyStopTicket > 0 )
        {
            if ( !OrderDelete( _BuyStopTicket ) )
            {
                Alert( "OrderDelete Error #", GetLastError() );
                return(-1);
            }
        }
        if(TrailingStop > MarketInfo( Symbol(), MODE_STOPLEVEL))
        {
            if(NormalizeDouble( _SellOpenPrice - Ask, Digits ) > 
                 NormalizeDouble( TrailingStop*Point, Digits ) )
            {
                if(NormalizeDouble( Ask + TrailingStop*Point, 
                   Digits ) < _SellStopLoss
                      || _SellStopLoss <= 0.0 )
                {
                    if(!OrderModify( _SellTicket, _SellOpenPrice, 
                       NormalizeDouble( Ask + TrailingStop*Point, 
                       Digits ), 
                       _SellTakeProfit, 0 ) )
                    {
                        Alert( "OrderModify Error #", 
                               GetLastError() );
                        return(-1);
                    }
                }                    
            }
        }
        return(0);
    }
 
 
//+------------------------------------------------------------------+
//| If execution has reached this point, this means that there are no|
//| pending orders or open positions                                 |
//+------------------------------------------------------------------+
//---- Place BuyStop and SellStop:
    double _OpenPriceLevel, _StopLossLevel, _TakeProfitLevel;
    _OpenPriceLevel = NormalizeDouble( Ask + Luft*Point, Digits);
 
    if ( StopLoss > 0 )
      _StopLossLevel = NormalizeDouble( _OpenPriceLevel - 
                       StopLoss*Point, Digits );
    else
      _StopLossLevel = 0.0;
 
    if ( TakeProfit > 0 )
      _TakeProfitLevel = NormalizeDouble( _OpenPriceLevel + 
                         TakeProfit*Point, Digits );
    else
      _TakeProfitLevel = 0.0;
 
    if(OrderSend ( Symbol(), OP_BUYSTOP, Lot, _OpenPriceLevel, 
       5, _StopLossLevel, _TakeProfitLevel, "", _MagicNumber ) < 0)
    {
        Alert( "OrderSend Error #", GetLastError() );
        return(-1);
    }
 
 
    _OpenPriceLevel = NormalizeDouble( Bid - Luft*Point, Digits);
 
    if ( StopLoss > 0 )
      _StopLossLevel = NormalizeDouble( _OpenPriceLevel + 
                       StopLoss*Point, Digits );
    else
      _StopLossLevel = 0.0;
 
    if ( TakeProfit > 0 )
      _TakeProfitLevel = NormalizeDouble( _OpenPriceLevel - 
                         TakeProfit*Point, Digits );
    else
      _TakeProfitLevel = 0.0;
 
    if(OrderSend ( Symbol(), OP_SELLSTOP, Lot, _OpenPriceLevel,
       5, _StopLossLevel, _TakeProfitLevel, "", 
       _MagicNumber ) < 0 )
    {
        Alert( "OrderSend Error #", GetLastError() );
        return(-1);
    }
 
    return(0);
}

Aqui a diferença entre o expert inicial e o revisado é muito mais perceptível – o bloco de controle de posições é de compreensão muito simples e fácil.

Agora é a vez dos experts mais complexos, aqueles que não possuem qualquer limitação em relação à quantidade de posições abertas simultaneamente.

4. Controle sobre todas as posições


O uso de variáveis foi suficiente para armazenar características de um pedido. Agora nós teremos que criar algumas matrizes, uma para cada característica. Com exceção deste fato, a função é praticamente igual:

  • "zeroizar" todas as matrizes durante a inicialização;
  • buscar em todos os pedidos e armazenar em matrizes apenas as características daqueles que possuam o símbolo necessário e o MagicNumber igual ao parâmetro da função 'mágica';
  • para melhorar a usabilidade, adicionar uma variável global que irá armazenar a contagem total de pedidos do expert – isso será útil durante o acesso das matrizes.

Vamos iniciar imediatamente a escrita da função:


// the variable that will store the amount of all orders of the expert:
int _ExpertOrdersTotal = 0;
 
// arrays where the order characteristics will be stored:
int _OrderTicket[], _OrderType[];
double _OrderLots[], _OrderOpenPrice[], _OrderStopLoss[], 
_OrderTakeProfit[];
double _OrderProfit[], _OrderSwap[], _OrderCommission[];
datetime _OrderOpenTime[], _OrderExpiration[];
string _OrderComment[];
 
void AllOrdersInit( int magic )
{
    int _GetLastError = 0, _OrdersTotal = OrdersTotal();
 
    // change array sizes according to the current amount of 
    // positions
    // (if _OrdersTotal = 0, change the arrays size for 1)
    int temp_value = MathMax( _OrdersTotal, 1 );
    ArrayResize( _OrderTicket,     temp_value );
    ArrayResize( _OrderType,       temp_value );
    ArrayResize( _OrderLots,       temp_value );
    ArrayResize( _OrderOpenPrice,  temp_value );
    ArrayResize( _OrderStopLoss,   temp_value );
    ArrayResize( _OrderTakeProfit, temp_value );
    ArrayResize( _OrderOpenTime,   temp_value );
    ArrayResize( _OrderProfit,     temp_value );
    ArrayResize( _OrderSwap,       temp_value );
    ArrayResize( _OrderCommission, temp_value );
    ArrayResize( _OrderComment,    temp_value );
    ArrayResize( _OrderExpiration, temp_value );
 
    // zeroize the arrays
    ArrayInitialize( _OrderTicket,     0 );
    ArrayInitialize( _OrderType,       0 );
    ArrayInitialize( _OrderLots,       0 );
    ArrayInitialize( _OrderOpenPrice,  0 );
    ArrayInitialize( _OrderStopLoss,   0 );
    ArrayInitialize( _OrderTakeProfit, 0 );
    ArrayInitialize( _OrderOpenTime,   0 );
    ArrayInitialize( _OrderProfit,     0 );
    ArrayInitialize( _OrderSwap,       0 );
    ArrayInitialize( _OrderCommission, 0 );
    ArrayInitialize( _OrderExpiration, 0 );
 
    _ExpertOrdersTotal = 0;
    for ( int z = _OrdersTotal - 1; z >= 0; z -- )
    {
        if ( !OrderSelect( z, SELECT_BY_POS ) )
        {
          _GetLastError = GetLastError();
          Print("OrderSelect(", z, ",SELECT_BY_POS) - Error #", 
                _GetLastError );
          continue;
        }
        if ( OrderMagicNumber() == magic && OrderSymbol() == 
             Symbol() )
        {
            // fill the arrays
            _OrderTicket[_ExpertOrdersTotal] = OrderTicket();
            _OrderType[_ExpertOrdersTotal] = OrderType();
            _OrderLots[_ExpertOrdersTotal] = 
            NormalizeDouble( OrderLots(), 1 );
            _OrderOpenPrice[_ExpertOrdersTotal] = 
            NormalizeDouble( OrderOpenPrice(), Digits );
            _OrderStopLoss[_ExpertOrdersTotal] = 
            NormalizeDouble( OrderStopLoss(), Digits );
            _OrderTakeProfit[_ExpertOrdersTotal] = 
            NormalizeDouble( OrderTakeProfit(), Digits );
            _OrderOpenTime[_ExpertOrdersTotal] = OrderOpenTime();
            _OrderProfit[_ExpertOrdersTotal] = 
            NormalizeDouble( OrderProfit(), 2 );
            _OrderSwap[_ExpertOrdersTotal] = 
            NormalizeDouble( OrderSwap(), 2 );
            _OrderCommission[_ExpertOrdersTotal] = 
            NormalizeDouble( OrderCommission(), 2 );
            _OrderComment[_ExpertOrdersTotal] = OrderComment();
            _OrderExpiration[_ExpertOrdersTotal] = 
            OrderExpiration();
            _ExpertOrdersTotal++;
        }
    }
 
    // change the arrays size according to the amount of 
    // positions that belong to the expert
    // (if _ExpertOrdersTotal = 0, change the arrays size for 1)
    temp_value = MathMax( _ExpertOrdersTotal, 1 );
    ArrayResize( _OrderTicket,     temp_value );
    ArrayResize( _OrderType,       temp_value );
    ArrayResize( _OrderLots,       temp_value );
    ArrayResize( _OrderOpenPrice,  temp_value );
    ArrayResize( _OrderStopLoss,   temp_value );
    ArrayResize( _OrderTakeProfit, temp_value );
    ArrayResize( _OrderOpenTime,   temp_value );
    ArrayResize( _OrderProfit,     temp_value );
    ArrayResize( _OrderSwap,       temp_value );
    ArrayResize( _OrderCommission, temp_value );
    ArrayResize( _OrderComment,    temp_value );
    ArrayResize( _OrderExpiration, temp_value );
}

Para examinar em detalhes o funcionamento da função, vamos escrever um expert simples capaz de exibir informações a respeito de todas as posições abertas pelo expert.

O seu código é bastante simples:

extern int _MagicNumber    = 0;
 
#include AllOrdersControl.mq4>
 
int start()
{
    AllOrdersInit( _MagicNumber );
 
    
    if ( _ExpertOrdersTotal > 0 )
    {
        string OrdersList = StringConcatenate(Symbol(), 
                   ", MagicNumber ", _MagicNumber, ":\n");
        for ( int n = 0; n _ExpertOrdersTotal; n ++ )
        {
            OrdersList = StringConcatenate( OrdersList, 
                            "Order # ", _OrderTicket[n], 
                ", profit/loss: ", 
                DoubleToStr( _OrderProfit[n], 2 ), 
                " ", AccountCurrency(), "\n" );            
        }
        Comment( OrdersList );
    }
 
    return(0);
}

Caso o _MagicNumber for configurado como 0, o expert irá exibir a lista de posições abertas manualmente:

5. Conclusão


Por fim, eu gostaria de comparar a velocidade dos experts que realizam buscas em seus pedidos de forma independente àquela dos experts que utilizam funções. Para este fim, ambas versões foram testadas no modo "Every tick" (a cada tick) 10 vezes consecutivamente (otimização pelo _MagicNumber). O tempo de teste foi medido pelo próprio MetaTrader – o tempo decorrido é medido automaticamente.

Os resultados são os seguintes:

Expert Advisor

Tempo decorrido em 10 tests (mm:ss)

CrossMACD_beta

(sem função)

07:42

CrossMACD

11:37

DoublePending_beta

(sem função)

08:18

DoublePending

09:42

Como você pode ver na tabela, experts que usam funções trabalham um pouco mais lentamente (na lista, durante testes). É um preço justo a se pagar pela usabilidade e simplicidade do código fonte do expert.


De todo modo, cada usuário deve decidir por si mesmo se irá usá-las ou não.

Traduzido do russo pela MetaQuotes Software Corp.
Artigo original: https://www.mql5.com/ru/articles/1404

Arquivos anexados |
CrossMACD.mq4 (3.01 KB)
CrossMACD_beta.mq4 (3.63 KB)
Como avaliar os resultados dos testes do Expert Como avaliar os resultados dos testes do Expert

O artigo fornece fórmulas e a ordem de cálculo relativas aos dados exibidos no relatório do verificador.

Eventos no MetaTrader 4 Eventos no MetaTrader 4

O artigo trata do monitoramento programado de eventos no terminal do cliente do MetaTrader 4, como a abertura/fechamento/modificação de pedidos, e é destinado a um usuário que possua habilidades básicas no trabalho com o terminal e em programação em MQL4.

Armazenamento e visualização de informações Armazenamento e visualização de informações

O artigo trata de métodos convenientes e eficientes de armazenamento e visualização de informações. São consideradas aqui alternativas ao arquivo log padrão do terminal e à função Comment().

Comentador do sistema do expert. Uso prático dos indicadores integrados a um programa MQL4 Comentador do sistema do expert. Uso prático dos indicadores integrados a um programa MQL4

O artigo descreve o uso de indicadores técnicos na programação com o MQL4.