Técnicas do MQL5 Wizard que você deve conhecer (Parte 44): Indicador técnico Average True Range (ATR)

Introdução

O Average True Range é um indicador de volatilidade comum e popular, que, para os traders de forex, é provavelmente a “coisa mais próxima” dos dados de volume. Desenvolvido como um indicador destinado a acompanhar a faixa das barras de preço sem ignorar as mudanças intra-barra, ele se tornou um verdadeiro pilar na indústria, não apenas para filtrar sinais de entrada, mas também para orientar o dimensionamento de posições. Analisamos este indicador decompondo-o em possíveis padrões, como temos feito com os artigos dos indicadores anteriores, com a principal diferença de que também olhamos para padrões fora da classe de sinais personalizada, considerando também a classe de gerenciamento de dinheiro personalizada para Expert Advisors montados com o wizard.

Antes disso, vamos concluir o indicador que havíamos iniciado por último, o ADX.

Reversão do ADX

O Padrão 6 para o ADX é a reversão, caracterizada por uma queda no buffer principal do ADX no final de uma tendência proeminente. Recapitulando brevemente o ADX: ele mede a força de uma tendência, com picos ou elevações no buffer principal do oscilador indicando força da tendência vigente. Além disso, há 2 buffers extras, o DI+ e o DI-, que também quantificam a força das altas e baixas de preço, respectivamente.

Assim, um sinal de alta é marcado por uma forte tendência de baixa que ocorre há algum tempo, somada a uma queda nas leituras do buffer principal do oscilador de acima do nível 50 para abaixo de 40 em cerca de 2–3 barras de preço. O argumento por trás disso é que, como o ADX mede a força da tendência, a tendência atual está enfraquecendo e, portanto, uma reversão dela — neste caso, uma tendência de alta — está prestes a ocorrer. Por outro lado, um sinal de baixa é marcado por uma forte tendência de alta que também apresenta queda semelhante no buffer principal do ADX para abaixo de 40 a partir de um valor elevado. Implementamos isso na classe de sinal da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 6.                                             |
//+------------------------------------------------------------------+
bool CSignalADX::IsPattern_6(ENUM_POSITION_TYPE T)
{  if(Base(X()+3) >= 50 && Base(X()) <= 40)
   {  if(T == POSITION_TYPE_BUY && Close(StartIndex()) > Close(StartIndex() + m_ma_period))
      {  return(true);
      }
      else if(T == POSITION_TYPE_SELL && Close(StartIndex()) < Close(StartIndex() + m_ma_period))
      {  return(true);
      }
   }
   return(false);
}

E o teste exclusivamente deste padrão, ao atribuir ao parâmetro de entrada ‘Patterns Used’ o valor inteiro 64, nos dá os seguintes resultados:

ADX e Rompimento de Suporte/Resistência

O Padrão 7, que é o 8^º e penúltimo dos padrões do ADX que estamos considerando, combina picos no buffer principal do ADX com rompimentos de níveis de suporte ou resistência. Como a interpretação das linhas de suporte e resistência é mais problemática em código do que no trading manual, vamos recorrer a um indicador secundário, as Bandas de Bollinger, para ajudar a definir melhor esses níveis. Existem alternativas mais refinadas para isso, que considerei nos artigos recentes sobre RSI e Bandas de Bollinger, e o leitor pode consultá-los para redefinir o que escolhemos usar aqui.

Nossos rompimentos de suporte e resistência serão simplesmente marcados por atravessar os limites inferior e superior do indicador Bandas de Bollinger. Portanto, um sinal de alta é marcado por uma elevação no buffer principal do ADX acima do nível 25 e também um pico de preço através da banda superior das Bollinger. Já um sinal de baixa é marcado por uma elevação semelhante no ADX e uma queda no preço abaixo da banda inferior. Implementamos isso em MQL5 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 7.                                             |
//+------------------------------------------------------------------+
bool CSignalADX::IsPattern_7(ENUM_POSITION_TYPE T)
{  if(Base(X()+2) < 25 && Base(X()) > 25)
   {  if(T == POSITION_TYPE_BUY && Close(StartIndex()) >= Upper(StartIndex()))
      {  return(true);
      }
      else if(T == POSITION_TYPE_SELL && Close(StartIndex()) <= Lower(StartIndex()))
      {  return(true);
      }
   }
   return(false);
}

Testando o Expert Advisor montado com o wizard que usa apenas este padrão, ao definir o parâmetro de entrada “Patterns Used” como 128, obtemos os seguintes resultados:

ADX com Confirmação RSI

Nosso padrão final, 8, combina ADX com um indicador que já analisamos: o RSI. Como o ADX mede tendências e o RSI geralmente é usado para marcar pontos de sobrecompra e sobrevenda, a combinação dos dois, do ponto de vista do ADX, precisa considerar tendências ascendentes ou fortes, e não seu fim. Assim, focamos nos cruzamentos do RSI no nível 50, e não quando ele atinge os limites 70/30.

O sinal de alta é marcado, portanto, por um cruzamento do RSI de abaixo de 50 para acima de 50, juntamente com uma elevação no buffer principal do ADX de abaixo de 25 para acima de 25. Inversamente, o sinal de baixa é assinalado por uma queda no RSI de acima de 50 para abaixo, com nova alta no valor do ADX acima do nível 25. Implementamos isso em MQL5 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 8.                                             |
//+------------------------------------------------------------------+
bool CSignalADX::IsPattern_8(ENUM_POSITION_TYPE T)
{  if(Base(X()+1) < 25 && Base(X()) > 25)
   {  if(T == POSITION_TYPE_BUY && RSI(StartIndex()) > 50 && RSI(StartIndex() + 1) < 50)
      {  return(true);
      }
      else if(T == POSITION_TYPE_SELL && RSI(StartIndex()) < 50 && RSI(StartIndex() + 1) > 50)
      {  return(true);
      }
   }
   return(false);
}

O teste apenas deste padrão, atribuindo o valor inteiro 256 a “Patterns Used”, nos dá os seguintes resultados:

Otimização para Padrões Ideais do ADX

Nosso Expert Advisor montado pelo wizard, para o qual há artigos-guia aqui e aqui explicando como fazer isso com o código anexado ao final deste artigo, também pode ser usado com todos os padrões de ADX considerados até agora, embora com pesos diferentes. Como mencionei antes, isso não é necessariamente o ideal, pois diferentes padrões podem se anular, de modo que, nas otimizações, os resultados tendem a ser “curve fitted” e frequentemente falham em replicar o desempenho em dados fora da amostra. Dito isso, aqui estão alguns resultados de testes da combinação dos nove padrões do ADX que consideramos até agora.

O ATR

O oscilador Average True Range, já introduzido acima, mede a volatilidade, que para traders de forex é crucial, dado que não há dados de volume. Vamos, portanto, também analisar seus padrões, alguns dos quais são aplicáveis fora da nossa típica classe de sinais personalizados.

Sinal de Rompimento por Volatilidade

Quando o valor atual do ATR sobe significativamente acima de sua média recente, isso pode indicar um rompimento de volatilidade. Isso, por sua vez, implica em uma estratégia de negociação em que a entrada na direção do rompimento, quando o ATR aumenta significativamente, sinaliza que o mercado provavelmente terá grandes movimentos de preço nessa direção. Indicadores complementares como a Média Móvel, MACD etc. também podem determinar a direção da negociação. Implementamos isso em MQL5 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 0.                                             |
//+------------------------------------------------------------------+
bool CSignalATR::IsPattern_0(ENUM_POSITION_TYPE T)
{  if(ATR(X()) > ATR(X() + 1) && ATR(X() + 1) > ATR(X() + 2) && ATR(X() + 2) > ATR(X() + 3))
   {  if(T == POSITION_TYPE_BUY && Close(X()) > Close(X() + 1) && Close(X() + 1) > Close(X() + 2) && Close(X() + 2) > Close(X() + 3))
      {  return(true);
      }
      else if(T == POSITION_TYPE_SELL && Close(X()) < Close(X() + 1) && Close(X() + 1) < Close(X() + 2) && Close(X() + 2) < Close(X() + 3))
      {  return(true);
      }
   }
   return(false);
}

O teste deste padrão isolado, com o parâmetro “Patterns Used” definido como 1, nos fornece os seguintes relatórios como um de seus muitos resultados favoráveis em uma breve fase de otimização. Estamos otimizando para o par EUR/USD no ano de 2022, no período horário.

Limite de ATR para Confirmação de Rompimento

Confirmações de rompimento com ATR são fundamentais, dado que o ATR é uma medida de volatilidade. Ao atribuir um valor à faixa média (máximas menos mínimas) em um período definido, ele ajuda os traders a determinar quanto o preço normalmente se move a cada nova barra. Um rompimento ocorre quando o preço ultrapassa um nível definido de suporte ou resistência. O ATR, portanto, pode servir como filtro contra falsos rompimentos, usando limites de volatilidade para confirmar o movimento.

Um problema comum nos rompimentos é que os preços podem ultrapassar um nível brevemente e depois recuar. O limite do ATR, quando aplicado a esses rompimentos, ajuda a filtrar, confirmando o rompimento se o preço ultrapassar um percentual específico acima/abaixo do nível-chave em relação ao valor do ATR. Por exemplo, se o ATR for 20 pips, um rompimento pode ser considerado válido se o preço ultrapassar o suporte/resistência em pelo menos 1,5x ou 2x desses 20 pips, indicando uma mudança real de momentum em vez de ruído. Essas leituras do ATR, portanto, são muito sensíveis, motivo pelo qual definir um período de ATR mais curto (por exemplo, 7 ou 10 em vez do típico 14) pode ser usado para mercados mais rápidos ou estratégias de curto prazo, oferecendo melhor adaptação à volatilidade. Já com Swing Trading, um período maior (ex.: 14 ou 20) suaviza o ruído e fornece um sinal de confirmação de rompimento mais estável.

Nossa implementação em MQL5, porém, usa uma abordagem um pouco diferente, em que rastreamos oscilações de preço em relação a um valor absoluto de ATR. Se as mudanças de preço em uma determinada direção vierem acompanhadas de movimento razoável no ATR, acima de um limite otimizado, um novo sinal é disparado na direção da tendência. Codificamos isso da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 1.                                             |
//+------------------------------------------------------------------+
bool CSignalATR::IsPattern_1(ENUM_POSITION_TYPE T)
{  if(ATR(X()) >= m_threshold_points*m_symbol.Point())
   {  if(T == POSITION_TYPE_BUY && Close(X()) > Close(X() + 1) && Close(X() + 1) > Close(X() + 2) && Close(X() + 2) > Close(X() + 3))
      {  return(true);
      }
      else if(T == POSITION_TYPE_SELL && Close(X()) < Close(X() + 1) && Close(X() + 1) < Close(X() + 2) && Close(X() + 2) < Close(X() + 3))
      {  return(true);
      }
   }
   return(false);
}

Uma execução de teste a partir de otimizações apenas com este padrão nos dá os seguintes resultados:

ATR como Sinal de Saída

A medição de volatilidade de mercado pelo ATR o torna uma ferramenta eficaz para determinar pontos de saída dinâmicos com base nas condições atuais do mercado. Diferente das estratégias de saída fixas em pips ou pontos, as saídas baseadas no ATR se adaptam à volatilidade do mercado, garantindo que as saídas ocorram em níveis significativos, e não em limites arbitrários. Um aumento repentino nos valores do ATR pode indicar um evento de mercado significativo (como atas do Fed, etc.) ou uma potencial reversão. Portanto, os traders podem optar por sair de uma posição quando o ATR se expande além de um determinado limite, sinalizando volatilidade elevada que pode levar ao esgotamento da tendência ou a reversões. Essa iminente reversão, portanto, constitui um sinal.

Swing traders podem usar ainda o ATR para sair de posições em níveis de preço conhecidos/identificados, somando ou subtraindo um múltiplo do ATR aos topos ou fundos recentes. Isso lhes permite considerar o movimento médio do preço e sair próximo a pontos-chave de reversão. Esse tipo de saída, baseada em níveis de ATR por swing traders, reduz a exposição a excursões adversas ou perdas indesejadas, especialmente durante períodos de maior volatilidade que podem sinalizar uma reversão iminente ou fase de consolidação.

Além disso, em mercados laterais, o ATR tende a ser baixo. Portanto, quando o ATR sobe de repente, isso pode indicar um possível rompimento ou aumento da volatilidade. Traders podem usar essa alta como sinal de saída se já estivessem posicionados dentro da faixa. A regra fundamental aqui é que evitar saídas em baixa volatilidade ajuda os traders a não ficarem presos em mercados laterais e voláteis, mantendo assim um perfil risco/retorno favorável em suas operações. Nossa implementação em MQL5, no entanto, é um pouco simplista porque estamos construindo uma classe de sinal personalizada e buscamos entradas. É assim que codificamos o padrão 2:

//+------------------------------------------------------------------+
//| Check for Pattern 2.                                             |
//+------------------------------------------------------------------+
bool CSignalATR::IsPattern_2(ENUM_POSITION_TYPE T)
{  if(ATR(X()) >= 2.0 * m_threshold_points*m_symbol.Point())
   {  if(T == POSITION_TYPE_SELL && Close(X()) > Close(X() + 1) && Close(X() + 1) > Close(X() + 2) && Close(X() + 2) > Close(X() + 3))
      {  return(true);
      }
      else if(T == POSITION_TYPE_BUY && Close(X()) < Close(X() + 1) && Close(X() + 1) < Close(X() + 2) && Close(X() + 2) < Close(X() + 3))
      {  return(true);
      }
   }
   return(false);
}

Nossa abordagem aqui essencialmente chama uma reversão de tendência quando os valores do ATR ficam muito altos, mais que o dobro de um limite otimizado. Esse certamente não é o melhor método para explorar isso, já que, como o leitor pode notar, mencionamos formas “mais interessantes” de capitalizar saídas acima. Contudo, como sempre, o código-fonte anexado pode ser modificado para adotar uma abordagem alternativa. Uma execução de teste de uma breve otimização para o par EUR/CHF no ano de 2022, no período de 1 hora, nos fornece o seguinte relatório:

Sinal de Contração de Volatilidade

A contração do ATR também pode servir como sinal para se preparar para uma expansão da volatilidade, o “Silêncio antes da Tempestade”. Períodos de baixa volatilidade geralmente precedem um surto de preços ou uma fase de forte movimento. Alguns traders monitoram a contração do ATR para antecipar quando um rompimento é provável, posicionando-se para o movimento iminente. Um aumento repentino no ATR após esse período costuma ser uma forte confirmação de que ocorreu um rompimento. Assim, os traders podem usar a contração do ATR para entrar em operações assim que a volatilidade começar a se expandir novamente, alinhando-se à tendência.

Outro benefício das contrações do ATR se relaciona a saídas com limite de tempo. Alguns traders encerram posições após um determinado período, usando o ATR para orientar quando fechar posições que estão estagnadas. Se o ATR estiver baixo ou em declínio com o passar do tempo, isso pode sinalizar perda de momentum, o que justificaria sair da posição, já que mantê-la não trará movimentos significativos. Em estratégias de seguidor de tendência, a contração do ATR também pode ser útil. Numa tendência forte, se surgir uma contração, isso pode indicar que a tendência está perdendo força e pode entrar em consolidação. Isso pode oferecer aos seguidores de tendência a oportunidade de se prepararem para possíveis reversões ou realizarem lucros. Para traders de tendência, uma saída temporária pode fazer sentido.

Para swing traders, a contração do ATR pode sinalizar que o preço está preso numa fase de consolidação, sugerindo que é hora de sair das posições e evitar ser pego em movimentos laterais. Por outro lado, quando a contração termina, swing traders podem procurar pontos de entrada quando a volatilidade volta a se expandir. Alternativamente, swing traders podem usar a contração do ATR para identificar mercados de faixa, negociando o intervalo ao comprar no suporte e vender na resistência até que ocorra um rompimento.

Vale notar também, especialmente nos opacos mercados de forex, que a contração do ATR muitas vezes ocorre juntamente com a queda nos volumes de negociação, o que geralmente implica indecisão dos participantes do mercado. Quando o volume aumenta e o ATR se expande, isso pode sugerir um possível rompimento à medida que nova liquidez entra no mercado. Combinar contração do ATR com aumento subsequente de volume é uma confirmação útil para traders de rompimento que buscam entrar durante a expansão da volatilidade.Para este artigo, a contração de volatilidade como sinal de entrada é usada para capturar reversões. Essas reversões iminentes definem, então, nossa direção antecipada de preço. Se o ATR diminuir após uma tendência de baixa, esperamos um repique e, portanto, temos um sinal de alta. Se, por outro lado, essa queda no ATR ocorrer ao final de uma alta, tomamos isso como um sinal de baixa. Nosso código para isso é apresentado abaixo:

//+------------------------------------------------------------------+
//| Check for Pattern 3.                                             |
//+------------------------------------------------------------------+
bool CSignalATR::IsPattern_3(ENUM_POSITION_TYPE T)
{  if(ATR(X()) < ATR(X() + 1) && ATR(X() + 1) < ATR(X() + 2) && ATR(X() + 2) < ATR(X() + 3))
   {  if(T == POSITION_TYPE_SELL && Close(X() + 3) > Close(X() + 4) && Close(X() + 4) > Close(X() + 5) && Close(X() + 5) > Close(X() + 6))
      {  return(true);
      }
      else if(T == POSITION_TYPE_BUY && Close(X() + 3) < Close(X() + 4) && Close(X() + 4) < Close(X() + 5) && Close(X() + 5) < Close(X() + 6))
      {  return(true);
      }
   }
   return(false);
}

O teste de alguns dos resultados de otimização que usam apenas o padrão 3, com o parâmetro de entrada “patterns used” definido como 8, nos dá os seguintes resultados:

Canal ATR (Bandas ATR)

Os Canais ATR (também conhecidos como Bandas ATR) são bandas dinâmicas baseadas em volatilidade que podem ser plotadas acima e abaixo do preço usando um múltiplo do Average True Range (ATR). Assim como as Bandas de Bollinger, eles ajudam a criar um canal em torno do preço, o que nesse caso específico pode ser útil para refletir a volatilidade do mercado.

E, assim como as Bandas, estes canais se expandem e se contraem de acordo com a volatilidade, fornecendo aos traders uma noção de quanto o preço normalmente se move a partir da sua média em um determinado período. Além disso, as bandas superior e inferior atuam como níveis dinâmicos de suporte e resistência, de modo que, à medida que o preço flutua dentro dessas bandas, toques ou rompimentos desses “níveis” podem gerar sinais de potenciais reversões ou de continuidade. Diferentemente dos suportes/resistências estáticos, estes são mais dinâmicos e responsivos às condições de mercado prevalecentes.

Assim, os sinais dessas bandas ocorrem quando temos um rompimento de preço acima da banda superior do ATR (indicando tendência de alta ou pressão compradora) ou um rompimento abaixo da banda inferior (indicando tendência de baixa ou pressão vendedora). Para traders manuais, seria necessário implementar um indicador personalizado que plote fisicamente essas bandas. Mas no nosso caso, como usamos Expert Advisors montados pelo wizard (com guias aqui e aqui para novos leitores), não precisamos nos preocupar com isso. Como estamos automatizando nosso processo de negociação, podemos combinar as leituras dos indicadores de preço (média móvel) e ATR para definir essas bandas em cada nova barra. Implementamos o padrão em MQL5 da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 4.                                             |
//+------------------------------------------------------------------+
bool CSignalATR::IsPattern_4(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && Close(X()) > MA(X()) + 2.0 * ATR(X()))
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Close(X()) < MA(X()) - 2.0 * ATR(X()))
   {  return(true);
   }
   return(false);
}

Essas bandas podem assumir funções extras, como filtrar falsos rompimentos quando usadas com outros indicadores, como Bandas de Bollinger ou Canais de Keltner, confirmando que o rompimento é significativo o bastante. Outras aplicações do canal ATR se sobrepõem um pouco ao que já mencionamos acima, mas ainda merecem ser citadas. Os Canais ATR podem ajudar a identificar a força e a direção de uma tendência. Quando o preço se move consistentemente próximo à banda superior do ATR, isso indica uma forte tendência de alta. Da mesma forma, o preço ao longo da banda inferior indica forte tendência de baixa. Esse reconhecimento de tendência pode ser útil em alguns mercados que parecem instáveis em períodos mais longos. Por outro lado, se o preço luta para romper as bandas ATR ou toca-as frequentemente sem continuidade, isso pode sinalizar esgotamento da tendência ou perda de momentum.

Traders também usam as Bandas ATR para identificar oportunidades de reversão à média, especialmente em mercados laterais. Quando o preço toca a banda superior ou inferior, isso pode sinalizar que o ativo está sobrecomprado ou sobrevendido, e uma reversão para a média (preço médio) é provável.Portanto, dependendo do período em consideração, quando o preço recua após tocar a banda sem rompê-la, isso pode sinalizar ao trader que é hora de realizar lucros ou inverter posições.

Ao usar take-profit baseado em volatilidade, essas bandas podem fornecer níveis dinâmicos. Um take-profit colocado logo fora da banda ATR pode proteger operações contra o ruído normal do mercado, permitindo espaço para flutuações de preço dentro da banda, sem deixar dinheiro na mesa. Isso não foi considerado em nossa implementação do padrão 4, já que estamos fazendo uma classe de sinal personalizada, mas pode ser incluído em uma classe de trailing customizada de outro Expert Advisor montado com o wizard. Testes de otimização, com configurações semelhantes às que usamos acima (EUR/CHF, período horário, ano 2022), apresentam os seguintes resultados:

Em seguida, realizamos uma otimização combinando todos esses sinais, com diferentes pesos, obtendo os seguintes resultados de uma das execuções favoráveis:

ATR na Classe de Trailing

Consideramos como o ATR pode ser usado para gerar sinais de entrada e saída para um Expert Advisor, mesmo que esse não seja sempre o propósito principal. Principalmente, o ATR é usado em definição de stops ou no dimensionamento de posições; portanto, analisamos esses casos dentro de classes personalizadas que ainda podem ser montadas em um Expert Advisor via MQL5 wizard.

Mantemos nossa implementação aqui simples: para definir um nível de trailing stop, simplesmente incrementamos um benchmark por um múltiplo do ATR. Nosso benchmark, para nossos propósitos, pode assumir 3 formas: Preço bruto, Preço da média móvel e o Preço do indicador SAR Cada uma dessas, por si só, fornece um padrão que indexamos como 0, 1 e 2, e codificamos da seguinte forma:

//+------------------------------------------------------------------+
//| Check for Pattern 0.                                             |
//+------------------------------------------------------------------+
void CTrailingATR::IsPattern_0(double &Price, ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY)
   {  Price -= (m_stop_level * ATR(StartIndex()));
   }
   else if(T == POSITION_TYPE_SELL)
   {  Price += (m_stop_level * ATR(StartIndex()));
   }
}
//+------------------------------------------------------------------+
//| Check for Pattern 1.                                             |
//+------------------------------------------------------------------+
void CTrailingATR::IsPattern_1(double &Price, ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY)
   {  Price = (MA(StartIndex()) - (m_stop_level * ATR(StartIndex())));
   }
   else if(T == POSITION_TYPE_SELL)
   {  Price = (MA(StartIndex()) + (m_stop_level * ATR(StartIndex())));
   }
}
//+------------------------------------------------------------------+
//| Check for Pattern 2.                                             |
//+------------------------------------------------------------------+
void CTrailingATR::IsPattern_2(double &Price, ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && SAR(StartIndex()) < Low(StartIndex()))
   {  Price = (SAR(StartIndex()) - (m_stop_level * ATR(StartIndex())));
   }
   else if(T == POSITION_TYPE_SELL && SAR(StartIndex()) > High(StartIndex()))
   {  Price = (SAR(StartIndex()) + (m_stop_level * ATR(StartIndex())));
   }
}

Otimizações e testes podem ser realizados padrão por padrão, como fizemos acima. Contudo, para brevidade, vamos apenas executar uma simulação única que busca otimizar o uso de todos os padrões com diferentes pesos. Os resultados são apresentados a seguir:

ATR no Gerenciamento de Risco

Gaps de stop loss podem ser úteis na definição do tamanho da posição. Isso porque, o argumento é: se alguém tem uma posição aberta, então o stop loss é o que limitaria a perda máxima que poderia incorrer nessa posição, caso a operação fosse contra. Portanto, ao medir o valor em ticks de um gap de stop loss, pode-se calcular um valor nominal de tamanho de posição em lotes que não acionaria mais do que aquela porcentagem definida da margem livre naquele momento.

Uma vez definidos um nível de stop loss e um percentual máximo de risco, podemos obter o número de lotes que, em teoria, limitariam nossas perdas. Isso é apenas em teoria porque os stops não garantem execução no preço definido. Eles só são acionados se aquele preço estiver disponível — e é por isso que janeiro de 2015 foi devastador para traders do CHF. Qual seria então o melhor seguro? Dimensionamento mínimo e responsável de posição. Se adotarmos os mesmos 3 diferentes métodos possíveis de stop loss que vimos acima com o trailing stop, é assim que implementaríamos 3 padrões paralelos para uma classe de gerenciamento de risco personalizada:

//+------------------------------------------------------------------+
//| Getting lot size for open long position.                         |
//+------------------------------------------------------------------+
double CMoneyATR::CheckOpenLong(double price, double sl)
{  if(m_symbol == NULL)
      return(0.0);
//--- select lot size
   double lot;
   if(price == 0.0)
      lot = m_account.MaxLotCheck(m_symbol.Name(), ORDER_TYPE_BUY, m_symbol.Ask(), m_percent);
   else
      lot = m_account.MaxLotCheck(m_symbol.Name(), ORDER_TYPE_BUY, price, m_percent);
//---
   double result  = 0.0, results = 0.0;
   price =m_symbol.Bid();
//--- if the model 0 is used and "ATR-Based Stop Loss"
   if(((m_patterns_usage & 0x01) != 0))
   {  IsPattern_0(price, POSITION_TYPE_BUY);
      result += m_pattern_0 * price;
      results += m_pattern_0;
   }
//--- if the model 1 is used and "ATR-MA-Channel Stop Loss"
   if(((m_patterns_usage & 0x02) != 0))
   {  IsPattern_1(price, POSITION_TYPE_BUY);
      result += m_pattern_1 * price;
      results += m_pattern_1;
   }
//--- if the model 2 is used and "ATR-SAR-Channel Stop Loss"
   if(((m_patterns_usage & 0x04) != 0))
   {  IsPattern_2(price, POSITION_TYPE_BUY);
      result += m_pattern_2 * price;
      results += m_pattern_2;
   }
//---
   if(results > 0)
   {  result /= results;
      double _risk = (fabs(m_symbol.Bid()-result)/m_symbol.Point())*(m_symbol.TickSize()/m_symbol.Point())*m_symbol.TickValue();
      _risk /= m_account.FreeMargin();
      _risk *= 100.0;
      double _risk_lots = m_percent/_risk;// where m_percent is also max risk
      lot = fmin(2.0*lot, fmax(_risk_lots, m_symbol.LotsMin()));
   }
//--- return trading volume
   return(Optimize(lot));
}
//+------------------------------------------------------------------+
//| Getting lot size for open short position.                        |
//+------------------------------------------------------------------+
double CMoneyATR::CheckOpenShort(double price, double sl)
{  if(m_symbol == NULL)
      return(0.0);
//--- select lot size
   double lot;
//---
   if(price == 0.0)
      lot = m_account.MaxLotCheck(m_symbol.Name(), ORDER_TYPE_SELL, m_symbol.Bid(), m_percent);
   else
      lot = m_account.MaxLotCheck(m_symbol.Name(), ORDER_TYPE_SELL, price, m_percent);
//---
   double result  = 0.0, results = 0.0;
   price =m_symbol.Ask();
//--- if the model 0 is used and "ATR-Based Stop Loss"
   if(((m_patterns_usage & 0x01) != 0))
   {  IsPattern_0(price, POSITION_TYPE_SELL);
      result += m_pattern_0 * price;
      results += m_pattern_0;
   }
//--- if the model 1 is used and "ATR-MA-Channel Stop Loss"
   if(((m_patterns_usage & 0x02) != 0))
   {  IsPattern_1(price, POSITION_TYPE_SELL);
      result += m_pattern_1 * price;
      results += m_pattern_1;
   }
//--- if the model 2 is used and "ATR-SAR-Channel Stop Loss"
   if(((m_patterns_usage & 0x04) != 0))
   {  IsPattern_2(price, POSITION_TYPE_SELL);
      result += m_pattern_2 * price;
      results += m_pattern_2;
   }
//---
   if(results > 0)
   {  result /= results;
      double _risk = (fabs(result-m_symbol.Ask())/m_symbol.Point())*(m_symbol.TickSize()/m_symbol.Point())*m_symbol.TickValue();
      _risk /= m_account.FreeMargin();
      _risk *= 100.0;
      double _risk_lots = m_percent/_risk;// where m_percent is also max risk
      lot = fmin(2.0*lot, fmax(_risk_lots, m_symbol.LotsMin()));
   }
//--- return trading volume
   return(Optimize(lot));
}

Essa abordagem, além de ter a fraqueza de depender excessivamente do preço do stop loss estar disponível, ocasionalmente corre o risco de atribuir tamanhos de lote excessivos em casos em que o gap do stop loss seja muito pequeno. Por isso normalizamos os lotes para não excederem o dobro dos lotes que obteríamos no percentual de risco padrão da margem livre. Esse percentual de risco (m_percent), portanto, serve a dois propósitos: primeiro, ele define o teto do número de lotes caso os compremos como uma fração da margem livre; segundo, também define a porcentagem máxima nominal de margem livre que perderíamos se nosso stop loss estivesse em um nível estabelecido.

Execuções de teste com alguns dos melhores resultados de otimização, novamente com configurações semelhantes às anteriores, nos dão os seguintes resultados:

Mais uma vez, não fizemos testes padrão por padrão, mas simplesmente otimizamos nosso Expert Advisor para usar todos os padrões, embora com diferentes pesos, como no caso acima com os trailing stops.

Conclusão

Encerramos, assim, nossa análise do indicador ADX que havíamos considerado no último artigo, e também iniciamos e concluímos o indicador ATR. Foram apresentadas várias ideias e implementações diferentes do ATR neste artigo; no entanto, não foram todas codificadas ou testadas, por questões de brevidade. O leitor, portanto, é convidado a levar essas ideias adiante com suas próprias implementações e testes, idealmente em uma variedade ainda maior de símbolos e com mais dados históricos, para obter uma compreensão melhor do que é adequado às suas circunstâncias.