Negociação noturna na sessão asiática: como continuar tendo lucro

MetaTrader 5 — Negociação | 12 janeiro 2018, 12:20

15 523

Introdução

Muitos têm se deparado repetidamente com o conceito de negociação noturna. A primeira coisa que vem à mente, ao ouvir essa palavra, é que o trading é realizado à noite. A noite cai em momentos diferentes, em diferentes partes do mundo, devido à diferença de fusos horários. Os pregões europeus e americanos têm lugar nos fusos horários -4 e +1 em relação ao Tempo Universal Coordenado (UTC), respectivamente.

Mais tarde, os mercados da Ásia e do Pacífico, cujo fuso horário é oposto ao americano e europeu, começam a trabalhar. Aqui a negociação começa quando os traders norte-americanos vão para casa e os europeus vão dormir. Eis a negociação noturna que nós conhecemos. Os períodos dos pregões podem ser representados no mapa do mundo pela figura 1 (o tempo passa da direita para a esquerda):

Fig. 1. Pregões no mapa-múndi

A partir do exposto, conclui-se que a negociação durante a noite ocorre, basicamente, em fase de correção nos pares: EUR/USD, GBP/USD, USD/CHF, USD/CAD, EUR/GBP, no entanto, mostra uma atividade considerável nos pares: USD/JPY, GBP/JPY, AUD/JPY. Naturalmente, não há nenhuma garantia de que vai ser assim todos os dias. Tendo em vista o que já dissemos, diferentes estratégias em horário noturno podem ser usadas com cada par de moedas.

Estratégia de negociação durante a noite

Basicamente, todas as estratégias no mercado Forex podem ser divididas em tendência e laterais. A primeira focada na busca de sinais de mudança do mercado. Principalmente, trata-se do rompimento de canais horizontais ou do pulo a partir de canais "touro" ou "urso". A estratégia lateral se concentra no salto na faixa do canal horizontal. Os mercados laterais e de tendência podem apresentar diferente volatilidade. Muitas vezes, ela se forma quando são publicadas notícias macroeconômicas relevantes. Na prática, embora uma volatilidade grande seja caraterística dos movimentos de tendência, há exceções. Para analisar sinais de tendência e de movimentos laterais, podem ser aplicados os mesmos indicadores, mas, interpretados de forma diferente.

Tomemos o popular EUR/USD. Geralmente, durante a sessão asiática, esse par de moedas começa a diminuir a volatilidade e se mover lateralmente. Nesta etapa, a correção pode ser tão pequena que pode ser considerada um movimento horizontal.

Fig. 2. Movimento de correção, na sessão asiática, no par EUR/USD

Na Fig. 2, o movimento do par EUR/USD, no timeframe H1, durante a sessão asiática é destacado por retângulos amarelos. No primeiro retângulo (à esquerda), pode ser vista uma pequena flutuação dentro do canal. No início da sessão, ocorre um movimento segundo a tendência previamente estabelecida, logo, uma pequena correção (no meio da sessão) e, no final, um retorno brusco. No segundo retângulo, aparece um lento movimento ascendente que, neste caso, repete o movimento do final do dia. No terceiro, a situação mudou um pouco. Ao contrário de sessões anteriores, a tendência diária ajusta o movimento inicial, durante a noite.

Em todos os casos descritos, no período da sessão asiática, podem ser vistos pequenos movimentos na faixa de preço, como uma espécie de "incerteza" do mercado. Um movimento desse tipo pode ser interpretado como lateral.

Nos retângulos amarelos, podem ser vistas as bordas superior e inferior. Elas limitam o canal em que o preço oscila. A pesar de, no gráfico formado, ser fácil traçar o contorno do canal, a direção do preço é conhecida, em tempo real. Aqui, a volatilidade suscita grandes questões. O que fazer?

Proponho resolver este problema com a ajuda do indicador de tendência Bollinger Bands, ele dá bons sinais na fase de correção.

Fig. 3. Uso do indicador Bollinger Bands, no par EUR/USD M30

Na Fig. 3, é apresentado o gráfico do par EUR/USD no timeframe М30. Nele é plotado o indicador Bollinger Bands, o período é o mais baixo possível (10), as outras configurações são por padrão. Aqui, pode-se ver que o preço se introduz no chamado canal dinâmico criado pelo indicador. No entanto, este canal emite sinais pouco precisos. Por exemplo, no primeiro retângulo, o preço se move para baixo, e o canal repete seu movimento. Além disso, o preço não se afasta da borda inferior do canal. Porém, no final da sessão asiática, tudo muda. O mercado começa a se a apartar dos limitadores de canais criados. No segundo retângulo, a atividade do indicador é observada apenas no final. No terceiro retângulo, a situação é semelhante com a primeira.

A partir desta observação, segue-se que, durante três sessões consecutivas, são formados sinais precisos apenas no final do pregão. Ou seja, é visto um certo padrão, e com base nele é possível tentar construir uma estratégia.

Agora, consideremos outra estratégia baseada numa volatilidade acentuada. Para a sessão asiática, serão pares com iene japonês. Esta estratégia é amplamente descrita na rede. Seu princípio consiste em entrar no mercado no ponto mais volátil, num possível movimento brusco em certa direção. Duas ordens pendentes são posicionadas simultaneamente em direções opostas, a distâncias iguais, com os mesmos parâmetros, em cima do preço atual (para venda) e em baixo (para compra). A hora de colocação destas ordens se encontra, como regra, na segunda metade da sessão asiática (há exceções).

Assim, na Fig. 4, é apresentado o gráfico do par USD/JPY, no timeframe H1:

Fig. 4. Sessão asiática no par USD/JPY H1

Consideremos as áreas da sessão asiática em mais detalhes:

Fig. 5. Áreas da sessão asiática, par USD/JPY H1

Na Fig. 5, pontos potenciais de entrada no mercado são marcados com rótulos vermelhos. Todos eles são colocados no preço de abertura da vela. Estes são os momentos em que a estratégia descrita sugere colocar as ordens pendentes.

Agora vamos examinar cada área individualmente. Em todas as quatro áreas, o tempo de abertura é 8h00 GMT (5h00 UTC).

Na parte superior esquerda, a abertura da vela começa no nível de 113.521. Preço mínimo 113.341, máximo 113.553. No total, temos 32 pontos (a partir do preço de abertura) para cima e 180 pontos para baixo.
Na área superior esquerda, a abertura da vela começa no nível de 114.152. Preço mínimo 114.109, máximo (já na hora seguinte) 114.308. No total, temos 156 pontos (a partir do preço de abertura) para cima e 43 para baixo.
A área inferior esquerda é aberta no nível de 113.601. Preço mínimo 113.587, máximo (depois de três horas) 113.747. No total, temos 146 pontos (a partir do preço de abertura) para cima e 14 para baixo.
Última área inferior direito: abertura 113.192, mínimo 112.957, máximo 113.193. No total, 1 ponto para cima, 235 para baixo.

Combinamos tudo numa tabela, para maior clareza:

Tabela 1

№ trecho	Preço de abertura	Preço máximo	Preço mínimo	Pontos máximos	Pontos mínimos
1	113.521	113.553	113.341	180	32
2	114.152	114.308	114.109	156	43
3	113.601	113.747	113.587	146	14
4	113.192	113.193	112.957	235	1
Total	---	---	---	mínimo 146	máximo 43

Como pode ser visto a partir da tabela 1, durante quatro sessões, o mínimo dos movimentos máximos foi 146 pontos, enquanto o máximo dos mínimos, 43 pontos. Arredondamos o valor máximo até ao nível de 140 pontos (para o lado menor) e o valor mínimo até ao nível de 45 pontos (para o lado maior), respectivamente.

Para todas as quatro situações, posicionamos duas ordens pendentes opostas em 50 pontos. Colocamos Stop-Loss em 100-110 pontos, Take-Profit em 50-80 pontos. Lucro será de 200-320 pontos, respectivamente. Ou seja, em todos os quatro casos, obtemos a ativação do Take-Profit.

Mais uma vez obtemos uma estratégia funcional para tirar rendimentos. Resta apenas torná-la código e, assim, testar no histórico, a fim de descobrir se traz lucro ou não.

Codificamos as estratégias

Estratégia com base no indicador Bollinger Bands

Primeiro, conectamos a classe CTrade, para facilitar o gerenciamento de operações. Em seguida, tratamos das variáveis de entrada.

A variável div_work responde pelos saltos bruscos dos preços: ela restringe a faixa limite em que o sinal pode se encontrar.
A variável div_signal é responsável pela distorção do sinal. XXXXXXXXXXX ponto de contato com as bordas superior e inferior do indicador, certa reserva XXXXXXXXXXX. Em outras palavras, o sinal é desencadeado quando o preço sai do limite, na distância desta variável. Isto filtra uma série de sinais falsos.
A variável work_alt é um sinalizador que, após surgir um sinal oposto, permite fechar a posição atual e abrir uma nova.

//+------------------------------------------------------------------+
//|                                        BollingerBandsForFlat.mq5 |
//|                                                          Aktiniy |
//|                                                             BBFF |
//+------------------------------------------------------------------+
#property copyright "Aktiniy"
#property link      "BBFF"
#property version   "1.01"
#include<Trade\Trade.mqh>
//--- input parameters
input char     time_h_start=22;       // Início do horário de negociação
input char     time_h_stop=3;         // Fim do horário de negociação
input int      bands_period=12;       // Período do Bollinger Bands
input int      bands_shift=0;         // Deslocamento do Bollinger Bands
input double   bands_diviation=2;     // Desvio do Bollinger Bands
input double   div_work=3;            // Desvio do sinal
input double   div_signal=5;          // Atenuação do sinal principal
input bool     work_alt=true;         // Trabalho com a posição se houver um sinal oposto
input int      take_profit=50;        // Take Profit
input int      stop_loss=100;         // Stop Loss
//---
input bool     mon=true;              // Trabalho na segunda-feira
input bool     tue=false;             // Trabalho na terça-feira
input bool     wen=true;              // Trabalho na quarta-feira
input bool     thu=true;              // Trabalho na quinta-feira
input bool     fri=true;              // Trabalho na sexta-feira
//---
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 da posição~~
//--- Variable
MqlDateTime time_now_str;
datetime time_now_var;
CTrade trade;
int bb_handle;
double bb_base_line[3];
double bb_upper_line[3];
double bb_lower_line[3];
bool work_day=true;

No código, as outras variáveis de entrada são comentadas o suficiente.

No que diz respeito às variáveis globais, aqui temos:

duas variáveis de tempo iguais (time_now_str, time_now_var) para facilitar o trabalho,
a seguir, o objeto da classe para trabalhar com ordens,
identificador do indicador,
três matrizes pequenas para dados atuais sobre o indicador (bb_base_line[], bb_upper_line[], bb_lower_line[]).
Variável work_day é responsável pela autorização para posicionar ordens de acordo com os dias da semana.

Em seguida, há um pequeno código para inicializar certos parâmetros da classe:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   trade.SetExpertMagicNumber(magic_number);
   trade.SetDeviationInPoints(order_deviation);
   trade.SetTypeFilling(ORDER_FILLING_FOK);
   trade.SetAsyncMode(false);
//---
   return(INIT_SUCCEEDED);
  }

Agora, examinemos o código básico para interação e obtenção de sinais.

Primeiro, obtemos o tempo atual a partir do servidor, em seguida, com ajuda do operador-alternador, verificamos se é permitido colocar ordens hoje, inserimos informações na variável work_day.

Foi assumido que o EA ia funcionar não só na sessão asiática, ou seja, seria universal. Além disso, é possível que o tempo do terminal seja diferente dependendo do servidor. Portanto, é necessário verificar o tempo de funcionamento. Há duas hipóteses, isto é, trabalha-se quer durante o período quer na transição do período diário (através do separador). Inserimos as informações no sinalizador work.

Se o horário de trabalho e o dia selecionado correspondem, é calculado o identificador do identificador, e seus dados são copiados para a matriz declarada anteriormente. Em seguida, ficamos sabendo o preço de compra e venda, pois é de acordo com estes parâmetros que são definidos os sinais de compras e venda. Depois, se, por um lado, não houver posições abertas e, por outro, existir um sinal, colocamos a ordem apropriada.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   time_now_var=TimeCurrent(time_now_str);// hora atual
   bool work=false;
   
      switch(time_now_str.day_of_week)
     {
      case 1: if(mon==false){work_day=false;}
      else {work_day=true;}
      break;
      case 2: if(tue==false){work_day=false;}
      else {work_day=true;}
      break;
      case 3: if(wen==false){work_day=false;}
      else {work_day=true;}
      break;
      case 4: if(thu==false){work_day=false;}
      else {work_day=true;}
      break;
      case 5: if(fri==false){work_day=false;}
      else {work_day=true;}
      break;
     }

//--- verificamos a hora de trabalho     
   if(time_h_start>time_h_stop)             // transição com a transição para o dia seguinte
     {
      if(time_now_str.hour>=time_h_start || time_now_str.hour<=time_h_stop)
        {
         work=true;
        }                                   // transmissão do sinalizador para trabalho
     }
   else                                     // trabalho durante o dia
     {
      if(time_now_str.hour>=time_h_start && time_now_str.hour<=time_h_stop)
        {
         work=true;
        }
     }                                     // transmissão do sinalizador para permissão de rabalho

   int pos=PositionsTotal();

   if(work==true && work_day==true)        // permissão de trabalho recebida
     {
      bb_handle=iBands(_Symbol,_Period,bands_period,bands_shift,bands_diviation,PRICE_CLOSE);         // descobrimos o identificador do indicador Bollinger Bands
      int i_bl=CopyBuffer(bb_handle,0,0,3,bb_base_line);
      int i_ul=CopyBuffer(bb_handle,1,0,3,bb_upper_line);
      int i_ll=CopyBuffer(bb_handle,2,0,3,bb_lower_line);
      if(i_bl==-1 || i_ul==-1 || i_ll==-1)
        {Alert("Error of copy iBands: base line=",i_bl,", upper band=",i_ul,", lower band=",i_ll);}   // verificamos a cópia de dados

      double price_ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
      double price_bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);

      if(pos<1)
        {
         if((price_ask-(div_signal*_Point))>=bb_upper_line[2]-(div_work*_Point) && (price_ask-(div_signal*_Point))<=bb_upper_line[2]+(div_work*_Point))// sinal de venda
           {
            trade.Sell(order_volume,_Symbol,price_bid,(price_bid+(stop_loss*_Point)),(price_bid-(take_profit*_Point)),"pos<1_sell");
           }
         if((price_bid+(div_signal*_Point))<=bb_lower_line[2]+(div_work*_Point) && (price_bid+(div_signal*_Point))>=bb_lower_line[2]-(div_work*_Point))// sinal de compra
           {
            trade.Buy(order_volume,_Symbol,price_ask,(price_ask-(stop_loss*_Point)),(price_ask+(take_profit*_Point)),"pos<1_buy");
           }
        }
      if(pos>0 && work_alt==true)
        {
         if(trade.RequestType()==ORDER_TYPE_BUY)                     // se antes disto havia uma ordem de compra
            if((price_ask-(div_signal*_Point))>=bb_upper_line[2]-(div_work*_Point) && (price_ask-(div_signal*_Point))<=bb_upper_line[2]+(div_work*_Point))// sinal de venda
              {
               trade.PositionClose(_Symbol,order_deviation);
               trade.Sell(order_volume,_Symbol,price_bid,(price_bid+(stop_loss*_Point)),(price_bid-(take_profit*_Point)),"pos>0_sell");
              }
         if(trade.RequestType()==ORDER_TYPE_SELL)                   // se antes disto havia uma ordem de venda
            if((price_bid+(div_signal*_Point))<=bb_lower_line[2]+(div_work*_Point) && (price_bid+(div_signal*_Point))>=bb_lower_line[2]-(div_work*_Point))// sinal de compra
              {
               trade.PositionClose(_Symbol,order_deviation);
               trade.Buy(order_volume,_Symbol,price_ask,(price_ask-(stop_loss*_Point)),(price_ask+(take_profit*_Point)),"pos>0_buy");
              }
        }
     }
   else
     {
      if(pos>0)
        {
         trade.PositionClose(_Symbol,order_deviation);
        }
     }
  }
//+------------------------------------------------------------------+

E o último elemento do código: se a sessão noturna for fechada, todas as ordens serão fechadas. Aqui termina o código do EA.

Estratégia baseada na mudança brusca da volatilidade

Aqui, tudo é muito simples: as ordens são colocadas apenas numa hora determinada order_time. As ordens são colocadas a uma distância order_div, desde o preço atual, com o stop-loss (order_sl) e take-profit (order_tp) correspondentes. Se nenhuma das ordens pendentes for desencadeada, a tendência será lateral, e as ordens serão excluídas após o tempo time_to_del ter terminado(indicado em segundos).

Os outros dados de entrada são os mesmos que no expert anterior.

Aqui são adicionadas as variáveis globais:

work — sinalizador para permitir colocar apenas uma ordem,
work_del — sinalizador para permitir excluir a ordem oposta se uma das ordens for ativada,
work_day — sinalizador para autorizar o trabalho no dia atual.

Além disso, foram adicionados dois layout de resultados, para obter informações e eliminar ordens pendentes.

//+------------------------------------------------------------------+
//|                                                TimeBuyOrSell.mq5 |
//|                                                          Aktiniy |
//|                                                             TBOS |
//+------------------------------------------------------------------+
#property copyright "Aktiniy"
#property link      "TBOS"
#property version   "1.01"
#include<Trade\Trade.mqh>
//--- input parameters
input int      order_time=0;                        // Tempo de abertura da ordem
input int      order_sl=200;                        // Stop Loss
input int      order_tp=180;                        // Take Profit
input int      order_div=120;                       // Desvio na colocação das ordens a partir do preço atual
input int      time_to_del=10800;                   // Hora de remoção da ordens
//---
input bool     mon=true;                            // Trabalho na segunda-feira
input bool     tue=false;                           // Trabalho na terça-feira
input bool     wen=true;                            // Trabalho na quarta-feira
input bool     thu=true;                            // Trabalho na quinta-feira
input bool     fri=true;                            // Trabalho na sexta-feira
//---
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 da posição
//--- Variable
CTrade trade;
MqlDateTime time_now_str;
datetime time_now_var;
bool work=true;
bool work_del=true;
bool work_day=true;
//---
MqlTradeResult result_buy={0};
MqlTradeResult result_sell={0};

Em seguida, vem um pequeno código para inicializar certos parâmetros da classe, idênticos ao usados na anterior.

O início da função OnTick é semelhante ao EA descrito anteriormente. Após obter o sinalizador de trabalho, neste dia, verifica-se se a hora atual corresponde ao trabalho. Se tudo correr bem, calculamos os parâmetros de abertura de ordens (Take Profit, Stop Loss, preço de abertura e hora de remoção, em caso de falha). Enviamos os pedidos de negociação relevantes para o servidor.

Após colocar as ordens pendentes, o EA toma conta da ativação de uma delas e remove as desnecessárias usando o bilhete do layout de resultados(result_buy, result_sell).

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   time_now_var=TimeCurrent(time_now_str);// hora atual

   switch(time_now_str.day_of_week)
     {
      case 1: if(mon==false){work_day=false;}
      else {work_day=true;}
      break;
      case 2: if(tue==false){work_day=false;}
      else {work_day=true;}
      break;
      case 3: if(wen==false){work_day=false;}
      else {work_day=true;}
      break;
      case 4: if(thu==false){work_day=false;}
      else {work_day=true;}
      break;
      case 5: if(fri==false){work_day=false;}
      else {work_day=true;}
      break;
     }

   if(time_now_str.hour==order_time && work==true && work_day==true)
     {
      double price_ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
      double price_bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);

      double div=order_div*_Point;
      double sl=order_sl*_Point;
      double tp=order_tp*_Point;

      double price_buy=price_ask+div;
      double price_sell=price_bid-div;

      double buy_sl=price_buy-sl;
      double buy_tp=price_buy+tp;
      double sell_sl=price_sell+sl;
      double sell_tp=price_sell-tp;

      datetime time_end=time_now_var+time_to_del;     //3600 segundos, uma hora

      trade.BuyStop(order_volume,price_buy,_Symbol,buy_sl,buy_tp,ORDER_TIME_SPECIFIED,time_end,"BuyLimit");
      trade.Result(result_buy);

      trade.SellStop(order_volume,price_sell,_Symbol,sell_sl,sell_tp,ORDER_TIME_SPECIFIED,time_end,"SellLimit");
      trade.Result(result_sell);

      work=false;
     }

   if(PositionsTotal()>0 && work_del==true)
     {
      PositionSelect(_Symbol);
      long position_type=PositionGetInteger(POSITION_TYPE);
      if(position_type==POSITION_TYPE_SELL)
         trade.OrderDelete(result_buy.order);
      if(position_type==POSITION_TYPE_BUY)
         trade.OrderDelete(result_sell.order);

      work_del=false;
     }
   if(PositionsTotal()==0)
      work_del=true;

   if(time_now_str.hour!=order_time)
     {
      work=true;
     }

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

No final do código, é colocado o sinalizador para autorizar a colocação de ordens em vista do tempo de abertura.

Teste e rentabilidade

Estratégia com base no indicador Bollinger Bands

Símbolo: EURUSD
Período: М30 (2017.01.01 - 2017.11.03)
Corretora: Halifax Investment Services Pty Ltd
Moeda: AUD
Depósito inicial: 100.00
Alavancagem: 1:100

Durante a otimização, foram identificados os parâmetros:

Em resumo: o trabalho é na noite, 1-11 (MSC), período do indicador 11, desvio do sinal 12, atenuação do sinal principal 13, Stop Loss=140 e Take Profit=120, trabalho todos os dias da semana, excepto às terças.

Para começar, confiramos os resultados do teste em "OHLC em M1", Fig. 6 e 7:

Fig. 6. Resultados do teste da estratégia baseada no Bollinger Bands no OHLC em M1

Fig. 7. Resultados do teste no gráfico (Bollinger Bands no OHLC em M1)

Resultados do teste nos mesmos três parâmetros, no modo "Cada tick baseado em ticks reais.", Fig. 8 e 9:

Fig. 8. Resultados do teste da estratégia com base no Bollinger Bands, no modo Cada tick baseado em ticks reais

Fig. 9. Resultados do teste no gráfico (Bollinger Bands, no modo Cada tick baseado em ticks reais)

Como pode ser visto a partir dos resultados, há lucro em ambos os casos: o primeiro - 152%, no segundo - 48%, (afeta a qualidade do histórico). Em ambos os testes, o rebaixamento foi inferior a 25%. Eu acho que é um resultado bastante interessante que merece atenção.

Mais cedo, na Fig. 3, nós examinamos três períodos da sessão e descrevemos a estratégia. Agora, consideramos como o expert advisor realizou seu trabalho, nas duas primeiras seções (Fig. 10 e 11):

Fig. 10. Resultado do expert advisor, no primeiro período considerado previamente

Na Fig. 10 (ele é o primeiro período da Fig. 3), pode ser visto como o expert advisor realiza três entradas. A primeira é mal-sucedida e acaba com um stop-loss, em seguida, as restantes - no final da sessão asiática e início da europeia - são fechadas segundo o take-profit.

Fig. 11. Resultado do expert advisor, no segundo período considerado previamente

Na Fig. 11 (ele é o segundo período da Fig. 3) o expert advisor executa duas entradas, isto é, no final da sessão asiática e no início da europeia. Um deles acabou por ser rentável, o segundo, desfavorável. No terceiro período, na Fig. 3, o expert advisor não entrou no mercado. Era terça-feira, e, como configurado, o EA não devia negociar naquele dia.

Agora, vamos ver como a estratégia se manifestará em outros pares importantes:

Símbolo: AUDUSD

Período: M30 (2017.01.01 - 2017.11.07)

Parâmetros:

Fig. 13. Resultados de teste AUDUSD M30 (BollingerBands)

Símbolo: GBPUSD

Período: M30 (2017.01.01 - 2017.11.06)

Parâmetros:

Fig. 14. Resultados de teste GBPUSD M30 (BollingerBands)

Símbolo: NZDUSD

Período: M30 (2017.01.01 - 2017.11.07)

Parâmetros:

Fig.15. Resultados de teste NZDUSD M30 (BollingerBands)

Símbolo: USDCAD

Período: M30 (2017.01.01 - 2017.11.07)

Parâmetros:

Fig.16. Resultados de teste USDCAD M30 (BollingerBands)

Símbolo: USDCHF

Período: M30 (2017.01.01 - 2017.11.07)

Parâmetros:

Fig.17. Resultados de teste USDCHF M30 (BollingerBands)

Observando todos os dados dos testes, podemos tirar as seguintes conclusões.

EURUSD, NZDUSD, AUDUSD são os melhores pares para trabalhar com este EA. Os parâmetros deixam claro que os sinais são processados mais nos pares mencionados anteriormente, onde o Take Profit e Stop Loss diferem por não mais do que três vezes. Naturalmente, aqui, o lucro é mais crescente.
Não há dúvida de que o dia da semana afeta o lucro. Apesar de os pares de moedas se comportarem diferente dependendo do dia da semana, não foi possível encontrar uma única dependência: todo depende tanto do par selecionado quanto das configurações selecionadas.

Estratégia baseada na mudança brusca da volatilidade

São alterados os seguintes parâmetros de teste:

Símbolo: USDJPY
Período: H1 (2017.01.01 - 2017.11.03)

Para começar, verificamos a estratégia delineada acima. Eis seus parâmetros:

order_time=8;
order_sl=140;
order_tp=70;
order_div=50;
time_to_del=18000.

Aqui, aumentamos o stop-loss de 110 para 140, o que é tornou um pouco maior a rentabilidade da estratégia. Os resultados são apresentados nas Fig. 18 e 19, respectivamente:

Fig. 12. Resultado de teste da estratégia de mudança brusca da volatilidade, no par USDJPY, H1

Fig. 18. Resultado de teste da estratégia de mudança brusca da volatilidade, no par USDJPY, H1

Fig. 13. Resultados do teste no gráfico

Fig. 19. Resultados do teste no gráfico USDJPY H1

De acordo com o gráfico, a estratégia começa a funcionar mais ou menos a partir do meio do teste. Mas, no período de testes mais longo (mais ou menos desde 2015), em geral, a estratégia não é rentável. Além disso, de acordo com os parâmetros de entrada é realizada às 8.00 MSC, e, assim, novamente aborda a sessão europeia. Esse tipo de negociação pode ser chamado de matinal.

Desta maneira, o resultado obtido não é de natureza positiva. Fazemos a otimização num período mais amplo, e só durante a "noite".

São alterados os seguintes parâmetros de teste:

Símbolo: USDJPY
Período: H1 (2015.01.01 - 2017.11.03)

Parâmetros de teste:

Ou seja, o expert advisor trabalha apenas na terça-feira, coloca posições às 4, horário de Moscou (sessão asiática), stop-loss e take-profit de 270 e 220 pontos, respectivamente, as ordens são colocadas a 130 pontos do preço de entrada. Os resultados são apresentados nas Fig. 20 e 21:

Fig. 14. Resultado de teste da estratégia de mudança brusca da volatilidade, no par USDJPY, H1 (2015-2017)

Fig. 20. Resultado de teste da estratégia de mudança brusca da volatilidade, no par USDJPY, H1 (2015-2017)

Fig.15. Resultados do teste no gráfico USDJPY H1 (2015-2017)

Fig. 21. Resultados do teste no gráfico USDJPY H1 (2015-2017)

No último teste, nos modos "Cada tick baseado em ticks reais" ou "OHLC em M1", os resultados não mudaram muito, por isso é apresentada a primeira opção (Fig. 20 e 21)

Fim do artigo

Pode-se concluir que é possível negociar de "noite" (sessão asiática) com certo lucro e um rebaixamento relativamente pequeno. A estratégia com base no indicador Bollinger Bands, tanto durante a noite quanto durante o dia, teve um bom comportamento no teste (este artigo só apresenta os resultados da sessão asiática, e mostra uma pequena parte da sessão europeia). No futuro, espero continuar a trabalhar para melhorar esta estratégia, porque acho que é bastante simples e promissora.

Quanto à estratégia baseada na alteração da volatilidade, basta dizer que é bastante simples, mas mostra um desempenho significativamente menor. Porém, pode se usar como um complemento a outras estratégias. Ela também foi testada durante o dia e na sessão europeia, e mostrou bom desempenho. Durante o teste, no período mais longo, ficou esclarecido que ela depende mais dos dias da semana do que a estratégia baseada no Bollinger Bands. O expert advisor resultou redundante, e qualquer possibilidade de melhoramento futuro é mínimo.

Arquivos:

#	Nome	Tipo	Descrição
1	BollingerBandsForFlat_v1.01.mq5	Conselheiro	Expert advisor focado em negociar na sessão asiática, em fase de correção, com base nos sinais do indicador Bollinger Bands
2	TimeBuyOrSell_v1.01.mq5	Conselheiro	Expert advisor focado na negociação, no período de maior volatilidade

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

Arquivos anexados |

Baixar como ZIP

BollingerBandsForFlat_v1.01.mq5 (13.81 KB)

TimeBuyOrSell_v1.01.mq5 (9.09 KB)

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

Negociação pelos níveis de DiNapoli

O artigo considera uma das variantes da implementação prática do Expert Advisor para negociar com os níveis de DiNapoli usando as ferramentas padrão da MQL5. São realizados o teste de desempenho e suas conclusões.

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"

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.

Decompondo as entradas em indicadores

Diferentes situações acontecem na vida do trader. Muitas vezes, tentamos restaurar uma estratégia por meio do histórico de trades bem-sucedidos, no entanto, ao observar o histórico de perdas procuramos aperfeiçoar e melhorá-la. E, de fato, em ambos os casos, comparamos as transações com indicadores conhecidos. Este artigo sugere métodos de comparação de lotes de trades com uma série de indicadores.