MetaTrader 4 / Sistemas de negociação
English Русский 中文 Español Deutsch 日本語 한국어 Français Italiano Türkçe
A Regra de Ouro dos Traders

A Regra de Ouro dos Traders

MetaTrader 4 — Sistemas de negociação | 8 setembro 2015, 14:27
1 484 0
Genkov
Genkov

Introdução

A principal tarefa de um trader não é apenas encontrar o momento certo para entrar no mercado. É também necessário encontrar o momento certo para sair. A regra de ouro da negociação diz: "Sempre corte suas perdas o mais rápido possível e deixe os seus lucros correrem".

Precisamos entender três princípios básicos de uma boa negociação para executar lucro baseado em alta expectativa matemática.

  1. Conheça o seu risco ao entrar no mercado (através de um valor inicial de Stop Loss);
  2. Cortar seus lucros rapidamente e permitir que seus lucros sejam executados (não feche sua posição antes que seja necessário pelo sistema);
  3. Conheça a expectativa matemática de seu sistema - teste e ajuste-o regularmente.


Passo a Passo do Método para Arrastar Posições Permitindo a Tomada do Lucro

Muitos pensam que é impossível lucrar, pois não sabemos a direção do mercado. Mas será que realmente precisamos saber a direção do mercado para negociar com sucesso? Uma negociação bem sucedida é baseada principalmente num sistema corretamente projetado, considerando momentos adequados para entrar no mercado. Tais considerações são feitas usando o poder da expectativa e as regras do passo a passo do método para arrastar posições permitindo a tomada do lucro no mais alto nível possível.

O momento de entrada no mercado pode ser encontrado em muitos caminhos, por exemplo, utilizando modelos de candlesticks, modelos de onda, etc. Ao mesmo tempo, o fator de lucro deve ser considerado (relação de ganhos/perdas).

Este método baseia-se no seguinte requisito: um operador seleciona o valor mais baixo possível de Stop Loss quando abrir uma posição. Esse valor pode ser determinada utilizando vários métodos; pode ser igual a 1,5% do depósito, por exemplo. Quando o mercado atinge um lucro igual ao valor do Stop Loss, a metade do lote é fechada, mas o Stop Loss não é alterado!

Portanto, criamos uma espécie de rede de segurança, no caso do mercado ir no sentido oposto. Ou seja, reduzimos o nosso risco pela fixação de perdas mínimas. Se o mercado se moveu na direção favorável apenas para em seguida voltar, então o Stop Loss é disparado. (Fig. 1-3).


Fig. 1. Abrindo uma posição


Fig. 2. Definindo Stop Loss

se o mercado retrocedeu:


Fig. 3. Se o mercado retrocedeu, você está no nível para empatar

Código do Programa para Arrastar Posição

Este artigo fornece um código de programa para arrastar posições abertas de acordo com o segundo princípio de ouro, pois permite que o lucro corra para o mais alto nível possível.

Se o mercado ainda se move numa direção favorável e atinge algum valor predeterminado; por exemplo, 100 pips, então o Stop Loss é reposto para um nível de empate. Redefinições adicionais são realizadas quando atinge o lucro em intervalo predeterminado; por exemplo, 50 pips. Nós podemos mover o Stop Loss em cada barra seguinte, mas as corretoras não gostam de redefinições freqüentes, especialmente quando a ordem é realizada nos timeframes menores. O arquivo de erro (stdlib.mq4) a partir da pasta das bibliotecas ainda tem o "error # 8 error = too frequent requests" exatamente para este caso.

O método para determinar o próximo nível Stop Loss é selecionado para uma posição de preço no momento de lucrar, dependendo dos níveis Fibonacci. Os níveis Fibonacci aplicados são construídos de acordo com método "Vegas Tunnel".

O cálculo dos níveis Fibonacci níveis é gerado pela função LevelFibo():

//+------------------------------------------------------------------+
   void LevelFibo()
   {
   double Fb1,Fb2,Fb3,Fb4,Fb5,Fb6,Fb7,Fb8,Fb9,Fb10,Fb11,Fb12,Fb13;
   // canal "Vegas" 
   double Ma144_1 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,1);
   double Ma169_1 = iMA(NULL,0,169,0,MODE_EMA,PRICE_CLOSE,1);
   // canal mediano "Vegas" 
   double MedVegas=NormalizeDouble((Ma144_1+Ma169_1)/2,Digits); 
   // cálculo dos valores dos níveis Fibo usando o método "Vegas"
   Fb1=MedVegas-377*Point;     Fb12=MedVegas+377*Point;
   Fb2=MedVegas-233*Point;     Fb11=MedVegas+233*Point;
   Fb3=MedVegas-144*Point;     Fb10=MedVegas+144*Point;
   Fb4=MedVegas-89*Point;      Fb9=MedVegas+89*Point;
   Fb5=MedVegas-55*Point;      Fb8=MedVegas+55*Point;
   Fb6=MedVegas-34*Point;      Fb7=MedVegas+34*Point;
   }
//+------------------------------------------------------------------+

Ao calcular o Stop Loss para as posições compradas, o lucro é a diferença entre a máxima do preço da primeira barra (High[1]) e o nível de abertura da posição (OrderOpenPrice() ). O nível de Stop Loss é definido como o "mais próximo" do nível Fibonacci relativo ao valor da mínima do preço da primeira barra (Low[1] - Fig. 4)


Fig. 4. Cálculo do Stop Loss para posição BUY

Ao calcular o Stop Loss para posições vendidas, o lucro é a diferença entre o nível de abertura da posição (OrderOpenPrice() ) e a máxima do preço da primeira bar (High[1] - Fig. 5).


Fig. 5. Cálculo do Stop Loss para posição SELL

Para posições compradas, os valores do Stop Loss são baseados nos níveis fibo. Dependem do menor valor do primeiro candlestick, que é apresentado como uma função separada.

O código de função é mostrado abaixo:

//+----------------------------------------------------------------------------+
//| Função (tabela) para especificar valores do Stop Loss para a posição BUY   |
//| pelos níveis fibo de acordo com o menor valor do primeiro candle           |
//+----------------------------------------------------------------------------+
 void StopLevelFiboBuy()
   {
   if(Low[1]>Fb12)                                newSL_B=Fb12-100*Point;
   if(Low[1]<=Fb12 && Low[1]>(Fb12+Fb11)/2)       newSL_B=(Fb12+Fb11)/2;
   if(Low[1]<=(Fb12+Fb11)/2 && Low[1]>Fb11)       newSL_B=Fb11;
   if(Low[1]<=Fb11 && Low[1]>(Fb11+Fb10)/2)       newSL_B=(Fb11+Fb10)/2;
   if(Low[1]<=(Fb10+Fb11)/2 && Low[1]>Fb10)       newSL_B=Fb10;
   if(Low[1]<=Fb10 && Low[1]>(Fb10+Fb9)/2)        newSL_B=Fb9;
   if(Low[1]<=(Fb10+Fb9)/2 && Low[1]>Fb9)         newSL_B=Fb8;
   if(Low[1]<=Fb9  && Low[1]>Fb8)                 newSL_B=Fb7;
   if(Low[1]<=Fb8  && Low[1]>Fb7)                 newSL_B=(Fb7+MedVegas)/2;
   if(Low[1]<=Fb7  && Low[1]>MedVegas)            newSL_B=Fb6;
   if(Low[1]<=MedVegas && Low[1]>(MedVegas+Fb6)/2)newSL_B=Fb6;
   if(Low[1]<=(MedVegas+Fb6)/2 && Low[1]>Fb6)     newSL_B=Fb5;
   if(Low[1]<=Fb6  && Low[1]>Fb5)                 newSL_B=Fb4;
   if(Low[1]<=Fb5  && Low[1]>Fb4)                 newSL_B=(Fb3+Fb4)/2;
   if(Low[1]<=Fb4  && Low[1]>Fb3)                 newSL_B=Fb3;
   if(Low[1]<=Fb3  && Low[1]>(Fb3+Fb2)/2)         newSL_B=(Fb3+Fb2)/2;
   if(Low[1]<=(Fb3+Fb2)/2  && Low[1]>Fb2)         newSL_B=Fb2;
   if(Low[1]<=Fb2  && Low[1]>(Fb2+Fb1)/2)         newSL_B=(Fb1+Fb2)/2;
   if(Low[1]<=(Fb2+Fb1)/2 && Low[1]>Fb1)          newSL_B=Fb1;
   if(Low[1]<=Fb1)                                newSL_B=Fb1-100*Point;
   }
//+------------------------------------------------------------------+

A tabela de valores do Stop Loss para posições Sell pelos níveis fibo depende do valor máximo da primeira função StopLevelFiboSell() (dos clandesticks), é representada pela seguinte código:

//+-----------------------------------------------------------------------------+
//| Função (tabela) para especificar valores do Stop Loss para uma posição SELL |
//| pelos níveis fibo de acordo com o menor valor do primeiro candle            |
//+-----------------------------------------------------------------------------+
 void StopLevelFiboSell()
   {
   if(High[1]<=Fb12 && High[1]>(Fb12+Fb11)/2)        newSL_S=Fb12+100*Point;
   if(High[1]<=Fb12 && High[1]>Fb11)                 newSL_S=Fb12;
   if(High[1]<=Fb11 && High[1]>Fb11+Fb10)            newSL_S=Fb11;
   if(High[1]<=Fb10 && High[1]>(Fb10+Fb9)/2)         newSL_S=(Fb11+Fb10)/2;
   if(High[1]<=Fb9  && High[1]>Fb8)                  newSL_S=(Fb10+Fb9)/2;
   if(High[1]<=Fb8  && High[1]>Fb7)                  newSL_S=Fb9;
   if(High[1]<=Fb7  && High[1]>MedVegas)             newSL_S=Fb8;
   if(High[1]<=MedVegas && High[1]>MedVegas)         newSL_S=Fb7;
   if(High[1]<=(MedVegas+Fb6)/2 && High[1]>Fb6)      newSL_S=MedVegas;
   if(High[1]<=Fb6  && High[1]>Fb5)                  newSL_S=MedVegas;
   if(High[1]<=Fb5  && High[1]>Fb4)                  newSL_S=Fb6;
   if(High[1]<=Fb4  && High[1]>Fb3)                  newSL_S=Fb5;
   if(High[1]<=Fb3  && High[1]>Fb2)                  newSL_S=Fb4;
   if(High[1]<=Fb2  && High[1]>(Fb2+Fb1)/2)          newSL_S=(Fb2+Fb3)/2;
   if(High[1]<(Fb2+Fb1)/2   && High[1]>Fb1)          newSL_S=Fb2;
   if(High[1]<Fb1)                                   newSL_S=(Fb2+Fb1)/2;
   }
//+------------------------------------------------------------------+

Seria apropriado acrescentar a função de cálculo LevelFibo Fibonacci para cada uma das duas funções de dependência mencionadas. Como foi feito nos arquivos de demonstração anexos.

Agora, a combinação das duas funções permite que a função de cálculo LevelFibo() identifique os níveis de Stop Loss focadas nestes níveis. Esta combinação faz sentido, quando as funções trabalham juntas. Portanto, o número de funções chamadas durante o arrastar das posições será reduzido - apenas uma permanecerá, em vez de duas.

Depois de combinadas, veremos o seguinte:

//+-----------------------------------------------------------------------------+
//| Função (tabela) para especificar valores do Stop Loss para a posição BUY    |
//| pelos níveis Fibo de acordo com o menor valor do primeiro candle            |
//+-----------------------------------------------------------------------------+
   void StoplevelFiboBuy()
   {
   double Fb1,Fb2,Fb3,Fb4,Fb5,Fb6,Fb7,Fb8,Fb9,Fb10,Fb11,Fb12,Fb13;
   double Ma144_1 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,1);
   double Ma169_1 = iMA(NULL,0,169,0,MODE_EMA,PRICE_CLOSE,1);
   double MedVegas=NormalizeDouble((Ma144_1+Ma169_1)/2,Digits); 
   Fb1=MedVegas-377*Point;     Fb12=MedVegas+377*Point;
   Fb2=MedVegas-233*Point;     Fb11=MedVegas+233*Point;
   Fb3=MedVegas-144*Point;     Fb10=MedVegas+144*Point;
   Fb4=MedVegas-89*Point;      Fb9=MedVegas+89*Point;
   Fb5=MedVegas-55*Point;      Fb8=MedVegas+55*Point;
   Fb6=MedVegas-34*Point;      Fb7=MedVegas+34*Point;
   if(Low[1]>Fb12)                                newSL_B=Fb12-100*Point;
   if(Low[1]<=Fb12 && Low[1]>(Fb12+Fb11)/2)       newSL_B=(Fb12+Fb11)/2;
   if(Low[1]<=(Fb12+Fb11)/2 && Low[1]>Fb11)       newSL_B=Fb11;
   if(Low[1]<=Fb11 && Low[1]>(Fb11+Fb10)/2)       newSL_B=(Fb11+Fb10)/2;
   if(Low[1]<=(Fb10+Fb11)/2 && Low[1]>Fb10)       newSL_B=Fb10;
   if(Low[1]<=Fb10 && Low[1]>(Fb10+Fb9)/2)        newSL_B=Fb9;
   if(Low[1]<=(Fb10+Fb9)/2 && Low[1]>Fb9)         newSL_B=Fb8;
   if(Low[1]<=Fb9  && Low[1]>Fb8)                 newSL_B=Fb7;
   if(Low[1]<=Fb8  && Low[1]>Fb7)                 newSL_B=(Fb7+MedVegas)/2;
   if(Low[1]<=Fb7  && Low[1]>MedVegas)            newSL_B=Fb6;
   if(Low[1]<=MedVegas && Low[1]>(MedVegas+Fb6)/2)newSL_B=Fb6;
   if(Low[1]<=(MedVegas+Fb6)/2 && Low[1]>Fb6)     newSL_B=Fb5;
   if(Low[1]<=Fb6  && Low[1]>Fb5)                 newSL_B=Fb4;
   if(Low[1]<=Fb5  && Low[1]>Fb4)                 newSL_B=(Fb3+Fb4)/2;
   if(Low[1]<=Fb4  && Low[1]>Fb3)                 newSL_B=Fb3;
   if(Low[1]<=Fb3  && Low[1]>(Fb3+Fb2)/2)         newSL_B=(Fb3+Fb2)/2;
   if(Low[1]<=(Fb3+Fb2)/2  && Low[1]>Fb2)         newSL_B=Fb2;
   if(Low[1]<=Fb2  && Low[1]>(Fb2+Fb1)/2)         newSL_B=(Fb1+Fb2)/2;
   if(Low[1]<=(Fb2+Fb1)/2 && Low[1]>Fb1)          newSL_B=Fb1;
   if(Low[1]<=Fb1)                                newSL_B=Fb1-100*Point;
   }
// ----------------------------------------------------------------------+

O código de comando principal para arrastar as posições é representado como um fragmento de Expert Advisor com a seqüência de ações para a execução das funções acima mencionadas, de acordo com os valores dos preços das barras atuais. Passo a passo para o início do arrasto de posição após uma ordem aberta apropriado foi selecionado.

Um pequeno fragmento de código para arrastar a posição é mostrado abaixo:

//+------------------------------------------------------------------+
//| ABRINDO POSIÇÕES PARA ARRASTAR                                   |
//+------------------------------------------------------------------+
for(int i=OrdersTotal()-1; i>=0; i--)
  {
   if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
     {Print("Order selection error = ",GetLastError());}
   if(OrderSymbol()==Symbol())
     {
      if(OrderType()==OP_BUY)
        {
         if(OrderMagicNumber()==Magic)
           {
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=SL_B*Point && OrderLots()==0.2)Close_B_lot();
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())/Point>=100 && OrderLots()==0.1 && OrderStopLoss()<OrderOpenPrice())
              {
               Print(" 1 - StopLoss shift");
               if(!OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+2*Point,OrderTakeProfit(),0,Aqua))
                 {
                  Print(" at Modif.ord.# ",OrderTicket()," Error # ",GetLastError());
                 }
               return;
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=120*Point && OrderOpenPrice()>Ma144_1-144*Point)
              {
               StoplevelFiboBuy();
               newSL_B=newSL_B+21*Point;
               if((Bid-newSL_B)/Point<StopLevel)newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print("2nd shift of StopLoss ");
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=200*Point && (High[1]-OrderOpenPrice())<=250*Point)
              {
               StoplevelFiboBuy();
               if((Bid-newSL_B)/Point<StopLevel)newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print(" 3rd shift by level order # ",OrderTicket());
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=250*Point && OrderOpenPrice()>Ma144_1-144*Point)
              {
               StoplevelFiboBuy();
               newSL_B=newSL_B+10*Point;
               if((Bid-newSL_B)/Point<StopLevel) newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print(" 4th shift by level order # ",OrderTicket());
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=300*Point && (High[1]-OrderOpenPrice())<=350*Point)
              {
               StoplevelFiboBuy();
               newSL_B=newSL_B+20*Point;
               if((Bid-newSL_B)/Point<StopLevel) newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print(" 5th shift by level order # ",OrderTicket());
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            ...
           }
        }
     }
  }

A seqüência passo a passo de arrasto consiste em 8 passos na versão do Expert Advisor demo anexado.

Abaixo está a tela mostrando os passos de operação do Expert Advisor demo para arrastar a posição Buy. A posição foi aberta devido ao fato de que o modelo "absorção de três candles" foi formado. Além disso, o "martelo invertido" está entre as candles absorvidos. Esse fato reforça a força do sinal para abrir uma posição de compra.


Fig. 6. Exemplo para arrastar uma posição BUY.

Indicador "Vegas" deve ser usado para ver as linhas fibo. Ele pode ser visto no site MQL4: https://www.mql5.com/en/code/7148

Preferência visualizar numa tela "dark":

Fig. 7. Tela do monitor (versão demo para Buy)

Fig. 8. Exemplo para arrastar uma posição Sell

Os parâmetros testados devem ser instalados para exibir o trabalho do Expert Advisors demo, como mostrado na Fig. 9-10:


Fig. 9. Parâmetros testados do Expert Advisor Demo_trail_Buy.mql


Fig. 10. Parâmetros testados do Expert Advisor Demo_trail_Sell.mql

Nota: Os arquivos com Expert Advisors demo estão anexados ao artigo, como mini-robôs para arrastar posições de compra e venda. Posições são abertas em lote duplo aqui. Mas quando Stop Loss é movido para um nível de empate, existe confiança no futuro movimento de preços na direção certa, sendo possível adicionar outra posição.


Conclusão

Exemplos apresentados para arrastar ordens mostram que o método de ordens com stop Loss focado em níveis dinâmicos fibo pode produzir resultados bastantes positivos. O método descrito pode ser recomendado para uso prático na negociação.

Níveis Dynamic Fibo identificando as funções:

  • LevelFiboKgd.mq4
  • StopLevelFiboBuy.mq4
  • StopLevelFiboSell.mq4
  • Arquivos de demonstração:
  • Demo_trail_Buy_v1.mq4 – arquivo demo para Comprar
  • Demo_trail_Sell_v1.mq4 - arquivo demo para Vender


Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/1349

Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.

Outros artigos do autor

Ir para discussão
Métodos de Análise Técnica e Previsão do Mercado Métodos de Análise Técnica e Previsão do Mercado
O artigo demonstra as possibilidades e potencialidades de um método matemático bem conhecido juntamente com o pensamento visual e perspectivas de mercado "fora da caixa". Por um lado, serve para atrair a atenção de um grande público, pois incentiva as mentes criativas a reconsiderarem o paradigma da negociação como tal. Por outro, pode dar origem a desenvolvimentos de alternativas e implementações de códigos a respeito de uma ampla gama de ferramentas de análise e previsão.
Técnica de Teste (Otimização) e Alguns Critérios para Seleção dos Parâmetros do Expert Advisor Técnica de Teste (Otimização) e Alguns Critérios para Seleção dos Parâmetros do Expert Advisor
Não existe problemas para encontrar o Santo Graal nos testes, o mais difícil é livrar-se dele. Este artigo aborda a seleção do parâmetros operacionais do Expert Advisor com o processamento de grupo automatizado da otimização, resultados dos testes quanto a utilização máxima da capacidade de desempenho de terminal e a carga mínima do usuário final.
Análise Fractal dos Movimentos Conjuntos de Moedas Análise Fractal dos Movimentos Conjuntos de Moedas
O quanto independente são as cotações das moedas? São os seus movimentos coordenados ou não? O movimento de uma moeda sugere o movimento de outra? O artigo tenta resolver esta questão usando uma dinâmica não-linear e métodos geométricos fractais.
Econometria do EURUSD - Previsão um passo à frente Econometria do EURUSD - Previsão um passo à frente
O artigo foca na previsão um passo à frente para EURUSD usando o programa EViews e uma avaliação mais profunda dos resultados da previsão usando os programas em EViews. A previsão envolve modelos de regressão e é avaliada por meio de um Expert Advisor desenvolvido para MetaTrader 4.