Técnicas do MQL5 Wizard que você deve conhecer (Parte 56): Fractais de Bill Williams

Introdução

O indicador de fractais de Bill Williams é um indicador fundamental e importante dentro do conjunto de ferramentas pelo qual ele é conhecido. Ele identifica principalmente pontos de reversão na ação de preço dos ativos negociados. Baseia-se no conceito de fractais, como um padrão repetitivo de 5 barras, frequentemente marcado como bearish quando a barra central das 5 possui a máxima mais alta, ou bullish nos casos em que a barra central possui a mínima mais baixa. Analisamos alguns dos padrões deste indicador que podem ser utilizados por traders, como já fizemos anteriormente em artigos sobre o MQL5 Wizard.

Fractais Consecutivos na Mesma Direção

Para o nosso primeiro padrão, padrão-0, uma formação bullish é definida quando uma série de mínimas de fractais bullish se forma no mesmo nível ou próxima da mínima anterior.. Isso geralmente é interpretado como o mercado encontrando suporte nesse ponto. É importante observar que, por mínimas de fractais consecutivas, entende-se que não há fractal de máxima entre essas mínimas. Este é um indicador significativo, pois padrões típicos são compostos por máximas de fractais seguidas de mínimas de fractais, em alternância. Para o padrão bullish, no entanto, isso é interpretado como diferentes compradores entrando no mercado em níveis de preço semelhantes, o que reforça a tese de uma fase de acumulação que precede um movimento de alta.

Por outro lado, múltiplas máximas de fractais bearish consecutivas podem mapear um nível de resistência que o preço não consegue romper. Essa forte rejeição (ou rejeição repetida em timeframes maiores) frequentemente indica forte pressão vendedora e uma provável continuação ou início de uma tendência de baixa.

Implementamos o Padrão-0 em MQL5 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 0.                                             |
//+------------------------------------------------------------------+
bool CSignalFractals::IsPattern_0(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && FractalLow(X() + 1) != 0.0 && FractalLow(X()) != 0.0)
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && FractalHigh(X() + 1) != 0.0 && FractalHigh(X()) != 0.0)
   {  return(true);
   }
   return(false);
}

Por padrão, o indicador de fractais de Bill Williams é fornecido entre o conjunto de indicadores embutidos. No entanto, ele requer alguns ajustes, pois muitos dos seus valores nos buffers Upper/Highs e Lower/Lows produzem NaNs no uso inicial. Portanto, criamos uma versão modificada introduzindo 2 funções: FractalHigh e FractalLow. O código de ambas está listado abaixo:

double            FractalHigh(int ind)
{  //
   m_high.Refresh(-1);
   if(m_high.MaxIndex(ind, 5) == ind)
   {  return(m_high.GetData(ind));
   }
   return(0.0);
}

double            FractalLow(int ind)
{  //
   m_low.Refresh(-1);
   if(m_low.MinIndex(ind, 5) == ind)
   {  return(m_low.GetData(ind));
   }
   return(0.0);
}

Na função do padrão-0, simplesmente chamamos a função FractalLow nas 2 barras consecutivas anteriores ao verificar um sinal bullish, ou a função FractalHigh nas mesmas barras ao buscar um padrão bearish. Esse número de barras consecutivas pode ser personalizado pelo leitor, aumentando-o caso haja necessidade de filtrar mais sinais falsos. Como costuma acontecer, no entanto, menos configurações de trade exigem testes ao longo de períodos mais longos antes de se tornarem confiáveis. Realizamos todos os testes para os padrões deste indicador no símbolo GBPUSD, no timeframe de 4 horas, no ano de 2024, tendo otimizado os padrões para o ano de 2023. O teste forward walk para o padrão-0 nos fornece o seguinte relatório.

O padrão-0 indica fortes continuações de tendência. Portanto, pode ajudar a reabrir posições em uma tendência predominante caso tenha havido realização de lucros.

Rompimento de Tendência com Fractais

O padrão-1, o nosso segundo, define sua formação bullish inicialmente com um fractal bearish que atuou como resistência. Uma formação bullish ocorre quando o preço, contrariando a tendência, rompe de forma decisiva acima dessa máxima de fractal. Esse rompimento é então interpretado como compradores superando os vendedores, de modo que o antigo nível de resistência se transforma em suporte, sinalizando uma reversão de tendência. Isso também pode representar uma forte continuação de tendência se ocorrer dentro de uma tendência bullish muito mais ampla que se tornou menos evidente em timeframes menores.

Uma versão bearish do padrão-1 seria, como esperado, o oposto. Um fractal de mínima bullish seria seguido pelo preço rompendo abaixo da marca dessa mínima de fractal. Essa quebra é interpretada como uma indicação de que os vendedores estão assumindo o controle e preparando o cenário para uma tendência de baixa. Implementamos isso em MQL5 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 1.                                             |
//+------------------------------------------------------------------+
bool CSignalFractals::IsPattern_1(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && FractalHigh(X() + 1) != 0.0 && Close(X()) > FractalHigh(X() + 1))
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && FractalLow(X() + 1) != 0.0 && Close(X()) < FractalLow(X() + 1))
   {  return(true);
   }
   return(false);
}

No código acima, verificamos pontos de fractal na barra anterior e, em seguida, comparamos o preço de fechamento atual com o preço desse fractal. Como argumentado na lógica, o fractal de máxima (o fractal bearish) é relevante para o padrão bullish, e o fractal de mínima também é importante para o padrão bearish.

A execução forward no ano de 2024, a partir da otimização dos limiares de abertura e fechamento para o ano de 2023, nos apresenta o seguinte relatório:

O padrão-1 se destaca porque, diferentemente do padrão-0, que é de continuação, este pode servir como reversão. Por isso, é sempre uma boa ideia utilizá-lo em conjunto com outros indicadores.

Fractais Internos (Lower Highs, Higher Lows)

O padrão-2 tem sua formação bullish definida quando fractais bullish (mínimas de swing) se formam próximos da faixa de um fractal mais amplo anterior. A ação de preço frequentemente se comprime dentro dessa faixa, com os fractais de mínima quase formando uma linha reta. Assim, quando ocorre um movimento acima dessa faixa estreita, isso confirma um viés bullish, pois os compradores estariam empurrando o preço para fora de uma zona de consolidação.

Por outro lado, em uma formação de fractais bearish, se os topos de swing formam um agrupamento dentro dos limites de uma faixa de fractal bearish anterior, isso também marca um período de indecisão. Uma vez que o preço caia abaixo do limite inferior dessa faixa e o suporte falhe, esse rompimento para baixo confirmaria um movimento bearish. É assim que implementamos isso em MQL5:

//+------------------------------------------------------------------+
//| Check for Pattern 2.                                             |
//+------------------------------------------------------------------+
bool CSignalFractals::IsPattern_2(ENUM_POSITION_TYPE T)
{  CArrayDouble _buffer;
   if(T == POSITION_TYPE_BUY)
   {  for(int i = 0; i < m_periods; i++)
      {  if(FractalLow(X() + i) != 0.0)
         {  _buffer.Add(FractalLow(X() + i));
         }
      }
      if(_buffer[_buffer.Maximum(0, _buffer.Total())] - _buffer[_buffer.Minimum(0, _buffer.Total())] <= fabs(Close(X()) - Close(X() + 10)))
      {  return(true);
      }
   }
   else if(T == POSITION_TYPE_SELL)
   {  for(int i = 0; i < m_periods; i++)
      {  if(FractalHigh(X() + i) != 0.0)
         {  _buffer.Add(FractalHigh(X() + i));
         }
      }
      if(_buffer[_buffer.Maximum(0, _buffer.Total())] - _buffer[_buffer.Minimum(0, _buffer.Total())] <= fabs(Close(X()) - Close(X() + 10)))
      {  return(true);
      }
   }
   return(false);
}

A implementação desse padrão exige, conforme nossa abordagem, o uso de uma classe padrão de array. Isso ocorre porque estamos buscando pontos de fractais ao longo de um período fixo, e a quantidade que iremos obter é incerta. Com isso, também precisamos ter uma noção do desvio padrão desses pontos de fractais.

Como nossa classe de array não fornece a função de desvio padrão como o tipo de dado vector e, além disso, esse cálculo é intensivo em termos computacionais, optamos por utilizar a faixa (range) desses pontos em vez disso. Para termos uma noção de que essa faixa está comprimida, comparamos sua magnitude com a magnitude da tendência no preço de fechamento e, se for menor, temos uma confirmação.

Estritamente falando, essa é uma avaliação rudimentar, pois é fácil perceber que, em mercados em tendência, quando a magnitude da variação do preço de fechamento se torna muito grande, qualquer conjunto de faixas de pontos de fractais passará nesse teste. Por isso, pode ser uma boa ideia que os leitores façam ajustes, como comparar a faixa dos pontos de fractais ou seu desvio padrão com um valor absoluto. Esse valor pode ser ajustado por meio de otimização.

Uma execução forward após otimizar nosso Expert Advisor montado pelo Wizard, com o par USDJPY no timeframe de 4 horas, nos fornece os seguintes resultados:

O padrão 2 é um padrão de compressão que indica potencial para rompimento. O padrão 2 é um padrão de compressão que indica potencial para rompimento.

Divergência de Fractais com a Ação de Preço

A divergência com a ação de preço é o nosso padrão-3. Essa divergência é interpretada como bullish com o argumento de que, apesar da queda dos preços, o suporte subjacente está se fortalecendo, sugerindo uma reversão de alta iminente.Uma execução forward após otimizar nosso Expert Advisor montado pelo Wizard, com o par USDJPY no timeframe de 4 horas, nos fornece os seguintes resultados: Essa divergência é interpretada como bullish com o argumento de que, apesar da queda dos preços, o suporte subjacente está se fortalecendo, sugerindo uma reversão de alta iminente.

Uma divergência bearish, por outro lado, ocorre quando o preço forma uma máxima mais alta, enquanto os topos de fractais bearish são mais baixos do que os anteriores. Essa configuração geralmente sinaliza que, embora o preço esteja subindo, a resistência está comprimindo o preço, o que pode ser um alerta de perda de força compradora e de uma reversão para baixo. Implementamos isso em MQL5 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 3.                                             |
//+------------------------------------------------------------------+
bool CSignalFractals::IsPattern_3(ENUM_POSITION_TYPE T)
{  CArrayDouble _buffer;
   if(T == POSITION_TYPE_BUY)
   {  for(int i = 0; i < m_periods; i++)
      {  if(FractalLow(X() + i) != 0.0)
         {  _buffer.Add(FractalLow(X() + i));
         }
         if(_buffer.Total() >= 2)
         {  break;
         }
      }
      if(_buffer[0] > _buffer[1] && Low(X()) < Low(X() + 1))
      {  return(true);
      }
   }
   else if(T == POSITION_TYPE_SELL)
   {  for(int i = 0; i < m_periods; i++)
      {  if(FractalHigh(X() + i) != 0.0)
         {  _buffer.Add(FractalHigh(X() + i));
         }
         if(_buffer.Total() >= 2)
         {  break;
         }
      }
      if(_buffer[0] < _buffer[1] && High(X()) > High(X() + 1))
      {  return(true);
      }
   }
   return(false);
}

A codificação do padrão-3 também exige o uso da classe padrão de array disponível na IDE do MQL5. Isso se deve principalmente às razões já mencionadas no padrão-2; no entanto, neste caso, estamos buscando apenas 2 pontos de fractais, em vez de uma coleção ao longo de um período definido pelo parâmetro de entrada ‘m_periods’. Utilizamos os 2 pontos de fractais juntamente com os 2 pontos extremos de preço para estabelecer nosso sinal potencial, conforme já discutido anteriormente.

Uma execução forward-walk após a otimização, para o mesmo símbolo, timeframe e período de teste dos padrões anteriores, nos apresenta o seguinte relatório:

Fractais Opostos Gêmeos (Zonas de Reversão)

Fractais opostos gêmeos constituem o nosso padrão-4. A formação bullish para esse padrão envolve dois fractais posicionados de forma idêntica: um bullish (nas mínimas) e um bearish (nas máximas). O cruzamento desses dois cria uma zona de indecisão. Quando o preço rejeita o fractal bullish e sobe acima do fractal bearish, um sinal bullish é confirmado.

Na formação bearish, a sequência é um fractal bullish imediatamente seguido por um fractal bearish. Se o preço rejeita o fractal bearish (máxima) e cai abaixo do fractal bullish, então um sinal de venda também é confirmado. Codificamos isso em MQL5 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 4.                                             |
//+------------------------------------------------------------------+
bool CSignalFractals::IsPattern_4(ENUM_POSITION_TYPE T)
{  bool _1 = (FractalHigh(X() + 1) != 0.0 && FractalLow(X() + 1) != 0.0);
   bool _2 = (FractalHigh(X() + 2) != 0.0 && FractalLow(X() + 2) != 0.0);
   if(_1 || _2)
   {  if(T == POSITION_TYPE_BUY)
      {  if((_1 && Close(X()) > FractalHigh(X() + 1)) || (_2 && Close(X()) > FractalHigh(X() + 2)))
         {  return(true);
         }
      }
      else if(T == POSITION_TYPE_SELL)
      {  if((_1 && Close(X()) < FractalLow(X() + 1)) || (_2 && Close(X()) < FractalLow(X() + 2)))
         {  return(true);
         }
      }
   }
   return(false);
}

Nosso código utiliza dois valores booleanos para verificar o padrão de fractais gêmeos. Optamos por utilizar 2 valores booleanos porque os efeitos desse padrão único podem apresentar um leve atraso de reação (em vez de atraso clássico). Cada valor marca ou a última barra completa ou a barra anterior a ela. Se o padrão for identificado, prosseguimos simplesmente verificando se o preço de fechamento rompeu algum dos seus níveis-chave, conforme já explicado anteriormente. 

Uma execução forward-walk após a otimização para esse padrão nos fornece o seguinte relatório:

O aparecimento consecutivo de fractais bullish e bearish também destaca outro ponto de indecisão no mercado. Os rompimentos para qualquer um dos lados são, então, utilizados como sinais para o padrão-4.

Confirmação de Topos e Fundos com Fractais

Para esse padrão, padrão-5, analisamos a ação de preço ao longo de uma série de barras em relação aos níveis de referência dos fractais. A formação bullish é definida quando um fractal bullish (que frequentemente representa um potencial nível de suporte) é estabelecido e a ação de preço subsequente não rompe significativamente abaixo desse nível. Se o preço continua rejeitando esse nível, isso reforça a tese de que ele atua como uma zona de suporte bullish.

Por outro lado, uma formação ou swing bearish é estabelecida quando um fractal de máxima é formado e, após a ação de preço subsequente, o preço não ultrapassa o nível máximo desse fractal. O argumento aqui é que a incapacidade persistente de romper para cima a partir do fractal reforça seu papel como área de resistência e, portanto, sinaliza um sentimento bearish. Implementamos isso em MQL5 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 5.                                             |
//+------------------------------------------------------------------+
bool CSignalFractals::IsPattern_5(ENUM_POSITION_TYPE T)
{  vector _std;
   _std.Init(5);
   _std.Fill(0.0);
   if(T == POSITION_TYPE_BUY && FractalLow(X() + m_periods) != 0.0)
   {  if(_std.CopyRates(m_symbol.Name(), m_period, 4, 0, m_periods) && _std.Std() <= fabs(Close(X()) - Close(X() + m_periods)))
      {  return(true);
      }
   }
   else if(T == POSITION_TYPE_SELL && FractalHigh(X() + m_periods))
   {  if(_std.CopyRates(m_symbol.Name(), m_period, 2, 0, m_periods) && _std.Std() <= fabs(Close(X()) - Close(X() + m_periods)))
      {  return(true);
      }
   }
   return(false);
}

Nosso código acima utiliza um vector não apenas para copiar o buffer de preços necessário, mas também para recuperar de forma eficiente o desvio padrão desses dados. Comparamos esse desvio com a magnitude da tendência predominante no preço de fechamento, como fizemos no padrão 2. As limitações e cautelas levantadas no padrão 2 também se aplicam aqui, portanto o leitor tem liberdade para fazer ajustes modificando o código apresentado.

Uma execução walk forward após a otimização, utilizando símbolo, janelas e timeframe semelhantes aos anteriores, nos fornece o seguinte relatório:

Eu não vinha realizando testes forward walk nesta série, mas como as janelas de teste são muito pequenas, agora passamos a incluí-los como padrão. O que ficará ausente serão as execuções de otimização durante o período de treinamento, pois incluir ambos deixaria o artigo excessivamente carregado.

Falha de Swing com Fractais

O padrão-6 foca na “falha” da ação de preço em romper níveis de fractais. Para o caso bullish, após um swing de fractal de alta, se o preço tenta cair ainda mais e essa tentativa falha — ou seja, a nova mínima é rejeitada por uma reversão rápida para cima — isso frequentemente indica que os vendedores estão esgotados e que os compradores precisam entrar no mercado.

Por outro lado, no caso bearish, quando um fractal de máxima é formado e o preço tenta subir acima desse fractal, mas falha, essa “falha de swing” é interpretada como um sinal de que os vendedores estão no controle e que o preço provavelmente seguirá para uma tendência de baixa. Implementação em MQL5 conforme segue:

//+------------------------------------------------------------------+
//| Check for Pattern 6.                                             |
//+------------------------------------------------------------------+
bool CSignalFractals::IsPattern_6(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && FractalLow(X() + 2) != 0.0)
   {  if(Low(X() + 1) <= FractalLow(X() + 2) && Close(X()) >= High(X() + 2))
      {  return(true);
      }
   }
   else if(T == POSITION_TYPE_SELL && FractalHigh(X() + 2) != 0.0)
   {  if(High(X() + 1) >= FractalHigh(X() + 2) && Close(X()) <= Low(X() + 2))
      {  return(true);
      }
   }
   return(false);
}

Este é um dos nossos padrões mais simples em termos de codificação. Como discutido anteriormente, estamos simplesmente comparando preços mínimos anteriores com o fractal de mínima anterior a eles e, no caso bullish, comparando o preço de fechamento com o preço máximo de 2 barras antes. Seguimos o inverso disso no caso bearish. A escolha de quão longe retroceder no histórico pode ser analisada pelo leitor.

Uma execução forward walk após a otimização, assim como ocorreu com os padrões 0–5 para os limiares de abertura e fechamento deste padrão, nos apresenta o seguinte relatório:

Um fractal de máxima (ou mínima) que não é ultrapassado por candles subsequentes frequentemente atua como uma rejeição. Isso é um forte sinal de exaustão da tendência.

Agrupamento de Fractais em torno de Médias Móveis

Nosso oitavo padrão, padrão-7, combina o indicador de fractais com médias móveis. Para a configuração bullish, quando uma série de fractais de mínima se agrupa próxima a uma média móvel (por exemplo, MA de 50), isso é interpretado como um indicativo de que a média móvel está atuando como um forte nível de suporte. Esses fractais de mínima, portanto, tendem a fornecer oportunidades de entrada para compradores e, uma vez que o preço se move decisivamente acima do nível de resistência mais próximo ou até mesmo da própria média móvel, isso confirma a tese bullish.

Da mesma forma, uma formação bearish ocorre quando múltiplos fractais de máxima se concentram ao redor da média móvel, que nesse momento atua como resistência. Da mesma forma, uma formação bearish ocorre quando múltiplos fractais de máxima se concentram ao redor da média móvel, que nesse momento atua como resistência. A implementação disso em MQL5 é a seguinte:

//+------------------------------------------------------------------+
//| Check for Pattern 7.                                             |
//+------------------------------------------------------------------+
bool CSignalFractals::IsPattern_7(ENUM_POSITION_TYPE T)
{  CArrayDouble _buffer;
   if(T == POSITION_TYPE_BUY)
   {  for(int i = 1; i < m_periods; i++)
      {  if(FractalLow(X() + i) != 0.0)
         {  _buffer.Add(fabs(FractalLow(X() + i) - MA(X() + i)));
         }
      }
      if(_buffer[_buffer.Maximum(0, _buffer.Total())] <= fabs(Close(X() + 1) - Close(X() + m_periods)) && Close(X() + 1) <= MA(X() + 1) && Close(X()) > MA(X()))
      {  return(true);
      }
   }
   else if(T == POSITION_TYPE_SELL)
   {  for(int i = 1; i < m_periods; i++)
      {  if(FractalHigh(X() + i) != 0.0)
         {  _buffer.Add(fabs(FractalHigh(X() + i) - MA(X() + i)));
         }
      }
      if(_buffer[_buffer.Maximum(0, _buffer.Total())] <= fabs(Close(X() + 1) - Close(X() + m_periods)) && Close(X() + 1) >= MA(X() + 1) && Close(X()) < MA(X()))
      {  return(true);
      }
   }
   return(false);
}

O padrão 7, assim como os padrões 2 e 3, também utiliza a classe de array, mas desta vez para registrar a magnitude da distância entre o ponto de fractal e a média móvel. Como discutido anteriormente, buscamos situações em que essa distância seja a menor possível, e é por isso que consideramos seu valor máximo entre todos os pontos de distância armazenados no buffer. Novamente comparamos essa magnitude com a tendência predominante, portanto o leitor é lembrado de fazer ajustes conforme já mencionado anteriormente em outros padrões, como o padrão 6.

A execução forward com configurações de entrada provenientes da otimização do mesmo ativo utilizado nos padrões anteriores nos fornece o seguinte relatório:

Quando muitos fractais se formam próximos a uma média móvel, isso sugere uma zona de pivô, sendo que um rompimento desse agrupamento confirma uma continuação ou reversão.

Padrão de Gap com Fractais

Para o padrão-8, o sinal bullish ocorre quando um fractal de mínima bullish está localizado próximo a um gap de preço (geralmente em cenários de alta volatilidade ou eventos de notícias). Nessa situação, o gap atua como uma área de suporte. A presença de um fractal no gap é então interpretada como compradores enxergando essa região como uma oportunidade. Uma vez que o gap seja “preenchido” ou sustentado, um movimento de alta torna-se provável.

A formação bearish também ocorre quando um fractal de máxima bearish aparece próximo ou na localização de um gap de preço aberto para cima. Nesse cenário, o gap representa um nível de resistência. A presença do fractal indicaria que os vendedores estão defendendo esse nível e, caso o preço inicie uma tendência de baixa, essa tendência bearish será confirmada. Implementamos isso em MQL5 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 8.                                             |
//+------------------------------------------------------------------+
bool CSignalFractals::IsPattern_8(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && FractalLow(X() + 2) != 0.0)
   {  if(Low(X() + 1) > High(X() + 2) && Close(X()) >= High(X() + 2))
      {  return(true);
      }
   }
   else if(T == POSITION_TYPE_SELL && FractalHigh(X() + 2) != 0.0)
   {  if(High(X() + 1) < Low(X() + 2) && Close(X()) <= Low(X() + 2))
      {  return(true);
      }
   }
   return(false);
}

Para o padrão-8, estamos simplesmente interessados em um gap de preço, portanto nossa implementação acima é quase tão simples quanto a do padrão 6.

E uma execução forward com configurações semelhantes de ativo e ambiente de teste — USDJPY no timeframe de 4 horas no ano de 2023 — é apresentada abaixo:

A coincidência entre gaps de preço e rompimentos de fractais sempre amplifica o movimento do preço. Essas configurações, no entanto, são mais comuns em eventos impulsionados por notícias.

Alinhamento de Fractais com Níveis de Fibonacci

Nosso padrão final combina fractais com níveis de Fibonacci. Um alinhamento bullish ocorre quando um fractal de mínima coincide com um nível-chave de retração de Fibonacci. Essa confluência entre o suporte identificado pelo fractal e o nível de Fibonacci aumenta a força da área de suporte. Essa confirmação dupla, portanto, serve como um sinal bullish robusto — caso o preço se mantenha nesse nível. Normalmente, isso pode indicar um repique ou continuação de tendência.

Em uma formação bearish, o fractal de máxima se alinha com um nível crítico de retração de Fibonacci. Esse alinhamento, então, reforça a resistência naquele ponto. Se o preço então tiver dificuldade em romper acima da zona de Fibonacci e, em vez disso, reverter para baixo a partir dessa região de confluência, isso confirma um sinal bearish. Ambas as configurações são codificadas em MQL5 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 9.                                             |
//+------------------------------------------------------------------+
bool CSignalFractals::IsPattern_9(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && FractalLow(X()) != 0.0)
   {  if(Is_Fibo_Level(X()))
      {  return(true);
      }
   }
   else if(T == POSITION_TYPE_SELL && FractalHigh(X()) != 0.0)
   {  if(Is_Fibo_Level(X()))
      {  return(true);
      }
   }
   return(false);
}

O código para o nosso padrão final foi um pouco complicado de conceber, já que aquilo que é evidente e intuitivo no trading manual dificilmente se traduz da mesma forma quando se trata de automação. Como poderíamos “plotar” e marcar níveis de Fibonacci? Desenvolvemos uma função rudimentar para nos auxiliar nisso, chamada “Is_Fibo_Level()”. Seu código é apresentado abaixo:

bool Is_Fibo_Level(int ind)
{  double _r=0.0;
   vector _h,_l;
   int _size = 3 * PeriodSeconds(PERIOD_MN1) / PeriodSeconds(m_period);
   _h.Init(_size);
   _l.Init(_size);
   if(_h.CopyRates(m_symbol.Name(),m_period,2,0,_size) && _l.CopyRates(m_symbol.Name(),m_period,4,0,_size))
   {  _r = _h.Max()-_l.Min();
      if(_l.Min()-ATR(ind) <= Close(ind) && Close(ind) <= _l.Min()+ATR(ind))
      {  return(true);
      }
      else if(_l.Min()+(0.236*_r)-ATR(ind) <= Close(ind) && Close(ind) <= _l.Min()+(0.236*_r)+ATR(ind))
      {  return(true);
      }
      else if(_l.Min()+(0.382*_r)-ATR(ind) <= Close(ind) && Close(ind) <= _l.Min()+(0.382*_r)+ATR(ind))
      {  return(true);
      }
      else if(_l.Min()+(0.5*_r)-ATR(ind) <= Close(ind) && Close(ind) <= _l.Min()+(0.5*_r)+ATR(ind))
      {  return(true);
      }
      else if(_l.Min()+(0.618*_r)-ATR(ind) <= Close(ind) && Close(ind) <= _l.Min()+(0.618*_r)+ATR(ind))
      {  return(true);
      }
      else if(_h.Max()-ATR(ind) <= Close(ind) && Close(ind) <= _h.Max()+ATR(ind))
      {  return(true);
      }
   }
   return(false);
}

Essa função simplesmente amostra preços ao longo dos últimos 3 meses, um período arbitrário que, evidentemente, não captura níveis-chave de preço da mesma forma que ocorreria em uma análise manual. Costuma-se dizer que a prova está no resultado, portanto insistir demais na forma como interpretamos visualmente o mercado pode não se traduzir necessariamente em melhor desempenho de trading. Por isso, desenvolvemos isso no padrão-9, onde simplesmente buscamos a coincidência entre pontos de fractais e níveis definidos por essa função. O ATR também é utilizado de forma bastante rudimentar para definir a largura desses níveis, de modo que, caso a janela de 3 meses apresente baixa volatilidade, muitos sobreposições tendem a ocorrer. Isso pode servir como ponto de partida para o leitor interessado em realizar modificações.

Uma execução forward walk, como fizemos com os outros cinco padrões, nos fornece o seguinte relatório:

Esse padrão, portanto, atua como uma confirmação de zonas-chave de reversão. Nesta série, sempre que analisamos padrões, também consideramos a possibilidade de não apenas utilizar um padrão isolado — como foi o caso nos 9 padrões acima — mas também de utilizar todos os padrões em conjunto.

Combinando os Padrões

O código anexado para todos os 9 padrões está na forma de uma classe de sinal personalizada. Utilizamos essa classe em um MQL5 Wizard para montar Expert Advisors. Há guias aqui e aqui sobre como fazer isso. As otimizações individuais e execuções de teste que realizamos acima foram baseadas na atribuição ao parâmetro de entrada maps-used de um índice especial no formato 2 elevado ao índice do padrão. Assim, para o padrão 5 isso foi 2^5, que resulta em 32; para o padrão 7 foi 128, e assim por diante. Ao operar com múltiplos padrões, porém, esse parâmetro funciona como um mapa, e não como um ponteiro para um padrão específico. Temos 9 padrões, portanto o valor máximo do nosso parâmetro maps-used é 2^9, que resulta em 512 menos um (já que começamos a contagem a partir de zero).

Se otimizarmos para encontrar a melhor combinação de padrões com limiares padrão de abertura e fechamento, nossas melhores configurações de entrada são as seguintes:

Uma execução de teste nos dados de treinamento nos fornece o seguinte relatório:

E uma execução forward walk, para o ano subsequente de 2024, nos fornece os seguintes resultados:

Esses resultados reforçam o que tem sido enfatizado em artigos anteriores: a combinação de padrões exige conhecimento especializado por parte do trader. Ele precisa ser muito específico ao combinar padrões. Não deve buscar respostas apenas em execuções de otimização. Temos padrões individuais acima que conseguiram bons resultados em forward walk. Isso foi com base em testes de 1 ano, portanto períodos de teste mais longos são certamente necessários e, como sempre, desempenho passado não garante resultados futuros. Ainda assim, isso destaca a importância de adotar uma abordagem focada na seleção de padrões para um sinal, em vez de simplesmente fazer uma média entre eles.

Importância dos Timeframes

A interpretação de fractais é altamente dependente do timeframe utilizado. Timeframes mais altos, como H4, Diário e Semanal, fornecem sinais mais fortes e confiáveis, pois tendem a filtrar grande parte do ruído do mercado. Os fractais nesses timeframes frequentemente marcam níveis-chave de suporte e resistência que instituições e traders de longo prazo realmente observam. Os sinais gerados surgem lentamente, o que pode ser frustrante para muitos traders, mas, quando aparecem, geralmente são setups de alta confiança.

Por outro lado, timeframes mais baixos como M15, M20 e M30 aparecem com mais frequência, mas podem ser menos confiáveis devido às flutuações de curto prazo. Eles são mais adequados para estratégias de scalping, onde reações rápidas são recompensadas. No entanto, em geral, são mais propensos a falsos rompimentos e exigem filtros adicionais para melhorar a precisão.

Existem também timeframes intermediários como H1 e H2, que teoricamente oferecem um equilíbrio entre os dois extremos. O leitor é incentivado a explorar isso, porém a prática indica que eles funcionam melhor quando combinados com fractais em timeframes mais altos.

Conclusão

Os fractais tendem a ser mais eficazes em mercados com alta liquidez e forte interesse institucional. Picos de preço com baixo volume tendem a criar fractais falsos que são rapidamente invalidados, razão pela qual a análise de volume ou gráficos footprint podem ser utilizados para aumentar a confiabilidade das decisões baseadas em fractais.

Dito isso, analisamos 9 padrões distintos deste indicador “fundamental” e, embora ele tenha limitações significativas em timeframes menores, quando utilizado com paciência em timeframes maiores, pode produzir resultados interessantes, como demonstrado pelos testes forward walk de 1 ano em alguns dos padrões.

Arquivo	Descrição
SignalWZ_56.mqh	Arquivo de Classe de Sinal
WZ_56.mq5	Arquivo Expert demonstrando arquivos incluídos