Um exemplo de um Sistema de Comércio Baseado no indicador Heiken-Ashi

Introdução

Com o aparecimento do gráfico de candelabro nos EUA, mais de duas décadas atrás, houve uma revolução no entendimento de como as forças de um touro ou um urso trabalham nos mercados ocidentais. Candelabros se tornaram um instrumento de negociação popular, e negociantes começaram a trabalhar com eles de forma a facilitar a leitura dos gráficos. Mas a interpretação dos candelabros difere de um para o outro.

Um desses métodos, que muda o gráfico candelabro tradicional, e facilita sua percepção, é chamado de tecnologia Heikin Ashi.

1. «Nani Desu Ka?»*

A primeira publicação sobre esse tópico apareceu em 2004 na edição de fevereiro do periódico «Technical Analysis of STOCKS & COMMODITIES», onde Dan Valcu publicou um artigo chamado «Using The Heikin Ashi Technique» (link para o artigo original).

Em sua página da internet, o autor aponta que durante o verão de 2003 ele estudou a tecnologia de Ichimoku, e como acontece frequentemente, acidentalmente descobriu alguns diagramas, nos quais ele viu uma tendência claramente visível no mercado. Acabou sendo um diagrama Heikin-Ashi, ou para ser mais preciso, alguns candelabros alterados.

Esse método de análise foi desenvolvido por um negociante japonês que se tornou muito bem sucedido e utiliza esse método até hoje. Para a surpresa do autor, ele não descobriu nenhuma outra informação relacionada em livros ou na internet, então ele decidiu torná-la disponível para todos os negociantes publicando ela em um periódico.

O método Heikin-Ashi (heikin em Japonês significa o "meio" ou o "equilíbrio", e ashi significa "pé" ou "barra") é uma ferramenta visual para avaliar tendências, sua direção e força. Esse não é o "santo graal" da negociação, mas é definitivamente um instrumento bom e fácil de usar para visualização de tendências.

Vamos considerar como o cálculo do valor do candelabro OHLC é realizado:

Fechamento da barra atual = FechamentoHA = (Abertura + Alto + Baixo + Fechamento) / 4
Abertura da barra atual: AberturaHA = (AberturaHA [antes.] + FechamentoHA [antes]) / 2
Máximo da barra atual: AltoHA = Max (Alto, AberturaHA, FechamentoHA)
Mínimo da barra atual: BaixoHA = Min (Baixo, AberturaHA, FechamentoHA)

Os valores de "abertura", "alto", "baixo" e "fechamento" estão se referindo à barra atual. O prefixo "ha" indica os valores correspondentes modificados do heikin-ashi.

Para facilitar a percepção de informação do mercado, a tecnologia Heikin-Ashi modifica o gráfico de candelabros tradicional, criando os chamados candelabros sintéticos, que removem irregularidade do gráfico normal, oferecendo uma imagem melhor das tendências e consolidações. Só de observar o gráfico candelabro, criado utilizando esse método, você consegue uma boa visão geral do mercado e seu estilo:

Figura 1. Na esquerda está um gráfico candelabro normal (a), na direita (b) um gráfico Heikin-Ashi

A figura 1 mostra a diferença entre os candelabros japoneses tradicionais dos candelabros de Heikin-Ashi. A característica distinta desses gráficos é que em uma tendência em alta a maioria das velas brancas não possuem sombra. Em uma tendência em baixa não há sombra superior para a maior parte das velas pretas. O gráfico Heiken Ashi não apresenta travas, então um novo candle abre no nível do meio do anterior.

Os candelabros no gráfico de Heikin-Ashi mostram uma maior extensão da indicação da tendência do que os candelabros tradicionais. Quando a tendência enfraquece, os corpos dos candelabros são reduzidos e a sombra cresce. A mudança na cor dos candelabros é um sinal para comprar/vender. É mais conveniente determinar o fim de um movimento corretivo, baseado nesses gráficos.

Esse indicador é uma parte do MetaTrader 5 e você pode localizá-lo na pasta «Indicators \\ Examples \\ Heiken_Ashi.mq5». Antes de instalar o indicador no gráfico, eu recomendo fazer o gráfico linear. Também, nas propriedades do gráfico, na aba "Geral", desmarque o item "do gráfico do topo".

Gostaria de mais uma vez focar a sua atenção no fato de que o método Heikin-Ashi não é um "santo graal". Para provar isso, tentaremos criar um sistema de negociação simples (TS) utilizando apenas essa técnica.

Para isso, precisamos criar um simples Expert Advisor usando a linguagem de programação do MQL5 e as classes da biblioteca padrão, e depois testar em dados do histórico, usando o strategy tester do terminal MetaTrader5.

2. Algoritmo do sistema de negociação

Sem tornar as coisas muito complexas, nós criamos o algoritmo utilizando as mesmas seis regras básicas do procedimento Heikin-Ashi, propostas por Dan Valcu na seguinte página da internet: http://www.educofin.com/.

1. Uma tendência em crescimento - candelabro azul FechamentoHA> AberturaHA.
2. Uma tendência em decadência - candelabro vermelho FechamentoHA < AberturaHA.
3. Uma tendência em crescimento forte - um candelabro azul, no qual não há Baixa AberturaHA == BaixoHA.
4. Uma tendência em decadência forte - um candelabro vermelho, o qual não é Baixa AberturaHA == BaixoHA.
5. Consolidação - uma sequência de candelabros com pequenos corpos (de qualquer cor) e sombras longas.
6. Mudança de tendência - um candlestick com um corpo pequeno e longas sombras da cor oposta. Não é sempre um sinal confiável e algumas vezes pode ser apenas uma parte da consolidação (5).

Uma tendência de (1,2) é fácil de entender - se nós estamos em uma transação, nós simplesmente seguramos a posição, movendo o stop por 1-2 pontos abaixo/acima do candelabro anterior.

Em uma tendência forte (3,4) agimos da mesma forma - puxando para cima o stop.

A consolidação (5) e uma mudança de tendência (6), fecham a posição (se não for fechada pelo stop), no entanto precisamos decidir se vamos abrir ou não uma posição oposta. Para fazer a decisão, precisamos de alguma forma determinar se uma consolidação ou reversão está acontecendo. Vamos precisar de um filtro, construído em indicadores, análise de candlestick ou análise gráfica.

O objetivo do nosso artigo não inclui o estabelecimento de uma estratégia lucrativa, mas quem sabe o que conseguiremos realizar como resultado. Portanto, vamos considerar que no surgimento de uma vela da cor oposta, vamos fechar a posição e então abrir uma nova na direção oposta.

E, assim, o nosso algoritmo é da seguinte forma:

1. Após a formação de uma vela da cor oposta, fechamos a posição anterior, se possuirmos uma, e abrimos uma posição na abertura da nova vela, configurando um stop 2 pontos abaixo/acima do mínimo/máximo da vela anterior.
2. A tendência - movemos 2 pontos abaixo/acima do mínimo/máximo da vela anterior.
3. Com uma tendência forte, nós tomamos as mesmas providências que tomamos com a tendência, isto é, movemos o stop.

No geral, tudo é bem simples e esperançosamente claro para o leitor. Agora vamos implementar isso no MQL5.

3. Programando o Consultor Especialista no MQL5

Para criar um Expert Advisor, precisaremos apenas de um parâmetro de entrada - o tamanho do lote, as duas funções do handler de evento OnInit(), OnTick() e nossa própria função CheckForOpenClose().

Para configurar os parâmetros de entrada no MQL5 utilizamos as variáveis de Entrada.

//--- input parameters
input double Lot=0.1;    // Port size

A função OnInit() é a Init que lida com o evento. Eventos Init são gerados imediatamente após carregar o Expert Advisor.

No código dessa função conectaremos o indicador ao Expert Advisor. Como mencionado antes, o MetaTrader 5 padrão inclui um indicador Heiken_Ashi.mq5.

Você pode se perguntar porque há tanta complexidade se nós possuímos fórmulas para calcular o indicador e nós podemos calcular os valores no código do Expert Advisor. Sim, eu admito, é possível fazer isso, mas se você olhar para um delas com cuidado:

AberturaHA=(AberturaHA[anterior]+FechamentoHA[anterior])/2

você verá que ela usa os valores prévios, que criam uma certa inconveniência para cálculos independentes e complica a sua vida. Portanto, ao invés de cálculos independentes, exploraremos as capacidades do MQL5 de conectar o indicador personalizado, especificamente a função iCustom.

Para fazer isso, adicionamos ao corpo da função OnInit() a seguinte linha:

   hHeiken_Ashi=iCustom(NULL,PERIOD_CURRENT,"Examples\\Heiken_Ashi");

e obtemos uma variável global hHeiken_Ashi - nome do indicador Heiken_Ashi.mq5, que precisaremos no futuro.

A função OnTick() é o nome do evento NewTick (), que é gerado com o aparecimento de um novo ponto.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- check the ability of trading and the calculated number of bars
   if(TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
      if(BarsCalculated(hHeiken_Ashi)>100)
        {
         CheckForOpenClose();
        }
//---
  }

A função TerminalInfoInteger (TERMINAL_TRADE_ALLOWED) verifica se a negociação é permitida ou não. Utilizando a função BarsCalculated (HHeiken_Ashi), verificamos a quantidade de dados calculados para o indicador solicitado, em nosso caso o Heiken_Ashi.mq5.

E se ambas as condições são satisfeitas, observamos o cumprimento da nossa função CheckForOpenClose() onde o trabalho principal acontece. Vamos olhar pra ela com mais cuidado.

Já que os termos do nosso TS especificam que a instalação das ordens acontece na abertura de uma nova vela, precisamos determinar se uma nova vela abriu ou não. Há muitas formas de fazer isso, mas a mais simples é verificar o volume de pontos. Assim, se o volume do ponto é igual a um, isso indica a abertura de uma nova barra e você deveria verificar os termos do TS e colocar ordens.

Implementamos isso da seguinte forma:

//--- process the orders only after receiving the first tick of the new candlestick 
   MqlRates rt[1];
   if(CopyRates(_Symbol,_Period,0,1,rt)!=1)
     {
      Print("CopyRates of ",_Symbol," failed, no history");
      return;
     }
   if(rt[0].tick_volume>1) return;

Crie um arranjo variável do tipo MqlRates do tamanho de um elemento. Utilizando a função CopyRates () obtenha nela os valores da última barra. Então verifique o volume do ponto e se for maior do que um, termine a função, se não, então continue os cálculos.

Em seguida, utilizando a diretiva #define, declaramos algumas constantes mnemônicas:

//--- to check the conditions we need the last three bars
#define  BAR_COUNT   3
//--- the number of indicator buffer for storage Open
#define  HA_OPEN     0
//--- the number of the indicator buffer for storage High
#define  HA_HIGH     1
//--- the number of indicator buffer for storage Low
#define  HA_LOW      2
//--- the number of indicator buffer for storage Close
#define  HA_CLOSE    3

Então anunciamos o arranjo:

double   haOpen[BAR_COUNT],haHigh[BAR_COUNT],haLow[BAR_COUNT],haClose[BAR_COUNT];

E utilizando a função CopyBuffer () obtemos valores do indicador nos arranjos apropriados.

   if(CopyBuffer(hHeiken_Ashi,HA_OPEN,0,BAR_COUNT,haOpen)!=BAR_COUNT
      || CopyBuffer(hHeiken_Ashi,HA_HIGH,0,BAR_COUNT,haHigh)!=BAR_COUNT
      || CopyBuffer(hHeiken_Ashi,HA_LOW,0,BAR_COUNT,haLow)!=BAR_COUNT
      || CopyBuffer(hHeiken_Ashi,HA_CLOSE,0,BAR_COUNT,haClose)!=BAR_COUNT)
     {
      Print("CopyBuffer from Heiken_Ashi failed, no data");
      return;
     }

Quero focar sua atenção em como os dados são armazenados nas variáveis do arranjo.

A barra mais "velha" (historicamente) é armazenada no primeiro elemento do arranjo (zero).

A barra "mais jovem" (atual) no posterior, BAR_COUNT-1 (figura 2).

Figura 2. A ordem das velas e os valores dos índices do arranjo

E assim nós obtemos os valores OHLC Heikin-Ashi, resta verificar as condições para a abertura ou manutenção das posições.

Considere em detalhes o processamento do sinal de venda.

Como apontado anteriormente, nós conseguimos valores de três velas Heikin-Ashi. O valor atual é localizado nas células com o número [BAR_COUNT-1 = 2], e ele não é necessário para nós. Os valores anteriores estão nas células [BAR_COUNT-2 = 1], e as barras anteriores estão em [BAR_COUNT-3 = 0] (veja Fig. 2), e com base nestas duas barras verificaremos os termos e condições para fazer o negócio.

Então precisamos verificar as posições abertas no instrumento. Para fazer isso, nós utilizaremos a classe CPositionInfo de classes de negociação da biblioteca padrão. Essa classe nos permite obter informação sobre posições abertas. Usando o método Select (_Symbol) determinamos a presença de posições abertas em nosso instrumentos e, se estiverem presentes, então, usando o método Type () determinamos o tipo de posições abertas.

Se no momento atual nós possuímos uma posição aberta para comprar, então precisamos fechá-la.

Para fazer isso utilizamos os métodos da classe CTrade da biblioteca de classe padrão, que é projetada para realizar operações de negociação.

Utilizando o método PositionClose (símbolo de cadeia constante com desvio ulong) vamos fechar a compra, onde o símbolo é o nome do instrumento e, o segundo parâmetro, desvio, é o desvio permissível do preço de fechamento.

Então verificamos a combinação de velas de acordo com o nosso TS. Uma vez que já verificamos a direção das velas recém formadas (com o índice [BAR_COUNT-2]), nós apenas precisamos verificar a vela antes disso (com índice [BAR_COUNT-3]), e realizar as etapas, necessárias para a abrir a posição.

     //--- check if there is an open position, and if there is, close it
      if(posinf.Select(_Symbol))
        {
         if(posinf.Type()==POSITION_TYPE_BUY)
           {
            //            lot=lot*2;
            trade.PositionClose(_Symbol,3);
           }
        }
      //--- check and set Stop Loss level
      double stop_loss=NormalizeDouble(haHigh[BAR_COUNT-2],_Digits)+_Point*2;
      double stop_level=SymbolInfoDouble(_Symbol,SYMBOL_ASK)+SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*_Point;
      if(stop_loss<stop_level) stop_loss=stop_level;
      //--- check the combination: the candle with the opposite color has formed
      if(haOpen[BAR_COUNT-3]<haClose[BAR_COUNT-3])
        {
         if(!trade.PositionOpen(_Symbol,ORDER_TYPE_SELL,lot,SymbolInfoDouble(_Symbol,SYMBOL_BID),stop_loss,0))
            Print(trade.ResultRetcodeDescription());
        }
      else
      if(posinf.Select(_Symbol))
        {
         if(!trade.PositionModify(_Symbol,stop_loss,0))
            Print(trade.ResultRetcodeDescription());
        }

Aqui é necessário voltar a sua atenção para o uso de três métodos da classe CTrade:

• O método PositionOpen (símbolo, tipo de ordem, volume, preço, sl, tp, comentário) utilizado para abrir uma posição onde o símbolo é o nome do instrumento, order_type - tipo de ordem, volume - o tamanho do lote, preço - preço de compra, sl - Stop, tp - lucro, comentário - um comentário;
• O método PositionModify (símbolo, sl, tp) utilizado para mudar o valor do stop e lucro, onde símbolo - o nome do instrumento, sl - stop, tp - lucro. Gostaria de chamar a sua atenção para o fato de que antes de utilizar esse método, você deveria verificar a presença de uma posição aberta;
• O método ResultRetcodeDescription () é utilizado para obter a descrição do erro do código na forma de uma linha.

Calculando a variável stop_loss, o valor do AlltoHA [BAR_COUNT-2] é um cálculo recebido do indicador e precisa de normalização feita pela função NormalizeDouble (AltoHA [BAR_COUNT-2], _Dígitos) de forma a ser utilizado corretamente.

Isso completa o processamento de um sinal para vender.

Para comprar utilizamos o mesmo princípio.

Aqui está o código completo do Expert Advisor:

//+------------------------------------------------------------------+
//|                                           Heiken_Ashi_Expert.mq5 |
//|                                               Copyright VDV Soft |
//|                                                 [e-mail] |
//+------------------------------------------------------------------+
#property copyright "VDV Soft"
#property link      "[e-mail]"
#property version   "1.00"

#include <Trade\AccountInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>

//--- the list of global variables
//--- input parameters
input double Lot=0.1;    // Lot size
//--- indicator handles
int      hHeiken_Ashi;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   hHeiken_Ashi=iCustom(NULL,PERIOD_CURRENT,"Examples\\Heiken_Ashi");
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- trading should be allowed and number of bars calculated>100
   if(TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
      if(BarsCalculated(hHeiken_Ashi)>100)
        {
         CheckForOpenClose();
        }
//---
  }
//+------------------------------------------------------------------+
//| Checking of the position opening conditions                      |
//+------------------------------------------------------------------+
void CheckForOpenClose()
  {
//--- process orders only when new bar is formed
   MqlRates rt[1];
   if(CopyRates(_Symbol,_Period,0,1,rt)!=1)
     {
      Print("CopyRates of ",_Symbol," failed, no history");
      return;
     }
   if(rt[0].tick_volume>1) return;

//--- to check the conditions we need the last three bars
#define  BAR_COUNT   3
//--- number of the indicator buffer for storage Open
#define  HA_OPEN     0
//--- number of the indicator buffer for storage High
#define  HA_HIGH     1
//--- number of the indicator buffer for storage Low
#define  HA_LOW      2
//--- number of the indicator buffer for storage Close
#define  HA_CLOSE    3

   double   haOpen[BAR_COUNT],haHigh[BAR_COUNT],haLow[BAR_COUNT],haClose[BAR_COUNT];

   if(CopyBuffer(hHeiken_Ashi,HA_OPEN,0,BAR_COUNT,haOpen)!=BAR_COUNT
      || CopyBuffer(hHeiken_Ashi,HA_HIGH,0,BAR_COUNT,haHigh)!=BAR_COUNT
      || CopyBuffer(hHeiken_Ashi,HA_LOW,0,BAR_COUNT,haLow)!=BAR_COUNT
      || CopyBuffer(hHeiken_Ashi,HA_CLOSE,0,BAR_COUNT,haClose)!=BAR_COUNT)
     {
      Print("CopyBuffer from Heiken_Ashi failed, no data");
      return;
     }
//---- check sell signals
   if(haOpen[BAR_COUNT-2]>haClose[BAR_COUNT-2])// bear candlestick 
     {
      CPositionInfo posinf;
      CTrade trade;
      double lot=Lot;
     //--- check if there is an open position, and if there is, close it
      if(posinf.Select(_Symbol))
        {
         if(posinf.Type()==POSITION_TYPE_BUY)
           {
            //            lot=lot*2;
            trade.PositionClose(_Symbol,3);
           }
        }
      //--- check and set Stop Loss level
      double stop_loss=NormalizeDouble(haHigh[BAR_COUNT-2],_Digits)+_Point*2;
      double stop_level=SymbolInfoDouble(_Symbol,SYMBOL_ASK)+SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*_Point;
      if(stop_loss<stop_level) stop_loss=stop_level;
      //--- check the combination: the candle with the opposite color has formed
      if(haOpen[BAR_COUNT-3]<haClose[BAR_COUNT-3])
        {
         if(!trade.PositionOpen(_Symbol,ORDER_TYPE_SELL,lot,SymbolInfoDouble(_Symbol,SYMBOL_BID),stop_loss,0))
            Print(trade.ResultRetcodeDescription());
        }
      else
      if(posinf.Select(_Symbol))
        {
         if(!trade.PositionModify(_Symbol,stop_loss,0))
            Print(trade.ResultRetcodeDescription());
        }
     }
//---- check buy signals
   if(haOpen[BAR_COUNT-2]<haClose[BAR_COUNT-2]) // bull candle
     {
      CPositionInfo posinf;
      CTrade trade;
      double lot=Lot;
     //--- check if there is an open position, and if there is, close it
      if(posinf.Select(_Symbol))
        {
         if(posinf.Type()==POSITION_TYPE_SELL)
           {
            //            lot=lot*2;
            trade.PositionClose(_Symbol,3);
           }
        }
      //--- check and set Stop Loss level
      double stop_loss=NormalizeDouble(haLow[BAR_COUNT-2],_Digits)-_Point*2;
      double stop_level=SymbolInfoDouble(_Symbol,SYMBOL_BID)-SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*_Point;
      if(stop_loss>stop_level) stop_loss=stop_level;
      //--- check the combination: the candle with the opposite color has formed
      if(haOpen[BAR_COUNT-3]>haClose[BAR_COUNT-3])
        {
         if(!trade.PositionOpen(_Symbol,ORDER_TYPE_BUY,lot,SymbolInfoDouble(_Symbol,SYMBOL_ASK),stop_loss,0))
            Print(trade.ResultRetcodeDescription());
        }
      else
      if(posinf.Select(_Symbol))
        {
         if(!trade.PositionModify(_Symbol,stop_loss,0))
            Print(trade.ResultRetcodeDescription());
        }

     }
  }
//+------------------------------------------------------------------+

O texto completo do Expert Advisor pode ser encontrado no arquivo anexo Heiken_Ashi_Expert.mq5. Copiando para o catálogo .. \\ MQL5 \\ Experts, depois execute o MetaEditor através do menu "Tools -> Editor MetaQuotes Language», ou use a tecla «F4». Em seguida na janela "Navegador", abra a aba «Experts», e baixe o arquivo Heiken_Ashi_Expert.mq5, clicando duas vezes sobre ele, na janela editar e compile pressionando «F7».

Se todas as operações foram realizadas corretamente, então a aba "Expert Advisors", na janela "Navegador" do arquivo Heiken_Ashi_Expert será criada. O indicador Heiken_Ashi.mq5 deve ser compilado da mesma forma, ele está localizado no catálogo \\ MQL5 \\ Indicadores \\ Exemplos \\.

4. Testando o sistema de negociação nos dados históricos

Para verificar a viabilidade do nosso sistema de negociação, utilizamos o verificador de estratégia do MetaTrader 5, que é parte da plataforma de negociação. O verificador é executado através do menu do terminal "Visualizar -> Verificador de estratégia" ou pressionando a combinação de teclas «Ctrl + R». Uma vez lançado, localizamos a aba "Configurações" (figura 3).

Figura 3. Configurações do verificador de estratégia

Configurando o Expert Advisor - escolha de uma lista dos nossos Expert Advisors, indique o intervalo de teste como o começo de 2000 até o fim de 2009, a quantidade inicial de depósito é 10.000 USD, desabilite a otimização (uma vez que possuímos apenas um parâmetro de entrada, e nós só queremos verificar a viabilidade do TS).

O teste será feito utilizando dois pares de moedas correntes. Decidi escolher os pares de moedas correntes EURUSD e GBPUSD.

Para o teste, decidi tomar os seguintes intervalos de tempo: H3, H6 e H12. Você perguntará o porquê? A resposta é porque eu queria testar o TS em intervalos de tempo, que não estavam presentes no terminal MetaTrader 4.

Então aqui vamos nós. Selecionamos a moeda corrente de teste EURUSD, o período de teste H3, e clicamos "Iniciar". Ao completar o teste, observamos duas novas abas na janela do verificador: "Resultados" (figura 4) e "Gráfico" (figura 5).

Figura 4. Os resultados da verificação de estratégia de EURUSD H3

Dos resultados do teste (figura 4) você pode ver que para o período do início de 2000 ao final de 2009 com os dados parâmetros, o TS rendeu uma perda de $ -2.560,60 USD.

O gráfico (Fig. 5) mostra a distribuição de lucros e perdas com o tempo, o que nos dá a oportunidade para analisar a performance do TS por todo o tempo, e fazer a análise dos erros do sistema.

Figura 5. Aba "Gráfico" do verificador de estratégia (EURUSD H3)

Quase esqueci de mencionar que a aba "Resultados", por padrão, cria um relatório simples. Além disso, temos a habilidade de ver transações, ordens e relatórios de arquivo escritos.

Para isso, apenas posicionamos o cursor sobre a guia, clicamos com o botão direito do mouse e selecionamos o item do menu adequado:

Figura 6. Menu de contexto da aba Resultados do verificador de estratégia

Aqui estão os resultados do teste ao longo de um período de 6 horas (H6):

Figura 7. Aba Resultados do verificador de estratégia (EURUSD H6)

Ao longo de um período de doze horas (H12):

Figura 8. Aba Resultados do verificador de estratégia (EURUSD H12)

Parece que no par de moedas correntes, como o EURUSD, a nossa estratégia não é eficiente. Mas podemos notar que a variação do período de trabalho significativamente afeta o resultado.

Estendemos o nosso teste ao par de moedas correntes GBPUSD de forma a tomar conclusões finais sobre a eficiência do nosso TS.

Figura 9. Aba Resultados do verificador de estratégia (GBPUSD H3)

Figura 10. Aba Resultados do verificador de estratégia (GBPUSD H6)

Figura 11. Aba Resultados do verificador de estratégia (GBPUSD H12)

Figura 12. Aba Gráficos do verificador de estratégia (GBPUSD H12)

Após analisar os resultados do teste, vemos que ao utilizar um par de moedas correntes, como GBPUSD, nosso sistema demonstrou resultados positivos em dois casos separados. Ao longo de um período de doze horas, recebemos lucro considerável de 8.903,23 USD, apesar de que ele foi recebido ao longo de nove anos.

Aqueles interessados podem testar outros pares de moedas correntes. Minha suposição é que quanto mais volátil o par é, melhor resultado deve ser obtido, e mais longo o período de tempo que deve ser utilizado.

Conclusão

Em conclusão, enfatizo que esse sistema de negociação não é o "santo graal" e não pode ser utilizado sozinho.

No entanto, com sinais adicionais (análise de candelabros, análise de ondas, indicadores, tendências) nós separamos os sinais reversos dos sinais de consolidação, então, em alguns instrumentos de negociação voláteis, pode ser bem viável, apesar de improvável de trazer um lucro "louco".

__________________________________
* "Nani Desu Ka?" - O que é isso? (Japonês)