MetaTrader 5 / Sistemas de negociação
English Русский 中文 Español Deutsch 日本語
preview
Funcionalidades do Assistente MQL5 que você precisa conhecer (Parte 39): Índice de força relativa

Funcionalidades do Assistente MQL5 que você precisa conhecer (Parte 39): Índice de força relativa

MetaTrader 5 — Sistemas de negociação |
200 1
Stephen Njuki
Stephen Njuki

Introdução

No artigo anterior, começamos a analisar as Bandas de Bollinger na classe personalizada de sinais para os EAs, construídos no Assistente. Analisamos seis das oito configurações previstas que podem ser úteis para o trader ao avaliar posições compradas e vendidas dentro da classe de sinais personalizados. Como o artigo ficou muito extenso, deixamos as duas últimas configurações, assim como os testes combinados de todas as configurações ou padrões possíveis, para uma próxima oportunidade. Agora, vamos examinar o padrão 6.


Bandas se expandem após uma tendência de baixa ou de alta

Nosso sétimo modelo, identificado como padrão 6, é baseado principalmente no aumento da volatilidade. A expansão do intervalo entre a banda superior e a inferior de Bollinger é sempre interpretada como um sinal de aumento na volatilidade. Neste modelo, como esse aumento ocorre no final de uma tendência, o mercado geralmente apresenta oscilações bruscas de preço, o que leva à suposição de uma possível reversão.

Portanto, ao interpretar esse padrão, o alargamento do intervalo entre a banda superior e a inferior após um movimento de alta é considerado um sinal de baixa, enquanto rompimentos semelhantes após uma tendência de baixa indicam um sinal de alta. Assim, trata-se de um sinal contrário à tendência, que busca oportunidades de abertura de posições opostas à tendência recente. Vamos implementar esse padrão no MQL5 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 6.                                             |
//+------------------------------------------------------------------+
bool CSignalBollingerBands::IsPattern_6(ENUM_POSITION_TYPE T)
{  m_bands.Refresh(-1);
   m_close.Refresh(-1);
   m_high.Refresh(-1);
   m_low.Refresh(-1);
   if(Gap(StartIndex()) > Gap(StartIndex() + 1) && Gap(StartIndex() + 1) > Gap(StartIndex() + 2))
   {  if(T == POSITION_TYPE_BUY && m_close.GetData(StartIndex() + 2) < m_close.GetData(StartIndex() + 3) && m_close.GetData(StartIndex() + 3) < m_close.GetData(StartIndex() + 4))
      {  return(true);
      }
      else if(T == POSITION_TYPE_SELL && m_close.GetData(StartIndex() + 2) > m_close.GetData(StartIndex() + 3) && m_close.GetData(StartIndex() + 3) > m_close.GetData(StartIndex() + 4))
      {  return(true);
      }
   }
   return(false);
}

Como mostrado no código acima, a verificação do aumento da volatilidade é um pré-requisito tanto para tendências de alta quanto de baixa. Após essa verificação, consideramos a tendência anterior a partir do momento em que a volatilidade começou a se expandir. Não consideramos a tendência atual, pois, como mencionado anteriormente, nesse ambiente instável a direção não é definitiva, embora muitas vezes a tendência antes do pico de volatilidade aponte uma direção mais clara.

Assim, essa situação, em que as tendências atuais não são claramente definidas, sempre representa o risco de continuidade da ruptura, em que, em vez de ocorrer a reversão, o preço simplesmente escapa dessa "zona de consolidação" e continua a tendência anterior, com aumento da volatilidade. Por isso, esse tipo de sinal deve ser combinado com uma análise de volume. Se as bandas se expandem enquanto o volume cai, isso confirma a reversão da tendência. Se o volume não diminui, é melhor que os traders aguardem um ponto de reversão mais adequado.

Como já mencionado, é difícil obter informações de volume, por isso, usamos principalmente os intervalos das barras de preço como indicadores aproximados. Um indicador alternativo, como o RSI, que analisaremos a seguir, também pode ser usado para confirmar pontos de sobrecompra e sobrevenda. O teste do nosso EA montado no Assistente fornece os seguintes resultados:

r_6_ol

c_6_ol


Mudança de orientação e inclinação das bandas

O último padrão para as Bandas de Bollinger está relacionado à inclinação das bandas superior e inferior. Quando a banda inferior sobe mais rapidamente que a superior por uma magnitude igual ou superior ao parâmetro de desvio das bandas de Bollinger, interpretamos isso como um sinal de alta. Isso ocorre porque tal configuração antecipa uma ruptura para cima através da banda superior. A confirmação com uma real quebra do preço pode complementar esse sinal. Isso permite refinar o ponto de entrada. A situação de baixa é o oposto: se os topos estão caindo mais rápido que os fundos, as bandas inferiores funcionam como suporte que está prestes a ser rompido. Novamente, o fechamento do preço abaixo das bandas inferiores atua como sinal confirmatório. Vamos implementar isso no MQL5 da seguinte maneira:

//+------------------------------------------------------------------+
//| Check for Pattern 7.                                             |
//+------------------------------------------------------------------+
bool CSignalBollingerBands::IsPattern_7(ENUM_POSITION_TYPE T)
{  m_bands.Refresh(-1);
   m_close.Refresh(-1);
   m_high.Refresh(-1);
   m_low.Refresh(-1);
   if
   (
      T == POSITION_TYPE_BUY &&
      Lower(StartIndex()) > Lower(StartIndex() + 1) &&
      Lower(StartIndex() + 1) > Lower(StartIndex() + 2) &&
      Upper(StartIndex()) >= Upper(StartIndex() + 1) &&
      Upper(StartIndex() + 1) >= Upper(StartIndex() + 2) &&
      Lower(StartIndex()) - Lower(StartIndex() + 2) >= m_deviation * (Upper(StartIndex()) - Upper(StartIndex() + 2))
   )
   {  return(true);
   }
   else if
   (
      T == POSITION_TYPE_SELL &&
      Upper(StartIndex()) < Upper(StartIndex() + 1) &&
      Upper(StartIndex() + 1) < Upper(StartIndex() + 2) &&
      Lower(StartIndex()) <= Lower(StartIndex() + 1) &&
      Lower(StartIndex() + 1) <= Lower(StartIndex() + 2) &&
      Upper(StartIndex() + 2) - Upper(StartIndex()) >= m_deviation * (Lower(StartIndex() + 2) - Lower(StartIndex()))
   )
   {  return(true);
   }
   return(false);
}

Como mencionado acima, esse sinal pode ser complementado com uma ruptura no preço. O código-fonte está incluído ao final do artigo. O teste do EA pronto com o mapa de entrada (input map) 80 para o oitavo padrão produz os seguintes resultados:

r_7_ol

c_7_ol

Este é um dos melhores ciclos de otimização utilizando apenas o padrão 7. No entanto, como já foi dito, modificamos nosso sinal personalizado permitindo o uso simultâneo de múltiplos padrões. Se realizarmos várias execuções de otimização buscando a melhor combinação de padrões e seus respectivos limiares de abertura/fechamento, obteremos uma série de resultados de teste plausíveis, entre os quais estão os seguintes:

r_all_ol

c_all_ol

Esses resultados apresentam variações, e por isso é possível argumentar a favor do uso de múltiplos padrões com as Bandas de Bollinger, embora seja importante lembrar que esses sinais também podem se neutralizar mutuamente ao se adaptarem a diferentes condições de mercado. Isso dificulta a verificação cruzada do sistema, mas, ao se obter bons resultados com dados de teste de qualidade, o sistema pode se mostrar digno de consideração futura. As condições de compra e venda, que fazem a filtragem da entrada do mapa de parâmetros para os padrões usados nesta classe personalizada de sinais com as Bandas de Bollinger, são idênticas às usadas abaixo com a classe personalizada RSI. A seguir, está um exemplo típico da condição de compra. A condição de venda é implementada de maneira similar.

//+------------------------------------------------------------------+
//| "Voting" that price will grow.                                   |
//+------------------------------------------------------------------+
int CSignalRSI::LongCondition(void)
{  int result  = 0, results = 0;
//--- if the model 0 is used and "Price Crossing the Upper Band or the Lower Band"
   if(((m_patterns_used & 0x01) != 0) && IsPattern_0(POSITION_TYPE_BUY))
   {  result += m_pattern_0;
      results++;
   }
//--- if the model 1 is used and "Price Bouncing Off Lower Band or Upper Band "
   if(((m_patterns_used & 0x02) != 0) && IsPattern_1(POSITION_TYPE_BUY))
   {  result += m_pattern_1;
      results++;
   }
//--- if the model 2 is used and "Price Squeeze Followed by a Breakout Above Upper Band or Below Lower Band "
   if(((m_patterns_used & 0x04) != 0) && IsPattern_2(POSITION_TYPE_BUY))
   {  result += m_pattern_2;
      results++;
   }
//--- if the model 3 is used and "Price Double Bottoms Near Lower Band or Double Top Near Upper Band "
   if(((m_patterns_used & 0x08) != 0) && IsPattern_3(POSITION_TYPE_BUY))
   {  result += m_pattern_3;
      results++;
   }
//--- if the model 4 is used and "Price Bounces Off the Middle Band from Above & Bounce Off from Below "
   if(((m_patterns_used & 0x10) != 0) && IsPattern_4(POSITION_TYPE_BUY))
   {  result += m_pattern_4;
      results++;
   }
//--- if the model 5 is used and "Volume Divergence at Lower Band or Upper Band  "
   if(((m_patterns_used & 0x20) != 0) && IsPattern_5(POSITION_TYPE_BUY))
   {  result += m_pattern_5;
      results++;
   }
//--- if the model 6 is used and "Bands Widening After Downtrend or After Uptrend "
   if(((m_patterns_used & 0x40) != 0) && IsPattern_6(POSITION_TYPE_BUY))
   {  result += m_pattern_6;
      results++;
   }
//--- if the model 7 is used and "Bands Orientation and Angle Changes "
   if(((m_patterns_used & 0x80) != 0) && IsPattern_7(POSITION_TYPE_BUY))
   {  result += m_pattern_7;
      results++;
   }
//--- return the result
   if(results > 0)
   {  return(int(round(result / results)));
   }
   return(0);
}

Em ambas as condições, usamos operações bit a bit para verificar se o mapa de parâmetros de entrada dos padrões utilizados permite a aplicação do padrão definido. Como vimos no exemplo das Bandas de Bollinger, os 8 modelos têm seus próprios índices: 1, 2, 4, 8, 10, 20, 40 e 80. Como o mapa de entrada para os padrões usados é um número inteiro entre 0 e 255, nós apenas verificamos se cada padrão foi selecionado com base nesse valor de entrada. Por exemplo, o valor de entrada 107 do mapa de parâmetros implica que apenas os padrões 0, 1, 3, 5 e 6 foram escolhidos. No nosso último teste com as Bandas de Bollinger, otimizamos prioritariamente esse mapa, além de outros valores de limiar. Agora, vamos prosseguir com o artigo e analisar o Índice de Força Relativa (RSI). 


Índice de força relativa

RSI é um oscilador muito popular, no qual muitos traders confiam para abrir e fechar operações. Como descrito na introdução do artigo e no link fornecido, trata-se de um índice que acompanha a velocidade da variação de preços para antecipar possíveis reversões da tendência de preço em questão. Tecnicamente, o par EURUSD oscilou entre 0,95 e 1,60 de junho de 2002 até hoje, e é possível afirmar que ele ainda poderá se manter dentro desse intervalo nos próximos 22 anos. É evidente que essas são variações enormes. No entanto, não se comparam aos índices acionários, que quase todos subiram desde seus níveis de 2002. Assim, a capacidade de prever quando um par de moedas está sobrecomprado ou sobrevendido continua sendo uma habilidade essencial para muitos traders. A fórmula do índice é a seguinte:

onde:

  • RS – força relativa (Relative Strength), definida como a razão entre o lucro médio e a perda média durante um determinado período:

O período usado para calcular esses lucros/prejuízos médios é um parâmetro de entrada do indicador RSI. A implementação em MQL5 está presente no código da biblioteca. Dando continuidade ao tema do artigo anterior, vamos examinar oito padrões do RSI. Analisaremos cada um desses padrões de forma semelhante à que utilizamos anteriormente, apresentando os resultados dos testes de cada padrão junto com sua descrição. Realizamos os testes no timeframe diário do par de moedas USDJPY no ano de 2023.


Níveis de sobrecompra/sobrevenda (abordagem tradicional)

Nosso padrão 0 para o RSI é o rompimento tradicional abaixo ou acima dos níveis 30 e 70 do oscilador, respectivamente. Esse é o modo básico de usar o indicador e já demonstrou sua eficácia. Assim, rompimentos abaixo do nível 30 indicam sobrevenda do título financeiro e frequentemente sinalizam uma entrada de alta, enquanto rompimentos acima de 70 sinalizam sobrecompra. Vamos implementar isso na nossa classe personalizada de sinais da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 0.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_0(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   if(T == POSITION_TYPE_BUY && Base(StartIndex()) <= 30.0)
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex()) >= 70.0)
   {  return(true);
   }
   return(false);
}

As execuções de teste do EA construído no Assistente (mais detalhes podem ser encontrados aqui e aqui) apresentaram os seguintes resultados:

r_0

c_0

Esse uso tradicional do RSI, como o de muitos osciladores, não está livre de falhas, pois em mercados com forte tendência o oscilador pode permanecer acima do nível 70 por longos períodos (em cenários de alta) ou abaixo de 30 em cenários de baixa. Isso geralmente implica que o oscilador deve ser combinado com outros indicadores, como médias móveis, ou até com outros osciladores, como meaningsMACD, para uma identificação mais precisa dos sinais atuais. Além disso, ajustar os níveis do oscilador de 70/30 para, por exemplo, 80/20 pode ser apropriado ao lidar com ativos de alta volatilidade, a fim de evitar entradas prematuras.

O padrão funciona bem em mercados de faixa limitada ou em consolidação, como já mencionado. Os níveis do oscilador podem servir como referências confiáveis para determinar o momento de saída das posições, já que indicam estados extremos do mercado.


Oscilações fracassadas do RSI (reversões)

O próximo padrão, embora inicialmente se assemelhe bastante ao padrão 0, diferencia-se por buscar uma confirmação no oscilador após testar seus níveis-chave. Um sinal de alta ocorre quando há um teste do nível 30 seguido por um rompimento acima dele, enquanto a entrada de baixa é sinalizada por um avanço acima dos 70 com fechamento subsequente abaixo desse nível. Vamos implementar isso no MQL5 da seguinte maneira:

//+------------------------------------------------------------------+
//| Check for Pattern 1.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_1(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   if(T == POSITION_TYPE_BUY && Base(StartIndex() + 1) < 30.0 && Base(StartIndex()) > 30.0)
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex() + 1) > 70.0 && Base(StartIndex()) < 70.0)
   {  return(true);
   }
   return(false);
}

As execuções de teste para o padrão 1 apresentaram os seguintes resultados:

r_1

c_1

O padrão 1 geralmente fornece sinais mais fortes do que apenas o cruzamento dos níveis-limite, pois confirma a mudança no sentimento do mercado com mais de um movimento do RSI. Ele indica que o sentimento do mercado está mudando, sem necessariamente precisar de confirmação pelo preço. Esse último ponto torna o padrão mais confiável do que a divergência entre o RSI e a direção do preço, que também pode ser usada como sinal do RSI, como será mostrado a seguir.


Divergência do RSI (divergência de alta/baixa)

O padrão 2 surge quando o RSI se move em uma direção, enquanto o preço segue na direção oposta, o que novamente indica uma possível mudança no impulso do mercado. Essa divergência sinaliza que a tendência de alta ou baixa predominante pode estar enfraquecendo e, portanto, um possível movimento de reversão pode ser iminente. Essas divergências podem ser tanto de alta quanto de baixa, sendo que a divergência de alta ocorre quando o preço atinge fundos mais baixos, enquanto o RSI forma fundos mais altos, e a divergência de baixa ocorre quando o preço atinge topos mais altos, enquanto o RSI forma topos mais baixos. Abaixo está a implementação do padrão na nossa classe personalizada de sinais:

//+------------------------------------------------------------------+
//| Check for Pattern 2.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_2(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   m_close.Refresh(-1);
   if(T == POSITION_TYPE_BUY && 
   Close(StartIndex()) < Close(StartIndex() + 1) && 
   Close(StartIndex() + 1) < Close(StartIndex() + 2) && 
   Base(StartIndex()) > Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) > Base(StartIndex() + 2)
   )
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && 
   Close(StartIndex()) > Close(StartIndex() + 1) && 
   Close(StartIndex() + 1) > Close(StartIndex() + 2) && 
   Base(StartIndex()) < Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) < Base(StartIndex() + 2)
   )
   {  return(true);
   }
   return(false);
}

As execuções de teste do EA montado no Assistente, que utiliza exclusivamente o padrão 2 e requer o valor 4 no mapa de parâmetros de entrada, forneceram os seguintes resultados:

r_2

c_2

A divergência do RSI, como já mencionado no padrão 1 acima, não é tão consistente, porém seu uso principal é como um indicador antecipado de reversão de preço. Elas são especialmente relevantes em mercados com tendência definida ou em situações de tendências muito fortes. No entanto, os sinais de divergência emitidos podem indicar apenas um recuo e não uma reversão, por isso não são considerados tão confiáveis. Por essa razão, costuma-se combiná-los com outros indicadores, como médias móveis, além de linhas de suporte e resistência.

É muito importante filtrar os falsos sinais de divergência. Aqui, o uso de timeframes maiores pode ajudar, pois, embora menos produtivos na geração de sinais, tendem a ser mais confiáveis. Também é importante observar as divergências ocultas. Elas confirmam a continuação da tendência, sendo que a continuação de alta é observada quando o preço faz fundos mais altos e o RSI fundos mais baixos, enquanto a divergência oculta de baixa ocorre quando o preço atinge topos mais baixos e o RSI forma topos mais altos.


RSI cruza a linha média (nível 50) para cima/baixo

O padrão 3 foca no ponto médio do RSI, o nível 50, considerando qualquer cruzamento abaixo desse nível como sinal de baixa, e qualquer rompimento acima dele como sinal de alta. Por padrão, a presença do RSI próximo ao nível 50 deve indicar ausência de sinal claro, portanto, como era de se esperar, os cruzamentos desse nível têm caráter apenas sugestivo e geralmente requerem confirmação, ou atuam como filtro para outros indicadores de tendência.

Os cruzamentos da linha média podem funcionar tanto como sinal de continuação quanto como sinal de reversão da tendência. A continuação da tendência é confirmada, para um sinal de alta, se o RSI cruza o nível 50 de baixo para cima; para um sinal de baixa, se ele cruza esse nível na direção oposta. As reversões também são confirmadas em tendências de baixa quando o RSI rompe o nível 50 de baixo para cima antes de cair novamente abaixo dele, e em tendências de alta ao formar uma figura em U invertida acima dessa linha média. Vamos implementar nosso padrão 3 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 3.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_3(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   m_close.Refresh(-1);
   m_high.Refresh(-1);
   m_low.Refresh(-1);
   if(T == POSITION_TYPE_BUY && Base(StartIndex() + 1) < 50.0 && Base(StartIndex()) > 50.0)
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex() + 1) > 50.0 && Base(StartIndex()) < 50.0)
   {  return(true);
   }
   return(false);
}

Os testes executados apenas com esse padrão, com o valor de entrada do parâmetro de padrão definido como 8, fornecem os seguintes resultados:

r_3

c_3

O cruzamento da linha média representa uma simplificação extrema de todos os modelos abordados até agora, tornando-o o menos preciso entre os sinais potenciais. Por isso, é comum o uso de ordens pendentes com esse tipo de sinal, assim como seu uso em múltiplos timeframes. Além disso, o padrão 3 pode ser usado em trailing stops, quando traders, por exemplo, que estão em uma posição comprada permanecem nela enquanto o RSI estiver acima dessa linha média de 50, e saem da posição assim que ele cruza esse nível ou cai abaixo dele. Para posições vendidas, aplicam-se as condições inversas.


Rompimento da linha de tendência do RSI

O padrão 4 é, provavelmente, o mais complexo entre os oito analisados neste artigo, pois considera os topos e fundos do RSI, bem como os rompimentos das respectivas linhas de tendência. Um sinal de alta ocorre quando, após topos descendentes no RSI, há um avanço do RSI que rompe a linha de tendência desses topos. Por outro lado, o aumento dos fundos do RSI, seguido de uma queda do valor atual do RSI abaixo da linha de tendência desses fundos, é interpretado como sinal de baixa. O padrão é implementado no código da seguinte maneira:

//+------------------------------------------------------------------+
//| Check for Pattern 4.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_4(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   if(T == POSITION_TYPE_BUY && 
   Base(StartIndex()) > Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) < Base(StartIndex() + 2) && 
   Base(StartIndex() + 2) > Base(StartIndex() + 3) && 
   Base(StartIndex() + 3) < Base(StartIndex() + 4) && 
   Base(StartIndex() + 4) > Base(StartIndex() + 2) && 
   Base(StartIndex()) >= 2.0*Base(StartIndex() + 2)-Base(StartIndex() + 4)
   )
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && 
   Base(StartIndex()) < Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) > Base(StartIndex() + 2) && 
   Base(StartIndex() + 2) < Base(StartIndex() + 3) && 
   Base(StartIndex() + 3) > Base(StartIndex() + 4) && 
   Base(StartIndex() + 4) < Base(StartIndex() + 2) && 
   Base(StartIndex()) <= 2.0*Base(StartIndex() + 2)-Base(StartIndex() + 4)
   )
   {  return(true);
   }
   return(false);
}

Observe que não estamos necessariamente buscando os últimos picos ou vales reais do RSI, mas sim verificando se há, nas últimas 5 leituras do RSI, uma sequência de picos (para sinal de alta) ou de vales (para sinal de baixa). Se essa verificação dentro dos últimos 5 valores do RSI for positiva, então simplesmente verificamos o rompimento da linha de tendência. Novamente, não nos aprofundamos na geometria da linha real que conecta esses picos e vales, apenas observamos a mudança no RSI entre esses dois pontos extremos. Se não houver um crescimento no mesmo ritmo do valor atual do RSI, interpretamos isso como um rompimento da linha de tendência, pois, se a linha do pico ou do vale tivesse se mantido, o valor atual estaria tão distante do último vale ou pico quanto seu antecessor na sequência. O teste usando apenas o padrão 4, com o valor de entrada dos padrões definidos em 10, produziu os seguintes resultados:

r_4

c_4

O rompimento da linha de tendência do RSI usado neste artigo, como indicado na fonte geral, considera ou verifica esse padrão apenas nas últimas 5 leituras do RSI. Uma abordagem mais abrangente, voltada à identificação de pontos fractais ou de picos/vales do RSI, pode trazer resultados mais interessantes.


Zonas de sobrecompra/sobrevenda do RSI com confirmação por média móvel

O padrão 5 é simplesmente uma combinação do padrão 0 com uma confirmação por média móvel. Assim, as condições de alta descritas no padrão 0 acima permanecem, com o acréscimo de que o preço deve estar acima da média móvel para configurar uma condição de compra, enquanto as condições de venda serão confirmadas quando o preço estiver abaixo da média móvel. A função em MQL5 é implementada assim:

//+------------------------------------------------------------------+
//| Check for Pattern 5.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_5(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   m_close.Refresh(-1);
   m_ma.Refresh(-1);
   if(T == POSITION_TYPE_BUY && Base(StartIndex()) < 30.0 && Close(StartIndex()) > m_ma.Main(StartIndex()))
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex()) > 70.0 && Close(StartIndex()) < m_ma.Main(StartIndex()))
   {  return(true);
   }
   return(false);
}

Os testes realizados utilizando apenas esse padrão, com o valor do mapa de entrada definido como 20, apresentaram os seguintes resultados:

r_5

c_5


Padrões RSI "Fundo duplo / Topo duplo"

Esse padrão também se assemelha de certa forma ao padrão 1, na medida em que exige o teste dos níveis-chave do oscilador RSI, 70 e 30. No entanto, ao contrário do padrão 1, que requer apenas um pico ou queda, o padrão 6 exige duas quedas consecutivas abaixo da linha dos 30, cada uma seguida de uma recuperação a partir desse nível, para configurar um sinal de alta. Da mesma forma, dois saltos consecutivos acima do nível 70, seguidos de um fechamento abaixo desse nível, são interpretados como sinal de baixa. No código, isso é implementado da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 6.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_6(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   if(T == POSITION_TYPE_BUY && Base(StartIndex()) < 30.0 && 
   Base(StartIndex()) > Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) < Base(StartIndex() + 2) && 
   Base(StartIndex() + 2) > Base(StartIndex() + 3) && 
   Base(StartIndex() + 3) < Base(StartIndex() + 4)
   )
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex()) > 70.0 && 
   Base(StartIndex()) < Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) > Base(StartIndex() + 2) && 
   Base(StartIndex() + 2) < Base(StartIndex() + 3) && 
   Base(StartIndex() + 3) > Base(StartIndex() + 4)
   )
   {  return(true);
   }
   return(false);
}

Os testes com apenas o padrão 6, onde o valor de entrada dos padrões é igual a 40, resultaram nos seguintes dados:

r_6

c_6


RSI com múltiplos timeframes

Nosso último padrão — o padrão 7 — simplesmente aplica o padrão 0 em múltiplos timeframes. Assim, as condições de alta e baixa são idênticas às que vimos acima no padrão 0. Um parâmetro de entrada adicional, aceito pela nossa classe personalizada de sinais, será o timeframe adicional, que servirá para construir um segundo handler do RSI. Para fins de teste eficiente e para evitar o ruído de preço, que pode ser mais comum em timeframes mais curtos, nosso segundo timeframe será maior do que o timeframe de teste padrão. O código necessário é apresentado a seguir:

//+------------------------------------------------------------------+
//| Check for Pattern 7.                                             |
//+------------------------------------------------------------------+
bool CSignalRSI::IsPattern_7(ENUM_POSITION_TYPE T)
{  m_rsi.Refresh(-1);
   m_rsi_alt.Refresh(-1);
   if(T == POSITION_TYPE_BUY && Base(StartIndex()) <= 30.0 && Alt(StartIndex()) <= 30.0)
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex()) >= 70.0 && Alt(StartIndex()) >= 70.0)
   {  return(true);
   }
   return(false);
}

O teste utilizando apenas esse padrão com o valor 80 no mapa de entrada resultou nos seguintes dados:

r_7

c_7

Assim como no caso das Bandas de Bollinger (veja a conclusão acima), também temos a opção de múltiplos padrões para essa classe de sinais personalizados. Otimizamos os padrões de entrada utilizados, representados por um número inteiro de 0 a 255, a fim de encontrar a combinação ideal de padrões para o RSI. Como resultado da nossa execução de otimização, obtivemos o valor 189 no mapa de padrões utilizados. Em formato binário, isso é 10111101, o que significa que os únicos padrões "inadequados" segundo nosso teste de otimização são os padrões 1 e 6 (oscilações fracassadas do RSI e fundo/topo duplo). O teste foi realizado para o par USDJPY, sem verificação cruzada. Os resultados do teste estão apresentados abaixo:

r_all

c_all


Considerações finais

Analisamos o oscilador RSI, um indicador técnico extremamente popular, destacando os padrões de seus sinais. Alguns desses padrões são bastante comuns e prontamente associados ao RSI, como o tradicional padrão 0, enquanto outros, como o padrão 4 de rompimento de linha de tendência, podem parecer estranhos para alguns traders. No entanto, além de testar cada padrão individualmente com a exclusão dos demais, nossa classe personalizada de sinais também permite o uso de múltiplos padrões simultaneamente, utilizando o mapa de parâmetros de entrada como uma máscara para selecionar mais de um padrão. Dessa forma, os padrões que abrem uma posição não precisam, necessariamente, ser os mesmos que gerenciam ou determinam o seu fechamento. 

Acredito que os leitores possam se interessar por padrões adicionais que não abordamos neste artigo. Utilizamos apenas oito padrões, o que significa que nossos dados de entrada para os padrões utilizados não excederam 2 elevado à oitava potência menos um (255). Se aumentarmos esse número de padrões, por exemplo, para 10, nosso mapa de entrada para os padrões utilizados variaria de 0 até 2 elevado à décima potência menos 1, o que dá 1023. Padrões adicionais que podem ser considerados incluem a estratégia de rompimento do RSI, na qual, se o preço de um ativo ultrapassa um nível-chave de resistência no gráfico de preços e, simultaneamente, rompe o nível 70 no gráfico do RSI, esse sinal, diferentemente dos padrões tratados até agora, é interpretado como um forte sinal de alta e o início de uma tendência principal. Da mesma forma, um sinal de baixa também surgirá se o preço cair abaixo de um nível-chave de suporte no gráfico e o RSI cair abaixo de 30. Isso também contradiz a forma como interpretamos o RSI neste artigo. A implementação desse código depende de o trader conhecer os níveis-chave de suporte e resistência no gráfico do ativo em que está operando, portanto esse trabalho fica a critério do leitor.

Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/15850

Arquivos anexados |
Baixar como ZIP
SignalWZ_39.mqh (19.43 KB)
wz_39.mq5 (8.13 KB)

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

Esse artigo foi escrito por um usuário do site e reflete seu ponto de vista pessoal. A MetaQuotes Ltd. não se responsabiliza pela precisão das informações apresentadas nem pelas possíveis consequências decorrentes do uso das soluções, estratégias ou recomendações descritas.

Outros artigos do autor

Últimos Comentários | Ir para discussão (1)
Arber Coku
Arber Coku | 22 set. 2024 em 12:06
Olá,
Obrigado por compartilhar isso conosco. Funciona perfeitamente para mim em algumas ações, como você descreveu para os valores no artigo.

Não consegui encontrar gráficos como esse no usdjpy ou em outros pares de forex, talvez meu problema seja que não tenho o conjunto necessário para eles.

Se você tiver um, pode compartilhá-lo conosco?
Simulação de mercado (Parte 20): Iniciando o SQL (III) Simulação de mercado (Parte 20): Iniciando o SQL (III)
Apesar de podermos fazer as coisas com um banco de dados, tendo cerca de 10 ou pouco mais registros. A coisa realmente se torna melhor assimilada, quando usamos um arquivo de banco de dados que contenha mais de 15 mil registros. Ou seja, se você for criar isto manualmente irá ser uma bela de uma tarefa. No entanto, dificilmente você irá encontrar algum banco de dados, mesmo para fins didáticos disponível para download. Mas não precisamos de fato recorrer a este tipo de coisa. Podemos usar o MetaTrader 5, para criar um banco de dados para nos. Neste artigo veremos como fazer isto.
Do básico ao intermediário: Herança Do básico ao intermediário: Herança
Este com toda a certeza, é um artigo, que você deverá dedicar um bom tempo a fim de entender como, por que as coisas mostradas aqui funcionam. Isto pelo simples fato de que, tudo que será visto e mostrado aqui, é originalmente direcionado ao que seria uma programação orientada em objetos. Mas que na verdade, tem como base e princípios uma programação estrutural.
Recursos do Assistente MQL5 que você precisa conhecer (Parte 40): Parabolic SAR Recursos do Assistente MQL5 que você precisa conhecer (Parte 40): Parabolic SAR
O Parabolic Stop-and-Reversal (SAR) é um indicador de pontos de confirmação e término de tendência. Como ele detecta tendências com atraso, sua principal função era posicionar ordens stop-loss móveis para posições abertas. Vamos analisar se é possível utilizá-lo como sinal de EA com a ajuda de classes de sinais personalizadas para EAs, montadas usando o Assistente.
Simulação de mercado (Parte 19): Iniciando o SQL (II) Simulação de mercado (Parte 19): Iniciando o SQL (II)
Como eu disse no primeiro artigo sobre SQL, não faz sentido você perder tempo, programado rotinas e mais rotinas a fim de conseguir, gerar ou produzir algo que o próprio SQL já contém. Porém sem saber o básico do básico, você não conseguirá fazer nada em SQL, a fim de aproveitar de alguma forma o que esta ferramenta tem a nos oferecer. Sendo assim, aqui neste artigo iremos ver como fazer para conseguir executar tarefas primordiais a serem feitas em bancos de dados.