MetaTrader 5 / Exemples
English Русский 中文 Español Deutsch 日本語 Português 한국어 Italiano Türkçe
Programmation des modes d'EA à l'aide d'une approche orientée objet

Programmation des modes d'EA à l'aide d'une approche orientée objet

MetaTrader 5 — Exemples | 13 janvier 2022, 15:57
224 0
Denis Kirichenko
Denis Kirichenko

Introduction

Dans cet article, nous allons discuter des modes de programmation dans lesquels un MQL5 EA peut fonctionner. L'objectif de cet article est de décrire l'idée que « chaque mode est implémenté à sa manière ». L'auteur pense que cette approche permet d'accomplir plus efficacement des tâches à différents stades de développement d'une EE.

Dans un premier temps, nous examinons les étapes du développement d'une EE. Ensuite, les modes dans lesquels un EA dans MetaTrader 5 peut fonctionner et ses applications auxiliaires sont explorés. Le développement de la hiérarchie des classes pour la mise en œuvre de l'idée ci-dessus termine cet article.


1. Étapes de développement

Le développement d'un robot de trading (EA) est un processus multi-aspects. Les blocs clés ici sont l'algorithmique de l'idée et son test. Notamment, la logique de trading d'EA et l'algorithme de code sont testés.

En tant que schéma, les étapes de ce processus peuvent être représentées comme suit (Fig.1).

Fig. 1. Étapes de développement et mise en œuvre d'un EA

Fig.1. Étapes de développement et mise en œuvre d'une EE

La cinquième étape «Trading algorithmique» présente le travail des développeurs, programmeurs, analystes et autres spécialistes impliqués. Il arrive souvent que tous ces rôles soient remplis par une seule personne. Supposons qu'il s'agisse d'un trader-programmeur.

Ce schéma peut être mis à jour et étendu. À mon avis, il illustre les points les plus importants dans le développement d'une EA. Le modèle cyclique de ce schéma permet d'améliorer et de modifier le code de l'EA tout au long de sa durée de vie.

Il convient de noter que chaque étape nécessite certains outils, connaissances et compétences.

À mon avis, le développeur rencontre la matrice de variante simple suivante (Fig.2).

Fig.2. Matrice des variantes

Fig.2. Matrice des variantes

De toute évidence, seul le robot mettant en œuvre une stratégie de trading gagnante avec un code de haute qualité doit passer à la cinquième étape « Trading algorithmique ».


2. Les modes Expert Advisor dans MQL5

L'environnement MQL5 permet de travailler avec un EA dans différents modes. Ils sont au nombre de 7. Nous allons examiner chacun d'eux plus bas.

Du point de vue du type de fichier programme, 2 groupes peuvent être distingués :

  1. Modes nécessitant le fichier de code source et le fichier exécutable ;
  2. Modes nécessitant uniquement le fichier exécutable.

Les modes de débogage et de profilage appartiennent au premier groupe.

Un autre critère de classification modale est le travail d'un EA dans un flux de cotations réelles ou historiques. Tous les modes de test sont liés à des citations historiques.

6 modes sont définis par programmation. Une conclusion si une évaluation environnementale fonctionne en mode standard (version) ou non peut être faite sur la base des résultats. Un programme prêt (fichier avec l'extension *.ex5), qui a été codé pour travailler sur les marchés financiers, est censé fonctionner dans ce même mode. En même temps, un programme prêt à l'emploi permet d'utiliser également d'autres modes dans le Testeur de stratégie.

Créons une énumération des modes opératoires du programme MQL appelée ENUM_MQL_MODE:

//+------------------------------------------------------------------+
//| MQL Mode                                                         |
//+------------------------------------------------------------------+
enum ENUM_MQL_MODE
  {
   MQL_MODE_RELEASE=0,       // Release
   MQL_MODE_DEBUG=1,         // Debugging
   MQL_MODE_PROFILER=2,      // Profiling  
   MQL_MODE_TESTER=3,        // Testing
   MQL_MODE_OPTIMIZATION=4,  // Optimization
   MQL_MODE_VISUAL=5,        // Visual testing 
   MQL_MODE_FRAME=6,         // Gathering frames
  };

Plus tard, cela sera nécessaire pour reconnaître le type de mode dans lequel un EA travaille.


2.1. Fonction d'identification et de vérification du mode

Écrivez une fonction simple qui itérera sur tous les modes et imprimera les informations dans le journal.

//+------------------------------------------------------------------+
//| Checking all MQL modes                                           |
//+------------------------------------------------------------------+
void CheckMqlModes(void)
  {
//--- if it is debug mode
   if(MQLInfoInteger(MQL_DEBUG))
      Print("Debug mode: yes");
   else
      Print("Debug mode: no");
//--- if it is code profiling mode
   if(MQLInfoInteger(MQL_PROFILER))
      Print("Profile mode: yes");
   else
      Print("Profile mode: no");
//--- if it is test mode
   if(MQLInfoInteger(MQL_TESTER))
      Print("Tester mode: yes");
   else
      Print("Tester mode: no");
//--- if it is optimization mode
   if(MQLInfoInteger(MQL_OPTIMIZATION))
      Print("Optimization mode: yes");
   else
      Print("Optimization mode: no");
//--- if it is visual test mode
   if(MQLInfoInteger(MQL_VISUAL_MODE))
      Print("Visual mode: yes");
   else
      Print("Visual mode: no");
//--- if it is frame gathering optimization result mode
   if(MQLInfoInteger(MQL_FRAME_MODE))
      Print("Frame mode: yes");
   else
      Print("Frame mode: no");
  }

Le travail de cette fonction dans chaque mode va être vérifié. Il peut être appelé dans le gestionnaire d'événements OnInit().

Pour les besoins du test, créons un modèle d'EA appelé Test1_Modes_EA.mq5.

Une option pour spécifier le mode dans lequel l'EA va fonctionner est activée dans les paramètres d'entrée. Il est important de s'assurer que le mode correct est nommé, sinon les informations seront inexactes. C'est ce qui s'est passé.

Ci-dessous, le mode de libération.

CL      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Current mode: MQL_MODE_RELEASE
QD      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Debug mode: no
KM      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Profile mode: no
EK      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Tester mode: no
CS      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Optimization mode: no
RJ      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Visual mode: no
GL      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Frame mode: no

Pour le mode de libération, les drapeaux de tous les autres modes ont été mis à zéro. Ainsi, la fonction a identifié qu'il ne s'agissait ni du mode de débogage (mode de débogage : non), ni du mode de profilage (mode de profil : non) etc. En utilisant la méthode de la négation, nous sommes arrivés à la conclusion que nous travaillons en mode de libération.

Nous allons maintenant voir comment le mode déboguer a été identifié.

HG      0       17:27:47.709    Test1_Modes_EA (EURUSD.e,H1)     Current mode: MQL_MODE_DEBUG
LD      0       17:27:47.710    Test1_Modes_EA (EURUSD.e,H1)     Debug mode: yes
RS      0       17:27:47.710    Test1_Modes_EA (EURUSD.e,H1)     Profile mode: no
HE      0       17:27:47.710    Test1_Modes_EA (EURUSD.e,H1)     Tester mode: no
NJ      0       17:27:47.710    Test1_Modes_EA (EURUSD.e,H1)     Optimization mode: no
KD      0       17:27:47.710    Test1_Modes_EA (EURUSD.e,H1)     Visual mode: no
RR      0       17:27:47.710    Test1_Modes_EA (EURUSD.e,H1)     Frame mode: no

Le mode de débogage a été reconnu correctement.

Tout manuel de programmation contient des informations selon lesquelles le débogage facilite la recherche et la localisation des erreurs dans le code. Il met également en évidence les particularités du programme. Vous trouverez plus de détails sur le débogage dans l'environnement MQL5 dans l'article «Débogage des programmes MQL5».

Ce mode est le plus souvent utilisé aux étapes de formalisation et de construction de l'algorithme d'une idée de trading.

En programmation, le débogage est activé soit à l'aide des macros IS_DEBUG_MODE, soit la fonction MQLInfoInteger() avec l'identifiant MQL_DEBUG.

Nous passons au mode profilage.

GS      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Current mode: MQL_MODE_PROFILER
OR      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Debug mode: no
GE      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Profile mode: yes
QM      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Tester mode: no
CE      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Optimization mode: no
FM      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Visual mode: no
GJ      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Frame mode: no

La fonction a correctement estimé que le Profiler était impliqué.

Dans ce mode, il peut être vérifié à quelle vitesse le programme fonctionne. Le profileur transmet les informations sur le temps passé aux blocs de programme. Cet instrument est censé signaler les goulots d'étranglement d'un algorithme. Il n'est pas toujours possible de s'en débarrasser mais néanmoins ces informations peuvent être utiles.

Le profilage peut être activé via les macros IS_PROFILE_MODE ou la fonction MQLInfoInteger() avec l'identifiant MQL_PROFILER.

Voyons maintenant le mode test. Ces informations apparaîtront dans l'onglet «Journal» du Testeur de stratégie.

EG      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Current mode: MQL_MODE_TESTER
OS      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Debug mode: no
GJ      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Profile mode: no
ER      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Tester mode: yes
ED      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Optimization mode: no
NL      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Visual mode: no
EJ      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Frame mode: no

Le mode de test a été identifié correctement.

C'est le mode par défaut de l'EA lorsque le Testeur de stratégie est ouvert.

Il n'y a pas de macros pour ce mode et donc dans MQL5 nous ne pouvons le déterminer qu'à l'aide de la fonction MQLInfoInteger() avec l'identifiant MQL_TESTER.

Passons maintenant à l'optimisation. Un journal avec des enregistrements sera stocké dans le dossier de l'agent. Dans mon cas, le chemin est le suivant : %Program Files\MetaTrader5\tester\Agent-127.0.0.1-3000\logs

OH      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Current mode: MQL_MODE_OPTIMIZATION
KJ      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Debug mode: no
NO      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Profile mode: no
FI      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Tester mode: yes
KE      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Optimization mode: yes
LS      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Visual mode: no
QE      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Frame mode: no

Si le mode optimisation est actif, le mode test est activé par défaut.

Le mode optimisation est actif dans le Strategy Tester si le champ «Optimisation» n'est pas désactivé dans l'onglet «Paramètres».

Pour savoir si l'EA est testé en mode optimisation dans MQL5, appelez soit la fonction MQLInfoInteger() avec l'identifiant MQL_OPTIMIZATION.

Nous passons au mode visualisation.

JQ      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Current mode: MQL_MODE_VISUAL
JK      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Debug mode: no
KF      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Profile mode: no
CP      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Tester mode: yes
HJ      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Optimization mode: no
LK      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Visual mode: yes
KS      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Frame mode: no

Ici, nous pouvons voir que le mode de test visuel et le mode de test standard sont impliqués.

L'EA fonctionne dans ce mode dans le Testeur de stratégie si le champ «Visualisation» de l'onglet «Paramètres» est signalé.

L'établissement du fait de tester un programme MQL5 en mode test visuel peut se faire à l'aide de la fonction MQLInfoInteger() avec l'identifiant MQL_VISUAL_MODE.

Le dernier mode est le mode de gestion des trames.

HI      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Current mode: MQL_MODE_FRAME
GR      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Debug mode: no
JR      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Profile mode: no
JG      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Tester mode: yes
GM      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Optimization mode: yes
HR      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Visual mode: no
MI      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Frame mode: no

Chose intéressante, la fonction ne reconnaissait que les modes de test et d'optimisation car le drapeau des trames était mis à zéro. Si l'appel de la fonction est transféré vers le gestionnaire OnTesterInit(), le journal «Experts» va contenir les entrées suivantes :

IO      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Current mode: MQL_MODE_FRAME
GE      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Debug mode: no
ML      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Profile mode: no
CJ      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Tester mode: no
QR      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Optimization mode: no
PL      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Visual mode: no
GS      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Frame mode: yes

En effet, seul le mode de collecte de trames était désormais détecté.

Ce mode est utilisé dans le Testeur de stratégie si le champ «Optimisation» de l'onglet «Paramètres» n'est pas désactivé. Comme l'expérience l'a montré, ce mode est défini dans le corps des gestionnaires OnTesterInit(), OnTesterPass() et OnTesterDeinit().

La fonction MQLInfoInteger() avec l'identifiant MQL_FRAME_MODE peut faciliter l'identification du fait de tester un EA en mode collecte de trames.

Vous trouverez ci-dessous le code de la fonction de service MqlMode(), qui spécifie automatiquement le mode dans lequel fonctionne l'EA.

//+------------------------------------------------------------------+
//| Identify the current MQL mode                                    |
//+------------------------------------------------------------------+
ENUM_MQL_MODE MqlMode(void)
  {
   ENUM_MQL_MODE curr_mode=WRONG_VALUE;

//--- if it is debug mode
   if(MQLInfoInteger(MQL_DEBUG))
      curr_mode=MQL_MODE_DEBUG;
//--- if it is code profiling mode
   else if(MQLInfoInteger(MQL_PROFILER))
      curr_mode=MQL_MODE_PROFILER;
//--- if it is visual test mode
   else if(MQLInfoInteger(MQL_VISUAL_MODE))
      curr_mode=MQL_MODE_VISUAL;
//--- if it is optimization mode
   else if(MQLInfoInteger(MQL_OPTIMIZATION))
      curr_mode=MQL_MODE_OPTIMIZATION;
//--- if it is test mode
   else if(MQLInfoInteger(MQL_TESTER))
      curr_mode=MQL_MODE_TESTER;
//--- if it is frame gathering optimization result mode
   else if(MQLInfoInteger(MQL_FRAME_MODE))
      curr_mode=MQL_MODE_FRAME;
//--- if it is release mode
   else
      curr_mode=MQL_MODE_RELEASE;
//---
   return curr_mode;
  }

Étant donné que les tests standard sont identifiés en mode d'optimisation et de test visuel, le mode de test standard doit être vérifié après le mode d'optimisation et de visualisation.

Si nous jetons un œil au travail de la fonction dans le deuxième modèle de l'EA Test2_Modes_EA.mq5, nous pouvons voir qu'une nouvelle entrée apparaît dans le journal lorsque le modèle est lancé. Par exemple, pour le mode de profilage, l'entrée ci-dessous a été effectuée :

HG      0       11:23:52.992    Test2_Modes_EA (EURUSD.e,H1)    Current mode: MQL_MODE_PROFILER

Nous avons discuté des détails des modes opérationnels de l'Expert MQL5 pour créer des modèles de classe correspondant à un mode spécifié. Nous allons le mettre en œuvre dans la prochaine partie de l'article.


3. Modèle de l'EA conçu pour fonctionner dans différents modes

Je suggère de revenir sur les étapes de développement d'une évaluation environnementale.

Au stade de l'algorithmique, un programmeur fait le plus souvent du débogage et du profilage. Pour tester les données historiques, ils essaient tous les modes du Testeur de stratégie. Le mode final (mode libération) est utilisé dans le trading en ligne.

À mon avis, une EA doit avoir plusieurs facettes dans le sens où les exigences des étapes de développement et de test doivent être reflétées dans son code.

À cela, l'algorithme principal sera préservé et, à la suite de cela, l'EA aura un comportement différent à différents modes. L'ensemble d'outils de programmation orientés objet convient parfaitement à la mise en œuvre de cette idée.

Fig.2 Hiérarchie des classes pour l'EA conçu pour fonctionner dans différents modes

Fig.3. Hiérarchie de classe pour l'EA conçue pour fonctionner dans différents modes

La hiérarchie des classes avec implémentation de différents modes est représentée sur la Fig.3.

La classe de base CModeBaseencapsulant toutes les choses communes aura deux descendants directs : les classes CModeReleaseet CModeTester. Le premier sera un parent pour les classes de débogage et le second pour les classes liées au test de l'EA sur des données historiques.

Développons l'idée de combiner une approche procédurale et modulaire lors du développement de méthodes de classe dans le contexte des modes. À titre d'exemple, considérons la logique de trading suivante :

  1. Ouverture par un signal s'il n'y a pas de position ouverte ;
  2. Fermeture par le signal s'il y a une position ouverte;
  3. Stop loss suiveur s'il y a une position ouverte.

Le signal de trading est détecté par l'indicateur standard MACD lorsqu'une nouvelle barre apparaît.

Un signal d'achat apparaît lorsque la ligne principale monte et croise le signal un dans la zone négative de l'indicateur MACD (Fig.4).

Fig.4 Signal d'achat

Fig.4. Signal d'achat

Un signal de vente apparaît lorsque la ligne principale descend et croise le signal dans la zone positive de l'indicateur (Fig. 5).

Fig.5 Signal de vente

Fig.5. Signal de vente

La position se ferme soit lorsque le signal inverse apparaît, soit par le Stop Loss, qui est placé au cas où le mode de support de position est activé.

Alors la définition de la classe de base CModeBaseest la suivante :

//+------------------------------------------------------------------+
//| Class CModeBase                                                  |
//| Purpose: a base class for MQL-modes                              |            
//+------------------------------------------------------------------+
class CModeBase
  {
//--- === Data members === --- 
private:
   //--- a macd object & values
   CiMACD            m_macd_obj;
   double            m_macd_main_vals[2];
   double            m_macd_sig_vals[2];

protected:
   long              m_pos_id;
   bool              m_is_new_bar;
   uint              m_trailing_stop;
   uint              m_trail_step;
   //--- trade objects
   CSymbolInfo       m_symbol_info;
   CTrade            m_trade;
   CPositionInfo     m_pos_info;
   CDealInfo         m_deal_info;
   //--- mql mode
   ENUM_MQL_MODE     m_mql_mode;

   //--- a new bar object
   CisNewBar         m_new_bar;
   //--- current tick signal flag
   bool              m_is_curr_tick_signal;
   //--- close order type
   ENUM_ORDER_TYPE   m_close_ord_type;
   
//--- === Methods === --- 
public:
   //--- constructor/destructor
   void              CModeBase();
   void             ~CModeBase(void){};
   //--- initialization
   virtual bool      Init(int _fast_ema,int slow_ema,int _sig,ENUM_APPLIED_PRICE _app_price);
   virtual void      Deinit(void){};

   //--- Modules
   virtual void      Main(void){};

   //--- Procedures
   virtual void      Open(void){};
   virtual void      Close(void){};
   virtual void      Trail(void){};

   //--- Service
   static ENUM_MQL_MODE CheckMqlMode(void);
   ENUM_MQL_MODE     GetMqlMode(void);
   void              SetMqlMode(const ENUM_MQL_MODE _mode);
   void              SetTrailing(const uint _trailing,const uint _trail_step);

protected:
   //--- Functions
   ENUM_ORDER_TYPE   CheckOpenSignal(const ENUM_ORDER_TYPE _open_sig);
   ENUM_ORDER_TYPE   CheckCloseSignal(const ENUM_ORDER_TYPE _close_sig);
   ENUM_ORDER_TYPE   CheckTrailSignal(const ENUM_ORDER_TYPE _trail_sig,double &_sl_pr);
   //---
   double            GetMacdVal(const int _idx,const bool _is_main=true);

private:
   //--- Macros
   bool              RefreshIndicatorData(void);
   //--- Normalization
   double            NormalPrice(double d);
   double            NormalDbl(double d,int n=-1);
   double            NormalSL(const ENUM_ORDER_TYPE _ord_type,double op,double pr,
                              uint SL,double stop);
   double            NormalTP(const ENUM_ORDER_TYPE _ord_type,double op,double pr,
                              uint _TP,double stop);
   double            NormalLot(const double _lot);
  };

Tout peut être inclus dans une classe de base tant qu'il sera utilisé dans les classes héritières.

Les données MACD ne seront pas disponibles pour les descendants car ils sont représentés par des membres privés.

Il faut noter que parmi ces méthodes, il y en a des virtuelles : Main(), Open(), Close(), Trail(). Leur mise en œuvre dépendra largement du mode dans lequel l'EA travaille actuellement. Ces méthodes resteront vides pour la classe de base.

En outre, la classe de base comprend des méthodes qui ont la même logique de trading pour tous les modes MQL. Toutes les méthodes de signal leur appartiennent :

  • CModeBase::CheckOpenSignal(),
  • CModeBase::CheckCloseSignal(),
  • CModeBase::CheckTrailSignal().

Il convient de garder à l'esprit que cet article ne cible pas l'écriture de code pour tous les types de mode MQL. Les tests standard et visuels vont servir d'exemple.


3.1. Mode d'essai

Une fois l'algorithme codé et compilé, j'essaie généralement la stratégie sur des données historiques dans le testeur de stratégie pour vérifier si cela fonctionne comme prévu.

Le plus souvent, il est nécessaire de vérifier avec quelle précision le système met en œuvre les signaux de trading. Dans tous les cas, l'objectif fondamental à ce stade d'un EA est de lancer et d'échanger.

La classe CModeTesterpour les tests réguliers peut être implémentée comme suit :

//+------------------------------------------------------------------+
//| Class CModeTester                                                |
//| Purpose: a class for the tester mode                             |            
//| Derives from class CModeBase.                                    |
//+------------------------------------------------------------------+
class CModeTester : public CModeBase
  {
//--- === Methods === --- 
public:
   //--- constructor/destructor
   void              CModeTester(void){};
   void             ~CModeTester(void){};

   //--- Modules
   virtual void      Main(void);

   //--- Procedures
   virtual void      Open(void);
   virtual void      Close(void);
   virtual void      Trail(void);
  };

Le module principal est implémenté comme suit:

//+------------------------------------------------------------------+
//| Main module                                                      |
//+------------------------------------------------------------------+
void CModeTester::Main(void)
  {
//--- 1) closure
   this.Close();
//--- 2) opening
   this.Open();
//--- 3) trailing stop
   this.Trail();
  }

Pour le mode de test régulier, créez une opportunité d'imprimer des informations sur les signaux de trading dans le Journal.

Ajoutez des chaînes contenant des valeurs d'indicateur considérées comme la source du signal de trading.

Vous trouverez ci-dessous un extrait du Journal sur un signal d'ouverture de position suivi d'un signal de fermeture.

HE      0       13:34:04.118    Core 1  2014.11.14 22:15:00   ---=== Signal to open: SELL===---
FI      0       13:34:04.118    Core 1  2014.11.14 22:15:00   A bar before the last one, main: 0.002117; signal: 0.002109
DL      0       13:34:04.118    Core 1  2014.11.14 22:15:00   The last bar, main: 0.002001; signal: 0.002118
LO      0       13:34:04.118    Core 1  2014.11.14 22:15:00   market sell 0.03 EURUSD.e (1.25242 / 1.25251 / 1.25242)
KH      0       13:34:04.118    Core 1  2014.11.14 22:15:00   deal #660 sell 0.03 EURUSD.e at 1.25242 done (based on order #660)
GE      0       13:34:04.118    Core 1  2014.11.14 22:15:00   deal performed [#660 sell 0.03 EURUSD.e at 1.25242]
OD      0       13:34:04.118    Core 1  2014.11.14 22:15:00   order performed sell 0.03 at 1.25242 [#660 sell 0.03 EURUSD.e at 1.25242]
IK      0       13:34:04.118    Core 1  2014.11.14 22:15:00   CTrade::OrderSend: market sell 0.03 EURUSD.e [done at 1.25242]
IL      0       13:34:04.118    Core 1  2014.11.17 13:30:20   
CJ      0       13:34:04.118    Core 1  2014.11.17 13:30:20   ---=== Signal to close: SELL===---
GN      0       13:34:04.118    Core 1  2014.11.17 13:30:20   A bar before the last one, main: -0.001218; signal: -0.001148
QL      0       13:34:04.118    Core 1  2014.11.17 13:30:20   The last bar, main: -0.001123; signal: -0.001189
EP      0       13:34:04.118    Core 1  2014.11.17 13:30:20   market buy 0.03 EURUSD.e (1.25039 / 1.25047 / 1.25039)
FG      0       13:34:04.118    Core 1  2014.11.17 13:30:20   deal #661 buy 0.03 EURUSD.e at 1.25047 done (based on order #661)
OJ      0       13:34:04.118    Core 1  2014.11.17 13:30:20   deal performed [#661 buy 0.03 EURUSD.e at 1.25047]
PD      0       13:34:04.118    Core 1  2014.11.17 13:30:20   order performed buy 0.03 at 1.25047 [#661 buy 0.03 EURUSD.e at 1.25047]
HE      0       13:34:04.118    Core 1  2014.11.17 13:30:20   CTrade::OrderSend: market buy 0.03 EURUSD.e [done at 1.25047]

Veuillez noter qu'il n'y a pas de journal familier «Experts» dans le Testeur de stratégie. Toutes les informations peuvent être trouvées dans l'onglet «Journal», qui contient des enregistrements sur les actions effectuées par le testeur de stratégie pendant les tests et l'optimisation.

C'est pourquoi il faut rechercher les chaînes requises. Si les informations d'entrée doivent être séparées, elles peuvent être enregistrées dans un fichier.

La stratégie de test standard est implémentée dans le code deTestMode_tester.mq5de l’EA.


3.2. Mode de test visuel

Parfois, il est nécessaire de se référer à un graphique en direct et de voir comment un EA gère la situation actuelle.

Une visualisation simple permet non seulement de voir comment le système de trading réagit aux ticks, mais également de comparer des modèles de prix similaires à la fin des tests.

La définition de la classe CModeVisualpour les tests visuels peut être la suivante :

//+------------------------------------------------------------------+
//| Class CModeVisual                                                |
//| Purpose: a class for the tester mode                             |            
//| Derived from class CModeBase.                                    |
//+------------------------------------------------------------------+
class CModeVisual : public CModeTester
  {
//--- === Data members === --- 
private:
   CArrayObj         m_objects_arr;
   double            m_subwindow_max;
   double            m_subwindow_min;
   
//--- === Methods === --- 
public:
   //--- constructor/destructor
   void              CModeVisual(void);
   void             ~CModeVisual(void);

   //--- Procedures
   virtual void      Open(void);
   virtual void      Close(void);

private:
   bool              CreateSignalLine(const bool _is_open_sig,const bool _is_new_bar=true);
   bool              CreateRectangle(const ENUM_ORDER_TYPE _signal);
   void              RefreshRectangles(void);
  };

La classe contient des membres masqués. Un membre de la classe m_objects_arr implémente un tableau dynamique de type CArrayObj. Les objets graphiques, par exemple les lignes et les rectangles, appartiennent à ici. Deux autres membres de la classe (m_subwindow_max, m_subwindow_min) contrôlent les tailles maximale et minimale de la sous-fenêtre de l'indicateur.

Les méthodes privées sont responsables du travail avec les objets graphiques.

Cette classe ne contient pas les méthodes Main() et Trail(). Leurs analogues parents CModeTester::Main() et CModeTester::Trail() vont être appelés respectivement.

Les objets graphiques peuvent être créés dans le mode de test visuel. Cela ne peut pas être fait dans d'autres modes du testeur de stratégie.

Qu'une verticale rouge soit tracée sur le graphique lorsqu'un signal d'entrée apparaît et une verticale bleue lorsqu'un signal de sortie est reçu. Remplissez l'espace entre les points d'entrée et de sortie avec un rectangle de la couleur appropriée dans la sous-fenêtre de l'indicateur.

S'il s'agit d'une position longue, le rectangle est bleu clair. Si la position est courte, le rectangle est rose (Fig.6).

Fig.6. Objets graphiques en mode de test visuel

Fig.6. Objets graphiques en mode test visuel

La hauteur du rectangle dépend des valeurs de maximum et minimum de la sous-fenêtre du graphique au moment de la création. Pour que tous les rectangles soient de taille égale, un bloc de coordonnées rectangulaires changeantes doit être ajouté au code au cas où les coordonnées de la sous-fenêtre graphique changeraient.

Ainsi, dans la sous-fenêtre de l'indicateur MACD, nous obtenons les zones suivantes : incolore (pas de position), rose (position courte), bleu clair (position longue ).

La stratégie pour le mode de test visuel est implémentée dans le code de l'EA TestMode_visual_tester.mq5.


Conclusion

Dans cet article, j'ai essayé d'illustrer les capacités de mode du terminal MetaTrader 5 et du langage MQL5. Il faut dire qu'une approche multimodale de la programmation d'un algorithme de trading implique plus de coûts d'une part et d'autre part, il est possible de considérer chaque étape de développement l'une après l'autre. La programmation orientée objet est une aide ingénieuse pour un programmeur dans ce cas.

Les modes d'optimisation et de collecte de trames seront mis en évidence dans les futurs articles sur les propriétés statistiques d'un système de trading.


Traduit du russe par MetaQuotes Ltd.
Article original : https://www.mql5.com/ru/articles/1246

Fichiers joints |
Télécharger ZIP
cisnewbar.mqh (13.74 KB)
modes.mqh (62.77 KB)
test1_modes_ea.mq5 (9.43 KB)
test2_modes_ea.mq5 (10.01 KB)
testmode_tester.mq5 (6.12 KB)
testmode_visual_tester.mq5 (6.32 KB)
Avertissement: Tous les droits sur ces documents sont réservés par MetaQuotes Ltd. La copie ou la réimpression de ces documents, en tout ou en partie, est interdite.

Autres articles par cet auteur

Aller à la discussion
Principes de la tarification des changes à travers l'exemple du marché des dérivés de la Bourse de Moscou Principes de la tarification des changes à travers l'exemple du marché des dérivés de la Bourse de Moscou
Cet article décrit la théorie de la tarification des changes et les spécificités de compensation du marché des produits dérivés de la Bourse de Moscou. Ceci est un article complet pour les débutants qui veulent obtenir leur première expérience d’échange sur le trading de produits dérivés, ainsi que pour les traders forex expérimentés qui envisagent de négocier sur une plate-forme d’échange centralisée.
Le livre de recettes statistique du trader : Hypothèses Le livre de recettes statistique du trader : Hypothèses
Cet article considère l'hypothèse - l'une des idées de base de la statistique mathématique. Diverses hypothèses sont examinées et vérifiées à l'aide d'exemples utilisant des méthodes de statistiques mathématiques. Les données réelles sont généralisées à l'aide de méthodes non paramétriques. Le progiciel Statistica et la bibliothèque d'analyse numérique portée ALGLIB MQL5 sont utilisés pour le traitement des données.
Trading bidirectionnel et couverture des positions dans MetaTrader 5 à l’aide du panneau HedgeTerminal, Partie 1 Trading bidirectionnel et couverture des positions dans MetaTrader 5 à l’aide du panneau HedgeTerminal, Partie 1
Cet article décrit une nouvelle approche de la couverture des positions et trace la ligne dans les débats entre les utilisateurs de MetaTrader 4 et MetaTrader 5 à ce sujet. Les algorithmes qui rendent cette couverture fiable sont décrits en termes simples et illustrés par des graphiques et des diagrammes simples. Cet article est dédié au nouveau panneau HedgeTerminal, qui est essentiellement un terminal de trading complet dans MetaTrader 5. En utilisant HedgeTerminal et la virtualisation du trade qu’il offre, les positions peuvent être gérées de la même manière que MetaTrader 4.
Les bases de la programmation MQL5 : Variables globales du terminal Les bases de la programmation MQL5 : Variables globales du terminal
Cet article met en évidence les capacités orientées objet du langage MQL5 pour créer des objets facilitant le travail avec les variables globales du terminal. Comme exemple pratique, je considère un cas où des variables globales sont utilisées comme points de contrôle pour la mise en œuvre des étapes du programme.