Asistente MQL5 - Clases de patrones de velas - librería para MetaTrader 5

El Asistente MQL5 permite crear EAs listos para usar basados en las clases de la Librería Estándar que se entrega junto con el terminal de cliente. Para comprobar rápidamente tus ideas de trade, todo lo que necesitas es crear su propia clase de señales de trading. La estructura y ejemplos de estas clases pueden encontrarse en el artículo Asistente MQL5: Cómo Crear un Módulo de Señales de Trading..

La idea genérica es la siguiente: la clase de señales de trading se deriva del CExpertSignal, seguidamente, es necesario reemplazar los métodos virtuales LongCondition() y ShortCondition() por sus propios métodos.

Hay un libro "Estrategias de los mejores traders" (en Ruso), donde hay muchas estrategias de trading, nos centraremos en los patrones de velas invertidas, confirmados por los osciladores Stochastic, CCI, MFI and RSI.

La mejor manera es crear una clase separada, derivada de CExpertSignal para el control de la formación de patrones de velas. Para la confirmación de las señales de trade, generados por los patrones de vela, es suficiente escribir la clase, derivada de CCandlePattern y añadir las características necesarias (por ejemplo, confirmación de osciladores).

Aquí vamos a considerar la clase CCandlePattern, que permite simplificar la creación de clases señales de trade con los patrones de velas para el asistente MQL5.

Clase CCandlePattern

La clase CCandlePattern se deriva de la clase CExpertSignal (la clase base de las señales de trading)

class CCandlePattern : public CExpertSignal
  {
protected:
   //--- indicators
   CiMA              m_MA;
   //--- series de tiempo
   CiOpen            m_open;
   CiHigh            m_high;
   CiLow             m_low;
   CiClose           m_close;
   //--- parametros de entrada
   int               m_ma_period;

public:
   //--- constructor
                     CCandlePattern();
   //--- método de ajuste de la entrada de parámetros
   void              MAPeriod(int period)             { m_ma_period=period;                 } 
   //--- iniciando método
   virtual bool      ValidationSettings();
   virtual bool      InitIndicators(CIndicators *indicators);

   //--- comprobar la formación de un determinado patrón de vela
   bool              CheckCandlestickPattern(ENUM_CANDLE_PATTERNS CandlePattern);
   //--- check formation of bullish/bearish candlestick pattern
   bool              CheckPatternAllBullish();
   bool              CheckPatternAllBearish();

protected:
   //--- inicio indicadores y series de tiempo
   bool              InitMA(CIndicators *indicators);
   bool              InitOpen(CIndicators *indicators);
   bool              InitHigh(CIndicators *indicators);
   bool              InitLow(CIndicators *indicators);
   bool              InitClose(CIndicators *indicators);
   //--- métodos, utilizados para comprobar las velas
   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))); }
   //--- methods for checking of a certain candlestick model
   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 CCandlePattern en clases de señales de trade para el Asistente MQL5

La clase CCandlePattern puede utilizar una clase "padre" para clases de señales de trade para el asistente MQL5. Es necesario derivar la clase de señal de trade desde la clase CCandlePattern, también es necesario añadir métodos de control de posiciones largo/corto apertura/cierre (además de indicadores, etc....).

Formación del patrón de velas inversas puede utilizarse como una señal de trade, pero es mejor comprobar confirmación (por ejemplo, usando los osciladores).

• bool CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration) - Controlar las condiciones de la apertura de posiciones largas;
  
• bool CheckCloseLong(double &price)  - Controlar las condiciones de cierre de posiciones largas;
  
• bool CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration) - Controlar las condiciones de apertura de posiciones cortas;
  
• bool CheckCloseShort(double &price) - Controlar las condiciones de cierre de las psiciones cortas;

//+------------------------------------------------------------------+
//|                                          CSampleCandleSignal.mqh |
//+------------------------------------------------------------------+
// incluir las clase CCandlePattern
// candlepatterns.mqh debe estar ubicado en la misma carpeta
#include "CandlePatterns.mqh"
// Descripción del asistente de arranque
//+------------------------------------------------------------------+
//| Descripción de la clase                                          |
//| Title=Test signal                                                |
//| Type=Signal                                                      |
//| Name=CSampleCandleSignal                                         |
//| Class=CSampleCandleSignal                                        |
//| Page=                                                            |
//| Parameter=param1,int,9                                           |
....
//| Parameter=paramN,int,13                                          |
//| Parameter=MAPeriod,int,12                                        |
//+------------------------------------------------------------------+
// Fina de la descripción del asistente
//+------------------------------------------------------------------+
class CSampleCandleSignal : public CCandlePattern
  {
protected:
   //--- indicators
   ....
   //--- parámetros de entrada
   ...
public:
   //--- constructor
                     CTestClass();
   //--- métodos de ajuste de los parámetros de entrada
   ...
   //--- inicio de los indicadores y de las series de tiempo/ajuste de los parámetros de entrada
   virtual bool      ValidationSettings();
   virtual bool      InitIndicators(CIndicators *indicators);
   //--- ajuste de las señales de trade
   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);

protected:
   //--- métodos de inicio de los indicadores
   ...
   //--- métodos de acceso a los valores de los indicadores
   ...
  };

Los detalles sobre la estructura de las clases de señales de trade, utilizadas en el asistente MQL5, pueden encontrarse en el artículo Asistente MQL5: Cómo Crear un Módulo de Señales de Trading.

Echa un vistazo a la línea:

//| Parameter=MAPeriod,int,12  |

en la sección Descripción del asistente.

El método MAPeriod se utiliza en la clase "padre" CCandlePattern para el cálculo del precio medio de cierre y un promedio de los valores del cuerpo de la vela. Se establece de forma predeterminada, m_ma_period=12 en el constructor de la clase CCandlePattern(). Sin embargo, es mejor definirla usando el parámetro de entrada, nos permite utilizarlo en el Probador de estrategias del MetaTrader 5.

No olvidarse de hacer una llamar al ValidationSettings() y al InitIndicators() de la clase padre

Es mejor llamar a estos métodos primero:

bool CSampleCandleSignal ::ValidationSettings()
  {
//--- call of ValidationSettings of parent CCandlePattern class
   if(!CCandlePattern::ValidationSettings()) return(false);
//--- su códico
..
//--- ok
   return(true);
  }

Lo mismo es para el método InitIndicators():

bool CSampleCandleSignal ::InitIndicators(CIndicators *indicators)
  {
//--- Llamar a InitIndicators de la clase padre CCandlePattern
   if(!CCandlePattern::InitIndicators(indicators)) return(false);   
//--- su códido
...
//--- ok
   return(true);
  }

Comprobación de los patrones de las velas

Para comprobar la formación de un cierto patrón de vela es necesario llamar al método CheckCandlestickPattern(ENUM_CANDLE_PATTERNS CandlePattern) con el patrón, pasado a la función.

También se puede comprobar la formación de uno de los patrones de vela alcista/bajista utilizando los métodos CheckPatternAllBullish() y CheckPatternAllBearish().

Para simplificar el trabajo de los patrones de vela, se utiliza la enumeración de ENUM_CANDLE_PATTERNS:

enum ENUM_CANDLE_PATTERNS  // lista de patrones de velas
  {
   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
  };

Comprobación de los patrones de vela alcista:

///--- Comprobar formación del patrón "3 Soldados Blacos":
  CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS)

///--- Comprobar formación del patrón "Piercing Line" :
  CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE)

///--- Comprobar formación del patrón "Morning Doji":
  CheckCandlestickPattern(CANDLE_PATTERN_MORNING_DOJI)

///--- >Comprobar formación del patrón "Bullish Engulfing" :
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_ENGULFING)

///--- Comprobar formación del patrón "Bullish Haramii" :
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_HARAMI)

///--- Comprobar formación del patrón "Morning Star" :
  CheckCandlestickPattern(CANDLE_PATTERN_MORNING_STAR)

///--- Comprobar formación del patrón "Bullish Meeting Lines" :
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_MEETING_LINES)

///--- Comprobar formación del patrón "Hammer" :
  CheckCandlestickPattern(CANDLE_PATTERN_HAMMER)

///--- Comprobar formación de  uno de los patrones de vela alcista
  CheckPatternAllBullish();

Comprobación de los patrones de vela bajista:

///--- Comprobar formación del patrón "3 Cuervos Negros" :
  CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS)

///--- Comprobar formación del patrón "Dark Cloud Cover" :
  CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER)

///--- Comprobar formación del patrón "Evening Doji" :
  CheckCandlestickPattern(CANDLE_PATTERN_EVENING_DOJI)

///--- Comprobar formación del patrón "Bearish Engulfing" :
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_ENGULFING)

///--- Comprobar formación del patrón "Evening Star" :
  CheckCandlestickPattern(CANDLE_PATTERN_EVENING_STAR)

///--- Comprobar formación del patrón "Hanging Man" :
  CheckCandlestickPattern(CANDLE_PATTERN_HANGING_MAN)

///--- Comprobar formación del patrón "Bearish Harami" :
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_HARAMI)

///--- Comprobar formación del patrón "Bearish Meeting Lines" :
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_MEETING_LINES)

///--- Comprobar formación de uno de los patrones bajistas
  CheckPatternAllBearish();

Estos son ejemplos de uso de los métodos:

1. Apertura de posición larga

//+------------------------------------------------------------------+
//| Comprobación de condición de apertura de la posición larga       |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration)
  {
//--- comprobar las condiciones para abrir posiciones largas
//--- es mejor utilizar este código, además de la comprobación del indicador
//--- Por ejemplo, vamos a ver la formación de patrón "3 Soldados Blancos":
   if CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) return(true):
//--- no signal
   return(false);
  }

2. Cierre de posición largan

//-------------------------------------------------------------------+
//| comprobación de condición de cierre de posiciones cortas         |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckCloseLong(double &price)
  {
//--- comprobar las condiciones para cerrar las posiciones largas
//--- Por ejemplo, vamos a ver la formación de uno de los patrones bajistas:
   if CheckPatternAllBearish() return(true):
//--- no signal
   return(false);
  }

3. Apertura de posición corta

//-------------------------------------------------------------------+
//| Comprobación de condición de apertura d eposiciones cortas       |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration)
  {
//--- comprobar las condiciones para abrir posiciones cortas
//--- es mejor utilizar este código, además de la comprobación del indicador
//--- Por ejemplo, vamos a ver la formación del patrón "3 cuervos negros":
    if CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) return(true):
//--- no signal
   return(false);
  }

4. Cierre de posición corta

//-------------------------------------------------------------------+
//| Comprobación de condición de cierre de posiciones cortas         |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckCloseShort(double &price)
  {
//--- comprobar las condicionespara cerrar posiciones cortas
//--- es mejor utilizar este código, además de la comprobación del indicador
//--- Por ejemplo, vamos a ver la formación de uno de los patrones alcistas:
   if CheckPatternAllBullish() return(true):
//--- no signal
   return(false);
  }

Recomendaciones

Para disminuir las señales falsas, los patrones de velas invertidas deben confirmarse tanto por otros indicadores, como otros osciladores.

En el libro "Estrategias de los mejores traders" se consideran los siguientes patrones:

• 3 Cuervos Negros/3 Soldados Balncos
• Dark Cloud Cover/Piercing Line
• Morning Doji/Evening Doji
• Bearish Engulfing/Bullish Engulfing
  
• Evening Star/Morning Star
  
• Hammer/Hanging Man
  
• Bearish Harami/Bullish Harami
  
• Bearish Meeting Lines/Bullish Meeting Lines
  

confirmed by Stochastic, CCI, MFI and RSI oscillators.

Más adelante proporcionaremos las clases de señales de trade para su uso en asistente MQL5.