Recursos do Assistente MQL5 que você precisa conhecer (Parte 40): Parabolic SAR

Introdução

Continuamos nossa série de artigos em que exploramos diferentes configurações e ideias de trading que podem ser rapidamente aplicadas e testadas graças ao Assistente MQL5. Nos dois artigos anteriores, focamos nos indicadores e osciladores mais básicos, como aqueles fornecidos com as classes do Assistente na IDE. Utilizamos diferentes padrões que cada um desses indicadores pode oferecer, testamos esses padrões individualmente e também os otimizamos para configurações que usam uma amostra de múltiplos padrões, de modo que pudéssemos comparar os resultados dos testes de execuções independentes dos padrões com configurações coletivas ou otimizadas. 

Neste artigo, manteremos o mesmo formato, analisando sucessivamente vários padrões do Parabolic SAR e encerrando a narrativa com um teste combinando vários padrões, como fizemos nos artigos anteriores. O Parabolic SAR é calculado praticamente de forma independente a cada nova barra, já que alguns parâmetros usados em sua fórmula precisam ser ajustados, como veremos a seguir. No entanto, essa característica o torna muito sensível às variações de preço e à tendência geral, o que justifica seu uso na classe de sinais personalizados. Neste artigo, exploraremos 10 padrões individuais do indicador, testando cada um separadamente e, depois, executando um teste com uma amostra combinada desses padrões, como fizemos nos artigos anteriores.

O código-fonte incluído ao final do artigo é destinado ao uso no Assistente MQL5 para montar um EA que o utilize. Guias para iniciantes podem ser encontrados aqui e aqui.

Definição do Parabolic SAR

O Parabolic SAR é um buffer de valores compensados por valores extremos da tendência atual em quantidades crescentes (ou passos) até um limite especificado. Embora pareça complicado, é apenas uma maneira muito dinâmica de indicar a tendência atual e exibir possíveis pontos de reversão. A fórmula do Parabolic SAR é bastante volátil. Ela varia de acordo com as tendências de alta e de baixa. Para uma tendência de alta:

onde:  

• SAR n+1– valor do SAR para o próximo período.
• SAR n– valor atual do SAR.
• EP (Extreme Point) – o maior preço na tendência atual.
• α – fator de aceleração (acceleration factor, AF), que normalmente começa em 0,02 e aumenta em 0,02 sempre que um novo EP é atingido, até o máximo de 0,20 (esse valor pode ser ajustado conforme as configurações do usuário).

Também vale destacar que, em uma tendência de alta:

• EP é o maior topo desde o início da tendência.
• O valor do SAR aumentará à medida que a tendência continuar, sendo ajustado de acordo com o movimento do preço.

Para uma tendência de baixa:

onde:

• EP é o menor preço na atual tendência de baixa.

Também é importante notar que, em uma tendência de baixa:

• EP é o menor fundo desde o início da tendência.
• O valor do SAR diminuirá com o tempo, acompanhando a tendência de baixa.

Assim, à medida que a tendência se desenvolve, o aumento ou a queda do SAR (como no caso da baixa) tende a comprimi-lo em direção aos preços, o que torna mais provável uma reversão ou mudança de tendência. A implementação em MQL5 é feita por meio dos indicadores integrados e das classes padrão da biblioteca, por isso, neste artigo, nos referiremos apenas a eles. Agora, veremos os diferentes padrões que o SAR pode oferecer.

Cruzamento de intervalo de reversão (Reversal Gap Crossover)

Nosso primeiro padrão, 0, é um cruzamento de intervalo (gap), no qual os pontos do indicador SAR mudam de posição, ficando abaixo dos mínimos em caso de gap altista ou acima dos máximos no caso de gap baixista. Frequentemente, a distância do gap entre os pontos do Parabolic SAR e o ponto de preço mais próximo (que será o mínimo no caso de gap altista ou o máximo no caso de gap baixista) indica a força do sinal. Quanto maior o gap, mais forte é a nova tendência.

No entanto, é importante considerar as condições macroeconômicas do mercado, pois esse tipo de cruzamento de gap pode ocorrer com bastante frequência, especialmente em mercados altamente voláteis, o que pode gerar muitos falsos sinais. Por isso, esse sinal é mais confiável em mercados com baixa volatilidade. Em situações em que o SAR é usado para ajustar o stop-loss, é justamente nesses pontos de cruzamento que, em vez de encerrar a posição, o stop-loss é apenas movido para mais perto do SAR, enquanto outro sinal é utilizado para efetivamente fechar a posição e inverter a direção.

Para implementar nosso padrão 0 na nossa classe personalizada de sinais, usamos a seguinte função:

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

Testes com o EA montado usando o Assistente, que utiliza exclusivamente o padrão 0, nos deram os seguintes resultados:

Zona de compressão do SAR (SAR Compression Zone)

Nosso próximo padrão é a zona de compressão. Essencialmente, trata-se de uma versão aprimorada do padrão 0. A principal diferença, como o nome sugere, está na necessidade de compressão do preço (o que corresponde a uma tendência anterior de baixa volatilidade) antes da reversão do indicador SAR. Como já mencionado, o SAR indica qual tendência está atualmente predominando (alta ou baixa), e por isso, se a tendência anterior teve pouca movimentação, isso pode ser interpretado como compressão. A avaliação quantitativa de “pouca movimentação” pode exigir que adicionemos mais um parâmetro de entrada para definir esse valor. No entanto, decidi implementar o padrão da seguinte maneira:

bool              Compression(ENUM_POSITION_TYPE T, double &Out)
   {                 Out = 0.0;
                     int _i = StartIndex() + 1, _c = 0;
                     double _last = Base(StartIndex() + 1);
                     double _first = 0.0;
                     if
                     (
                     T == POSITION_TYPE_BUY &&
                     Base(StartIndex()) < Low(StartIndex()) &&
                     Base(_i) < Close(StartIndex()) &&
                     Base(_i) > High(_i)
                     )
                     {  while(Base(_i) > High(_i) && _c < __COMPRESSION_LIMIT)
                        {  _first = Base(_i);
                           _i++;
                           _c++;
                        }
                        if(_c > 0)
                        {  Out = fabs(_first - _last)/_c;
                           return(true);
                        }
                     }
                     else if
                     (
                     T == POSITION_TYPE_SELL &&
                     Base(StartIndex()) > High(StartIndex()) &&
                     Base(_i) > Close(StartIndex()) &&
                     Base(_i) < Low(_i)
                     )
                     {  while(Base(_i) < Low(_i) && _c < __COMPRESSION_LIMIT)
                        {  _first = Base(_i);
                           _i++;
                           _c++;
                        }
                        if(_c > 0)
                        {  Out = fabs(_first - _last)/_c;
                           return(true);
                        }
                     }
                     return(false);
   }

Isso, por sua vez, significa que nossa função do padrão 0 é processada da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 1.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_1(ENUM_POSITION_TYPE T)
{  double _compression = 0.0;
   if(Compression(T, _compression))
   {  if(T == POSITION_TYPE_BUY && _compression < 0.02*fabs(Base(StartIndex())-Low(StartIndex())))
      {  return(true);
      }
      else if(T == POSITION_TYPE_SELL && _compression < 0.02*fabs(Base(StartIndex())-High(StartIndex())))
      {  return(true);
      }
   }
   return(false);
}

Essa função quantifica o quanto os valores do indicador foram ajustados na tendência anterior. O valor limite para determinar um valor de entrada insignificante é justamente o que já temos como entrada: o valor de entrada do passo do SAR. Assim, se a proporção do passo inicial do gap do SAR em relação ao preço for maior do que a média de variação dos valores do SAR durante a tendência anterior, então temos uma compressão. E como as condições desse padrão são apenas compressão e reversão de tendência, continuaríamos abrindo a posição de acordo com as condições de reversão de tendência do padrão 0, já descritas acima. Os testes do EA montado com o Assistente e que utiliza exclusivamente o padrão 1 nos deram os seguintes resultados:

Estamos testando o símbolo EURJPY para o ano de 2023 no timeframe diário. Como definimos o modelo de compressão com uma limitação estrita da tendência geral por meio do parâmetro de proporção do passo, não há muitas operações. No entanto, esse comportamento pode ser ajustado com a introdução de outro parâmetro para suavizar a condição. O valor do parâmetro de entrada para o uso de padrões, nesse caso, é dois.

SAR de tendência estendida (Extended Trending SAR)

Esse padrão é um modelo de continuação que pode ser usado nos casos em que a reversão inicial da tendência foi contida, por exemplo, em situações nas quais o gap entre o SAR e o preço foi muito pequeno no início. É tudo bastante simples: o padrão de alta é identificado por um gap em expansão entre os pontos do SAR, enquanto o indicador permanece abaixo dos preços mínimos, e o sinal de baixa é identificado de maneira inversa, com gaps também se expandindo, enquanto o SAR permanece acima dos preços máximos. Alguns podem considerar esse padrão excessivamente atrasado, mas é sempre melhor testar antes de tirar conclusões. No MQL5, o padrão é implementado da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 2.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_2(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && 
   Base(StartIndex()) - Base(StartIndex() + 1) > Base(StartIndex() + 1) - Base(StartIndex() + 2) && 
   Base(StartIndex() + 1) - Base(StartIndex() + 2) > Base(StartIndex() + 2) - Base(StartIndex() + 3) && 
   Base(StartIndex() + 2) - Base(StartIndex() + 3) > Base(StartIndex() + 3) - Base(StartIndex() + 4) 
   )
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && 
   Base(StartIndex() + 1) - Base(StartIndex()) > Base(StartIndex() + 2) - Base(StartIndex() + 1) && 
   Base(StartIndex() + 2) - Base(StartIndex() + 1) > Base(StartIndex() + 3) - Base(StartIndex() + 2) && 
   Base(StartIndex() + 3) - Base(StartIndex() + 2) > Base(StartIndex() + 4) - Base(StartIndex() + 3) 
   )
   {  return(true);
   }
   return(false);
}

Para testar apenas o padrão 2, precisamos do mapa de parâmetros de entrada (input map) definido como 4 para os padrões utilizados. O teste do EA que utiliza apenas esse padrão, com as mesmas configurações empregadas anteriormente, nos fornece os seguintes resultados:

Falso reverso do SAR (SAR Flip Fake-Out)

Como o nome indica, o padrão detecta uma reversão que é quase imediatamente seguida por um retorno ao movimento anterior. Frequentemente, isso é sinalizado por tendências formadas por apenas um ou dois pontos no gráfico do SAR, sendo que a tendência que segue esses pontos e está do lado oposto a eles indica a direção real. Assim, para um sinal de alta, observamos uma tendência de alta normal, seguida de uma reversão caracterizada por apenas 1 ou 2 barras de preço, após a qual a tendência longa é retomada, sendo esse reinício o sinal de entrada. Da mesma forma, o padrão de baixa começa com uma tendência descendente, que reverte brevemente para uma alta em uma ou duas barras de preço, antes de retomar o movimento descendente. A implementação do padrão no código é a seguinte:

//+------------------------------------------------------------------+
//| Check for Pattern 3.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_3(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && Base(StartIndex()) < Low(StartIndex()) && Base(StartIndex() + 1) > High(StartIndex() + 1) && Base(StartIndex() + 2) < Low(StartIndex() + 2))
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex()) > High(StartIndex()) && Base(StartIndex() + 1) < Low(StartIndex() + 1) && Base(StartIndex() + 2) > High(StartIndex() + 2))
   {  return(true);
   }
   return(false);
}

Esse é o quarto padrão, identificado como padrão 3, que posiciona operações confiando exclusivamente em seus próprios sinais. Nosso mapa de parâmetros de entrada para os padrões utilizados deve ser igual a 8. Os testes realizados com as mesmas configurações anteriores para esse padrão não resultaram em nenhuma operação. As causas mais comuns para essa ausência de sinais são mercados instáveis/laterais, baixa volatilidade ou ruído de mercado. Indicadores auxiliares (como o MACD), análise da ação do preço (para suporte e resistência) ou análise de volume (caso essa informação esteja disponível) podem ser úteis. Considerando tudo isso, esse sinal deve ser mais confiável do que uma simples reversão isolada, como no caso do padrão 0.

Duplo reverso do SAR com continuação de tendência (Double SAR Flip with Trend Continuation)

Este é o padrão 3 com mais duas reversões. Isso leva a uma continuação da tendência, de forma semelhante ao padrão 3. Assim como o padrão 3 é mais forte que o padrão 0, o padrão 4 é mais confiável que o padrão 3. A implementação no código está apresentada abaixo. Os testes desse padrão ficam a critério do leitor. Idealmente, é necessário um período de teste superior a um ano. Como em 2023, para o par EURJPY no gráfico diário, nenhuma operação foi gerada com o padrão 3, não esperamos nenhum sinal também para o padrão 4.

//+------------------------------------------------------------------+
//| Check for Pattern 4.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_4(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && 
   Base(StartIndex()) < Low(StartIndex()) && 
   Base(StartIndex() + 1) > High(StartIndex() + 1) && 
   Base(StartIndex() + 2) < Low(StartIndex() + 2) && 
   Base(StartIndex() + 3) > High(StartIndex() + 4) && 
   Base(StartIndex() + 4) < Low(StartIndex() + 5)
   )
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && 
   Base(StartIndex()) > High(StartIndex()) && 
   Base(StartIndex() + 1) < Low(StartIndex() + 1) && 
   Base(StartIndex() + 2) > High(StartIndex() + 2) && 
   Base(StartIndex() + 3) < Low(StartIndex() + 4) && 
   Base(StartIndex() + 4) > High(StartIndex() + 5)
   )
   {  return(true);
   }
   return(false);
}

Divergência do SAR com a média móvel (SAR Divergence with Moving Average)

O padrão 5 surge devido a uma divergência. Como divergências entre os preços e o SAR ocorrem com bastante frequência, o indicador de média móvel é usado como confirmação. Assim, para um sinal de alta, o preço cairá em direção ao SAR, enquanto o SAR continuará subindo e a média móvel estará abaixo ou igual ao SAR. Por outro lado, para o modelo de baixa, o preço subirá enquanto o SAR cair, e a média móvel ainda estará acima ou igual a ambos os valores. O número de passos necessário para medir a subida ou queda pode ser definido livremente (ou por meio de testes); no entanto, para nossos propósitos, assumiremos o valor três. A implementação no código é a seguinte:

//+------------------------------------------------------------------+
//| Check for Pattern 5.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_5(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && 
   MA(StartIndex()) <= Base(StartIndex()) && 
   Base(StartIndex()) > Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) > Base(StartIndex() + 2) && 
   Close(StartIndex()) < Close(StartIndex() + 1) && 
   Close(StartIndex() + 1) < Close(StartIndex() + 2)
   )
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && 
   MA(StartIndex()) >= Base(StartIndex()) && 
   Base(StartIndex()) < Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) < Base(StartIndex() + 2) && 
   Close(StartIndex()) > Close(StartIndex() + 1) && 
   Close(StartIndex() + 1) > Close(StartIndex() + 2)
   )
   {  return(true);
   }
   return(false);
}

O teste do EA que utiliza apenas esses padrões nos dá os seguintes resultados:

Aqui lidamos com três buffers de dados — preços, média móvel e SAR. Optamos por observar a divergência entre preços e SAR, embora também seja possível analisar outros tipos, como entre a média móvel e o SAR. No entanto, essa divergência, por conta do efeito de atraso da média móvel, também apresentará um leve atraso comparado à divergência entre preço e SAR, que foi a que implementamos neste artigo. Por outro lado, ela tende a ser menos ruidosa, já que o preço gera muitas variações no curto prazo que frequentemente não resultam em nada no longo prazo. Recomendamos ao leitor que explore essa alternativa por conta própria. O valor de entrada para a aplicação de padrões neste caso é 32.

Construção de canais Parabolic SAR (Parabolic SAR Channeling)

O padrão combina o movimento do preço com a tendência atual do SAR para gerar sinais. Canais de preço são relativamente fáceis de entender observando um gráfico, mas implementar essa lógica em código costuma ser mais complicado do que parece à primeira vista. Por isso, desde o início, pode ser uma boa ideia definir uma função elementar que determine os limites superior e inferior atuais do canal de preço, sendo que a faixa desse canal é definida pela quantidade de barras de preço que devem ser verificadas no histórico. Vamos chamar essa função de Channel. A lógica implementada na interface está apresentada abaixo:

bool              Channel(ENUM_POSITION_TYPE T)
   {                 vector _max,_max_i;
                     vector _min,_min_i;
                     _max.Init(2);
                     _max.Fill(High(0));
                     _max_i.Init(2);
                     _max_i.Fill(0.0);
                     _min.Init(2);
                     _min.Fill(Low(0));
                     _min_i.Init(2);
                     _min_i.Fill(0.0);
                     for(int i=0;i<m_ma_period;i++)
                     {  if(High(i) > _max[0])
                        {  _max[0] = High(i);
                           _max_i[0] = i;
                        }
                        if(Low(i) < _min[0])
                        {  _min[0] = Low(i);
                           _min_i[0] = i;
                        }
                     }
                     double _slope = (Close(0) - Close(m_ma_period-1))/m_ma_period;
                     double _upper_scale = fabs(_slope);
                     double _lower_scale = fabs(_slope);
                     for(int i=0;i<m_ma_period;i++)
                     {  if(i == _max_i[0])
                        {  continue;
                        }
                        else
                        {  double _i_slope = (High(i) - _max[0])/(i - _max_i[0]);
                           if((_i_slope > 0.0 && _slope > 0.0)||(_i_slope < 0.0 && _slope < 0.0))
                           {  if(fabs(_i_slope-_slope) < _upper_scale)
                              {  _max[1] = High(i);
                                 _max_i[1] = i;
                              } 
                           }
                        }
                     }
                     for(int i=0;i<m_ma_period;i++)
                     {  if(i == _min_i[0])
                        {  continue;
                        }
                        else
                        {  double _i_slope = (Low(i) - _min[0])/(i - _min_i[0]);
                           if((_i_slope > 0.0 && _slope > 0.0)||(_i_slope < 0.0 && _slope < 0.0))
                           {  if(fabs(_i_slope-_slope) < _lower_scale)
                              {  _min[1] = Low(i);
                                 _min_i[1] = i;
                              } 
                           }
                        }
                     }
                     vector _projections;
                     _projections.Init(4);
                     _projections[0] = _max[0] + (_max_i[0]*_slope);
                     _projections[1] = _min[0] + (_min_i[0]*_slope);
                     _projections[2] = _max[1] + (_max_i[1]*_slope);
                     _projections[3] = _min[1] + (_min_i[1]*_slope);
                     if(T == POSITION_TYPE_BUY && Close(0) < Close(m_ma_period) && Close(0) < _projections.Mean())
                     {  return(true);
                     }
                     else if(T == POSITION_TYPE_SELL && Close(0) > Close(m_ma_period) && Close(0) > _projections.Mean())
                     {  return(true);
                     }
                     return(false);
   }

Os principais dados de saída desse canal serão, considerando o tipo de posição, os seguintes: o canal indica uma possível reversão? E, para responder a essa pergunta, primeiro precisamos definir quais pontos de preço determinam as linhas superior e inferior. Assim como é fácil identificar visualmente um gráfico de preços comum, é igualmente fácil perceber no código a necessidade de usar fractais. E embora essa seja uma abordagem válida, desde que o indicador de fractais seja realmente eficaz, descobri que focar na inclinação geral de um período histórico definido (look-back period) oferece uma solução mais generalista.

Portanto, para definirmos nosso canal, primeiro precisamos obter uma noção da inclinação ao longo do período em análise. Nosso período histórico será o mesmo usado pelo indicador de média móvel, que foi destacado no padrão 5 acima. Os leitores podem criar um parâmetro adicional próprio, mas sempre considerei que, quanto menos parâmetros de entrada, mais generalizável é o modelo. Assim, uma vez que obtemos a inclinação, precisamos identificar dois topos no período determinado que melhor se ajustem a essa inclinação.

Contudo, normalmente se espera que o ponto mais alto do período esteja posicionado ao longo da linha superior do canal; por isso, se começarmos obtendo o valor máximo, em seguida teremos que percorrer todos os demais topos até encontrarmos o segundo valor alto cuja inclinação, em relação ao nosso ponto mais alto, corresponda da melhor forma à inclinação da tendência geral. Aqui, naturalmente, a tendência geral é a variação no preço de fechamento ao longo de todo o período analisado.

Uma vez que tenhamos essas duas referências, repetimos o mesmo processo para a linha inferior do canal, encontrando o ponto mais baixo e outro fundo que se alinhe melhor com a inclinação da tendência ao ser conectado à mínima. Os dois pares de pontos definem duas linhas e, portanto, com isso você tem um canal baseado exclusivamente no período histórico. Ao observar um gráfico de preços, definitivamente não se deve adotar uma abordagem tão mecanicista, pois é improvável que um histórico fixo sempre contenha pontos de dados suficientemente relevantes. Simplesmente conectar esses pontos e tentar extrapolá-los inevitavelmente resultará na formação de vários canais aleatórios. Um histórico fixo frequentemente não cobre todos os pontos de preço históricos essenciais para a análise.

É por isso que definimos nosso canal como tendo duas linhas superiores e duas inferiores, e não apenas uma de cada. Cada uma dessas linhas passa por quatro pontos que já identificamos anteriormente. Nosso sinal de alta com o padrão 6 ocorre quando o preço está na metade inferior do canal e o Parabolic SAR também indica uma tendência de alta. Para o cenário de baixa, o preço estará na metade superior do canal e o SAR indicará uma tendência de baixa. Para determinar em qual metade do canal o preço atual está, basta calcular a média de todas as quatro projeções de pontos de preço. Essas projeções são simplesmente extensões das linhas que passam por nossos dois topos e dois fundos até o índice atual, mantendo a mesma inclinação da tendência geral. Implementamos esse padrão no MQL5 da seguinte maneira:

//+------------------------------------------------------------------+
//| Check for Pattern 6.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_6(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && Base(StartIndex()) < Low(StartIndex()))
   {  return(Channel(T));
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex()) > High(StartIndex()))
   {  return(Channel(T));
   }
   return(false);
}

Os testes com as mesmas configurações que utilizamos anteriormente para o EURJPY no gráfico diário de 2023 nos deram os seguintes resultados:

O valor de entrada para aplicação de padrões neste padrão é 64.

Considerações

Analisamos sete dos dez possíveis modelos do Parabolic SAR. Os três restantes serão abordados em outro momento, pois incluir todos tornaria o artigo excessivamente longo. Os padrões que abordaremos no próximo artigo incluirão a divergência entre Parabolic SAR e volume, o SAR invertido em um timeframe superior e a sobreposição entre SAR e RSI. Cada um dos padrões analisados neste artigo pode ser utilizado e implementado de diferentes formas e em diversos formatos. Neste artigo e nos dois anteriores, utilizamos os métodos integrados de padrões do arquivo da classe de sinais, da qual nossa classe de sinal personalizada herda. Nos dois artigos anteriores, declaramos e utilizamos o parâmetro m_patterns_used, que era redundante e desnecessário, já que nossa classe pai já possui o parâmetro m_patterns_usage. Esse último reduz a complexidade do código e oferece resultados mais enxutos, já que o mapa de parâmetros de entrada está sendo utilizado da maneira correta.

Os leitores não devem repetir esse erro e devem corrigir os códigos anexados aos dois artigos recentes. Este artigo permite concluir que a implementação de canais de preço em EAs não é muito comum. Talvez valha a pena dedicar um artigo exclusivo ao uso de canais de preço como classe de sinais. Embora a análise de gráficos com canais seja uma tarefa simples, já que os pontos que definem os limites superior e inferior são facilmente identificáveis visualmente, fazer isso por meio de código é muito mais desafiador. Por esse motivo, é possível que voltemos a tratar desse tema em um artigo futuro.

Por fim, nesta série de padrões, fazemos algo que contraria alguns sinais integrados baseados em padrões que fazem parte da biblioteca padrão. Nós otimizamos as condições-limite ideais para cada padrão. Isso vai de encontro à regra amplamente aceita de que os valores de limiar são definidos pelo próprio trader com base em sua experiência e observações ao trabalhar com os indicadores. Embora os resultados dos nossos testes pareçam promissores, eles são mais difíceis de generalizar e, portanto, de submeter à validação cruzada, pois estamos utilizando múltiplos padrões. Por isso, eu recomendaria que o trader definisse previamente esses pesos-limiar no caso de serem usados múltiplos padrões. Se for necessário utilizar apenas um padrão, como descrito no artigo anterior, no qual foram listados os valores do mapa de parâmetros de entrada para cada padrão individual, então seria possível otimizar somente esse peso-limiar.