Assistant MQL5 - Classe de Modèles de Chandeliers - bibliothèque pour MetaTrader 5

L'Assistant MQL5 permet de créer des Expert Advisors prêts à l'emploi basés sur les classes de la bibliothèque standard livrées avec le terminal client. Il permet de vérifier rapidement vos idées de trading, tout ce dont vous avez besoin est de créer votre propre classe de signaux de trading. La structure de cette classe et de cet exemple se trouvent dans l'article Assistant MQL5 : Comment créer un module de signaux de trading.

L'idée générique est la suivante : la classe des signaux de trading est dérivée de CExpertSignal, ensuite, il est nécessaire de remplacer les méthodes virtuelles LongCondition() et ShortCondition() avec vos propres méthodes.

Il existe un livre "Stratégies des meilleurs traders" (en russe), de nombreuses stratégies de trading y sont envisagées, nous nous concentrerons sur les modèles de chandeliers d'inversion, confirmés par Stochastique, Oscillateurs CCI, MFI et RSI.

Le meilleur moyen est de créer la classe séparée, dérivée de CExpertSignal pour vérifier la formation des modèles de chandeliers. Pour la confirmation des signaux de trading, générés par les modèles de chandeliers, il suffit d'écrire la classe, dérivée de CCandlePattern et d'y ajouter les fonctionnalités nécessaires (par exemple, la confirmation par des oscillateurs).

Ici, nous allons considérer la classe CCandlePattern, elle permet de simplifier la création de classes de signaux de trading avec des modèles de chandeliers pour l'Assistant MQL5.

CCandlePattern class

La classe CCandlePattern est dérivée de la classe CExpertSignal (classe de base des signaux de trading)

class CCandlePattern : public CExpertSignal
  {
protected:
   //--- indicateurs
   CiMA              m_MA;
   //--- time series
   CiOpen            m_open;
   CiHigh            m_high;
   CiLow             m_low;
   CiClose           m_close;
   //--- paramètres d'entréeinput 
   int               m_ma_period;

public:
   //--- constructeur
                     CCandlePattern();
   //--- méthode de réglage des paramètres d'entrée
   void              MAPeriod(int period)             { m_ma_period=period;                 } 
   //--- méthodes d'initialisation
   virtual bool      ValidationSettings();
   virtual bool      InitIndicators(CIndicators *indicators);

   //--- vérifier la formation d'un certain modèle de chandelier
   bool              CheckCandlestickPattern(ENUM_CANDLE_PATTERNS CandlePattern);
   //--- vérifier la formation d'un modèle de chandelier haussier/baissier
   bool              CheckPatternAllBullish();
   bool              CheckPatternAllBearish();

protected:
   //--- initialisation des indicateurs et des time series
   bool              InitMA(CIndicators *indicators);
   bool              InitOpen(CIndicators *indicators);
   bool              InitHigh(CIndicators *indicators);
   bool              InitLow(CIndicators *indicators);
   bool              InitClose(CIndicators *indicators);
   //--- méthodes, utilisées pour la vérification des chandeliers
   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éthodes de vérification d'un certain modèle de chandelier
   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();
  };

Utilisation de CCandlePattern dans les classes de signaux de trading pour l'Assistant MQL5

La classe CCandlePattern peut être utilisée comme classe parente pour les classes de signaux de trading pour l'Assistant MQL5. Il est nécessaire de dériver la classe du signal de trading de la classe CCandlePattern, il est également nécessaire d'ajouter des méthodes pour vérifier l'ouverture/la fermeture des positions longues/courtes (en plus des indicateurs, etc...).

La formation d'un modèle de chandelier d'inversion peut être utilisée comme signal de trading, mais il est préférable de vérifier la confirmation (par exemple, en utilisant les oscillateurs).

• bool CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration) - Vérifie les conditions d'ouverture de la position longue ;
  
• bool CheckCloseLong(double &price)  - Vérifie les conditions de clôture de la position longue ;
  
• bool CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration) - Vérifie les conditions d'ouverture de la position courte ;
  
• bool CheckCloseShort(double &price) - Vérifie les conditions de clôture de la position courte ;

//+------------------------------------------------------------------+
//|                                          CSampleCandleSignal.mqh |
//+------------------------------------------------------------------+
// include CCandlePattern class
// le fichier Candlepatterns.mqh doit être situé dans le même dossier
#include "CandlePatterns.mqh"
// début de la description de l'assistant
//+------------------------------------------------------------------+
//| Description de la classe                                         |
//| Titre=Test signal                                                |
//| Type=Signal                                                      |
//| Nom=CSampleCandleSignal                                          |
//| Classe=CSampleCandleSignal                                       |
//| Page=                                                            |
//| Paramètre=param1,int,9                                           |
....
//| Paramètre=paramN,int,13                                          |
//| Paramètre=MAPeriod,int,12                                        |
//+------------------------------------------------------------------+
// fin de la description de l'assistant
//+------------------------------------------------------------------+
class CSampleCandleSignal : public CCandlePattern
  {
protected:
   //--- indicateurs
   ....
   //--- paramètres d'entrée
   ...
public:
   //--- constructeur
                     CTestClass();
   //--- méthodes de réglage des paramètres d'entrée
   ...
   //--- initialisation des indicateurs et des time séries/vérification des paramètres d'entrée
   virtual bool      ValidationSettings();
   virtual bool      InitIndicators(CIndicators *indicators);
   //--- vérification des signaux de trading
   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éthodes d'initialisation des indicateurs
   ...
   //--- méthodes d'accès aux valeurs des indicateurs
   ...
  };

Les détails sur la structure des classes de signaux de trading, utilisés dans l'Assistant MQL5, peuvent être trouvés dans l'article Assistant MQL5 : Comment créer un module de signaux de trading.

Jetez un œil à la ligne :

//| Paramètre=MAPeriod,int,12                                        |

dans la section de description de l'assistant.

La méthode MAPeriod est utilisée dans la classe parent CCandlePattern pour le calcul du cours de clôture moyen et des valeurs moyennes du corps de la bougie. Par défaut, m_ma_period=12 est défini dans le constructeur de classe CCandlePattern(). Cependant, il est préférable de le définir à l'aide du paramètre d'entrée, cela vous permettra de l'utiliser dans le Strategy Tester de MetaTrader 5.

N'oubliez pas d'appeler ValidationSettings() et InitIndicators() de la classe parente

Il est préférable d'appeler ces méthodes en premier :

bool CSampleCandleSignal ::ValidationSettings()
  {
//--- appel de ValidationSettings de la classe parente CCandlePatter
   if(!CCandlePattern::ValidationSettings()) return(false);
//--- votre code
..
//--- ok
   return(true);
  }

Il en est de même pour la méthode InitIndicators() :

bool CSampleCandleSignal ::InitIndicators(CIndicators *indicators)
  {
//--- appel des InitIndicators de la classe parente CCandlePattern
   if(!CCandlePattern::InitIndicators(indicators)) return(false);   
//--- votre code
...
//--- ok
   return(true);
  }

Vérification des modèles de chandelier

Pour vérifier la formation d'un certain motif de chandelier, il est nécessaire d'appeler la méthode CheckCandlestickPattern(ENUM_CANDLE_PATTERNS CandlePattern) avec le motif, passé à la fonction.

Vous pouvez également vérifier la formation de l'un des modèles de chandelier haussier/baissier en utilisant les méthodes CheckPatternAllBullish() et CheckPatternAllBearish().

Pour simplifier le travail des modèles de chandeliers, l'énumération ENUM_CANDLE_PATTERNS est utilisée :

enum ENUM_CANDLE_PATTERNS  // liste des modèles de chandeliers
  {
   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
  };

Vérification des modèles de chandeliers haussiers :

///--- Vérifie la formation du motif "3 White Soldiers" :
  CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS)

///--- Vérifie la formation du motif "Piercing Line" :
  CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE)

///--- Vérifie la formation du motif "Morning Doji" :
  CheckCandlestickPattern(CANDLE_PATTERN_MORNING_DOJI)

///--- Vérifie la formation du motif "Bullish Engulfing" :
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_ENGULFING)

///--- Vérifie la formation du motif "Bullish Haramii" :
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_HARAMI)

///--- Vérifie la formation du motif "Morning Star" :
  CheckCandlestickPattern(CANDLE_PATTERN_MORNING_STAR)

///--- Vérifie la formation du motif "Bullish Meeting Lines" :
  CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_MEETING_LINES)

///--- Vérifie la formation du motif "Hammer" :
  CheckCandlestickPattern(CANDLE_PATTERN_HAMMER)

///--- Vérifie la formation de l'un des motifs  haussiers de chandeliers
  CheckPatternAllBullish();

Vérification des modèles de chandeliers baissiers :

///--- Vérifie la formation du motif "3 Black Crows" pattern:
  CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS)

///--- Vérifie la formation du motif "Dark Cloud Cover" :
  CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER)

///--- Vérifie la formation du motif "Evening Doji" :
  CheckCandlestickPattern(CANDLE_PATTERN_EVENING_DOJI)

///--- Vérifie la formation du motif "Bearish Engulfing" :
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_ENGULFING)

///--- Vérifie la formation du motif "Evening Star" :
  CheckCandlestickPattern(CANDLE_PATTERN_EVENING_STAR)

///--- Vérifie la formation du motif "Hanging Man" :
  CheckCandlestickPattern(CANDLE_PATTERN_HANGING_MAN)

///--- Vérifie la formation du motif "Bearish Harami" :
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_HARAMI)

///--- Vérifie la formation du motif "Bearish Meeting Lines" :
  CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_MEETING_LINES)

///--- Vérifie la formation de l'un des motifs baissiers
  CheckPatternAllBearish();

Voici des exemples d'utilisation des méthodes :

1. Ouverture d'une position longue

//+------------------------------------------------------------------+
//| Vérification des conditions d'ouverture d'une position longue    |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration)
  {
//--- vérifie les conditions pour ouvrir une position longue
//--- il est préférable d'utiliser ce code en plus de la vérification de l'indicateur
//--- par exemple, vérifions la formation du motif "3 soldats blancs" :
   if CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) return(true):
//--- aucun signal
   return(false);
  }

2. Fermeture d'une position longue

//-------------------------------------------------------------------+
//| Vérification des conditions de fermeture d'une position longue   |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckCloseLong(double &price)
  {
//--- vérifie les conditions pour fermer la position longue
//--- par exemple, vérifions la formation d'un des modèles baissiers :
   if CheckPatternAllBearish() return(true):
//--- aucun signal
   return(false);
  }

3. Ouverture d'une position courte

//-------------------------------------------------------------------+
//| Vérification des conditions d'ouverture de la position courte    |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration)
  {
//--- vérifie les conditions pour ouvrir une position courte
//--- il est préférable d'utiliser ce code en plus de la vérification de l'indicateur
//--- par exemple, vérifions la formation du motif "3 corbeaux noirs" :
    if CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) return(true):
//--- aucun signal
   return(false);
  }

4. Fermeture d'une position courte

//-------------------------------------------------------------------+
//| Vérification des conditions de fermeture d'une position courte   |
//+------------------------------------------------------------------+
bool CSampleCandleSignal::CheckCloseShort(double &price)
  {
//--- vérifie les conditions pour fermer la position courte
//--- il est préférable d'utiliser ce code en plus de la vérification de l'indicateur
//--- par exemple, vérifions la formation d'un des motifs haussiers :
   if CheckPatternAllBullish() return(true):
//--- aucun signal
   return(false);
  }

Recommandations

Pour réduire les faux signaux, les modèles de chandeliers d'inversion doivent être confirmés par d'autres indicateurs, tels que des oscillateurs.

Les schémas suivants sont pris en compte dans le livre "Stratégies des meilleurs traders" :

• 3 Corbeaux Noirs/3 Soldats Blancs
• Couverture de Nuage Sombre/Ligne de Perçage
• Doji du Matin/Doji du Soir
• Engloutissement Baissier/Engloutissement Haussier
  
• Étoile du Soir/Étoile du Matin
  
• Marteau/Pendu
  
• Harami Baissier/Harami Haussier
  
• Lignes de Rencontre Baissières/Lignes de Rencontre Haussières
  

confirmé par les oscillateurs Stochastique, CCI, MFI et RSI.

Plus tard, nous fournirons les classes de signaux de trading à utiliser dans l'Assistant MQL5.