MACD Sample - expert pour MetaTrader 5

L'EA MACD Sample est inclus dans le pack standard du terminal client MetaTrader 5 et est un exemple d'EA qui trade à l'aide de l'indicateur MACD.

Le fichier de l'Expert Advisor MACD Sample.mq5 se trouve dans terminal_data_folder\MQL5\Experts\Examples\MACD\". Cet Expert Advisor est un exemple d'approche orientée objet dans le développement d'EA.

Examinons la structure de l'Expert Advisor et son fonctionnement.

1 Propriétés de l'EA

1.1. Propriétés de l'EA

//+------------------------------------------------------------------+
//|                                                  MACD Sample.mq5 |
//|                   Copyright 2009-2013, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright   "Copyright 2009-2013, MetaQuotes Software Corp."
#property link        "https://www.mql5.com"
#property version     "5.20"
#property description "l est important de s'assurer que l'expert travaille avec un graphique"
#property description "normal et l'utilisateur n'a fait aucune erreur lors de la saisie"
#property description "des variables (Lots, TakeProfit, TrailingStop) dans notre cas,"
#property description "nous vérifions le TakeProfit sur un graphique de plus de 2*trend_period barres"

Les 5 premières lignes contiennent un commentaire, les sept lignes suivantes définissent les propriétés du programme MQL5 (copyright, lien, version, description) en utilisant les directives du préprocesseur #property.

Lorsque vous exécutez l'Expert Advisor, ils s'affichent dans l'onglet "Commun" :

Figure 1 Paramètres communs de l'EA MACD Sample

1.2. Inclure les Fichiers

Ensuite, la directive #include indique au compilateur d'inclure les fichiers qui contiennent les classes trade de la bibliothèque standard.

• Trade.mqh (CTrade - une classe pour les opérations de trading) ;
  
• SymbolInfo.mqh (CSymbolInfo - classe pour travailler avec les propriétés d'un instrument de trading) ;
  
• PositionInfo.mqh (CPositionInfo - classe pour travailler avec les propriétés de position ouvertes) ;
  
• AccountInfo.mqh (CAccountInfo - classe pour travailler avec les propriétés du compte de trading).
  

//--- fichier d'include
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\AccountInfo.mqh>

Les instances des classes appropriées sont ensuite utilisées comme variables membres de la classe CExpert (section 3).

1.3. Entrées

Ensuite, le type, le nom, les valeurs par défaut et un commentaire. Leur rôle est montré dans la fig. 2.

//--- Expert Advisor input parameters
input double InpLots          =0.1; // Lots
input int    InpTakeProfit    =50;  // Take Profit (en pips)
input int    InpTrailingStop  =30;  // Niveau du Trailing Stop (en pips)
input int    InpMACDOpenLevel =3;   // Niveau d'ouverture du MACD (en pips)
input int    InpMACDCloseLevel=2;   // Niveau de clôture du MACD (en pips)
input int    InpMATrendPeriod =26;  // Période de tendance de la MA

Notez que les noms des paramètres d'entrée ont le préfixe "Inp". Notez également que les variables globales sont préfixées par "Ext". Une telle approche de nommage des variables simplifie l'utilisation de nombreuses variables différentes.

InpLots - le volume de la transaction, InpTakeProfit et InpTrailingStop déterminent les niveaux de Take Profit et de Trailing Stop,

Le texte du commentaire dans la ligne du paramètre d'entrée, ainsi que les valeurs par défaut ​, sont affichés dans l'onglet "Options" à la place du nom du paramètre d'entrée :

Figure 2. Paramètres d'entrée de l'EA MACD Sample

1.4. Variables Globales

Ensuite, la variable globale ExtTimeOut est déclarée. Il sera utilisé pour contrôler le temps d'exécution des opérations de trading.

int ExtTimeOut=10 ; // temps (en secondes) entre les opérations de trading

Après la déclaration de la classe CSampleExpert, à la ligne 76 une autre variable globale est déclarée : ExtExpert - Instance de classe CSampleExpert :

//--- la variable globale ExtExpert
CSampleExpert ExtExpert ;

L'objet ExtExpert (exemple de classe CSampleExpert) contient la logique de base de la stratégie de trading (Section 3).

2. Fonctions de Gestion des Evénements

Fonctions de Gestion des Evénements

2.1. La fonction d'initialisation OnInit()

La fonction OnInit() est appelée une fois lors du premier démarrage de l'Expert Advisor. Habituellement, dans le gestionnaire d'événements OnInit(), l'EA est préparé pour fonctionner : les paramètres d'entrée sont vérifiés, les indicateurs et les paramètres sont initialisés, etc. Dans le cas d'erreurs critiques, lorsque la poursuite du travail n'a pas de sens, la fonction est quittée avec un code de retour INIT_FAILED.

//+------------------------------------------------------------------+
//| Fonction d'initialisation de l'expert                            |
//+------------------------------------------------------------------+
int OnInit(void)
  {
//--- initialisation et création de tous les objets requis
   if(!ExtExpert.Init())
      return(INIT_FAILED);
//--- initialisation réussie
   return(INIT_SUCCEEDED);
  }

Dans ce cas, la méthode Init() de l'objet ExtExpert est appelée, qui renvoie true ou false selon la préparation de tous les objets requis pour l'opération (voir Section 3.4). En cas d'erreur, OnInit() est quitté avec un code de retour INIT_FAILED - c'est une manière correcte de terminer l'opération de l'EA/l'indicateur dans le cas d'une initialisation infructueuse.

2.2. La fonction OnTick()

La fonction OnTick() est appelée à chaque fois qu'une nouvelle cotation est reçue pour le symbole du graphique, sur lequel s'exécute l'EA.

//+------------------------------------------------------------------+
//| Fonction de l'Expert de gestion d'un nouveau tick                |
//+------------------------------------------------------------------+
void OnTick(void)
  {
   static datetime limit_time=0; // stores the last call time + timeout
//--- ne fonctionne pas si le temps requis ne s'est pas écoulé
   if(TimeCurrent()>=limit_time)
     {
      //--- vérification des données
      if(Bars(Symbol(),Period())>2*InpMATrendPeriod)
        {
         //--- après l'appel de la méthode Processing() augmente la valeur de limit_time de ExtTimeOut 
         if(ExtExpert.Processing())
            limit_time=TimeCurrent()+ExtTimeOut;
        }
     }
  }

Le gestionnaire d'événements OnTick() inclut un mécanisme d'appels périodiques de la méthode ExtExpert.Processing(), qui est utilisé pour l'analyse de marché et les opérations de trading lorsque les conditions de trading sont remplies.

L'intervalle de temps entre les appels est défini par la valeur du paramètre d'entrée ExtTimeOut.

2.3. La fonction de désinitialisation OnDeInit()

OnDeInit() est appelé lorsqu'un EA est supprimé du graphique. Si un programme place des objets graphiques pendant le fonctionnement, ils peuvent être supprimés du graphique.

Dans ces exemples, aucune fonction de désinitialisation n'est utilisée, aucune action n'est effectuée.

3. La classe CSampleExpert

3.1. La classe CSampleExpert

//+------------------------------------------------------------------+
//| Exemple de classe MACD Sample                                    |
//+------------------------------------------------------------------+
class CSampleExpert
  {
protected: 
   //--- variables protected - les membres de classe ne sont disponibles qu'à l'intérieur des méthodes de classe 
   double            m_adjusted_point;             // un multiplicateur pour les cotations à 3/5 chiffres
   CTrade            m_trade;                      // Exemple de classe CTrade
   CSymbolInfo       m_symbol;                     // Exemple de classe CSymbolInfo
   CPositionInfo     m_position;                   // Exemple de classe CPositionInfo
   CAccountInfo      m_account;                    // Exemple de classe CAccountInfo
   //--- poignées sur les indicateurs
   int               m_handle_macd;                // poignée sur l'indicateur MACD
   int               m_handle_ema;                 // poignée sur l'indicateur Moving Average
   //--- tampons des indicateurs
   double            m_buff_MACD_main[];           // the buffer of the main line of the MACD indicator
   double            m_buff_MACD_signal[];         // the buffer of the signal line of the MACD indicator
   double            m_buff_EMA[];                 // tampon de l'indicateur EMA
   //--- valeurs actuelles des indicateurs
   double            m_macd_current;
   double            m_macd_previous;
   double            m_signal_current;
   double            m_signal_previous;
   double            m_ema_current;
   double            m_ema_previous;
   //--- niveaux (en points standards)
   double            m_macd_open_level;
   double            m_macd_close_level;
   double            m_traling_stop;
   double            m_take_profit;

public: 
   //--- constructeur
                     CSampleExpert(void);
   //--- destructeur
                     ~CSampleExpert(void);
   //--- méthodes publiques pouvant être appelées en dehors de la classe 
   //--- méthode d'initialisation
   bool              Init(void);
   //--- méthode de dé-initialisation
   void              Deinit(void);
   //--- méthode de traitement
   bool              Processing(void);
protected: 
   //--- méthodes protected ne pouvant être appelées que depuis les méthodes de la classe 
   bool              InitCheckParameters(const int digits_adjust);
   bool              InitIndicators(void);
   bool              LongClosed(void);
   bool              ShortClosed(void);
   bool              LongModified(void);
   bool              ShortModified(void);
   bool              LongOpened(void);
   bool              ShortOpened(void);
  };

La classe contient la déclaration de variables (membres de classe) et de fonctions (méthodes de classe).

Pour un travail plus pratique avec les variables, toutes les variables membres de la classe contiennent le préfixe "m_" (membre), qui indique qu'une variable est un membre de la classe. Avant la déclaration d'une variable ou d'une méthode, son type est précisé (ou valeur de retour pour les fonctions).

La visibilité des variables et des méthodes membres de la classe est définie à l'aide de modificateurs d'accès. Dans la classe CSampleExpert, les modificateurs protected et public sont utilisés. Toutes les variables et méthodes définies dans la section publique, sont publiques et accessibles de l'extérieur. La classe CSampleExpert possède cinq de ces méthodes :

1. CSampleExpert(void) - un constructeur (appelé automatiquement lors de la création d'une instance de classe) ;
2. ~CSampleExpert(void) - un destructeur (appelé automatiquement lors de la suppression d'une instance de classe) ;
3. bool Init(void) - méthode d'initialisation, dans laquelle toutes les données nécessaires au fonctionnement sont préparées ;
   
4. void Deinit(void) - méthode de désinitialisation ;
   
5. bool Processing(void) - méthode de traitement.
   

Les variables membres de la classe CSampleExpert déclarées avec le modificateur d'accès protégé ne seront disponibles que dans les méthodes de la classe CSampleExpert (et les classes enfants).

1. double           m_adjusted_point - variable multiplicatrice pour une opération correcte avec des guillemets à 3/5 chiffres ;
   
2. CTrade          m_trade - exemple de classe СTrade ;
   
3. CSymbolInfo  m_symbol - exemple de classe CSymbolInfo ;
4. CPositionInfo  m_position - exemple de classe СPositionInfo ;
5. CAccountInfo  m_account - exemple de classe CAccountInfo ;
   
6. int                 m_handle_macd : une variable permettant de stocker la valeur du descripteur de l'indicateur MACD.
   
7. int                 m_handle_ema - une variable pour stocker la valeur du descripteur de l'indicateur EMA ;
8. double           m_buff_MACD_main[] - un tableau dynamique de type double, qui est utilisé pour demander les valeurs de la ligne MACD principale ;
9. double           m_buff_MACD_signal[] - un tableau dynamique de type double, qui est utilisé pour demander les valeurs de la ligne MACD du signal ;
10. double           m_buff_EMA[] - un tableau dynamique de type double, qui est utilisé pour demander les valeurs de l'indicateur EMA ;
11. double           m_macd_current - est utilisé pour stocker la valeur actuelle de la ligne MACD principale ;
12. double           m_macd_previous - est utilisé pour stocker la valeur précédente de la ligne MACD principale ;
13. double           m_signal_current - est utilisé pour stocker la valeur actuelle de la ligne MACD du signal ;
14. double           m_signal_previous - est utilisé pour stocker la valeur précédente de la ligne MACD du signal ;
15. double           m_ema_current - est utilisé pour stocker la valeur actuelle de l'indicateur EMA ;
16. double           m_ema_previous - est utilisé pour stocker la valeur précédente de l'indicateur EMA
17. double           m_macd_open_level,
18. double           m_macd_close_level,
19. double           m_traling_stop,
20. double           m_take_profit - sont utilisés pour stocker les valeurs des niveaux de prix (définis dans les paramètres d'entrée) en tenant compte du multiplicateur m_adjusted_point.
    

Méthodes de classe CSampleExpert déclarées avec le modificateur d'accès protégé :

1. bool  InitCheckParameters(const int digits_adjust) - vérification de l'exactitude des paramètres d'entrée et initialisation des paramètres de l'EA ;
   
2. bool InitIndicators(void) - initialisation (création) des indicateurs MACD et Moyenne mobile ;
   
3. bool  LongClosed(void) - renvoie true (et ferme une position longue ouverte) si les conditions de fermeture d'une position longue sont remplies ;
4. bool ShortClosed(void) - renvoie true (et ferme une position courte ouverte) si les conditions de clôture d'une position courte sont remplies ;
5. bool  LongModified(void) - renvoie true (et modifie le prix du Stop Loss) si les conditions de modification du niveau du Stop Loss d'une position longue ouverte sont remplies ;
6. bool  ShortModified(void) - renvoie true (et modifie le prix Stop Loss) si les conditions de modification du niveau Stop Loss d'une position courte ouverte sont remplies ;
7. bool  LongOpened(void) - renvoie true (et ouvre une position longue) si les conditions d'ouverture d'une position longue sont remplies ;
8. bool ShortOpened(void) - renvoie true (et ouvre une position courte) si les conditions d'ouverture d'une position courte sont remplies.

3.2. Constructeur de classe CSampleExpert

//+------------------------------------------------------------------+
//| Constructeur de la classe CSampleExpert                          |
//+------------------------------------------------------------------+
CSampleExpert::CSampleExpert(void) : m_adjusted_point(0),
                                     m_handle_macd(INVALID_HANDLE),
                                     m_handle_ema(INVALID_HANDLE),
                                     m_macd_current(0),
                                     m_macd_previous(0),
                                     m_signal_current(0),
                                     m_signal_previous(0),
                                     m_ema_current(0),
                                     m_ema_previous(0),
                                     m_macd_open_level(0),
                                     m_macd_close_level(0),
                                     m_traling_stop(0),
                                     m_take_profit(0)
  {
   ArraySetAsSeries(m_buff_MACD_main,true);
   ArraySetAsSeries(m_buff_MACD_signal,true);
   ArraySetAsSeries(m_buff_EMA,true);
  }

Le constructeur de classe est appelé automatiquement lorsqu'un objet class sample est créé. Lorsqu'il est appelé, les valeurs par défaut (entre parenthèses) des variables membres de la classe sont définies et la direction d'indexation de la série temporelle est définie pour m_buff_MACD_main[], m_buff_MACD_signal[], m_buff_EMA[].

3.3. Destructeur de classe CSampleExpert

//+------------------------------------------------------------------+
//| Destructeur de la classe CSampleExpert                           |
//+------------------------------------------------------------------+
CSampleExpert::~CSampleExpert(void)
  {
  }

Le destructeur de classe CSampleExpert ne contient aucun code.

3.4. La méthode Init de la classe CSampleExpert

//+------------------------------------------------------------------+
//| Initialisation et vérification des paramètres d'entrée           |
//+------------------------------------------------------------------+
bool CSampleExpert::Init(void)
  {
//--- définition des paramètres communs
   m_symbol.Name(Symbol());              // symbole
   m_trade.SetExpertMagicNumber(12345);  // magic
//--- prise en compte des cotations à 3/5 décimales
   int digits_adjust=1;
   if(m_symbol.Digits()==3 || m_symbol.Digits()==5)
      digits_adjust=10;
   m_adjusted_point=m_symbol.Point()*digits_adjust;
//--- définition des valeurs des niveaux en tenant compte du modificateur m_adjusted_point
   m_macd_open_level =InpMACDOpenLevel*m_adjusted_point;
   m_macd_close_level=InpMACDCloseLevel*m_adjusted_point;
   m_traling_stop    =InpTrailingStop*m_adjusted_point;
   m_take_profit     =InpTakeProfit*m_adjusted_point;
//--- définition du glissement (slippage) à 3 points
   m_trade.SetDeviationInPoints(3*digits_adjust);
//---
   if(!InitCheckParameters(digits_adjust))
      return(false);
   if(!InitIndicators())
      return(false);
//--- succès
   return(true);
  }

Dans la méthode Init(), les variables membres de classe sont initialisées et les paramètres d'entrée sont vérifiés.

Un appel de la méthode Name()pour l'objet m_symbol (instance de classeCSymbolInfo) définit le nom du symbole, sur lequel l'Expert Advisor s'exécute, puis la méthode SetExpertMagicNumber() est appelé ; il définit la valeur du nombre magique de l'EA pour l'objet m_trade (sera utilisé pour les opérations de trading). Ensuite, la méthode Digits() est utilisée pour demander le nombre de chiffres des symboles après la virgule et, si nécessaire, les valeurs des niveaux sont corrigées.

Ensuite, la méthode SetDeviationInPoints() de l'objet m_trade est appelée, dans laquelle la valeur du glissement autorisé dans les opérations de trading est définie.

3.5. La méthode InitCheckParameters de la classe CSampleExpert

//+------------------------------------------------------------------+
//| Vérificartion des paramètres d'entrée	                     |
//+------------------------------------------------------------------+
bool CSampleExpert::InitCheckParameters(const int digits_adjust)
  {
//--- vérification de la validité du niveau du Take Profit
   if(InpTakeProfit*digits_adjust<m_symbol.StopsLevel())
     {
      printf("Le Take Profit doit être plus grand que %d",m_symbol.StopsLevel());
      return(false);
     }
//--- vérification de la validité du niveau du Trailing Stop
   if(InpTrailingStop*digits_adjust<m_symbol.StopsLevel())
     {
      printf("Le Trailing Stop doit être plus grand que %d",m_symbol.StopsLevel());
      return(false);
     }
//--- vérification de la validité du volume du Trade
   if(InpLots<m_symbol.LotsMin() || InpLots>m_symbol.LotsMax())
     {
      printf("Le nombre de lots doit être dans l'intervalle %f à %f",m_symbol.LotsMin(),m_symbol.LotsMax());
      return(false);
     }
   if(MathAbs(InpLots/m_symbol.LotsStep()-MathRound(InpLots/m_symbol.LotsStep()))>1.0E-10)
     {
      printf("Le nombre de lots ne correspond pas à l'incrément de lot %f",m_symbol.LotsStep());
      return(false);
     }
//--- affiche un avertissement si Take Profit<=Trailing Stop
   if(InpTakeProfit<=InpTrailingStop)
      printf("Attention: le Trailing Stop doit être inférieur au Take Profit");
//--- succès
   return(true);
  }

L'exactitude des paramètres d'entrée de l'EA est vérifiée dans la méthode InitCheckParameters(). Si l'un des paramètres n'est pas valide, un message approprié apparaît et la fonction renvoie false.

3.6. La méthode InitIndicators() de la classe CSampleExpert

//+------------------------------------------------------------------+
//| Méthode d'initialisation des indicateurs                         |
//+------------------------------------------------------------------+
bool CSampleExpert::InitIndicators(void)
  {
//--- création du MACD
   if(m_handle_macd==INVALID_HANDLE)
      if((m_handle_macd=iMACD(NULL,0,12,26,9,PRICE_CLOSE))==INVALID_HANDLE)
        {
         printf("Erreur de création du MACD");
         return(false);
        }
//--- création de l'EMA
   if(m_handle_ema==INVALID_HANDLE)
      if((m_handle_ema=iMA(NULL,0,InpMATrendPeriod,0,MODE_EMA,PRICE_CLOSE))==INVALID_HANDLE)
        {
         printf("Erreur de création de l'EMA");
         return(false);
        }
//--- succès
   return(true);
  }

Dans la méthode InitIndicators(), l'exactitude des valeurs initiales des variables m_handle_macd et m_handle_ema est vérifiée (elles doivent être égales à INVALID_HANDLE, puisqu'elles ont été initialisées dans le constructeur), et les indicateurs techniques MACD et la Moyenne mobile sont créées (à l'aide des fonctions iMACD et iMA). En cas de succès, la fonction renvoie true et les descripteurs d'indicateur sont enregistrés dans les membres de classe m_handle_macd et m_handle_ema.

Les descripteurs des indicateurs créés seront ensuite utilisées pour vérifier la quantité de données calculées (BarsCalculated) et obtenir les valeurs numériques (CopyBuffer) des indicateurs dans la méthode Processing().

3.7. La méthode LongClosed() de la classe CSampleExpert

//+------------------------------------------------------------------+
//| Vérification des conditions pour fermer une position longue      |
//+------------------------------------------------------------------+
bool CSampleExpert::LongClosed(void)
  {
   bool res=false;
//--- La position devrait-elle être fermée ?
   if(m_macd_current>0)
      if(m_macd_current<m_signal_current && m_macd_previous>m_signal_previous)
         if(m_macd_current>m_macd_close_level)
           {
            //--- clôture de la position
            if(m_trade.PositionClose(Symbol()))
               printf("La position longue sur %s va être fermée",Symbol());
            else
               printf("Erreur lors de la clôture de la position sur %s : '%s'",Symbol(),m_trade.ResultComment());
            res=true;
           }
//--- retourne le résultat
   return(res);
  }

La méthode LongClosed() renvoie true (et ferme la position longue ouverte) si les conditions de fermeture de la position sont remplies :

1. m_macd_current>0 - la valeur actuelle de la ligne principale de l'indicateur MACD est positive (l'histogramme MACD est au-dessus de la ligne zéro);
   
2. m_macd_current<m_signal_current && m_macd_previous>m_signal_previous - la ligne principale de l'indicateur MACD a croisé le signal vers le bas.
   
3. m_macd_current>m_macd_close_level - la valeur actuelle de la ligne principale de l'indicateur MACD est supérieure à m_macd_close_level.
   

3.8. La méthode ShortClosed() de la classe CSampleExpert

//+------------------------------------------------------------------+
//| Vérification des conditions de clôture d'une position courte     |
//+------------------------------------------------------------------+
bool CSampleExpert::ShortClosed(void)
  {
   bool res=false;
//--- La position devrait-elle être fermée ?
   if(m_macd_current<0)
      if(m_macd_current>m_signal_current && m_macd_previous<m_signal_previous)
         if(MathAbs(m_macd_current)>m_macd_close_level)
           {
            //--- clôture de la position
            if(m_trade.PositionClose(Symbol()))
               printf("La position courte sur %s sera fermée",Symbol());
            else
               printf("Erreur de clôture de la position sur %s : '%s'",Symbol(),m_trade.ResultComment());
            res=true;
           }
//--- retourne le résultat
   return(res);
  }

La méthode ShortClosed() renvoie true (et ferme une position courte ouverte) si les positions de fermeture d'une position courte sont remplies :

1. m_macd_current<0 - la valeur actuelle de la ligne principale de l'indicateur MACD est négative (l'histogramme MACD est en dessous de la ligne zéro).
   
2. m_macd_current>m_signal_current && m_macd_previous<m_signal_previous - la ligne principale de l'indicateur MACD a croisé le signal vers le haut.
   
3. MathAbs(m_macd_current)>m_macd_close_level - la valeur actuelle de la ligne principale de l'indicateur MACD est supérieure à m_macd_close_level.

3.9. La méthode LongModified() de la classe CSampleExpert

//+------------------------------------------------------------------+
//| Vérification des conditions pour modifier des positions longues  |
//+------------------------------------------------------------------+
bool CSampleExpert::LongModified(void)
  {
   bool res=false;
//--- vérification si le Trailing Stop est nécessaire
   if(InpTrailingStop>0)
     {
      if(m_symbol.Bid()-m_position.PriceOpen()>m_adjusted_point*InpTrailingStop)
        {
         double sl=NormalizeDouble(m_symbol.Bid()-m_traling_stop,m_symbol.Digits());
         double tp=m_position.TakeProfit();
         if(m_position.StopLoss()<sl || m_position.StopLoss()==0.0)
           {
            //--- modification du Stop Loss et du Take Profit de la position
            if(m_trade.PositionModify(Symbol(),sl,tp))
               printf("Position longue sur %s à modifier",Symbol());
            else
              {
               printf("Erreur lors de la modification de la position sur %s : '%s'",Symbol(),m_trade.ResultComment());
               printf("Modification des paramètres : SL=%f,TP=%f",sl,tp);
              }
            res=true;
           }
        }
     }
//--- retourne le résultat
   return(res);
  }

La méthode LongModified() renvoie true (et modifie la valeur Stop Loss de la position) si les conditions de modification de la position longue sont remplies : le sens de la position est vérifié. Ensuite, la valeur du nouveau niveau Stop Loss est calculée et le paramètre Stop Loss de la position ouverte est modifié.

3.10. La méthode ShortModified de la classe CSampleExpert

//+------------------------------------------------------------------+
//| Vérification des conditions pour modifier les positions longues  |
//+------------------------------------------------------------------+
bool CSampleExpert::ShortModified(void)
  {
   bool   res=false;
//--- vérification si le Trailing Stop est nécessaire
   if(InpTrailingStop>0)
     {
      if((m_position.PriceOpen()-m_symbol.Ask())>(m_adjusted_point*InpTrailingStop))
        {
         double sl=NormalizeDouble(m_symbol.Ask()+m_traling_stop,m_symbol.Digits());
         double tp=m_position.TakeProfit();
         if(m_position.StopLoss()>sl || m_position.StopLoss()==0.0)
           {
            //--- modification du Stop Loss et du Take Profit de la position
            if(m_trade.PositionModify(Symbol(),sl,tp))
               printf("Position courte sur %s à modifier",Symbol());
            else
              {
               printf("Erreur de modification de la position sur %s : '%s'",Symbol(),m_trade.ResultComment());
               printf("Modification des paramètres : SL=%f,TP=%f",sl,tp);
              }
            res=true;
           }
        }
     }
//--- retourne le résultat
   return(res);
  }

La méthode ShortModified() renvoie true (et modifie la valeur Stop Loss de la position) si les conditions de modification de la position courte sont remplies : le sens de la position est vérifié. Ensuite, la valeur du nouveau niveau Stop Loss est calculée et le paramètre Stop Loss de la position ouverte est modifié.

3.11. La méthode LongOpened() de la classe CSampleExpert

//+------------------------------------------------------------------+
//| Vérification pour l'ouverture d'une position longue              |
//+------------------------------------------------------------------+
bool CSampleExpert::LongOpened(void)
  {
   bool res=false;
//--- vérification des conditions pour ouvrir une position longue
   if(m_macd_current<0)
      if(m_macd_current>m_signal_current && m_macd_previous<m_signal_previous)
         if(MathAbs(m_macd_current)>(m_macd_open_level) && m_ema_current>m_ema_previous)
           {
            double price=m_symbol.Ask();
            double tp   =m_symbol.Bid()+m_take_profit;
            //--- vérification de la marge libre
            if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_BUY,InpLots,price)<0.0)
               printf("Pas assez d'argent. Marge Libre = %f",m_account.FreeMargin());
            else
              {
               //--- ouverture d'une position longue
               if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_BUY,InpLots,price,0.0,tp))
                  printf("Position sur %s à ouvrir",Symbol());
               else
                 {
                  printf("Erreur d'ouverture d'une position BUY sur %s : '%s'",Symbol(),m_trade.ResultComment());
                  printf("Paramètres d'ouverture : prix=%f,TP=%f",price,tp);
                 }
              }
            res=true;
           }
//--- retourne le résultat
   return(res);
  }

La méthode LongOpened() renvoie true (et ouvre une position longue) si les conditions d'ouverture d'une position d'achat sont remplies :

1. m_macd_current<0 - la valeur actuelle de la ligne principale de l'indicateur MACD est négative (l'histogramme MACD est en dessous de la ligne zéro);
   
2. m_macd_current>m_signal_current && m_macd_previous<m_signal_previous - la ligne principale de l'indicateur MACD a croisé le signal un vers le haut ;
   
3. MathAbs(m_macd_current)>m_macd_open_level - la valeur actuelle de la ligne principale de l'indicateur MACD modulo est supérieure à m_macd_open_level ;
4. m_ema_current>m_ema_previous - l'ema grandit.

Lorsque toutes les conditions sont remplies, la marge libre est vérifiée (la méthode FreeMarginCheck() de la classe de bibliothèque CAccountInfo Standard) et une position longue est ouverte à l'aide de la PositionOpen () méthode de la classe CTrade.

3.12. La méthode ShortOpened de la classe CSampleExpert

//+------------------------------------------------------------------+
//| Vérification pour ouvrir une position courte                     |
//+------------------------------------------------------------------+
bool CSampleExpert::ShortOpened(void)
  {
   bool res=false;
//--- vérification des conditions pour ouvrir une position courte
   if(m_macd_current>0)
      if(m_macd_current<m_signal_current && m_macd_previous>m_signal_previous)
         if(m_macd_current>(m_macd_open_level) && m_ema_current<m_ema_previous)
           {
            double price=m_symbol.Bid();
            double tp   =m_symbol.Ask()-m_take_profit;
            //--- vérification de la marge libre
            if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_SELL,InpLots,price)<0.0)
               printf("Pas assez d'argent. Marge Libre = %f",m_account.FreeMargin());
            else
              {
               //--- ouverture d'une position courte
               if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_SELL,InpLots,price,0.0,tp))
                  printf("Position sur %s à ouvrir",Symbol());
               else
                 {
                  printf("Erreur d'ouverture d'une position SELL sur %s : '%s'",Symbol(),m_trade.ResultComment());
                  printf("Paramètres d'ouverture : price=%f,TP=%f",price,tp);
                 }
              }
            res=true;
           }
//--- retourne le résultat
   return(res);
  }

La méthode ShortOpened() renvoie true (et ouvre une position courte) si les conditions d'ouverture d'une position de vente sont remplies :

1. m_macd_current>0 - la valeur actuelle de la ligne principale de l'indicateur MACD est positive (l'histogramme MACD est au-dessus de la ligne zéro);
   
2. m_macd_current<m_signal_current && m_macd_previous>m_signal_previous - la ligne principale de l'indicateur MACD a croisé la ligne de signal vers le bas ;
   
3. m_macd_current>m_macd_open_level - la valeur actuelle de la ligne MACD principale est supérieure à m_macd_open_level ;
4. m_ema_current<m_ema_previous - l'ema chute.

Lorsque toutes les conditions sont remplies, la marge libre est vérifiée (la méthode FreeMarginCheck() de la classe de bibliothèque CAccountInfo Standard) et une position courte est ouverte à l'aide de la PositionOpen() méthode de la classe CTrade.

3.13 La méthode Processing() de la classe CSampleExpert

//+------------------------------------------------------------------+
//| la fonction main renvoie vrai si une position est traitée                      |
//+------------------------------------------------------------------+
bool CSampleExpert::Processing(void)
  {
//--- mise à jour des cotations
   if(!m_symbol.RefreshRates())
      return(false);
//--- mise à jour des valeurs de l'indicateur
   if(BarsCalculated(m_handle_macd)<2 || BarsCalculated(m_handle_ema)<2)
      return(false);
   if(CopyBuffer(m_handle_macd,0,0,2,m_buff_MACD_main)  !=2 ||
      CopyBuffer(m_handle_macd,1,0,2,m_buff_MACD_signal)!=2 ||
      CopyBuffer(m_handle_ema,0,0,2,m_buff_EMA)         !=2)
      return(false);
//--- pour simplifier le travail avec les indicateurs et pour un accès plus rapide
//--- les valeurs actuelles des indicateurs sont sauvegardés dans des variables internes (membres de classe)
   m_macd_current   =m_buff_MACD_main[0];
   m_macd_previous  =m_buff_MACD_main[1];
   m_signal_current =m_buff_MACD_signal[0];
   m_signal_previous=m_buff_MACD_signal[1];
   m_ema_current    =m_buff_EMA[0];
   m_ema_previous   =m_buff_EMA[1];
//--- une bonne entrée sur le marché est importante, mais une sortie correcte est encore plus importante
//--- on vérifie d'abord s'il y a une position ouverte
   if(m_position.Select(Symbol()))
     {
      if(m_position.PositionType()==POSITION_TYPE_BUY)
        {
         //--- si nécessaire, on essaye de fermer ou de modifier une position longue
         if(LongClosed())
            return(true);
         if(LongModified())
            return(true);
        }
      else
        {
         //--- si nécessaire, on essaye de fermer ou de modifier une position courte
         if(ShortClosed())
            return(true);
         if(ShortModified())
            return(true);
        }
     }
//--- aucune position ouverte
   else
     {
      //--- vérifie les conditions et ouvre une position longue si nécessaire
      if(LongOpened())
         return(true);
      //--- vérifie les conditions et ouvre une position courte si nécessaire
      if(ShortOpened())
         return(true);
     }
//--- sort sans aucun traitement de position
    return(false);
  }

La méthode Processing() de la classe CSampleExpert est la méthode de l'Expert Advisor. La méthode Processing() est appelée dans le gestionnaire d'événements OnTick() et l'intervalle de temps entre les appels successifs de cette méthode est surveillé (pas moins de ExtTimeOut secondes) (section 2.2).

En appelant la méthode RefreshRates() de la classe CSymbolInfo, les guillemets sont mis à jour. La fonction BarsCalculated() est utilisée pour demander le nombre de barres, pour lesquelles les indicateurs MACD et Moyenne mobile sont calculés (section 3.6.) ; si le nombre de barres est inférieur à 2, quittez la fonction et retournez false.

Ensuite, l'appel de fonction CopyBuffer demande les deux dernières valeurs des indicateurs techniques (les lignes MACD principale et de signal et les valeurs de moyenne mobile ); et si la quantité de données copiées est inférieure à deux, quittez la fonction. Après cela, les valeurs des indicateurs des tableaux m_buff_MACD_main[], m_buff_MACD_signal[] et m_buff_EMA[] sont copiées dans les variables m_macd_current, m_macd_previous, m_signal_current, m_signal_previous, m_ema_current et m_ema_previous.

L'étape suivante consiste à travailler avec une position réalisée au moyen de la classe CPositionInfo de la bibliothèque Standard. Si l'appel de la méthode Select() a renvoyé true, cela signifie qu'il existe actuellement une position ouverte, son type est déterminé à l'aide de la méthode PositionType(). Des travaux supplémentaires sont effectués en fonction du type de position ouverte.

4. Backtesting

Les meilleures valeurs des paramètres peuvent être trouvées à l'aide du Strategy Tester du terminal MetaTrader 5.

La figure 3 montre les résultats du test de l'Expert Advisor pour 2013 avec les paramètres par défaut.

Figure 3. Résultats du backtesting de l'Expert Advisor MACD Sample

Conclusion

L'Expert Advisor MACD Sample, inclus dans le pack de livraison standard du terminal MetaTrader 5, est un exemple d'approche orientée objet dans le développement d'EA.