Programmation des modes d'EA à l'aide d'une approche orientée objet
Denis Kirichenko | 13 janvier, 2022
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'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
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 :
- Modes nécessitant le fichier de code source et le fichier exécutable ;
- 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.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 :
- Ouverture par un signal s'il n'y a pas de position ouverte ;
- Fermeture par le signal s'il y a une position ouverte;
- 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
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
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 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.