Assistente MQL5 - Classe Padrões Candles - biblioteca para MetaTrader 5

O Assistente MQL5 permite a criação de Expert Advisors prontos para o uso com base nas classes da Biblioteca Padrão, disponibilizadas juntamente com o terminal do cliente. Ele permite verificar suas idéias de negociação rapidamente, tudo que você precisa é criar sua própria classe de sinais de negociação. As estruturas destas classes e exemplos podem ser encontrados no artigo Assistente MQL5: Como criar um Módulo de Sinais de Negociação.

A ideia genérica é o seguinte: a classe dos sinais de negociação deriva do CExpertSignal, em seguida, é necessário substituir os métodos virtuais LongCondition() e ShortCondition() com seus próprios métodos.

Há um livro chamado "Estratégias dos melhores traders" (em Russo), existem muitas estratégias de negociação que são considerados neste livro, vamos nos concentrar em padrões de velas de reversão, confirmados pelos osciladores Stochastic, CCI, MFI e RSI.

A melhor maneira é criar a classe separada, derivado de CExpertSignal para a verificação da formação de padrões de candles. Para confirmar os sinais de negociação, gerados por padrões de velas, apenas escreva a classe derivada de CCandlePattern e adicionar aos recursos necessários existentes(por exemplo, a confirmação por osciladores).

Agora vamos considerar a classe CCandlePattern, que permite simplificar a criação de classes de sinais de negociação com padrões de candles pelo Assistente MQL5.

Classe CCandlePattern

A CCandlePattern é derivada da classe CExpertSignal (classe base de sinais de negociação)

class CCandlePattern : public CExpertSignal
  {
protegido:
   //--- indicadores
   CiMA              m_MA;
   //--- série temporal
   CiOpen            m_open;
   CiHigh            m_high;
   CiLow             m_low;
   CiClose           m_close;
   //--- parâmetros de entrada
   int               m_ma_period;

pública:
   //--- construtor
                     CCandlePattern();
   //--- método de ajuste dos parâmetros de entrada
   void              MAPeriod(int period)             { m_ma_period=period;                 } 
   //--- métodos de inicialização
   virtual bool      ValidationSettings();
   virtual bool      InitIndicators(CIndicators *indicators);

   //--- verificar a formação de um determinado padrão candle
   bool              CheckCandlestickPattern(ENUM_CANDLE_PATTERNS CandlePattern);
   //--- verificar a formação da alta/baixa do padrão candle
   bool              CheckPatternAllBullish();
   bool              CheckPatternAllBearish();

protegido:
   //--- inicialização de indicadores e série temporal
   bool              InitMA(CIndicators *indicators);
   bool              InitOpen(CIndicators *indicators);
   bool              InitHigh(CIndicators *indicators);
   bool              InitLow(CIndicators *indicators);
   bool              InitClose(CIndicators *indicators);
   //--- métodos utilizados para a verificação dos candles
   double            AvgBodySize(int ind);
   double            MA(int ind)                const { return(m_MA.Main(ind));             }
   double            Open(int ind)              const { return(m_open.GetData(ind));        }
   double            High(int ind)              const { return(m_high.GetData(ind));        }
   double            Low(int ind)               const { return(m_low.GetData(ind));         }
   double            Close(int ind)             const { return(m_close.GetData(ind));       }
   double            CloseAvg(int ind)          const { return(MA(ind));                    }
   double            MidPoint(int ind)          const { return(0.5*(High(ind)+Low(ind)));   }
   double            MidOpenClose(int ind)      const { return(0.5*(Open(ind)+Close(ind))); }
   //--- métodos para a verificação de um determinado modelo de candles
   bool              CheckPatternThreeBlackCrows();
   bool              CheckPatternThreeWhiteSoldiers();
   bool              CheckPatternDarkCloudCover();
   bool              CheckPatternPiercingLine();
   bool              CheckPatternMorningDoji();
   bool              CheckPatternEveningDoji();
   bool              CheckPatternBearishEngulfing();
   bool              CheckPatternBullishEngulfing();
   bool              CheckPatternEveningStar();
   bool              CheckPatternMorningStar();
   bool              CheckPatternHammer();
   bool              CheckPatternHangingMan();
   bool              CheckPatternBearishHarami();
   bool              CheckPatternBullishHarami();
   bool              CheckPatternBearishMeetingLines();
   bool              CheckPatternBullishMeetingLines();
  };

Usando a CCandlePattern nas classes de sinais de negociação para o Assistente MQL5

A CCandlePattern pode usar uma classe principal para as classes de sinais de negociação pelo Assistente MQL5. É necessário derivar a classe de negociação de sinais da classe CCandlePattern, também é necessário adicionar os métodos de controle de abertura de posição comprada/vendida e abertura/fechamento de posição (para além de indicadores, etc ...).

Somente a formação dos padrões candles de reversão( podem ser usados como um sinal de negociação, mas é melhor utilizar uma confirmação (por exemplo, usando os osciladores).

• bool CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration) - Verifica as condições de abertura de uma posição comprada;
  
• bool CheckCloseLong(double &price)  - verifica as condições de fechamento de uma posição comprada;
  
• bool CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration) - verifica as condições de abertura de uma posição vendida;
  
• bool CheckCloseShort(double &price) - verifica as condições de fechamento de uma posição vendida;

//+------------------------------------------------------------------+
//|                                          CSampleCandleSignal.mqh |
//+------------------------------------------------------------------+
// inclue a classe CCandlePattern 
// o candlepatterns.mqh deve estar localizado na mesma pasta
#include "CandlePatterns.mqh"
// descriçao do início do assistente
//+------------------------------------------------------------------+
//| Descrição da classe                                              |
//| Título=Sinal de teste                                            |
//| Tipo=Sinal                                                       |
//| Nome=CSampleCandleSignal                                         |
//| Classe=CSampleCandleSignal                                       |
//| Pagina=                                                          |
//| Parametro=param1,int,9                                           |
....
//| Parâmetro=paramN,int,13                                          |
//| Parâmetro=MAPeriod,int,12                                        |
//+------------------------------------------------------------------+
// descrição final do assistente
//+------------------------------------------------------------------+
class CSampleCandleSignal : public CCandlePattern
  {
protegido:
   //--- indicadores
   ....
   //--- parâmetros de entrada
   ...
pública:
   //--- construtor
                     CTestClass();
   //--- métodos para a definição de parâmetros de entrada 
   ...
   //--- inicialização de indicadores e séries tempora/verificação de parâmetros de entrada
   virtual bool      ValidationSettings();
   virtual bool      InitIndicators(CIndicators *indicators);
   //--- verificação sinais de negociação
   virtual bool      CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration);
   virtual bool      CheckCloseLong(double &price);
   virtual bool      CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration);
   virtual bool      CheckCloseShort(double &price);

protegida:
   //--- métodos de inicialização de indicadores 
   ...
   //--- métodos para acesso aos valores dos indicadores
   ...
  };

Os detalhes sobre a estrutura de classes de sinal de negociação, usadas no Assistente MQL5, podem ser encontrados no artigo Assistente MQL5: Como criar um Módulo de Sinais de Negociação.

Dê uma olhada na linha:

//| Parameter=MAPeriod,int,12                                        |

na seção de descrição do Assistente.

O método MAPeriod é usado na classe principal CCandlePattern para o cálculo do preço médio de fechamento e valores médios do corpo do candle. Por padrão, m_ma_period = 12 fica no construtor de classe CCandlePattern(). No entanto, é melhor defini-lo usando o parâmetro de entrada, ele permitirá você usá-lo no Testador de Estratégias do terminal MetaTrader 5.

Não se esqueça de chamar ValidationSettings () e InitIndicators () da classe principal

É melhor chamar esses métodos primeiro:

bool CSampleCandleSignal ::ValidationSettings()
  {
//--- Chamar ValidationSettings da classe principal CCandlePattern
   if(!CCandlePattern::ValidationSettings()) return(false);
//--- seu código
..
//--- ok
   return(true);
  }

O mesmo vale para os métodos InitIndicators():

bool CSampleCandleSignal ::InitIndicators(CIndicators *indicators)
  {
//--- chamar InitIndicators da classe principal CCandlePattern
   if(!CCandlePattern::InitIndicators(indicators)) return(false);   
//--- seu código
...
//--- ok
   return(true);
  }

Verificando padrões candles

Para verificar a formação de um determinado padrão candle é necessário chamar o método CheckCandlestickPattern (ENUM_CANDLE_PATTERNS CandlePattern) com teste padrão, passado para a função.

Além disso, você pode verificar a formação de um dos padrões candle de alta/baixa usando os métodos CheckPatternAllBullish() e CheckPatternAllBearish().

Para simplificar o trabalho dos padrões de candles, a enumeração ENUM_CANDLE_PATTERNS é usado:

enum ENUM_CANDLE_PATTERNS  // lista dos padrões candles 
  {
   CANDLE_PATTERN_THREE_BLACK_CROWS     = 1,
   CANDLE_PATTERN_THREE_WHITE_SOLDIERS  = 2,
   CANDLE_PATTERN_DARK_CLOUD_COVER      = 3,
   CANDLE_PATTERN_PIERCING_LINE         = 4,
   CANDLE_PATTERN_MORNING_DOJI          = 5,
   CANDLE_PATTERN_EVENING_DOJI          = 6,
   CANDLE_PATTERN_BEARISH_ENGULFING     = 7,
   CANDLE_PATTERN_BULLISH_ENGULFING     = 8,
   CANDLE_PATTERN_EVENING_STAR          = 9,
   CANDLE_PATTERN_MORNING_STAR          = 10,
   CANDLE_PATTERN_HAMMER                = 11,
   CANDLE_PATTERN_HANGING_MAN           = 12,
   CANDLE_PATTERN_BEARISH_HARAMI        = 13,
   CANDLE_PATTERN_BULLISH_HARAMI        = 14,
   CANDLE_PATTERN_BEARISH_MEETING_LINES = 15,
   CANDLE_PATTERN_BULLISH_MEETING_LINES = 16
  };

Verificando os padrões candle de alta:

///--- Verifica a formação do padrão "3 Soldados Brancos":
  CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS)

///--- Verifica a formação do padrão "Linha penetrante":
  CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE)

///--- Verifica a formação do padrão "DOJI":
  CheckCandlestickPattern(CANDLE_PATTERN_MORNING_DOJI)

///--- Verifica a formação do padrão "Engolfo de Alta":
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_ENGULFING)

///--- Verifica a formação do padrão "Harami de Alta":
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_HARAMI)

///--- Verifica a formação do padrão "Estrela d'Manhã":
  CheckCandlestickPattern(CANDLE_PATTERN_MORNING_STAR)

///--- Verifica a formação do padrão "Encontro de Linhas de Alta":
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_MEETING_LINES)
a
///--- Verifica a formação do padrão "Martelo":
  CheckCandlestickPattern(CANDLE_PATTERN_HAMMER)

///--- Verifica a formação de um dos padrões  Candles de Alta
  CheckPatternAllBullish();

Verificando padrões candles de baixa

///--- Verifica a formação do padrão "3 Corvos Negros":
  CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS)

///--- Verifica a formação do padrão "Nuvem Escura":
  CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER)

///--- Verifica a formação do padrão  "Bom Dia DOJI":
  CheckCandlestickPattern(CANDLE_PATTERN_EVENING_DOJI)

///--- Verifica a formação do padrão "Engolfo de Baixa":
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_ENGULFING)

///--- Verifica a formação do padrão "Bom Dia Estrela ":
  CheckCandlestickPattern(CANDLE_PATTERN_EVENING_STAR)

///--- Verifica a formação do padrão "Homem Enforcado":
  CheckCandlestickPattern(CANDLE_PATTERN_HANGING_MAN)

///--- Verifica a formação do padrão "Harami de Baixa":
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_HARAMI)

///--- Verifica a formação do padrão  "Encontro de Linhas de Baixa":
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_MEETING_LINES)

///--- Verifique a formação de um dos padrões candles de baixa
  CheckPatternAllBearish();

Aqui estão alguns exemplos de uso dos métodos:

1. Abrir posição comprada

//+------------------------------------------------------------------+
//| Verificar a condição de abertura de posição comprada             |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration)
  {
//--- verificar as condições para abertura de posição comprada
//--- é melhor usar este código com a verificação do indicador
//--- por exemplo, vamos verificar formação de "três soldados brancos" padrão:
   if CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) return(true):
//--- nenhum sinal
   return(false);
  }

2. Fechar posição comprada

//-------------------------------------------------------------------+
//| Verificar a condição do fechamento de uma posição comprada       |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckCloseLong(double &price)
  {
//--- verificar as condições para fechar posição comprada
//--- por exemplo, vamos verificar a formação de um dos padrões de baixa:
   if CheckPatternAllBearish() return(true):
//--- nenhum sinal
   return(false);
  }

3. Abertura da posição vendida

//-------------------------------------------------------------------+
//| Verificar a condição de abertura de posição vendida              |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration)
  {
//--- verificar as condições para abrir posição vendida
//--- é melhor usar este código com a verificação do indicador
//--- por exemplo, vamos verificar a formação de "3 corvos negros" pattern:
    if CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) return(true):
//--- sem sinal
   return(false);
  }

4. Fechar posição vendida

//-------------------------------------------------------------------+
//| Verificar a condição do fechamento posição vendida               |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckCloseShort(double &price)
  {
//--- verificar as condições para fechar posição vendida
//--- é melhor usar este código com a verificaçao do indicador
//--- por exemplo, vamos verificar a formação de um padrão de alta:
   if CheckPatternAllBullish() return(true):
//--- sem sinal
   return(false);
  }

Recomendações

Para reduzir sinais falsos, os padrões candles de reversão devem ser confirmados por outros indicadores, tais como osciladores.

Os seguintes padrões são considerados no livro "Estratégias dos melhores traders":

• 3 Corvos Negros/3 Soldados Brancos
• Nuvem Negra/Linha Perfurante
• Bom Dia DOJI/Boa Noite DOJI
• Engolfo de Baixa/Engolfo de Alta
  
• Bom Dia Estrela/Boa Noite Estrela
  
• Martelo/Homem Enforcado
  
• Harami de Alta/Harami de Baixa
  
• Encontro de Linhas de Baixa/Encontro de Linhas de Alta
  

Confirmado pelos osciladores estocástico, CCI, MFI e RSI.

Mais tarde iremos fornecer as classes de sinais de negociação para uso no Assistente MQL5.