Ordem Parcialmente executada - Possível solução para mercado futuro

Novo comentário
 

Olá senhores, 

Algumas vezes minhas ordens limites são executadas parcialmente e acontece do mercado andar a favor sem executar por completo.

Estou pensando uma possível solução para evitar esse problema.

Caso a ordem foi executada parcialmente e o mercado andou 2 ou mais ticks a favor da operação, ele irá fazer um incremento à mercado.

Obs.: Os dados das variáveis cur_sl e cur_tp foram obtidos em outra rotina usando "Positions Properties".

Se alguém souber de alguma solução mais prática, poderia postar também.  

Segue o modelo de código abaixo:

void Check_Partial()
  {
//---
   uint  ord_total=OrdersTotal();
   for(uint i=0; i<ord_total; i++)
     {
      ulong ticket;
      if((ticket=OrderGetTicket(i))>0)
        {
         if(OrderGetString(ORDER_SYMBOL)==_Symbol)
            if(OrderGetInteger(ORDER_MAGIC)==EA_Magic)
              {
   	      //--- Para ordens de compra	
                if(OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_BUY_LIMIT)
                  {
                   if(OrderGetInteger(ORDER_STATE)==ORDER_STATE_PARTIAL)
                     {
                      if(SymbolInfoDouble(_Symbol,SYMBOL_LAST)>=(OrderGetDouble(ORDER_PRICE_OPEN)+(2*SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE))))
                        {
                         double fix_vol=OrderGetDouble(ORDER_VOLUME_INITIAL)-OrderGetDouble(ORDER_VOLUME_CURRENT);
                         Trade.Buy(fix_vol,_Symbol,SymbolInfoDouble(_Symbol,SYMBOL_LAST),cur_sl,cur_tp,"Fix Volume");
                        }
                     }
                  }
	      //--- Para ordens de venda
                if(OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_SELL_LIMIT)
                  {
                   if(OrderGetInteger(ORDER_STATE)==ORDER_STATE_PARTIAL)
                     {
                      if(SymbolInfoDouble(_Symbol,SYMBOL_LAST)<=(OrderGetDouble(ORDER_PRICE_OPEN)-(2*SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE))))
                        {
                         double fix_vol=OrderGetDouble(ORDER_VOLUME_INITIAL)-OrderGetDouble(ORDER_VOLUME_CURRENT);
                         Trade.Sell(fix_vol,_Symbol,SymbolInfoDouble(_Symbol,SYMBOL_LAST),cur_sl,cur_tp,"Fix Volume");
                        }
                     }
                  }
              }
               
        }
     }
   

  }
 

Serve sem código?

Eu faria um loop do while verificando se a quantidade de contratos que requeri foi atendida

enum eTipo_de_posicao
{
    eCompradora,
    eVendedora,
};

//+------------------------------------------------------------------+

bool verifique_o_preco_medio(double pPreco_atual, eTipo_de_posicao pTipo_de_posicao)
{
    bool retorno = false;
    if(pTipo_de_posicao == eCompradora)
    {
        retorno = pPreco_atual > posicao[ticket].preco_medio;
    }
    else if (pTipo_de_posicao == eVendedora)
    {
        retorno = pPreco_atual < posicao[ticket].preco_medio;
    }
    return retorno;
};

//+------------------------------------------------------------------+

if(PositionSelectByTicket(ticket))
{
    if(verifique_o_preco_medio(posicao[ticket].preco_medio, posicao[ticket].tipo_de_posicao)
    {
        do
        {
         //Realize novas compras
         //Obtenha o novo preço médio
	 //Atualize a quantidade atual de contratos
        }
        while(condicao_para_continuar_comprando()
		&& verifique_o_preco_medio(preco_atual, posicao[ticket].tipo_de_posicao)
                && !IsStopped());
    }
};

//+------------------------------------------------------------------+

bool condicao_para_continuar_comprando()
{
    return posicao[ticket].qntd_de_contratos_requerida > posicao[ticket].qntd_atual_de_contratos;

};
//+------------------------------------------------------------------+

Mais ou menos isso aí....

Agora observe que há uma recursividade acontecendo e por isso mesmo, afim de evitar o custo computacional, faço a seleção da posição que me interessa no código.

Se utilizar essa lógica varrendo continuamente o total de ordens como faz atualmente, esse código que postei vai virar um verdadeiro "tijolo" para seu processador.

 
Guilherme Mendonca:

Olá senhores, 


Guilherme, 

você deve usar o comando ORDER_MODIFY, alterando o preço da ordem pendente para um preço de execução imediata, ou seja para compra acima do ASK, para venda abaixo BID

 
Rogerio Giannetti Torres #:

Guilherme, 

você deve usar o comando ORDER_MODIFY, alterando o preço da ordem pendente para um preço de execução imediata, ou seja para compra acima do ASK, para venda abaixo BID

Você está certo Rogério.

Muito obrigado pela dica.

 
Que piada...
Novo comentário