Negociação pelos níveis de DiNapoli

16 janeiro 2018, 08:25
Dmitriy Zabudskiy
0
1 350

Introdução

Assim como a nossa vida real, o mercado está em constante evolução. Algo que performou perfeitamente ontem, nos mostra resultados desencorajadores hoje. No entanto, existem algumas estratégias fundamentais que enfrentam algumas pequenas correções ao longo do tempo, mas não mudam sua base ideológica. Uma delas é os "níveis de DiNapoli", uma estratégia que recebeu o nome de seu fundador. Representa a execução minimalista da retração de Fibonacci

Pontos iniciais da estratégia - os níveis de Fibonacci são 38.2% e 61.8%. Para os pontos de take profit, é aceito o seguinte: COP (Contracted Objective Point, ponto de objetivo ajustado) — 61.8%, OP (Objective Point, ponto de objetivo) — 100%, XOP (Expanded Objective Point, ponto de objetivo expandido) — 161.8%. Todas as distâncias são especificadas em percentual a partir do tamanho da tendência (ver figura 1).

Fig. 1. "Níveis de DiNapoli" no par de moedas EURUSD H4

Fig. 1. Níveis de DiNapoli no par de moedas EURUSD H4

Na figura 1, os níveis são definidos usando as ferramentas de Fibonacci que fazem parte do pacote padrão da MetaTrader 5 - retrações (na cor vermelha) e expansões (na cor azul) de Fibonacci. Além disso, a figura demonstra como os níveis são configurados. A linha vertical marcada com duas setas mostra o nível de 61.8%, que é retirado da tendência (linha descendente vermelha) e é ajustado para baixo do preço de reversão máximo, formando o nível COP.

Existem quatro variantes para entrar no mercado: "Arbustos", "Bonsai", "Campo minado A" e "Campo minado B". Os dois primeiros são os mais agressivos. A entrada no mercado por eles ocorre na primeira correção. Os dois últimos cenários implicam abrir uma posição na segunda correção. Outras diferenças entre essas variantes estão na colocação do nível de Stop Loss. Esses métodos são detalhados no artigo "Sistema de negociação DiNapoli" portanto, aqui nós não vamos entrar em detalhes.

Na figura fornecida acima, nós queríamos mostrar uma imagem clássica dos níveis de DiNapoli, e dizer os fundamentos da estratégica. Como você vê, a melhor opção para entrar no mercado está no nível de 61.8% (e aqui você pode ver uma marca de preço vermelho), no entanto, esse nível nem sempre é alcançado. Portanto, alguns traders começaram a vender ativamente em 38.2%: isso é evidenciado por uma vela descendente às 20:00. Essas entradas são mais características de uma operação mais agressiva de acordo com o método "Arbustos". Seguindo isso, um trader coloca um stop em um nível mais alto do que aquele, na qual a posição é aberta. O encerramento da operação ocorreu no nível COP (61.8%). Está marcado na figura com a marca de preço azul.

Parece bastante simples, mas na prática os níveis descritos nem sempre são desencadeados devido à variação frequente da tendência. Para determinar a tendência de forma mais definitiva, o autor da estratégia oferece o uso de indicadores além dos níveis: média móvel (MA) e oscilador estocástico. É nesta base que eu proponho desenvolver uma estratégia rentável e implementá-la no Expert Advisor.


Formando uma estratégia nas ferramentas padrão do MetaTrader 5

Uma estratégia de negociação eficaz dos níveis de DiNapoli implica no funcionamento de um conjunto grande de fatores. Portanto, a sua programação é bastante complexa e interessante. Além disso, há dificuldades na organização da negociação: de acordo com esta estratégia, às vezes você tem que aguardar por um longo momento para entrar no mercado. O monitoramento manual contínuo é uma tarefa difícil para um trader, portanto, a automação prevalece nesse tipo de negociação.

Eu vou tentar maximizar, de forma simples e compreensível, a estratégia que servirá de base para o nosso Expert Advisor.

Fig. 2. Os níveis de DiNapoli com indicadores auxiliares EURUSD H4 (tendência ascendente)

Fig. 2. Os níveis de DiNapoli com indicadores auxiliares EURUSD H4 (tendência ascendente)

A Figura 2 mostra o gráfico do par de moedas EURUSD H4. A seguir estão marcados: os níveis de DiNapoli, o indicador Estocástico (8,3,3) e duas médias móveis com um deslocamento de 5 e de períodos iguais a 25 (vermelho) e 7 (azul).

Vamos começar um a um. No gráfico, nós podemos ver uma tendência ascendente com a Grade de Fibonacci superposta sobre ela, com os níveis de 23.6%, 38.2%, 50%, 61.8%. Aqui, existem mais níveis do que com a realização clássica: a prática mostrou que o preço poderia repelir de cada um deles. 

Na recuperação (correção), a expansão de Fibonacci é superposta: esta é a forma como os níveis de COP e OP ocorrem. No entanto, tanto neste caso quanto na estratégia em geral, esses níveis são insignificantes. Aqui, eles são calculados exclusivamente para configurar o Take Profit (depois nós veremos no código).

O resultado líquido é que a entrada é possível em quatro pontos. A figura demonstra que, se for pego logo no início da tendência de reversão e abrindo uma posição no ponto 23.6%, obteremos lucro; No entanto, a redução será muito significativa. Certamente, isso não nos satisfará, então nós continuaremos buscando um ponto de entrada mais confiável. 

  • Regra um: A entrada no nível de DiNapoli é possível de 23.6% a 61.8%. Esta é uma faixa bastante ampla, é por isso que nós devemos proceder para à segunda etapa da análise.

O filtro de sinal seguinte é o indicador Estocástico (com parâmetros 8,3,3) com dois níveis - 30 e 70.

  • Regra dois: compre quando o sinal e as linhas principais do Estocástico estão abaixo do nível de 30; e venda quando estiver acima do nível de 70.

Agora, vamos determinar a tendência. Para fazer isso, use a média móvel (deslocamento 5, período 25). Acontece que a compra é possível quando o preço for maior que a linha de tendência, enquanto a venda é possível quando o mesmo é menor. Mas esta é uma faixa muito ampla e para reduzi-la, vamos apresentar mais uma média móvel (deslocamento 5, período 7). Mas mesmo ao usá-la, o intervalo pode permanecer muito grande. Nesses casos, a redução adicional é introduzida: é permitido abrir negócios apenas na "metade superior" das divergências, mais perto da linha com o período igual a 25.

  • Regra 3: compre na segunda metade do intervalo de tempo, mais perto da linha com o período igual a 25; enquanto que a linha com um menor intervalo de tempo é colocada acima.
  • Regra 4: vende na segunda metade do intervalo de tempo, próximo da linha de período igual a 25; enquanto que a linha com um menor intervalo de tempo é colocada abaixo.

Suponha que as condições acima mencionadas tenham funcionado e nós abrimos uma posição. Agora, vamos providenciar as regras para o encerramento. Para isso, nós usaremos os níveis formados pela expansão de Fibonacci, bem como o indicador Estocástico.

  • Regra 5: encerra a posição se o preço chegar a um dos níveis alvo de DiNapoli (COP, OP, XOP) ou o indicador estocástico dará o sinal de encerramento.

Nas figuras 2 e 3, as áreas que correspondem a essas regras são mostradas em retângulos amarelos.

Fig. 3. Os níveis de DiNapoli com os indicadores auxiliares EURUSD H4 (tendência descendente)

Fig.3. Os níveis de DiNapoli com os indicadores auxiliares EURUSD H4 (tendência descendente)

Como você pode ver, as regras resultantes são lógicas e claras. A colocação do Take Profit ou do Stop Loss e um menor trailing para o deslocamento do stop para o breakeven ainda não foram estipulados neles. Tudo isso será considerado abaixo.


Programando a Estratégia

Os parâmetros de entrada

Primeiro, conecte a classe CTrade (Trade.mqh). Em seguida, estabeleça os parâmetros dos níveis de DiNapoli - nível de entrada mínimo e máximo. Por padrão, eles são definidos como especificado acima: de 23.6% a 61.8%. Mas para diferentes pares de moedas, eles podem variar e estar em limites diferentes.

Os seguintes parâmetros são de Take Profit e Stop Loss. O Stop Loss é colocado por níveis a partir da máxima do preço. Nas figuras 2 e 3, elas são mostradas em vermelho. O Take Profit é colocado a partir do preço de colocação da ordem.

Ou seja, suponha que o nível de compra seja de 50%, o Stop Loss é definido como 70%, Take Profit - para 70%. Isso significa que, se assumir que 100% são 100 pontos, o Stop Loss será menor do que o preço de compra em 20 pontos, enquanto que o Take Profit será de até 70 pontos. Isso deve ser considerado ao otimizar o EA.

Além disso, nós devemos definir o trailing ou o deslocamento para breakeven De acordo com os parâmetros atuais no código, quando o preço passa de 400 pontos, o Stop Loss irá ser deslocado para o lucro em 10 pontos.

O resto dos parâmetros não requer comentários.

//+------------------------------------------------------------------+
//|                                               Dinapoli_v1.01.mq5 |
//|                                                          Aktiniy |
//|                                            https://www.mql5.com/ |
//+------------------------------------------------------------------+
#property copyright "Aktiniy"
#property link      "https://www.mql5.com/"
#property version   "1.01"
#include<Trade\Trade.mqh>
//--- parâmetros de entrada
//--- Fibo number
input double   percent_min_enter=23.6;      // Percentual de entrada mínima
input double   percent_max_enter=61.8;      // Percentual de entrada máxima
input double   percent_for_tp=60;           // Percentual do possível Take Profit
input double   percent_for_sl=70;           // Percentual do possível Stop Loss
input int      trailing_sl=400;             // Desloca para o breakeven ao atingir tal pontuação
input int      trailing_profit=10;          // Nível do breakeven em pontos
//--- ordem
input long     magic_number=65758473787389; // Número Mágico
input double   order_volume=0.01;           // Tamanho do lote
input int      order_deviation=100;         // Desvio na abertura de posição
//--- Estocástico
input int      stochastic_k=8;              // “Período %К" do indicador Estocástico
input int      stochastic_d=3;              // “Slowing" do indicator Estocástico
input int      stochastic_slowing=3;        // “Período %D" do Indicador Estocástico
input double   stochastic_up_level=70;      // “Nível do sinal de cima" do indicador Estocástico
input double   stochastic_down_level=30;    // "Nível do sinal de baixo" do indicador Estocástico
//--- MA RED 25 5
input int      ma_red_period=25;            // “Período" do indicador MA RED
input int      ma_red_shift=5;              // “Deslocamento" do indicador MA RED
//--- MA BLUE 7 5
input int      ma_blue_period=7;            // “Período" indicador MA BLUE
input int      ma_blue_shift=5;             // “Deslocamento" indicador MA BLUE
//--- Variable
CTrade trade;
int stochastic_handle=0;
char answer_stochastic=0;
int ma_red_handle=0;
int ma_blue_handle=0;
char answer_ma=0;
int fractals_handle=0;


Em conclusão, são determinadas as variáveis ​​que armazenam os manipuladores do indicado e as respostas das funções de sinal para elas.

Inicialização

Abaixo está uma pequena função de inicialização. Aqui, nós configuramos a CTrade e recebemos os manipuladores do indicador.

//+------------------------------------------------------------------+
//| Função de inicialização do Expert                                |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   trade.SetExpertMagicNumber(magic_number);
   trade.SetDeviationInPoints(order_deviation);
   trade.SetTypeFilling(ORDER_FILLING_FOK);
   trade.SetAsyncMode(false);

   stochastic_handle=iStochastic(_Symbol,_Period,stochastic_k,stochastic_d,stochastic_slowing,MODE_SMA,STO_LOWHIGH);
   ma_red_handle=iMA(_Symbol,_Period,ma_red_period,ma_red_shift,MODE_SMA,PRICE_CLOSE);
   ma_blue_handle=iMA(_Symbol,_Period,ma_blue_period,ma_blue_shift,MODE_SMA,PRICE_CLOSE);
   fractals_handle=iFractals(_Symbol,_Period);
//---
   return(INIT_SUCCEEDED);
  }


Antes de prosseguir com a função principal, vamos estudar o princípio das funções de sinal.

Obtenção do sinal a partir do estocástico

//+------------------------------------------------------------------+
//| Obtendo o sinal do Estocástico                                   |
//+------------------------------------------------------------------+
void Stochastic(char &answer)                                                                          // 0 - sem sinal; 1 - signal para cima; 2 - sinal para venda
  {
   answer=0;                                                                                           // resposta
   double stochastic_line_main[3];
   double stochastic_line_signal[3];
   int line_main=CopyBuffer(stochastic_handle,0,0,3,stochastic_line_main);
   int line_signal=CopyBuffer(stochastic_handle,1,0,3,stochastic_line_signal);
   if(line_main!=3 || line_signal!=3)
     {Alert("Error of copy iStochastic: main line=",line_main,", signal line=",line_signal);}          // checking copied data Stochastic

   if(stochastic_line_main[1]>stochastic_up_level && stochastic_line_signal[1]>stochastic_up_level)
     {answer=2;}                                                                                       // venda benéfica
   if(stochastic_line_main[1]<stochastic_down_level && stochastic_line_signal[1]<stochastic_down_level)
     {answer=1;}                                                                                       // compra benéfica
  }


Isso é, em última instância, simples: os três últimos valores do indicador são copiados, o último deles é comparado com os níveis predefinidos nas configurações. A função passa a resposta em uma variável.

Obtendo o sinal dos indicadores de MA

//+------------------------------------------------------------------+
//| Obtendo o sinal dos indicadores de MA                            |
//+------------------------------------------------------------------+
void MA(char &answer,                                               // 0 - sem sinal; 1 - sinal para cima; 2 - sinal para venda
        double &line_blue,
        double &line_red,
        double ask,
        double bid)
  {
   answer=0;                                                        // resposta
   double ma_red[3];
   double ma_blue[3];
   int red=CopyBuffer(ma_red_handle,0,0,3,ma_red);
   int blue=CopyBuffer(ma_blue_handle,0,0,3,ma_blue);
   if(red!=3 || blue!=3)
     {Alert("Error of copy iMA: MA red=",red,", MA blue=",blue);}   // check copied data MA red and blue

   line_blue=ma_blue[2];
   line_red=ma_red[2];

   if(ma_blue[2]>ma_red[2])                                         // supostamente a tendência é direcionada para cima
      if(ask<ma_blue[2])                                            // supostamente o preço está em posição de reversão
         if(ask>ma_red[2])
           {answer=1;}                                              // possível movimento repentino de tendência para cima

   if(ma_blue[2]<ma_red[2])                                         // supostamente a tendência é direcionada para baixo
      if(bid>ma_blue[2])                                            // supostamente o preço está em posição de reversão
         if(bid<ma_red[2])
           {answer=2;}                                              // possível movimento repentino de tendência para baixo
  }


Aqui, os três últimos valores também são copiados para os buffers; então, a título de comparação, é definido se o preço está entre as duas linhas do indicador. Anteriormente, nós discutimos que, muitas vezes, o intervalo dentro do qual a negociação é possível, deve ser reduzida. É devido a esta razão que a função passa não apenas a resposta, mas também os últimos valores das duas médias móveis. O mecanismo de estreitamento do intervalo de negociação será considerado mais tarde.

Recebendo os dados do indicador Fractals

A função do estabelecimento do tamanho da tendência é mais complexa. É implementado em cima dos dados do Fractals. No início da função, são copiados os 100 últimos dados, então o controle dos sinais para cima e baixo é realizado em dois ciclos. Aqui, um teste de disponibilidade dos fractais é realizado: todos os valores acima de 10000 são filtrados, então os vizinhos são comparados procurando-se o primeiro fractal maior e o menor desde o final.

//+------------------------------------------------------------------+
//| Recebendo os dados do indicador Fractals                         |
//+------------------------------------------------------------------+
void Fractals(double &price_up,
              double &price_down)
  {
   price_up=0;
   price_down=0;
   double fractals_up[100];
   double fractals_down[100];
   int up=CopyBuffer(fractals_handle,0,0,100,fractals_up);
   int down=CopyBuffer(fractals_handle,1,0,100,fractals_down);
   if(up!=100 || down!=100)
     {Alert("Error of copy iFractals: Fractals up=",up,", Fractals down=",down);} // verifica os dados copiados Fractals para cima e para baixo

   double price_high=0;
   double price_low=0;

   for(int x=99; x>0; x--)                                                        // ciclo para o fractal altista
     {
      if(fractals_up[x]<10000)                                                    // verifica a disponibilidade do fractal
        {
         if(price_high==0){price_high=fractals_up[x];}                            // check-up inicial
         if(price_high>fractals_up[x]){break;}                                    // se os fractais estão indo para baixo, para o ciclo
         else{price_high=fractals_up[x];}                                         // se os fractais estão indo para cima, copia
        }
     }

   for(int x=99; x>0; x--)                                                        // ciclo de repetição para o fractal baixista
     {
      if(fractals_down[x]<10000)                                                  // verificando a disponibilidade do fractal
        {
         if(price_low==0){price_low=fractals_down[x];}                            // check-up inicial
         if(price_low<fractals_down[x]){break;}                                   // se os fractals estão indo para cima, para o ciclo
         else{price_low=fractals_down[x];}                                        // se os fractals estão indo para baixo, copia
        }
     }

   double price_ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);                         // solicitação do preço de compra
   double price_bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);                         // solicitação de preço de venda

   if(price_high>price_ask && price_high>price_bid)                               // verificar se os preços de ask e bid estão entre o preço altista e baixista
      if(price_low<price_ask && price_low<price_bid)
        {
         price_up=price_high;                                                     // atribuindo valores na resposta
         price_down=price_low;
        }
  }
//+------------------------------------------------------------------+


Para garantir que o sinal seja confiável, antes da resposta, verifique se o preço está dentro da faixa encontrada. Isso é feito porque o último e provavelmente o fractal chave é formado após a criação das duas últimas velas (de acordo com as regras de formação fractal).

Cálculo do preço de abertura de posição

A função mais importante é responsável pelo cálculo dos níveis de DiNapoli. São passados ​​para ele O preço da máxima e mínima recebido anteriormente, bem como os dados sobre a direção da suposta tendência e os últimos valores das médias móveis. Em primeiro lugar, todas as distâncias obtidas são transformadas em pontos. Logo, as seções são calculadas com base no percentual estabelecido nos parâmetros de entrada. As seções são fracionárias, portanto, nós vamos normaliza-las.

//+------------------------------------------------------------------+
//| Cálculo do preço de abertura de posição                          |
//+------------------------------------------------------------------+
void Price_for_order(double high_price,
                     double low_price,
                     double &p_enter_min,
                     double &p_enter_max,
                     double &p_tp,
                     double &p_sl,
                     char trend,                                      // 1 - acima; 2 - abaixo
                     double blue_line,
                     double red_line
                     )
  {
   double point_price=(high_price-low_price);
   double point_enter_min=point_price*percent_min_enter/100;
   double point_enter_max=point_price*percent_max_enter/100;
   double point_tp=point_price*percent_for_tp/100;
   double point_sl=point_price*percent_for_sl/100;
   double point_ma_line=MathAbs(blue_line-red_line)/2;

   point_enter_min=NormalizeDouble(point_enter_min,_Digits);
   point_enter_max=NormalizeDouble(point_enter_max,_Digits);
   point_ma_line=NormalizeDouble(point_ma_line,_Digits);

   point_tp=NormalizeDouble(point_tp,_Digits);
   point_sl=NormalizeDouble(point_sl,_Digits);

   if(trend==1)                                                       // acima
     {
      p_enter_min=high_price-point_enter_min;
      double p_ma_min=red_line+point_ma_line;
      if(p_enter_min>p_ma_min)
        {p_enter_min=p_ma_min;}
      p_enter_max=high_price-point_enter_max;
      if(p_enter_max>p_enter_min)
        {p_enter_max=red_line;}

      p_tp=p_enter_min+point_tp;
      p_sl=high_price-point_sl;
     }

   if(trend==2)                                                       // abaixo
     {
      p_enter_min=low_price+point_enter_min;
      double p_ma_min=red_line-point_ma_line;
      if(p_enter_min<p_ma_min)
        {p_enter_min=p_ma_min;}
      p_enter_max=low_price+point_enter_max;
      if(p_enter_max<p_enter_min)
        {p_enter_max=red_line;}

      p_tp=p_enter_min-point_tp;
      p_sl=low_price+point_sl;
     }
  }


Além disso, dependendo da direção da tendência, os preços são calculados e a função retorna a resposta.

Modificação e encerramento da posição

Primeiro, obtenha todos os dados da última posição. Além disso, dependendo do tipo da ordem, ela é atualizada (deslocar para o breakeven) ou encerrada, se o Estocástico fornecer um sinal oposto.

//+------------------------------------------------------------------+
//| Modificação e encerramento da posição                            |
//+------------------------------------------------------------------+
void Position_mod(double ask,
                  double bid,
                  int point,
                  int profit,
                  char stochastic)
  {
   double price=trade.RequestPrice();
   double tp=trade.RequestTP();
   double sl=trade.RequestSL();
   double sl_point=point*_Point;
   double sl_profit=profit*_Point;
   double tp_point=(MathAbs(tp-price))/2;

   if(trade.RequestType()==ORDER_TYPE_BUY)              // ordem de compra
     {
      if(sl<price && bid>(price+sl_point))
        {
         sl_profit=sl_profit+price;
         trade.PositionModify(_Symbol,sl_profit,tp);
        }
      if(stochastic==2)                                 // movimento de baixa é esperado
        {
         trade.PositionClose(_Symbol,order_deviation);
        }
     }
   if(trade.RequestType()==ORDER_TYPE_SELL)             // ordem de venda
     {
      if(sl>price && ask<(price-sl_point))
        {
         sl_profit=sl_profit-price;
         trade.PositionModify(_Symbol,sl_profit,tp);
        }
      if(stochastic==1)                                 // movimento de alta é esperado
        {
         trade.PositionClose(_Symbol,order_deviation);
        }

     }
  }


Função de consolidação

A última função consolida todas as funções consideradas anteriormente. No início, todas as variáveis ​​de reconciliação são declaradas. Então, através das funções do indicador, são recebidos os principais valores atuais das "regras da estratégia de alta". Além disso, a divisão ocorre de acordo com as respostas recebidas sobre "regras para o movimento altista". O tamanho da tendência e os preços que fornecem a entrada no mercado são calculados. Se as posições abertas anteriormente não forem descobertas e o preço estiver dentro do intervalo calculado, a posição será aberta.

//+------------------------------------------------------------------+
//| Função tick do Expert                                            |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   double price_high=0;                                           // Máxima do preço para o cálculo dos fractais
   double price_low=0;                                            // Mínima do preço para o cálculo dos fractais

   double price_enter_min=0;                                      // Mínima do preço de entrada
   double price_enter_max=0;                                      // Máxima do preço de entrada
   double price_tp=0;                                             // Nível de Take Profit
   double price_sl=0;                                             // Nível de Stop Loss

   double price_ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);         // solicitação do preço de compra
   double price_bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);         // solicitação do preço de venda

   double ma_blue_line=0;                                         // valor de МА BLUE de período pequeno
   double ma_red_line=0;                                          // valor de МА RED de período grande

   Stochastic(answer_stochastic);
   MA(answer_ma,ma_blue_line,ma_red_line,price_ask,price_bid);

   if(answer_stochastic==1)                                       // movimento de alta é esperado
     {
      if(answer_ma==1)                                            // nós estamos na faixa de operação de compra 
        {
         Fractals(price_high,price_low);
         Price_for_order(price_high,price_low,price_enter_min,price_enter_max,price_tp,price_sl,1,ma_blue_line,ma_red_line);

         if(price_ask<price_enter_min && price_ask>price_enter_max)
           {
            if(PositionsTotal()==0)
              {
               trade.Buy(order_volume,_Symbol,price_ask,price_sl,price_tp,"Buy");
              }
           }
        }
     }

   if(answer_stochastic==2)                                        // nós estamos na faixa de operação de venda 
     {
      if(answer_ma==2)                                             // movimento de baixa é esperado
        {
         Fractals(price_high,price_low);
         Price_for_order(price_high,price_low,price_enter_min,price_enter_max,price_tp,price_sl,2,ma_blue_line,ma_red_line);

         if(price_bid>price_enter_min && price_bid<price_enter_max)
            if(PositionsTotal()==0)
              {
               trade.Sell(order_volume,_Symbol,price_bid,price_sl,price_tp,"Sell");
              }
        }
     }

   if(PositionsTotal()!=0)
     {
      Position_mod(price_ask,price_bid,trailing_sl,trailing_profit,answer_stochastic);
     }

  }


No caso, se as posições abertas já estiverem disponíveis, chama a função de atualização/exclusão da posição. Este é o fim do código. Agora, é hora de testar o Expert Advisor.


Resultados do teste

O Expert Advisor Dinapoli_v1.01 foi testado em vários pares de moedas, no tempo gráfico H4. Utilizamos o histórico de 01.01.2017 até 12.11.2017.

Símbolo: EURUSD

Parâmetros:

percent_min_enter=33.6 magic_number=65758473787389 stochastic_up_level=70
percent_max_enter=56 order_volume=0.01 stochastic_down_level=30
percent_for_tp=145 order_deviation=100 ma_red_period=25
percent_for_sl=100 stochastic_k=8 ma_red_shift=5
trailing_sl=675 stochastic_d=3 ma_blue_period=7
trailing_profit=40 stochastic_slowing=3 ma_blue_shift=5



Fig.4. Resultados do teste no EURUSD H4 (01.01.2017 - 12.11.2017)

Símbolo: GBPUSD

Parâmetros:

percent_min_enter=23.6 magic_number=65758473787389 stochastic_up_level=90
percent_max_enter=50 order_volume=0.01 stochastic_down_level=30
percent_for_tp=335 order_deviation=100 ma_red_period=15
percent_for_sl=63 stochastic_k=3 ma_red_shift=5
trailing_sl=425 stochastic_d=1 ma_blue_period=4
trailing_profit=20 stochastic_slowing=4 ma_blue_shift=5



Fig. 5. Resultado do teste no GBPUSD H4 (01.01.2017 - 12.11.2017)

Símbolo: NZDUSD

Parâmetros:

percent_min_enter=31.6 magic_number=65758473787389 stochastic_up_level=60
percent_max_enter=88 order_volume=0.01 stochastic_down_level=30
percent_for_tp=45 order_deviation=100 ma_red_period=24
percent_for_sl=95 stochastic_k=10 ma_red_shift=5
trailing_sl=550 stochastic_d=2 ma_blue_period=4
trailing_profit=100 stochastic_slowing=1 ma_blue_shift=5



Fig. 6. Resultado do teste no NZDUSD H4 (01.01.2017 - 12.11.2017)

Símbolo: USDCAD

Parâmetros:

percent_min_enter=23.6 magic_number=65758473787389 stochastic_up_level=60
percent_max_enter=73 order_volume=0.01 stochastic_down_level=20
percent_for_tp=315 order_deviation=100 ma_red_period=25
percent_for_sl=69 stochastic_k=10 ma_red_shift=5
trailing_sl=325 stochastic_d=1 ma_blue_period=3
trailing_profit=10 stochastic_slowing=1 ma_blue_shift=5



Fig. 7. Resultado do teste no USDCAD H4 (01.01.2017 - 12.11.2017)

Símbolo: USDCHF

Parâmetros:

percent_min_enter=49.6 magic_number=65758473787389 stochastic_up_level=70
percent_max_enter=69 order_volume=0.01 stochastic_down_level=40
percent_for_tp=55 order_deviation=100 ma_red_period=20
percent_for_sl=98 stochastic_k=13 ma_red_shift=5
trailing_sl=900 stochastic_d=6 ma_blue_period=12
trailing_profit=40 stochastic_slowing=3 ma_blue_shift=5



Fig. 8. Resultado do teste no USDCHF H4 (01.01.2017 - 12.11.2017)

Símbolo: USDJPY

Parâmetros:

percent_min_enter=23.6 magic_number=65758473787389 stochastic_up_level=60
percent_max_enter=50 order_volume=0.01 stochastic_down_level=20
percent_for_tp=295 order_deviation=100 ma_red_period=22
percent_for_sl=53 stochastic_k=3 ma_red_shift=5
trailing_sl=750 stochastic_d=1 ma_blue_period=5
trailing_profit=10 stochastic_slowing=1 ma_blue_shift=5



Fig.9. Resultado do teste no USDJPY H4 (01.01.2017 - 12.11.2017)

Símbolo: AUDUSD

Parâmetros:

percent_min_enter=23.6 magic_number=65758473787389 stochastic_up_level=80
percent_max_enter=81 order_volume=0.01 stochastic_down_level=40
percent_for_tp=305 order_deviation=100 ma_red_period=13
percent_for_sl=69 stochastic_k=3 ma_red_shift=5
trailing_sl=250 stochastic_d=4 ma_blue_period=1
trailing_profit=20 stochastic_slowing=4 ma_blue_shift=5



Fig.10. Resultado do teste no AUDUSD H4 (01.01.2017 - 12.11.2017)

A análise dos resultados obtidos demonstra alguma instabilidade nas entradas. Para todos os símbolos, exceto o USHCHF, observa-se uma linha reta quase que horizontal.

A razão para isso é a seguinte: para reduzir o rebaixamento do saldo, a estratégia implica a colocação de Stop Loss o mais próximo possível. Mas, de tal maneira, é necessário que a qualidade do sinal seja aumentada. Respectivamente, quanto melhor a qualidade do sinal de alta, menos entradas no mercado vão ocorrer, mas, ao mesmo tempo, o aumento do preço no gráfico fica mais estável (por exemplo, no símbolo USDCHF). No entanto, na prática, nós planejamos receber o maior lucro possível. Nós devemos certificar-se de que o Exper Advisor irá minimizar de forma constante as perdas em situações de mercado complexas.

Assim, na otimização e teste, você deve confiar em resultados com uma grande quantidade de entradas, mostradas em um longo período de tempo.

Símbolo: XAUUSD

Depois que o Expert Advisor foi testado em todos os pares de moedas populares, seria bom descobrir como ele se comportará no mercado de commodities. Portanto, eu testei no XAUUSD (futuros para o ouro em USD) e aqui está o resultado:

Parâmetros:

percent_min_enter=23.6 magic_number=65758473787389 stochastic_up_level=90
percent_max_enter=50 order_volume=0.2 stochastic_down_level=10
percent_for_tp=255 order_deviation=100 ma_red_period=23
percent_for_sl=80 stochastic_k=3 ma_red_shift=5
trailing_sl=750 stochastic_d=1 ma_blue_period=6
trailing_profit=10 stochastic_slowing=1 ma_blue_shift=5




Fig.11. Resultado do teste no XAUUSD H4 (01.01.2017 - 12.11.2017)

O resultado no ouro é interessante: as entradas calculadas do Expert Advisor com precisão de 83.3% (negócios rentáveis) e lucro constituído de 461%, com rebaixamento não inferior a 40%. Isso significa que o lucro prevaleceu por 10 vezes sobre o rebaixamento. É um índice bastante interessante, mas devido a um pequeno número de negócios (existem 18 negócios no total), não podemos fazer conclusões sérias com base nos testes realizados.


Desvantagens da estratégia de negociação

Como qualquer outro, o Expert Advisor que nós desenvolvemos possui suas desvantagens.

Fig.12. Expert Advisor em tendência (NZDUSD H4)

Fig.12. Expert Advisor em tendência (NZDUSD H4)

A Figura 12 demonstra como o Expert Advisor se comporta em um determinado canal. Tudo parece bastante estável, mas há a principal desvantagem que é óbvia: saída antecipada dos negócios.

Fig.13. Expert Advisor em mercado lateralizado (EURUSD H4)

Fig.13. Expert Advisor em mercado lateralizado (EURUSD H4)

E outro "gargalo": O Expert Advisor não funciona bem em mercado lateralizado. A Figura 13 demonstra que, a esse preço, o lucro do movimento não é grande; Também as entradas são calculadas não muito corretamente.

Tabela de resultados

SímboloTradesNegociações com lucro (%)Lucro líquido total, $ Max. Rebaixamento do saldo em %Retorno esperado, $PFRFSharpe
AUDUSD4116 (39.0%)49.9411.81.222.262.800.19
EURUSD5228 (53.8%)124.7917.72.402.234.010.28
GBPUSD4017 (42.5%)126.3919.03.164.845.020.24
NZDUSD13151 (38.9%)111.6311.90.852.255.290.26
USDCAD23145 (19.4%)85.7128.70.371.921.930.12
USDCHF1714 (82.3%)77.114.34.547.167.240.94
USDJPY21045 (21.4%)50.8852.30.241.350.960.07
XAUUSD1815 (83.3%)461.995.1
25.679.009.880.47

A partir da tabela, você pode ver que os resultados estão variando, embora as tendências comuns entre diferentes pares sejam visíveis. Com as mesmas configurações, alguns pares obtiveram lucro (embora moderado). Conclusão: para aumentar o lucro, você deve otimizar completamente as configurações do Expert Advisor para cada par de moedas. 

Conclusão

Por outro lado, nós nos certificamos de que a "velha escola" dos traders criou bases poderosas por muito tempo. A estratégia de negociação com os nível de DiNapoli provou ser altamente perspectiva; e, além disso, eu planejo continuar com o seu desenvolvimento. Hoje, ela tem suas desvantagens: por exemplo, no mercado lateralizado, o Expert Advisor foi bastante ruim. Além disso, o preço nem sempre atinge a linha COP; e sobretudo, as posições são efetivamente fechadas após o estocástico.

As vantagens do Expert Advisor desenvolvido incluem entradas suficientemente agressivas, o que é particularmente evidente na figura 13. O Expert Advisor atua estritamente de acordo com o algoritmo nas situações em que, manualmente, um trader, provavelmente, não abriria uma posição. Mas, como resultado, o lucro é alcançado e a redução é insignificante.

Arquivos anexados

# Nome Tipo Descrição
1 Dinapoli_v1.01.mq5 Expert Advisor Expert Advisor, que implementa a estratégia de usar os níveis de DiNapoli e indicadores auxiliares
2 AUDUSDH4.set Arquivo de configurações do Expert Advisor Configurações usadas no teste e otimização para o símbolo AUDUSD Н4
3 EURUSDH4.set Arquivo de configurações do Expert Advisor Configurações usadas no teste e otimização para o símbolo EURUSD H4
4 GBPUSDH4.set Arquivo de configurações do Expert Advisor Configurações usadas no teste e otimização para símbolo GBPUSD H4
5 NZDUSDH4.set Arquivo de configurações do Expert Advisor Configurações usadas no teste e otimização para o símbolo NZDUSD H4
6 USDCADH4.set Arquivo de configurações do Expert Advisor Configurações usadas no teste e otimização para o símbolo USDCAD H4
7 USDCHFH4.set Arquivo de configurações do Expert Advisor Configurações usadas no teste e otimização para o símbolo USDCHF H4
8 USDJPYH4.set Arquivo de configurações do Expert Advisor Configurações usadas no teste e otimização para o símbolo USDJPY H4
9 XAUUSDH4.set Arquivo de configurações do Expert Advisor Configurações usadas no teste e otimização para o símbolo XAUUSD H4

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

Arquivos anexados |
Dinapoli_v1.01.mq5 (29.64 KB)
AUDUSDH4.set (1.3 KB)
EURUSDH4.set (1.36 KB)
GBPUSDH4.set (1.3 KB)
NZDUSDH4.set (1.3 KB)
USDCADH4.set (1.3 KB)
USDCHFH4.set (1.3 KB)
USDJPYH4.set (1.3 KB)
XAUUSDH4.set (1.3 KB)
Negociação noturna na sessão asiática: como continuar tendo lucro Negociação noturna na sessão asiática: como continuar tendo lucro

O artigo discute o conceito de negociação em horário noturno, estratégias de trading e sua implementação em MQL5. É realizado um teste e são feitas conclusões.

Indicador NRTR e módulos de negociação baseados nele para o Assistente MQL5 Indicador NRTR e módulos de negociação baseados nele para o Assistente MQL5

Este artigo descreve o indicador NRTR e módulos de negociação criados com sua ajuda. Para estes fins, é criado um módulo de sinais de negociação que permite criar estratégias baseadas nas combinações do NRTR e indicadores adicionais que confirmam a tendência.

Estratégia de negociação "Momentum Pinball" Estratégia de negociação "Momentum Pinball"

Neste artigo, continuamos a falar sobre a programação das estratégias de negociação descritas no livro de L. Raschke e L. Connors "Street Smarts: High Probability Short-Term Trading Strategies, devoted to testing of range limits by price". Desta vez, estudamos o sistema "Momentum Pinball": é descrita a criação de dois indicadores, um robô de negociação e um bloco de sinal com base nele.

Avaliação do risco numa sequência de trades com um ativo. Continuação Avaliação do risco numa sequência de trades com um ativo. Continuação

O artigo desenvolve as idéias propostas, na seção anterior, e continua a examiná-las. Além disso, discute questões sobre a alocação da rentabilidade, a construção e o estudo de padrões estatísticos.