Pode o Heiken-Ashi em combinação com médias móveis oferecer bons sinais?

Introdução

Combinar estratégias pode aumentar a eficácia da negociação. Podemos combinar indicadores e padrões para obter confirmações adicionais. Neste artigo, veremos como usar o gráfico Heiken Ashi em conjunto com médias móveis como método de confirmação de tendência. No final, discutiremos opções de otimização.

Velas Heiken Ashi

As velas são uma maneira rápida e fácil de interpretar os dados OHLC (abertura, máxima, mínima, fechamento) e descobrir padrões. Uma vela de alta (geralmente verde) ocorre quando o mercado fecha acima do preço de abertura. Uma vela de baixa (geralmente vermelha) ocorre quando o mercado fecha abaixo do preço de abertura.

Vamos dar uma olhada no gráfico para melhor compreensão. A tendência é claramente de alta, com correções em torno das velas vermelhas. Preste atenção às velas pequenas que têm um preço de abertura que é quase igual ao preço de fechamento. Elas são chamadas de "dojis" e indicam indecisão e possíveis reversões ou consolidações.

As velas Heiken Ashi buscam limpar a imagem e mostrar uma tendência mais clara suavizando os dados OHLC. Veja como calcular as velas Heiken Ashi:

(abertura + máxima + mínima + fechamento) ÷ 4

Heikin-Ashi Alta = Máximo (Máxima-0, Abertura-0 e Fechamento-0) 

Heikin-Ashi Baixa = Mínimo (Mínima-0, Abertura-0 e Fechamento-0)

Heikin Ashi é um indicador de negociação japonês. Traduzido literalmente do japonês, significa "ritmo médio". Os gráficos Heikin-Ashi se assemelham a gráficos de velas, mas têm uma aparência mais suave, uma vez que acompanham o intervalo de movimento de preços em vez de rastrear cada movimento de preço, como é o caso das velas normais. Heikin Ashi foi criado por Munehisa Homma no século XVIII, o mesmo criador dos gráficos de velas. Esses gráficos são usados por traders e investidores para ajudar a identificar e prever movimentos de preços.

Assim como as velas padrão, a vela Heikin Ashi tem um corpo e sombras, mas seu propósito é diferente. O preço de fechamento da vela Heikin Ashi é calculado com base no preço médio da barra atual ou período de tempo (por exemplo, em um período diário, cada barra representa o movimento de preço nesse dia específico). A fórmula para o preço de fechamento da vela Heikin Ashi é a seguinte: (abertura + máxima + mínima + fechamento) ÷ 4. A abertura da vela Heikin Ashi ocorre no meio da vela anterior, conforme a fórmula: (abertura da vela anterior + fechamento da vela anterior) ÷ 2. Os pontos mais altos e mais baixos são representados pelas sombras, assim como nas velas normais.

As fórmulas acima suavizam as velas, o que nos dá uma tendência mais definida e clara.

Esses dois gráficos representam uma comparação entre um gráfico de velas padrão e um gráfico Heiken Ashi. Podemos observar semelhanças, mas também notamos que o primeiro gráfico é mais suave. Como o método Heiken Ashi mostra um valor médio, o preço indicado pode não ser o preço de mercado real.

Médias móveis

As médias móveis nos ajudam a confirmar a tendência e a segui-la. Este é o indicador técnico mais conhecido, o que se explica pela sua simplicidade e eficácia comprovada na análise. Podemos usá-lo para encontrar níveis de suporte e resistência, stops e níveis-alvo, bem como identificar a tendência principal. Essa versatilidade o torna uma ferramenta indispensável em nosso arsenal de negociação.

Na estatística, a média móvel é um cálculo para analisar pontos de dados, criando uma série de médias a partir de diferentes amostras do conjunto completo de dados. O indicador é um tipo de filtro com uma característica de impulso finito. Existem médias móveis simples, acumuladas e ponderadas (descritas abaixo).

O filtro da média móvel às vezes é chamado de filtro de caixa (boxcar filter), especialmente quando seguido por um processo de decimação (downsample).

Dada uma série de números e um tamanho de subconjunto fixo, o primeiro elemento da média móvel é obtido tomando a média do subconjunto fixo inicial da série de números. Em seguida, o subconjunto é modificado por meio de um "deslocamento para a frente", ou seja, excluindo o primeiro valor da série e incluindo o próximo valor no subconjunto.

A média móvel é comumente usada com dados de séries temporais para suavizar flutuações de curto prazo e destacar tendências ou ciclos de longo prazo. O limiar entre flutuações de curto e longo prazo depende da aplicação, e os parâmetros da média móvel serão ajustados de acordo. O indicador também é usado na economia para analisar o produto interno bruto, emprego ou outras séries temporais macroeconômicas. Do ponto de vista matemático, a média móvel é uma forma de convolução, portanto, pode ser considerada como um exemplo de filtro de baixa frequência usado no processamento de sinais. Ao ser usado com dados que não são séries temporais, a média móvel filtra componentes de alta frequência sem nenhuma relação específica com o tempo, embora geralmente se pressuponha algum tipo de ordenamento. Simplificadamente, pode ser considerada como uma forma de suavização de dados.

Como o nome sugere, esta é a média simples usada em estatísticas e em praticamente qualquer outra área de nossas vidas. É simplesmente a média geral das observações dividida pelo número de observações. Matematicamente, isso pode ser representado da seguinte forma:

Nós observamos que a média móvel fornece níveis dinâmicos dignos de suporte e resistência, em relação aos quais podemos colocar ordens em caso de queda do mercado.

Plano

Assim como em qualquer método de pesquisa, o objetivo é testar a estratégia e determinar se vale a pena usá-la como complemento ao nosso sistema de negociação existente ou não.

O primeiro passo é criar regras de negociação. Quando o sistema deve comprar e quando deve vender? Em outras palavras, quando um sinal é gerado, indicando que o mercado atual irá subir ou cair?

Condições de negociação:

• Compre sempre que o gráfico Heikin-Ashi for de alta e o mercado cruzar a média móvel de 100 períodos.
• Venda sempre que o gráfico Heikin Ashi for de baixa e o mercado cruzar a média móvel de 100 períodos.

Ao desenvolver um algoritmo de negociação, devemos considerar a frequência dos sinais, bem como a função de sinal usada para gerar os acionadores com base nas condições mencionadas.

Resultados

Estes são os resultados para EURUSD M30 de 1 de janeiro de 2022 a 5 de julho de 2023. Os melhores resultados podem ser obtidos otimizando em outros períodos. Para usar em todos os símbolos, é necessário realizar otimização e teste.

Código

int OnInit()
  {
//---
   handle_iCustomMA=iCustom(_Symbol,my_timeframe,"\\folder/s where you have the indicator\\sma",MAPeriod,MAShift);
   handle_iCustomHeiken=iCustom(_Symbol,my_timeframe_Heiken,"\\folder/s where you have the indicator\\Heiken_Ashi_copy");
//---
   if(handle_iCustomMA==INVALID_HANDLE)
     {
      //--- tell about the failure and output the error code
      PrintFormat("Failed to create handle of the iCustom indicator for the symbol %s/%s, error code %d",
                  _Symbol,
                  EnumToString(my_timeframe),
                  GetLastError());
      //--- the indicator is stopped early
      return(INIT_FAILED);
     }
   if(handle_iCustomHeiken==INVALID_HANDLE)
     {
      //--- tell about the failure and output the error code
      PrintFormat("Failed to create handle of the iCustom indicator for the symbol %s/%s, error code %d",
                  _Symbol,
                  EnumToString(my_timeframe_Heiken),
                  GetLastError());
      //--- the indicator is stopped early
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }

Este código é usado para inicializar dois indicadores personalizados na linguagem MQL5. O primeiro indicador é uma média móvel simples (SMA) com os parâmetros MAPeriod e MAShift. O segundo indicador é uma cópia do Heiken Ashi. O código cria handles para cada indicador e verifica se há erros. Se um erro for encontrado, ele exibe o código de erro e retorna INIT_FAILED. Se não houver erros, o código retorna INIT_SUCCEEDED.

void OnTick()
  {
   double heikenAshiOpen[], heikenAshiHigh[], heikenAshiLow[], heikenAshiClose[];
   CopyBuffer(handle_iCustomHeiken,0,0,2,heikenAshiOpen);
   CopyBuffer(handle_iCustomHeiken,1,0,2,heikenAshiHigh);
   CopyBuffer(handle_iCustomHeiken,2,0,2,heikenAshiLow);
   CopyBuffer(handle_iCustomHeiken,3,0,2,heikenAshiClose);
   Comment("heikenAshiOpen ",DoubleToString(heikenAshiOpen[0],_Digits),
           "\n heikenAshiHigh ",DoubleToString(heikenAshiHigh[0],_Digits),
           "\n heikenAshiLow ",DoubleToString(heikenAshiLow[0],_Digits),
           "\n heikenAshiClose ",DoubleToString(heikenAshiClose[0],_Digits));
//---
   MqlTick tick;
   double last_price = tick.ask;
   SymbolInfoTick(_Symbol,tick);
   int total = PositionsTotal();
//---
// Retrieve the current value
   MqlTradeResult  result;
   MqlRates rates[];
//---
   double array_ma[];
   ArraySetAsSeries(array_ma,true);
   int start_pos2=0,count2=5;
   if(!iGetArray2(handle_iCustomMA,0,start_pos2,count2,array_ma))
      return;
//------------------------------------------------------------------------------
     {
      if(DoubleToString(heikenAshiClose[0],_Digits) < DoubleToString(heikenAshiOpen[0],_Digits) && (DoubleToString(heikenAshiClose[1],_Digits) > DoubleToString(heikenAshiOpen[1],_Digits)))
        {
         Print("Open Order Buy");
         Alert(" Buying");
         Orden="Buy";
         sl=NormalizeDouble(tick.ask - ptsl*_Point,_Digits);
         tp=NormalizeDouble(tick.bid + pttp*_Point,_Digits);
         trade.PositionOpen(_Symbol,ORDER_TYPE_BUY,get_lot(tick.bid),tick.bid,sl,tp,"Buy");
         return;
        }
     }
     {
      if(DoubleToString(heikenAshiClose[0],_Digits) > DoubleToString(heikenAshiOpen[0],_Digits) && (DoubleToString(heikenAshiClose[1],_Digits) < DoubleToString(heikenAshiOpen[1],_Digits)))
        {
         Print("Open Order Sell");
         Alert(" Selling");
         Orden="Sell";
         sl=NormalizeDouble(tick.bid + ptsl*_Point,_Digits);
         tp=NormalizeDouble(tick.ask - pttp*_Point,_Digits);
         trade.PositionOpen(_Symbol,ORDER_TYPE_SELL,get_lot(tick.ask),tick.ask,sl,tp,"Sell");
         return;
        }
     }
   if(total>0)
     {
      if(Orden=="Sell" &&(DoubleToString(heikenAshiClose[0],_Digits) < DoubleToString(heikenAshiOpen[0],_Digits) ))
        {
         trade.PositionClose(_Symbol,5);
         Print("cerró sell");
         return;
        }
      if(Orden=="Buy" &&(DoubleToString(heikenAshiClose[0],_Digits) > DoubleToString(heikenAshiOpen[0],_Digits) ))
        {
         trade.PositionClose(_Symbol,5);
         Print("cerró buy");
         return;
        }
     }
  }

Este trecho de código é um script em MQL5 usado para abrir e fechar posições no mercado Forex. Ele começa declarando quatro arrays de ponto flutuante (heikenAshiOpen, heikenAshiHigh, heikenAshiLow e heikenAshiClose) e copia os valores do indicador personalizado iCustomHeiken. Em seguida, ele extrai os dados de ticks atuais do símbolo e declara arrays MqlTradeResult e MqlRates. Depois, ele declara um array para a média móvel (array_ma) e define o array como uma série. Em seguida, ele extrai os valores do indicador personalizado iCustomMA e os armazena no array array_ma. Por fim, ele verifica se o fechamento atual do Heiken Ashi está abaixo do aberto e o fechamento anterior do Heiken Ashi está acima do aberto, e se isso for verdade, ele abre uma ordem de compra com os stop-loss e take-profit especificados. Ele também verifica se o fechamento atual do Heiken Ashi está acima do aberto e o fechamento anterior do Heiken Ashi está abaixo do aberto, e se isso for verdade, ele abre uma ordem de venda com os stop-loss e take-profit especificados. Se houver posições abertas, ele verifica se o fechamento do Heiken Ashi está abaixo do aberto para a ordem de venda e acima do aberto para a ordem de compra e, se isso for verdade, ele fecha a posição.

O segundo inteiro, CopyBuffer, é o valor a partir do qual começar a contagem, e o segundo é o valor do número de contagens. Eu usei dois em vez de um para levar em consideração 1-n (neste caso, a vela Heiken Ashi imediatamente anterior). Isso foi necessário para a estratégia, a fim de detectar a mudança de cor na condição if (abrir ou não uma ordem).

As duas condições if de abertura/fechamento de ordens são o que você deve alterar no código. Por exemplo, você pode usar mais velas da mesma cor antes de abrir uma ordem ou mudar para a segunda vela de outra cor para fechar as ordens.

Outra boa solução para fechar ordens seria usar outra SMA com um período diferente e usar sinais de cruzamento para fechar as ordens. Como no exemplo mostrado:

//+------------------------------------------------------------------+
double get_lot(double price)
  {
   if(inp_lot_type==LOT_TYPE_FIX)
      return(normalize_lot(inp_lot_fix));
   double one_lot_margin;
   if(!OrderCalcMargin(ORDER_TYPE_BUY,_Symbol,1.0,price,one_lot_margin))
      return(inp_lot_fix);
   return(normalize_lot((AccountInfoDouble(ACCOUNT_BALANCE)*(inp_lot_risk/100))/ one_lot_margin));
  }
double normalize_lot(double lt)
  {
   double lot_step = SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   lt = MathFloor(lt / lot_step) * lot_step;
   double lot_minimum = SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
   lt = MathMax(lt, lot_minimum);
   return(lt);
  }
bool iGetArray2(const int handle2,const int buffer2,const int start_pos2,
                const int count2,double &arr_buffer2[])
  {
   bool result2=true;
   if(!ArrayIsDynamic(arr_buffer2))
     {
      //if(InpPrintLog)
      PrintFormat("ERROR! EA: %s, FUNCTION: %s, this a no dynamic array!",__FILE__,__FUNCTION__);
      return(false);
     }
   ArrayFree(arr_buffer2);
//--- reset error code
   ResetLastError();
//--- fill a part of the iBands array with values from the indicator buffer
   int copied2=CopyBuffer(handle2,buffer2,start_pos2,count2,arr_buffer2);
   if(copied2!=count2)
     {
      //--- if the copying fails, tell the error code
      //if(InpPrintLog)
      PrintFormat("ERROR! EA: %s, FUNCTION: %s, amount to copy: %d, copied: %d, error code %d",
                  __FILE__,__FUNCTION__,count2,copied2,GetLastError());
      //--- quit with zero result - it means that the indicator is considered as not calculated
      return(false);
     }
   return(result2);
  }

Este código é uma função em MQL5 que calcula o tamanho do lote para uma negociação. A função recebe uma variável double chamada preço e a utiliza para calcular o tamanho do lote. 

A função primeiro verifica se o tipo de lote é fixo e, se for, retorna o tamanho do lote normalizado. Se não for, ele calcula a margem para um lote e, em seguida, calcula o tamanho do lote com base no saldo da conta e na porcentagem de risco. Em seguida, ele retorna o tamanho do lote normalizado. 

Em seguida, a função utiliza a função normalize_lot para arredondar o tamanho do lote para o tamanho mais próximo e garantir que o tamanho do lote não seja menor que o tamanho mínimo do lote. 

Em seguida, a função utiliza a função iGetArray2 para copiar os valores do buffer do indicador e verificar se há erros. Se um erro for encontrado, a função retorna falso.

Conclusão

Vimos como é possível usar o Heiken Ashi com outro indicador.

Claramente, há espaço para otimização aqui, ajustando a frequência dos sinais e melhorando sua qualidade:

• Podemos selecionar uma condição relacionada ao gráfico Heikin Ashi em que acionamos o sinal após velas consecutivas.
• Podemos configurar o período de análise retrospectiva da média móvel. Também podemos adicionar outras médias móveis e mudar a estratégia para um cruzamento de média móvel em vez de um simples cruzamento do preço de mercado e uma única média móvel.
• Podemos incluir gráficos de velas no Heikin Ashi e combiná-los com as médias móveis.
• Também podemos incluir a distância entre o Heikin Ashi e a média móvel como uma medida de risco ou até mesmo como um disparador oposto.
• Também é possível usar a largura do corpo da vela como uma medida da força da tendência. Também podemos incluir o prumo da média móvel na fórmula.

Aprendemos a implementar essa estratégia, bem como a aplicar indicadores personalizados, e também aprendemos a usar um lote fixo e um lote com base na porcentagem de risco. Aprendemos como abrir e fechar ordens, bem como usar condições de ordens. Usamos a cópia do buffer para o Heiken Ashi e a média móvel. Realizamos um teste lucrativo e exibimos os resultados. Discutimos a adição de níveis de stop-loss e take-profit, bem como a normalização das casas decimais. Utilizamos o tamanho do passo do símbolo e o volume mínimo do símbolo para a normalização dos lotes.

Espero que você tenha gostado do artigo.