Exploration des classes de stratégies de trading de la bibliothèque standard - Personnalisation des stratégies
546
1
Introduction
Cet article est destiné aux utilisateurs novices/débutants qui souhaitent aborder une certaine forme de personnalisation avec des fonctionnalités et sans écrire un EA à partir de rien.
Dans MetaTrader 5, nous avons une grande possibilité de faire du trading expert avec une connaissance (et des compétences) minimale ou nulle du langage de programmation et du codage des sources, grâce à la fonction unique MetaEditor : Assistant MQL5. L'assistant (nous n'allons pas expliquer son fonctionnement détaillé dans cet article) est destiné à générer des programmes finis (fichiers .mq5 et .ex5), des algorithmes et du code. Il bénéficie de l'utilisation de la bibliothèque standard MQL5 et de ses classes de stratégies de trading (qui sont d'excellentes ressources).
Il existe de nombreuses classes de stratégies de trading dans la bibliothèque standard, certaines d'entre elles sont déjà très bonnes et proviennent d'études plus ou moins célèbres sur les marchés financiers et l'analyse de la rentabilité. Chaque indicateur de l'ensemble standard d'indicateurs fourni avec MetaTrader 5 comporte au moins une stratégie.
Pour établir des signaux de trading à partir de ces classes de stratégies de trading, l'assistant MQL5 utilise un mécanisme qui appelle les comportements des indicateurs constitués par une logique codée sous forme de « modèles de trading ». Et chaque EA spécifique générée fait appel à des indicateurs (via les instructions #include) et à leurs ensembles de modèles et de décisions de trading qui sont ensuite importés dans le noyau de l'EA à des fins de trading.
Assistant MQL5
La première étape consiste à créer un Expert Advisor à l'aide de l'assistant MQL5. Pour ouvrir l'assistant MQL5 dans MetaEditor, sélectionnez « Nouveau » dans le menu « Fichier » ou appuyez sur le bouton « Nouveau », puis sélectionnez l'option « Expert Advisor (générer) ».
Nommons notre Expert Advisor généré par l'assistant MQL5 « MyExpert ».
Ensuite, nous ajoutons deux indicateurs/signaux pour travailler avec (vous pouvez sélectionner autant de conditions que vous le souhaitez parmi les indicateurs disponibles). Pour notre exemple, ajoutons deux indicateurs célèbres : Indice de force relative (RSI) et moyenne mobile (MA). Ajoutez d'abord l'indicateur RSI, puis ajoutez l'indicateur MA.
Nous pouvons définir certains paramètres, comme nous le souhaitons, ou laisser les paramètres par défaut pour notre exemple.
Après avoir cliqué sur OK et continué avec l'assistant, nous ne sélectionnerons (pour l'instant) aucun Trailing stop dans la fenêtre suivante, mais si vous le souhaitez, vous pouvez en ajouter : cela n'affectera pas le sujet de cet article. Dans la fenêtre suivante, nous sélectionnerons 5,0 comme pourcentage de trading et 0,1 lots, ou tout autre paramètre que vous souhaitez : encore une fois, cela n'affectera pas l'argument de notre article.
Analyse du code généré
Après avoir terminé, vous aurez le fichier « MyExpert.mq5 ». Analysons les points principaux du code généré.
//+------------------------------------------------------------------+ //| MyExpert.mq5 | //| Harvester | //| https://www.mql5.com/en/users/Harvester | //+------------------------------------------------------------------+ #property copyright "Harvester" #property link "https://www.mql5.com/en/users/Harvester" #property version "1.00" //+------------------------------------------------------------------+ //| Include | //+------------------------------------------------------------------+ #include <Expert\Expert.mqh> //--- available signals #include <Expert\Signal\SignalRSI.mqh> #include <Expert\Signal\SignalMA.mqh> //--- available trailing #include <Expert\Trailing\TrailingNone.mqh> //--- available money management #include <Expert\Money\MoneyFixedLot.mqh>
Notez d'abord les fichiers #include ajoutés au code généré par l'assistant. On peut voir :
- Expert.mqh
- SignalRSI.mq
- SignalMA.mqh
Puis la portion de code suivante :
//--- Creating filter CSignalRSI CSignalRSI *filter0=new CSignalRSI; if(filter0==NULL) { //--- failed printf(__FUNCTION__+": error creating filter0"); ExtExpert.Deinit(); return(-3); } signal.AddFilter(filter0);
Comme le titre l'indique, c'est le « filtre » qui sera appliqué aux conditions de marché de l'EA généré qui doit être attaché à un graphique ou testé dans le Strategy Tester. Le filter0 est alors le premier filtre avec un « index » de zéro, et pour ce premier filtre nous avons sélectionné RSI dans notre exemple.
CSignalRSI signifie Class Signal RSI. Cette classe est utilisée pour appeler l'indicateur RSI et lui appliquer certaines conditions pour créer des signaux d'achat ou de vente en utilisant la logique des modèles de l'assistant. Le RSI est donc notre premier filtre (filtre numéro 0).
Dans la partie suivante du code, il y a quelques paramètres de filtre, puis la section Trailing Stop (nous avons opté pour l'absence de trailing) et plus tard - la partie du code qui concerne le Money Management.
En continuant, nous avons :
//--- Tuning of all necessary indicators if(!ExtExpert.InitIndicators()) { //--- failed printf(__FUNCTION__+": error initializing indicators"); ExtExpert.Deinit(); return(-10); } //--- ok return(0); }
Cette section appartient au fichier include Expert.mqh. Il s'agit de l'initialisation des indicateurs nécessaires au fonctionnement expert.
Et la dernière partie du code EA généré concerne la désinitialisation et les autres événements habituels de l'Expert Advisor :
//+------------------------------------------------------------------+ //| Deinitialization function of the expert | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { ExtExpert.Deinit(); } //+------------------------------------------------------------------+ //| "Tick" event handler function | //+------------------------------------------------------------------+ void OnTick() { ExtExpert.OnTick(); } //+------------------------------------------------------------------+ //| "Trade" event handler function | //+------------------------------------------------------------------+ void OnTrade() { ExtExpert.OnTrade(); } //+------------------------------------------------------------------+ //| "Timer" event handler function | //+------------------------------------------------------------------+ void OnTimer() { ExtExpert.OnTimer(); } //+------------------------------------------------------------------+
En fait, cet EA utilise deux indicateurs (RSI et MA) pour les décisions de trading via la bibliothèque standard de classes de trading qui utilisent la logique des « filtres » et des « pondérations ». Vous pouvez trouver plus d'informations à ce sujet dans la section Modules de signaux de trade de la référence MQL5. Mais notre objectif est d'utiliser nos propres stratégies de trading comme nouveaux filtres.
Donc, pour la première étape (en utilisant nos propres stratégies de trading), nous allons modifier légèrement notre MyExpert.mq5. Tout d'abord, ajoutons un autre filtre. Ce sera le filtre 2 et nous le placerons juste après la portion de code du filtre 1.
//--- Creating filter CSignalCCIxx CSignalCCIxx *filter2=new CSignalCCIxx; if(filter2==NULL) { //--- failed printf(__FUNCTION__+": error creating filter2"); ExtExpert.Deinit(); return(-4); } signal.AddFilter(filter2); //--- Set filter parameters filter2.PeriodCCIxx(Signal_CCIxx_PeriodCCI); filter2.Applied(Signal_CCIxx_Applied); filter2.Weight(Signal_CCIxx_Weight);
Revenons aux fichiers #include qui sont au cœur des filtres et de la prise de décision du marché. Le premier est le fichier #include <Expert\Expert.mqh>. Ce fichier include inclut à son tour d'autres fichiers :
- #include "ExpertBase.mqh"
- #include "ExpertTrade.mqh"
- #include "ExpertSignal.mqh"
- #include "ExpertMoney.mqh"
- #include "ExpertTrailing.mqh"
Ces fichiers d'inclusion constituent la structure principale de l'EA, la structure de trading, la gestion des signaux, de l'argent et des Trailing stop, respectivement. Nous n'allons pas analyser en profondeur ces fichiers ni les modifier. Notre objectif est de nous concentrer sur l'ajout de nos propres stratégies en utilisant les indicateurs existants de l'ensemble standard d'indicateurs MetaTrader 5 et en ajoutant leur fichier include.
Dans le code MyExpert.mq5, nous avons les fichiers #include des indicateurs RSI et MA que nous avons utilisés dans cet exemple comme signaux/filtres pour la décision de marché du trading. A ce stade, ajoutons notre propre fichier include personnalisé. À cette fin, nous utiliserons une version modifiée (« améliorée ») des signaux appartenant à l'indicateur CCI.
//+------------------------------------------------------------------+ //| Include | //+------------------------------------------------------------------+ #include <Expert\Expert.mqh> //--- available signals #include <Expert\Signal\SignalRSI.mqh> #include <Expert\Signal\SignalMA.mqh> #include <Expert\Signal\SignalCCIxx.mqh> // This is our own 'custom' indicator for custom Signal management of the EA
Le fichier SignalCCIxx.mqh doit être placé dans le dossier \MQL5\Include\Expert\Signal\ et il doit correspondre à l'intégrabilité de l'assistant EA généré, comme les autres classes de trading #include de la bibliothèque standard - les fichiers de signaux déjà présents dans ce dossier (SignalRSI.mqh et SignalMA.mqh).
Pour cet exemple, nous allons copier le fichier CCI original, en créer un autre appelé CCIxx avec un code légèrement modifié et l'utiliser comme fichier #include. Maintenant, par souci de simplicité, nous utilisons simplement une version copiée de l'indicateur CCI de la bibliothèque standard.
Ce que nous devons faire, c'est copier le fichier « \MQL5\Include\Expert\Signal\SignalCCI.mqh » vers le fichier « \MQL5\Include\Expert\Signal\SignalCCIxx.mqh ». Le plus simple est de faire une copie du fichier dans le dossier, puis de le renommer.
Regardons maintenant ce fichier. L'intégration de cette manière « personnalisée » dans l'assistant généré par MyExpert.mq5 n'est qu'un travail terminé. Nous avons ajouté le code filter2, comme expliqué ci-dessus, et maintenant nous allons compléter plus tard ce qui suit. Nous n'allons donc plus nous concentrer sur le fichier MyExpert.mq5, mais à partir de maintenant sur le fichier SignalCCIxx.mqh qui est le véritable cœur de l'EA grâce à son signal de trading filtre2 de l'indicateur CCI.
Stratégie de personnalisation
Nous revenons à l'ajout des filtres de stratégie « semi-personnalisés » que nous appelons CCIxx, c'est-à-dire la version modifiée de SignalCCI.mqh. Je le définis semi-personnalisé, car ce n'est en fait pas un signal personnalisé totalement nouveau, mais plutôt une version repensée de l'indicateur CCI à partir de l'ensemble standard d'indicateurs fourni avec MetaTrader 5. De cette façon, même les utilisateurs et les programmeurs inexpérimentés peuvent modifier légèrement les modèles et les filtres d'un EA généré par l’assistant MQL5 en utilisant le grand nombre d'indicateurs existants. En d'autres termes, vous pouvez créer vos propres versions de filtres et de modèles pour générer des signaux d'achat et de vente sur le marché. Cela reste une excellente base pour travailler avec des stratégies.
Prenons cet exemple. Il sera utile pour ceux qui ont juste besoin de cette fonction (pour ajouter des modèles personnalisés à des indicateurs existants) et pour ceux qui veulent participer au championnat de trading automatisé en utilisant simplement l'assistant pour créer rapidement des EAs entièrement fonctionnels (et valides) avec certaines personnalisations.
Cela peut être réalisé en une heure de travail seulement - en créant un EA convivial pour le championnat, entièrement fonctionnel, avec Trailing Stop, Money Management et tout ce qui est nécessaire pour un trading compétitif. Si l'on se concentre à nouveau sur le fait que l'EA est généré par l'assistant, comme je l'ai appelé Championship friendly, cela signifie en fait que le code généré est exempt d'erreurs, de sorte que les participants n'ont pas à corriger quoi que ce soit ou à craindre des bugs ou des erreurs !
L'EA ne fera que du trade et sera parfait pour le trading, au moins pour ceux qui veulent participer, mais qui ne connaissent pas la programmation et ne veulent pas commander un EA dans Jobs le service (une belle alternative pour participer au Championnat). Il existe de nombreux paramètres d'entrée qui peuvent être attribués afin d'avoir votre propre robot de trading proche de la stratégie que vous avez en tête.
Mais vous ne pouvez en fait utiliser que l'ensemble standard d'indicateurs avec l'ensemble standard de filtres/modèles proposés par MetaQuotes via l'assistant et la bibliothèque standard des classes de stratégie de trading. Il offre un grand nombre de combinaisons et de possibilités de trading réussi, car les indicateurs ont de nombreux paramètres (cadre temporel, symbole) et tous les paramètres des indicateurs eux-mêmes, par exemple la période, le prix appliqué, etc. Dans cet article, vous apprendrez rapidement et facilement comment personnaliser et ajouter des motifs/filtres pour les indicateurs standard de MetaTrader 5.
Continuons sur le fichier SignalCCIxx.mqh afin de personnaliser et modifier son comportement, pour faire notre propre modèle de trading de signaux CCI (CCIxx). Tout d'abord, dans le fichier MyExpert.mq5, ajoutons de nouvelles variables pour le nouveau code dans la section de saisie, comme dans l'exemple suivant (voir le code surligné) :
//+------------------------------------------------------------------+ //| Inputs | //+------------------------------------------------------------------+ //--- inputs for expert input string Expert_Title ="MyExpert"; // Document name ulong Expert_MagicNumber =26287; // bool Expert_EveryTick =false; // //--- inputs for main signal input int Signal_ThresholdOpen =40; // Signal threshold value to open [0...100] input int Signal_ThresholdClose=60; // Signal threshold value to close [0...100] input double Signal_PriceLevel =0.0; // Price level to execute a deal input double Signal_StopLevel =50.0; // Stop Loss level (in points) input double Signal_TakeLevel =50.0; // Take Profit level (in points) input int Signal_Expiration =4; // Expiration of pending orders (in bars) input int Signal_RSI_PeriodRSI =8; // Relative Strength Index(8,...) Period of calculation input ENUM_APPLIED_PRICE Signal_RSI_Applied =PRICE_CLOSE; // Relative Strength Index(8,...) Prices series input double Signal_RSI_Weight =0.7; // Relative Strength Index(8,...) Weight [0...1.0] input int Signal_MA_PeriodMA =90; // Moving Average(12,0,...) Period of averaging input int Signal_MA_Shift =0; // Moving Average(12,0,...) Time shift input ENUM_MA_METHOD Signal_MA_Method =MODE_SMA; // Moving Average(12,0,...) Method of averaging input ENUM_APPLIED_PRICE Signal_MA_Applied =PRICE_CLOSE; // Moving Average(12,0,...) Prices series input double Signal_MA_Weight =0.6; // Moving Average(12,0,...) Weight [0...1.0] input int Signal_CCIxx_PeriodCCI =8; // Commodity Channel Index(8,...) Period of calculation input ENUM_APPLIED_PRICE Signal_CCIxx_Applied =PRICE_CLOSE; // Commodity Channel Index(8,...) Prices series input double Signal_CCIxx_Weight =0.8; // Commodity Channel Index(8,...) Weight [0...1.0]
Nous avons modifié les valeurs des variables Signal_RSI_Weight et Signal_MA_Weight de 1,0 à 0,7 et 0,6 respectivement, et nous avons ajouté les lignes mises en évidence ci-dessus. Afin de travailler correctement avec les paramètres d'entrée pour la version modifiée CCIxx du modèle appartenant à l'indicateur CCI dans les classes de stratégie de trading, nous avons en fait copié ces 3 lignes de code du fichier SignalCCI.mqh et juste ajouté le suffixe « xx » après « CCI ».
La section « protected » de la déclaration de la classe contient de nombreux éléments intéressants :
class CSignalCCI : public CExpertSignal { protected: CiCCI m_cci; // object-oscillator //--- adjusted parameters int m_periodCCI; // the "period of calculation" parameter of the oscillator ENUM_APPLIED_PRICE m_applied; // the "prices series" parameter of the oscillator //--- "weights" of market models (0-100) int m_pattern_0; // model 0 "the oscillator has required direction" int m_pattern_1; // model 1 "reverse behind the level of overbuying/overselling" int m_pattern_2; // model 2 "divergence of the oscillator and price" int m_pattern_3; // model 3 "double divergence of the oscillator and price" //--- variables double m_extr_osc[10]; // array of values of extremums of the oscillator double m_extr_pr[10]; // array of values of the corresponding extremums of price int m_extr_pos[10]; // array of shifts of extremums (in bars) uint m_extr_map; // resulting bit-map of ratio of extremums of the oscillator and the price
Jetez un œil aux types int appelés m_pattern. Ces variables sont numérotées progressivement de 0 à 3, chacune d'elles est un « pattern » ou, en d'autres termes, un modèle des conditions de prise de décision de marché pour l'achat et la vente d'un instrument financier.
Nous allons ajouter 2 modèles personnalisés : m_pattern_4 et m_pattern_5. Cela se fait simplement en ajoutant deux lignes de code, deux variables de type entier.
//--- "weights" of market models (0-100) int m_pattern_0; // model 0 "the oscillator has required direction" int m_pattern_1; // model 1 "reverse behind the level of overbuying/overselling" int m_pattern_2; // model 2 "divergence of the oscillator and price" int m_pattern_3; // model 3 "double divergence of the oscillator and price" int m_pattern_4; // model 4 "our own first new pattern: values cross the zero" int m_pattern_5; // model 5 "our own second new pattern: values bounce around the zero"
Si vous continuez à regarder le code, vous comprendrez la logique de l'achat et de la vente, et tout le reste. Mais nous nous concentrerons ici uniquement sur les sections concernant l'ajout de nos propres modèles, car nous n'allons pas expliquer ligne par ligne ces fichiers d'inclusion (pour cela, le lecteur peut ouvrir les fichiers lui-même et les étudier, et il y a aussi la référence MQL5 pour aider à la compréhension).
Nous voulons également faire ceci : dans le fichier CSignalCCIxx.mqh appuyez sur CTRL+H, recherchez « CCI » et remplacez par « CCIxx ». Cliquez sur « Remplacer tout » - 41 occurrences doivent être trouvées et remplacées. Allons ici, en haut du fichier :
//+------------------------------------------------------------------+ //| Class CSignalCCIxx. | //| Purpose: Class of generator of trade signals based on | //| the 'Commodity Channel Index' oscillator. | //| Is derived from the CExpertSignal class. | //+------------------------------------------------------------------+ class CSignalCCIxx : public CExpertSignal { protected: CiCCIxx m_CCIxx; // object-oscillator
et changez ceci :
protected: CiCCIxx m_CCIxx; // object-oscillator
avec ceci comme dans l'original SignalCCI.mqh :
protected: CiCCI m_CCIxx; // object-oscillator
Nous faisons cela parce que la CiCCI est appelée depuis un autre include, et si nous changeons son nom, il y aura évidemment plusieurs erreurs. Nous pouvons maintenant compiler le fichier SignalCCIxx.mqh, et il devrait y avoir 0 erreurs et 0 avertissements. S'il y en a, vous avez peut-être fait des erreurs et vous devez recommencer la procédure.
Allons maintenant au cœur de l'ajout de nos propres motifs. Par pure fantaisie, nous ajoutons deux modèles de comportement de trading sur le marché. Au total, nous aurons 4 nouveaux signaux (modèles), 2 de chaque type pour l'achat et 2 de chaque type pour la vente. La partie à modifier est la suivante :
//+------------------------------------------------------------------+ //| Constructor CSignalCCIxx. | //| INPUT: no. | //| OUTPUT: no. | //| REMARK: no. | //+------------------------------------------------------------------+ void CSignalCCIxx::CSignalCCIxx() { //--- initialization of protected data m_used_series=USE_SERIES_HIGH+USE_SERIES_LOW; //--- setting default values for the oscillator parameters m_periodCCIxx =14; //--- setting default "weights" of the market models m_pattern_0 =90; // model 0 "the oscillator has required direction" m_pattern_1 =60; // model 1 "reverse behind the level of overbuying/overselling" m_pattern_2 =100; // model 2 "divergence of the oscillator and price" m_pattern_3 =50; // model 3 "double divergence of the oscillator and price" m_pattern_4 =90; // model 4 "our own first new pattern: " m_pattern_5 =90; // model 5 "our own second new pattern: }
Nous avons attribué la valeur 90 aux modèles m_pattern_4 et m_pattern_5, mais vous devriez (devez) les remplacer par les vôtres : il s'agit des poids que vous souhaitez attribuer à vos nouveaux modèles de marché, car ils influencent l'ensemble du comportement de trading de l'Expert Advisor.
Imaginons que nous ajoutons deux nouveaux modèles de marché. Ils vont être très simples - ils sont juste destinés à l'éducation et sont des signaux de trading non testés, ne faites donc pas de trading avec. Le réticule crosshair nous aidera à identifier les valeurs de l'indicateur CCI dans les figures ci-dessous pour les barres correspondantes.
Premier modèle
Franchir la ligne du zéro de bas en haut
C'est notre premier modèle pour : « voter pour que le prix augmente ».
- La figure 5 montre la valeur CCI qui correspond à la barre 1 (une barre avant la barre actuelle). Sa valeur est 45,16 donc > 0.
- La figure 6 montre la valeur CCI qui correspond à la barre 2 (deux barres avant la barre actuelle). Sa valeur était de -53,92 donc < 0.
- La ligne du zéro (valeur 0.00) de l'indicateur CCI a été franchie de bas en haut dans les 2 barres.
Franchir la ligne du zéro du haut vers le bas
C'est notre premier modèle pour : « voter pour que le prix baisse ».
- La figure 7 montre la valeur CCI qui correspond à la barre 1 (une barre avant la barre actuelle). Sa valeur est de -28,49 donc < 0.
- La figure 8 montre la valeur CCI qui correspond à la barre 2 (deux barres avant la barre actuelle). Sa valeur était de 2,41 donc > 0.
- La ligne zéro (valeur 0,00) de l'indicateur CCI a été franchie de haut en bas dans les 2 barres.
Deuxième motif
Franchir la ligne zéro de haut en bas et revenir en haut
Il s'agit de notre deuxième modèle pour : « voter pour que le prix augmente ».
- La figure 9 montre la valeur CCI qui correspond à la barre 1 (une barre avant la barre actuelle). Sa valeur est 119,06 donc > 0.
- La figure 10 montre la valeur CCI qui correspond à la barre 2 (deux barres avant la barre actuelle). Sa valeur était de -20,38 donc < 0.
- La figure 11 montre la valeur CCI qui correspond à la barre 3 (trois barres avant la barre actuelle). Sa valeur était de 116,85 donc > 0 à nouveau.
- La ligne zéro (valeur 0,00) de l'indicateur CCI a été franchie de haut en bas. Ensuite, la ligne indicatrice CCI est revenue au-dessus, rebondissant autour de la ligne zéro dans les 3 barres.
Franchir la ligne zéro de bas en haut et revenir en bas
Il s'agit de notre deuxième modèle pour : « voter pour que le prix baisse ».
- La figure 12 montre la valeur CCI qui correspond à la barre 1 (une barre avant la barre actuelle). Sa valeur est de -58,72 donc < 0.
- La figure 13 montre la valeur CCI qui correspond à la barre 2 (deux barres avant la barre actuelle). Sa valeur était de 57,65 donc > 0.
- La figure 14 montre la valeur CCI qui correspond à la barre 3 (trois barres avant la barre actuelle). Sa valeur était de -85,54 donc < 0 à nouveau.
- La ligne zéro (valeur 0,00) de l'indicateur CCI a été franchie de bas en haut. Ensuite, la ligne indicatrice CCI est revenue en dessous, rebondissant autour de la ligne zéro dans les 3 barres.
Mise en œuvre des modèles
Afin de mettre en œuvre ces 4 conditions (deux par modèle), nous devons modifier la section de code suivante de cette manière. En bas, nous avons ajouté les lignes de code en surbrillance pour la condition « acheter » (voir ci-dessus dans les commentaires : « Voter » que le prix va augmenter).
//+------------------------------------------------------------------+ //| "Voting" that price will grow. | //| INPUT: no. | //| OUTPUT: number of "votes" that price will grow. | //| REMARK: no. | //+------------------------------------------------------------------+ int CSignalCCIxx::LongCondition() { int result=0; int idx =StartIndex(); //--- if(Diff(idx)>0.0) { //--- the oscillator is directed upwards confirming the possibility of price growth if(IS_PATTERN_USAGE(0)) result=m_pattern_0; // "confirming" signal number 0 //--- if the model 1 is used, search for a reverse of the oscillator upwards behind the level of overselling if(IS_PATTERN_USAGE(1) && Diff(idx+1)<0.0 && CCIxx(idx+1)<-100.0) result=m_pattern_1; // signal number 1 //--- if the model 2 or 3 is used, perform the extended analysis of the oscillator state if(IS_PATTERN_USAGE(2) || IS_PATTERN_USAGE(3)) { ExtState(idx); //--- if the model 2 is used, search for the "divergence" signal if(IS_PATTERN_USAGE(2) && CompareMaps(1,1)) // 00000001b result=m_pattern_2; // signal number 2 //--- if the model 3 is used, search for the "double divergence" signal if(IS_PATTERN_USAGE(3) && CompareMaps(0x11,2)) // 00010001b return(m_pattern_3); // signal number 3 } // if the model 4 is used, look for crossing of the zero line if(IS_PATTERN_USAGE(4) && CCIxx(idx+1)>0.0 && CCIxx(idx+2)<0.0) result=m_pattern_4; // signal number 4 // if the model 5 is used, look for the bouncing around the zero line if(IS_PATTERN_USAGE(5) && CCIxx(idx+1)>0.0 && CCIxx(idx+2)<0.0 && CCIxx(idx+3)>0.0) result=m_pattern_5; // signal number 5 } //--- return the result return(result); }
Modifions la section de code correspondante pour la condition « vente ». En bas, nous avons ajouté les lignes de code en surbrillance pour la condition « vente » (voir ci-dessus dans les commentaires : « Voter » que le prix va baisser).
//+------------------------------------------------------------------+ //| "Voting" that price will fall. | //| INPUT: no. | //| OUTPUT: number of "votes" that price will fall. | //| REMARK: no. | //+------------------------------------------------------------------+ int CSignalCCIxx::ShortCondition() { int result=0; int idx =StartIndex(); //--- if(Diff(idx)<0.0) { //--- the oscillator is directed downwards confirming the possibility of falling of price if(IS_PATTERN_USAGE(0)) result=m_pattern_0; // "confirming" signal number 0 //--- if the model 1 is used, search for a reverse of the oscillator downwards behind the level of overbuying if(IS_PATTERN_USAGE(1) && Diff(idx+1)>0.0 && CCIxx(idx+1)>100.0) result=m_pattern_1; // signal number 1 //--- if the model 2 or 3 is used, perform the extended analysis of the oscillator state if(IS_PATTERN_USAGE(2) || IS_PATTERN_USAGE(3)) { ExtState(idx); //--- if the model 2 is used, search for the "divergence" signal if(IS_PATTERN_USAGE(2) && CompareMaps(1,1)) // 00000001b result=m_pattern_2; // signal number 2 //--- if the model 3 is used, search for the "double divergence" signal if(IS_PATTERN_USAGE(3) && CompareMaps(0x11,2)) // 00010001b return(m_pattern_3); // signal number 3 } if(IS_PATTERN_USAGE(4) && CCIxx(idx+1)<0.0 && CCIxx(idx+2)>0.0) result=m_pattern_4; // signal number 4 if(IS_PATTERN_USAGE(5) && CCIxx(idx+1)<0.0 && CCIxx(idx+2)>0.0 && CCIxx(idx+3)<0.0) result=m_pattern_5; // signal number 5 } //--- return the result return(result); }
Le (idx+1) ou (idx+2) ... (idx+n) des dernières lignes ajoutées est un point très simple mais très important de la question : +1, +2, +3, etc. ne sont que le nombre de barres précédant l'actuelle (l'actuelle est la « bougie » réellement vivante, la 0ème barre).
Donc, plus il y a idx+N, plus on remonte de barres. Chaque barre (idx+n) correspond à la valeur de l'indicateur dans la même position « verticale » sur la même période.
Dans cette figure 16, la barre zéro (la première bougie la plus à droite, correspondant à idx ou (idx+0) dans le code) a la valeur CCI correspondante inférieure à 0,00. De plus, la deuxième barre (idx+1) et la troisième barre (idx+2) ont des valeurs inférieures à la ligne 0,00. Nous n'avons pas signé d'autres barres avec une flèche verticale, mais si vous passez votre souris sur la 4ème barre en arrière (idx+3), vous pouvez voir que sa valeur CCI correspondante est supérieure à 0,00.
Pour la plupart des utilisateurs, ce fait est évident, mais pour les utilisateurs novices, il est préférable de savoir comment les barres/bougies graphiques du tableau des prix, la vue graphique de l'indicateur CCI, et respectivement la variable (idx) et la valeur de l'indicateur CCIxx correspondent les uns aux autres.
Ceci est important pour afficher vos indicateurs sélectionnés sur un graphique et essayer de « visualiser » (ou découvrir) les correspondances entre les barres/bougies de prix et le comportement de l'indicateur sélectionné, en essayant de faire une supposition pour une stratégie, que vous pouvez facilement coder à l'aide de la barre indice (idx) et valeur de la variable indicatrice.
Dans le fichier SignalCCIxx.mqh, le code suivant :
CCIxx(idx+1)>0.0 && CCIxx(idx+2)<0.0
écrit au moyen de mots :
CCI Indicator value (one bar before, named idx+1) is above the zero line of CCI indicator AND CCI Indicator value (two bars before, named idx+2) is below the zero line of CCI indicator
Il s'agit du plus petit exemple de la façon d'ajouter simplement deux modèles personnalisés en fonction de la valeur de l'indicateur que nous choisissons (dans ce cas - CCI).
La condition « le prix va augmenter » ou « le prix va baisser » doit être écrite et ajoutée dans les modèles de cette manière, et personne n'interdit de créer des conditions plus complexes. Avant le test final, examinons les mécanismes d'ouverture et de fermeture des positions.
Le mécanisme et la logique sont déjà très bien expliqués dans le manuel de référence MQL5 dans la section Classes de stratégies de trading de la bibliothèque standard.
En bref, dans le fichier MyExpert.mq5, nous avons 2 paramètres d'entrée (deux variables entières) :
//--- inputs for main signal input int Signal_ThresholdOpen =40; // Signal threshold value to open [0...100] input int Signal_ThresholdClose=60; // Signal threshold value to close [0...100]
Ces seuils d'ouverture et de clôture sont deux valeurs qui sont utilisées pour calculer si (selon nos modèles de trading) une transaction est ouverte longue ou courte puis fermée. Les seuils prennent un nombre de type entier de 0 à 100. Que signifient ces paramètres ?
Signal_ThresholdOpen est la valeur pour ouvrir une position longue ou courte, Signal_ThresholdClose est la valeur pour fermer une position précédemment ouverte. Ces valeurs sont calculées dans le cadre d'un mécanisme simple mais brillant, qui est collé à toute la logique des EA générées par l'assistant.
Chaque signal dans les fichiers Signal __.mqh ( __ représente le nom de l'indicateur utilisé, dans notre cas - MA, RSI et CCIxx) est composé de modèles, comme nous l'avons vu précédemment en détail. Examinons-les à nouveau dans notre exemple. À partir du fichier SignalMA.mqh, nous avons 4 modèles avec leur « poids » relatif pour chaque modèle :
//--- setting default "weights" of the market models m_pattern_0 =80; // model 0 "price is on the necessary side from the indicator" m_pattern_1 =10; // model 1 "price crossed the indicator with opposite direction" m_pattern_2 =60; // model 2 "price crossed the indicator with the same direction" m_pattern_3 =60; // model 3 "piercing"
et pour RSI à partir du fichier SignalRSI.mqh de la même manière :
//--- setting default "weights" of the market models m_pattern_0 =70; // model 0 "the oscillator has required direction" m_pattern_1 =100; // model 1 "reverse behind the level of overbuying/overselling" m_pattern_2 =90; // model 2 "failed swing" m_pattern_3 =80; // model 3 "divergence of the oscillator and price" m_pattern_4 =100; // model 4 "double divergence of the oscillator and price" m_pattern_5 =20; // model 5 "head/shoulders"
Dans « notre propre » SignalCCIxx.mqh (qui est presque entièrement une copie de SignalCCI.mqh), nous avons ces valeurs :
//--- setting default "weights" of the market models m_pattern_0 =90; // model 0 "the oscillator has required direction" m_pattern_1 =60; // model 1 "reverse behind the level of overbuying/overselling" m_pattern_2 =100; // model 3 "divergence of the oscillator and price" m_pattern_3 =50; // model 4 "double divergence of the oscillator and price" m_pattern_4 =80; // model 4 "our own first new pattern: " m_pattern_5 =90; // model 5 "our own second new pattern: "
Il s'agit des modèles standard 0, 1, 2, 3 et de nos propres modèles 4 et 5 avec les deux dernières valeurs de 80 et 90. Lorsque nous attachons le fichier MyExpert.ex5 au graphique ou le testons dans Strategy Tester, les modèles de tous les signaux que nous avons sélectionnés (RSI, MA et CCIxx) sont calculés en continu.
Si les conditions d'un ou plusieurs motifs sont remplies, le signal de ce motif est activé pour le calcul suivant. Par exemple, si m_pattern_4 du fichier SignalCCIxx.mqh se produit, à partir de la condition :
// if the model 4 is used, look for crossing of the zero line if(IS_PATTERN_USAGE(4) && CCIxx(idx+1)>0.0 && CCIxx(idx+2)<0.0) result=m_pattern_4; // signal number 4
il devient un signal trade potentiel. En d'autres termes, si la valeur de CCI à la barre 1 est > 0,0 et en même temps la valeur de CCI à la barre 2 était < 0,0, comme dans la figure 5 et la figure 6, la condition se produit et le m_pattern_4 (numéro de signal 4 ) est activé.
La valeur de pondération que nous avons mise en place pour ce signal de notre stratégie CCIxx est égale à la valeur absolue de 80, mais elle prendra-80 dans le cas d'un cas « voter que le prix va baisser », et 80 pour le cas « voter que le le prix va augmenter ». Le « voter que le prix va baisser » vient de mettre un signe négatif à la valeur d'origine du poids du motif.
En supposant que la condition du m_pattern_4 soit réussie, une transaction n'est ouverte seulement si :
Le signal numéro 4 (m_pattern_4) est le seul signal dont la condition est vraie (signal activé) ET il a atteint l'objectif de Signal_ThresholdOpen (sa valeur multipliée par un coefficient, a atteint et dépassé la valeur Signal_ThresholdOpen)
Le signal numéro 4 a atteint l'objectif de Signal_ThresholdOpen, tout en rivalisant avec d'autres signaux de son propre homologue de la stratégie CCIxx (les signaux/modèles « voter que le prix va baisser » de la stratégie CCIxx) et en concurrence avec tous les autres signaux d'autres indicateurs (signaux RSI et MA) des directions opposées (dans ce cas, la direction opposée est la direction courte, car nous analysons le m_pattern_4 à propos de « voter pour que le prix va augmenter »).
Nous pouvons donc considérer chaque modèle comme un concurrent dans 2 factions : les signaux haussiers et les signaux baissiers. Lorsque ces modèles/signaux de même direction (« voter pour que le prix va augmenter ») réussissent (activés), ils sont additionnés les uns aux autres et la somme est comparée à la valeur Signal_ThresholdOpen. Si aucune position n'a été ouverte ou si la somme est comparée à la valeur Signal_ThresholdClose dans le cas d'une position précédemment opposée (dans cet exemple, une position courte), le m_pattern_4 de SignalCCIxx.mqh a la valeur :
- 80 dans le cas de la condition « augmentation des prix »
- -80 en cas de condition « chute de prix »
Supposons que TOUS les autres modèles de TOUS les signaux (SignalRSI.mqh, SignalMA.mqh et les modèles 0,1,2,3 et 5 de SignalCCIxx.mqh) obtiennent la valeur 0. C'est comme si les « concurrents du signal » étaient hors du « jeu », et que les seuls concurrents étaient les deux de m_pattern_4 - un pour l'achat et un pour la vente. Ainsi, seul le modèle m_pattern_4 fonctionne, car il a une valeur différente de 0, c'est-à-dire 80.
//--- setting default "weights" of the market models m_pattern_0 =0; // model 0 "price is on the necessary side from the indicator" m_pattern_1 =0; // model 1 "price crossed the indicator with opposite direction" m_pattern_2 =0; // model 2 "price crossed the indicator with the same direction" m_pattern_3 =0; // model 3 "piercing"
Et pour le RSI à partir du fichier SignalRSI.mqh de la même manière :
//--- setting default "weights" of the market models m_pattern_0 =0; // model 0 "the oscillator has required direction" m_pattern_1 =0; // model 1 "reverse behind the level of overbuying/overselling" m_pattern_2 =0; // model 2 "failed swing" m_pattern_3 =0; // model 3 "divergence of the oscillator and price" m_pattern_4 =0; // model 4 "double divergence of the oscillator and price" m_pattern_5 =0; // model 5 "head/shoulders"
Dans « notre propre » SignalCCIxx.mqh (qui est presque entièrement une copie de SignalCCI.mqh), nous avons ces valeurs :
//--- setting default "weights" of the market models m_pattern_0 =0; // model 0 "the oscillator has required direction" m_pattern_1 =0; // model 1 "reverse behind the level of overbuying/overselling" m_pattern_2 =0; // model 3 "divergence of the oscillator and price" m_pattern_3 =0; // model 4 "double divergence of the oscillator and price" m_pattern_4 =80; // model 4 "our own first new pattern: " m_pattern_5 =0; // model 5 "our own second new pattern: "
Au début de l'article, nous avons ajouté ces lignes :
input int Signal_CCIxx_PeriodCCI =8; // Commodity Channel Index(8,...) Period of calculation input ENUM_APPLIED_PRICE Signal_CCIxx_Applied =PRICE_CLOSE; // Commodity Channel Index(8,...) Prices series input double Signal_CCIxx_Weight =0.8; // Commodity Channel Index(8,...) Weight [0...1.0]
Nous nous sommes concentrés sur la variable Signal_CCIxx_Weight qui a une valeur de 0,8. Le Signal_ThresholdOpen est atteint (déclenché) lorsque la valeur seuil est atteinte. La valeur est calculée de cette façon :
0.8 (Signal_CCIxx_Weight input parameter) * 80 (m_pattern_4's weight value) = 64 is the signal strength for the "voting that price will grow"
Il s'agit de « voter que le prix va augmenter », car l'algorithme a capté un signal de « croissance du prix » (m_pattern_4 de SignalCCIxx), et la valeur est 80.
Si hypothétiquement il capte un « vote que le prix va baisser » (m_pattern_4 de SignalCCIxx), la valeur est -80. Pour le « prix en baisse », l'algorithme met simplement un signe moins à la valeur du modèle. En supposant que le cas « vote pour que le prix va baisser », les calculs sont les suivants :
0.8 (Signal_CCIxx_Weight input parameter) * -80 (m_pattern_4's weight value) = -64 = the negative value is considered for short positions
-64 64 (en valeur absolue) est la force du signal pour le « vote pour que le prix va baisser ». La force du signal est toujours exprimée en valeur absolue, tandis que les valeurs de position courte sont précédées d'un signe moins et les valeurs de position longue d'un signe plus.
Revenons à un exemple ci-dessus de la position longue avec une valeur atteinte de 64 et une force de signal de 64. S'il n'y a pas d'autres signaux opposés (avec signe négatif) (m_pattern_N de Signal__) en concurrence, le Signal_ThresholdOpen qui a une valeur de 40 est atteint, car la force du signal long est de 64, et le niveau 40 de Signal_ThresholdOpen est atteint et dépassé par 24 (40+24=64). Le Signal_ThresholdOpen ayant été atteint, une position longue est ouverte.
Par exemple, si nous configurons la valeur 0,4 à Signal_CCIxx_Weight, aucune position longue ne sera ouverte car :
0.4 (the Signal_CCIxx_Weight) * 80(m_pattern_4) = 32 (strength of "long signal")
et le niveau 40 (Signal_ThresholdOpen) n'est pas atteint car 32 < 40, donc aucune position longue n'est ouverte.
L'exemple d'ensemble de valeurs ci-dessus (toutes les valeurs 0 sauf la 80 dans m_pattern_4 de SignalCCIxx.mqh) est juste utilisé à titre absurde pour nous faire comprendre l'excellente logique qui se cache derrière l'assistant et le système de pondérations et de seuils. Dans une programmation normale, vous attribueriez un poids préférentiel à chacun des m_pattern_N de chaque Signal__. Si vous attribuez la valeur 0 à un motif, cela signifie simplement que ce motif ne sera pas utilisé.
Si nous modifions une autre valeur dans l'exemple ci-dessus (avec tous les paramètres définis sur 0 à l'exception de m_pattern_4 de SignalCCIxx.mqh), disons m_pattern_1 de SignalRSI.mqh à 100, les calculs changent de sorte que nous avons maintenant 4 concurrents :
- m_pattern_4 (Bull) et m_pattern_4 (Bear) du fichier SignalCCIxx.mqh, valeurs de 80 et -80 respectivement.
- m_pattern_1 (Bull) et m_pattern_1 (Bear) du fichier SignalRSI.mqh, valeurs de 100 et -100 respectivement.
m_pattern_4 Bullish --> 0.8 * 80 = 64 m_pattern_2 Bullish --> 0.7 * 100 = 70
m_pattern_4 Bearish --> 0.8 * (-80) = -64 m_pattern_2 Bearish --> 0.7 * (-100) = -70
Nous aurons donc 4 combinaisons possibles :
A) m_pattern_4 Bullish + m_pattern_2 Bullish = {[0.8 * (80)] + [0.7 * (100)]}/2 = [64 + (70)]/2 = 134/2 = 67
B) m_pattern_4 Bullish + m_pattern_2 Bearish = {[0.8 * (80)] + [0.7 * (-100)]}/2 = [64 + (-70)]/2 = -6/2 = -3
C) m_pattern_4 Bearish + m_pattern_2 Bullish = {[0.8 * (-80)] + [0.7 * (100)]}/2 = [(-64) + 70]/2 = 6/2 = 3
D) m_pattern_4 Bearish + m_pattern_2 Bearish = {[0.8 * (-80)] + [0.7 * (-100)]}/2 = [(-64) + (-70)]/2 = -134/2 = -67
Cas A
Valeur positive de 67. La position longue est ouverte car Signal_ThresholdOpen avec une valeur de 40 est atteint et dépassé. La position longue plus tard est fermée lorsque le Signal_ThresholdClose avec la valeur 60 est atteint et dépassé par la valeur absolue du cas D = -67 = |67| (valeur absolue) car la force du boîtier D en valeur absolue 67 > 60 (c'est le seuil du Signal_ThresholdClose).
Cas B
Valeur négative -3. Aucune position courte n'est ouverte, car Signal_ThresholdOpen avec une valeur de 40 n'est pas atteint et dépassé par la valeur absolue du cas B : -3 est devenu 3 lorsque l'on considère sa valeur absolue afin de calculer la « force du signal », et 3 < 40 (valeur pour un signal en position ouverte). Il n'y a pas de positions courtes ouvertes et évidemment il n'y a pas de calculs pour fermer des positions courtes.
Cas C
Valeur positive 3. Aucune position longue n'est ouverte, car Signal_ThresholdOpen avec une valeur de 40 n'est pas atteint et dépassé par la valeur du cas C puisque 3 < 40 (valeur pour un signal d'ouverture de position). Il n'y a pas de positions longues ouvertes et évidemment il n'y a pas de calculs pour fermer des positions longues.
Cas D
Valeur négative -67. La position courte est ouverte car Signal_ThresholdOpen avec une valeur de 40 est atteint et dépassé par la force du signal qui est calculée simplement avec la valeur absolue de -67 qui est 67, et 67 > 40. La position courte ultérieure est fermée lorsque le Signal_ThresholdClose avec la valeur de 60 est atteint et dépassé par la valeur du cas A = 67 puisque 67 (la force du cas A) > 60 (c'est-à-dire le seuil du Signal_ThresholdClose).
En d'autres termes, pour ouvrir des positions courtes, nous devons d'abord identifier la direction en raison de la valeur négative des signaux, puis la valeur négative est transformée en sa valeur absolue afin de calculer la force du signal à comparer avec la valeur Signal_ThresholdOpen pour voir si ancien >= dernier.
La fermeture des positions longues s'effectue de la même manière : on considère d'abordla valeur négative pour fermer la position longue (au contraire, la valeur pour la fermeture de la position courte est positive), puis cette valeur négative est transformée en sa valeur absolue à comparer avec le Signal_ThresholdClose pour voir si ancien >= dernier.
Pour ouvrir des positions longues et fermer des positions courtes, les calculs sont effectués sur des nombres positifs (il n'y a pas de signaux avec un signe moins), donc pas besoin de considérer les valeurs absolues pour les calculs. L'ouverture des positions longues est déclenchée par une valeur positive de la force du signal, et la fermeture des positions courtes est également déclenchée par une valeur positive de la force du signal.
Les premiers sont considérés comme le signe plus et le signe moins pour ouvrir une position longue ou courte, et pour fermer une position courte ou fermer une position longue respectivement. Ensuite, nous avons calculé leurs valeurs absolues pour la comparaison avec les valeurs de seuil de Signal_ThresholdOpen et Signal_ThresholdClose qui sont toujours calculées avec un signe positif (pas de signe négatif pour Signal_ThresholdOpen et Signal_ThresholdClose).
Détails de la position
Continuons à approfondir les détails de la position :
- Trading normal. La position est ouverte puis fermée. Après cela, la position n'est pas rouverte immédiatement.
- Inversion de position. La position est ouverte, puis fermée et à nouveau ouverte dans la direction opposée.
La position longue est ouverte si :
Open_long >= Signal_ThresholdOpen | SI Signal_ThresholdClose <= Signal_ThresholdOpen | ||
|---|---|---|
|
| SI Signal_ThresholdClose >= Signal_ThresholdOpen | ||
|---|---|---|
|
Dans le cas de Signal_ThresholdClose >= Signal_ThresholdOpen, il s'agit du booléen « OU » car Signal_ThresholdClose >= Signal_ThresholdOpen, incorporant déjà la valeur de Signal_ThresholdOpen. Ainsi, la position sera fermée et remplacée par la valeur de Signal_ThresholdClose >= Signal_ThresholdOpen, elle sera de toute façon inversée.
La position courte est ouverte si :
Open_short >= Signal_ThresholdOpen. | Signal_ThresholdClose <= Signal_ThresholdOpen | ||
|---|---|---|
|
| SI Signal_ThresholdClose >= Signal_ThresholdOpen | ||
|---|---|---|
|
Dans le cas de Signal_ThresholdClose >= Signal_ThresholdOpen, il s'agit du booléen « OU » car Signal_ThresholdClose >= Signal_ThresholdOpen, incorporant déjà la valeur de Signal_ThresholdOpen. Ainsi, la position sera fermée et écrasée par la valeur de Signal_ThresholdClose >= Signal_ThresholdOpen, elle sera de toute façon longuement inversée.
Le mécanisme d'ouverture et de fermeture des positions des EA générés par l'assistant est très perspicace et intelligent, car il est basé sur un système de poids, de valeurs et de seuils. À l'aide de ce mécanisme, les positions seront gérées avec une grande « méthodologie » et sans erreurs de logique.
Niveau de prix et expiration du signal
Il existe une autre variable importante :
input double Signal_PriceLevel =0.0; // Price level to execute a deal
Cette variable est très importante pour la compréhension de base du mécanisme des EA générés par l'assistant et elle peut être simplifiée de cette manière :
Signal_PriceLevel détermine si le signal long sera traité comme Buy-Stop ou Buy-Limit, ou si le signal court sera traité comme Sell-Stop ou Sell-Limit. Pour plus de détails sur les ordres Stop et Limit, consultez la section d'aide correspondante sur les de MetaTrader 5.
Les valeurs négatives attribuées à la variable d'entrée Signal_PriceLevel signifient toujours des ordres stop (achat ou vente).
Les valeurs positives attribuées à la variable d'entrée Signal_PriceLevel signifient toujours des ordres à cours limité (achat ou vente).
Par exemple :
EURUSD - Positions longues
Signal_PriceLevel = -70 (moins 70)
ainsi, lorsque le signal activé est ouvert (par exemple, le prix actuel = 1,2500),
l'EA placera un ordre Buy Stop composé de 1,2500 + 70 = 1,2570
(pire que le prix actuel, selon le point de vue haussier)
Signal_PriceLevel = 60 (plus 60)
ainsi, lorsque le signal activé est ouvert (par exemple, le prix actuel = 1,2500),
l'EA placera un ordre Buy Limit composé de 1,2500 - 60 = 1,2440
(mieux que le prix actuel, du point de vue haussier)
EURUSD - Positions courtes
Signal_PriceLevel = -70 (moins 70)
ainsi, lorsque le signal activé est ouvert (par exemple, le prix actuel = 1,2500),
l'EA passera un ordre Sell Stop composé de 1,2500 - 70 = 1,2430
(mieux que le prix actuel, du point de vue baissier)
Signal_PriceLevel = 60 (plus 60)
ainsi, lorsque le signal activé est ouvert (par exemple, le prix actuel = 1,2500),
l'EA passera un ordre de Sell Limit composé de 1,2500 + 60 = 1,2560
(pire que le prix actuel, du point de vue baissier)
Enfin, la variable d'entrée
input int Signal_Expiration =4; // Expiration of pending orders (in bars)
détermine combien de fois (exprimé en barres) les ordres Stop/Limit seront actifs.
Organigramme
Pour une meilleure compréhension, vous pouvez considérer cet organigramme simplifié qui montre plus ou moins le mécanisme de la dynamique du fonctionnement des EA générés par l'assistant.
Strategy Tester
Revenons maintenant au contexte de notre stratégie personnalisée et compilons le fichier SignalCCIxx.mqh. S'il n'y a pas d'erreurs, tout devrait bien se passer. Eh bien, en fait, nous avons maintenant ajouté 2 nouveaux modèles de décision pour le trading de marché. Chaque modèle comporte une condition d'achat et de vente, ainsi que des conditions d'ouverture et de fermeture.
Compilons maintenant le fichier MyExpert.mq5, et si tout va bien, il y aura 0 erreur(s) et 0 avertissement(s). Eh bien, testons-la dans le Expert Advisors. J'ai utilisé certains paramètres dans Strategy Tester pour le symbole EUR/USD, pour une période similaire à celle du dernier Championnat de trading automatique 2011.
Bien qu'il montre de « bons » résultats et qu'il double plus que le dépôt initial en moins de 3 mois avec un montant fixe, je ne recommande pas d'utiliser cet EA pour de vrais échanges, mais je vous encourage plutôt à ajouter vos propres modèles/modèles et expérimentez avec eux, en les optimisant jusqu'à ce que vous obteniez de bons résultats qui vous conviennent.
Quoi qu'il en soit, notre objectif ici est de montrer que l'idée d'amplifier les classes de stratégie de trading existantes fonctionne.
Vous pouvez créer de nouveaux schémas/modèles et les partager avec MQL5.community. Grâce à l'assistant MQL5 et à la méthode simple présentée dans cet article, il sera facile de les tester et de les essayer. Cet article n'est qu'un exemple de la manière d'explorer les classes de stratégie de trading de la bibliothèque standard et de la simplicité avec laquelle vous pouvez modifier ces bibliothèques pour créer vos propres systèmes de trading.
Conclusion
Nous avons facilement ajouté 2 nouveaux filtres/motifs au signal CCI. Vous pouvez faire de même pour tous les autres indicateurs et créer votre propre groupe de signaux personnalisés. Si vous faites un travail très structuré et réfléchi, cela peut devenir un instrument de trading très puissant.
Il s'agit d'un moyen puissant et pratique d'ajouter vos propres stratégies en vous concentrant uniquement sur le cœur des stratégies en travaillant avec des indicateurs. Laissez l'assistant MQL5 faire tout le reste du travail concernant les fonctions de trading et les opérations de l'EA - c'est un gain de temps et aussi une garantie de l'exactitude d’Expert Advisor.
Vous pouvez facilement écrire vos propres stratégies en utilisant les MetaTrader 5 Indicateurs standard et de les emballer dans l'EA qui est ATC prêt.
Traduit de l’anglais par MetaQuotes Ltd.
Article original : https://www.mql5.com/en/articles/488
Stratégie statistique de Carry Trade
ID MetaQuotes dans le terminal mobile MetaTrader
Réseaux neuronaux : De la théorie à la pratique
Introduction à la méthode de décomposition en modes empiriques
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Vous acceptez la politique du site Web et les conditions d'utilisation