MetaTrader 4 / Systèmes de trading
English Русский 中文 Español Deutsch 日本語 Português 한국어 Italiano Türkçe
La règle d'or des Traders

La règle d'or des Traders

MetaTrader 4 — Systèmes de trading | 13 janvier 2022, 16:28
724 0
Genkov
Genkov

Introduction

La tâche principale d'un trader n'est pas seulement de trouver le bon moment pour entrer sur le marché. Il faut aussi trouver le bon moment pour en sortir. La règle d'or du trading dit : «Réduisez toujours vos pertes et laissez courir vos profits».

Pour réaliser des bénéfices sur la base d'une attente mathématique élevée, nous devons comprendre trois principes de base d'un bon trading.

  1. Connaissez votre risque en entrant sur le marché (c'est une valeur Stop Loss initiale);
  2. Réduisez vos bénéfices et laissez vos bénéfices s'écouler (ne fermez pas votre position avant que votre système ne l'exige) ;
  3. Connaissez les attentes mathématiques de votre système – testez-le et ajustez-le régulièrement.


Méthode de suivi des positions étape par étape permettant aux bénéfices de courir

Beaucoup pensent qu'il est impossible de faire du profit, car nous ne savons pas où ira le marché. Mais avons-nous vraiment besoin de le savoir pour trader avec succès ? Un trading réussi est principalement basé sur un système correctement conçu en tenant compte des moments appropriés pour entrer sur le marché. De telles considérations sont faites en utilisant le pouvoir d'attente et les règles de suivi des positions étape par étape qui permettent au profit de courir pour le plus haut niveau possible.

Le moment d'entrée sur le marché peut être trouvé de plusieurs manières, par exemple, en utilisant des modèles de chandeliers, des modèles de vagues, etc. Dans le même temps, le facteur de profit doit être pris en compte (rapport profit/perte).

Cette méthode est basée sur l'exigence suivante : un trader sélectionne la valeur Stop Loss la plus basse possible lors de l'ouverture d'une position. Cette valeur peut être déterminée à l'aide de diverses méthodes, par exemple par exemple, il peut être égal à 1,5% de l'acompte. Lorsque le marché atteint un profit égal à la valeur du Stop Loss, la moitié du lot est fermée mais le Stop Loss n'est pas modifié !

Par conséquent, nous créons une sorte de filet de sécurité, au cas où le marché irait dans le sens inverse. C'est-à-dire que nous réduisons notre risque en fixant les pertes minimales. Si le marché évoluait dans une direction favorable juste pour quelques temps plus tard, le Stop Loss est déclenché (Fig. 1-3).


Fig. 1. Ouvrir un position


Fig. 2. Réglage du Stop Loss

si le marché à chuté:


Fig. 3. Si le marché à chuté, vous êtes au seuil de rentabilité

Code du programme de suivi de position

Nous proposons un code de programme qui suit les positions ouvertes et actualise le deuxième principe d'or, car il permet aux bénéfices de courir au plus haut niveau possible.

Si le marché évolue toujours dans une direction favorable et atteint une valeur prédéterminée, par exemple 100 pips, le Stop Loss est réinitialisé à un niveau d'équilibre. D'autres réinitialisations sont effectuées lorsque vous atteignez le profit dans des intervalles prédéterminés, par exemple, 50 pips. Nous pouvons déplacer le Stop Loss à chaque barre suivante, mais les brokers n'aiment pas les réinitialisations fréquentes, en particulier lorsque la transaction est effectuée dans des délais inférieurs. L’ erreur (stdlib.mq4) du dossier des bibliothèques a la même erreur # 8 error = «demandes trop fréquentes» pour ce cas.

La méthode pour déterminer chaque prochain niveau de Stop Loss est sélectionnée par une position de prix au moment de réaliser un profit en fonction des niveaux de Fibonacci. Les niveaux de Fibonacci appliqués sont construits selon la méthode Vegas Tunnel ici.

Le calcul des niveaux de Fibonacci est effectué par la fonction de génération de niveaux LevelFibo() :

//+------------------------------------------------------------------+
   void LevelFibo()
   {
   double Fb1,Fb2,Fb3,Fb4,Fb5,Fb6,Fb7,Fb8,Fb9,Fb10,Fb11,Fb12,Fb13;
   // "Vegas" channel
   double Ma144_1 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,1);
   double Ma169_1 = iMA(NULL,0,169,0,MODE_EMA,PRICE_CLOSE,1);
   // "Vegas" channel median
   double MedVegas=NormalizeDouble((Ma144_1+Ma169_1)/2,Digits); 
   // calculate Fibo levels values using "Vegas" method
   Fb1=MedVegas-377*Point;     Fb12=MedVegas+377*Point;
   Fb2=MedVegas-233*Point;     Fb11=MedVegas+233*Point;
   Fb3=MedVegas-144*Point;     Fb10=MedVegas+144*Point;
   Fb4=MedVegas-89*Point;      Fb9=MedVegas+89*Point;
   Fb5=MedVegas-55*Point;      Fb8=MedVegas+55*Point;
   Fb6=MedVegas-34*Point;      Fb7=MedVegas+34*Point;
   }
//+------------------------------------------------------------------+

Lors du calcul du Stop Loss pour les positions BUY, le profit est la différence entre le prix Max de la première barre High[1] et le niveau d'ouverture de la position OrderOpenPrice(). Le niveau de Stop Loss est défini comme le niveau de Fibonacci «le plus proche» par rapport à la valeur Min de la première barre Low[1] (Fig. 4).


Fig. 4. Calcul du Stop Loss pour la position ACHETER

Lors du calcul du Stop Loss pour les positions de VENDRE, le profit est la différence entre le niveau d'ouverture de la position OrderOpenPrice() et le prix Max de la première barre High[1] (Fig. 5).


Fig. 5. Calcul du Stop Loss pour la position de VENDRE

Pour les positions d'achat, les valeurs Stop Loss sont basées sur les niveaux de Fibo. Selon la valeur la plus basse du premier chandelier, il est présenté comme une fonction distincte.

Le code de fonction est indiqué ci-dessous :

//+---------------------------------------------------------------------+
//| Function (table) for specifying Stop Loss values for BUY position   |
//| by Fibo levels according to the lowest value of the first candle    |
//+---------------------------------------------------------------------+
 void StopLevelFiboBuy()
   {
   if(Low[1]>Fb12)                                newSL_B=Fb12-100*Point;
   if(Low[1]<=Fb12 && Low[1]>(Fb12+Fb11)/2)       newSL_B=(Fb12+Fb11)/2;
   if(Low[1]<=(Fb12+Fb11)/2 && Low[1]>Fb11)       newSL_B=Fb11;
   if(Low[1]<=Fb11 && Low[1]>(Fb11+Fb10)/2)       newSL_B=(Fb11+Fb10)/2;
   if(Low[1]<=(Fb10+Fb11)/2 && Low[1]>Fb10)       newSL_B=Fb10;
   if(Low[1]<=Fb10 && Low[1]>(Fb10+Fb9)/2)        newSL_B=Fb9;
   if(Low[1]<=(Fb10+Fb9)/2 && Low[1]>Fb9)         newSL_B=Fb8;
   if(Low[1]<=Fb9  && Low[1]>Fb8)                 newSL_B=Fb7;
   if(Low[1]<=Fb8  && Low[1]>Fb7)                 newSL_B=(Fb7+MedVegas)/2;
   if(Low[1]<=Fb7  && Low[1]>MedVegas)            newSL_B=Fb6;
   if(Low[1]<=MedVegas && Low[1]>(MedVegas+Fb6)/2)newSL_B=Fb6;
   if(Low[1]<=(MedVegas+Fb6)/2 && Low[1]>Fb6)     newSL_B=Fb5;
   if(Low[1]<=Fb6  && Low[1]>Fb5)                 newSL_B=Fb4;
   if(Low[1]<=Fb5  && Low[1]>Fb4)                 newSL_B=(Fb3+Fb4)/2;
   if(Low[1]<=Fb4  && Low[1]>Fb3)                 newSL_B=Fb3;
   if(Low[1]<=Fb3  && Low[1]>(Fb3+Fb2)/2)         newSL_B=(Fb3+Fb2)/2;
   if(Low[1]<=(Fb3+Fb2)/2  && Low[1]>Fb2)         newSL_B=Fb2;
   if(Low[1]<=Fb2  && Low[1]>(Fb2+Fb1)/2)         newSL_B=(Fb1+Fb2)/2;
   if(Low[1]<=(Fb2+Fb1)/2 && Low[1]>Fb1)          newSL_B=Fb1;
   if(Low[1]<=Fb1)                                newSL_B=Fb1-100*Point;
   }
//+------------------------------------------------------------------+

Le tableau des valeurs Stop Loss par niveaux de Fibo en fonction de la valeur maximale du premier chandelier de la fonction StopLevelFiboSell() pour les positions Vendre est représenté par le code suivant :

//+----------------------------------------------------------------------+
//| Function (table) for specifying Stop Loss values for SELL position   |
//| by Fibo levels according to the highest value of the first candle    |
//+----------------------------------------------------------------------+
 void StopLevelFiboSell()
   {
   if(High[1]<=Fb12 && High[1]>(Fb12+Fb11)/2)        newSL_S=Fb12+100*Point;
   if(High[1]<=Fb12 && High[1]>Fb11)                 newSL_S=Fb12;
   if(High[1]<=Fb11 && High[1]>Fb11+Fb10)            newSL_S=Fb11;
   if(High[1]<=Fb10 && High[1]>(Fb10+Fb9)/2)         newSL_S=(Fb11+Fb10)/2;
   if(High[1]<=Fb9  && High[1]>Fb8)                  newSL_S=(Fb10+Fb9)/2;
   if(High[1]<=Fb8  && High[1]>Fb7)                  newSL_S=Fb9;
   if(High[1]<=Fb7  && High[1]>MedVegas)             newSL_S=Fb8;
   if(High[1]<=MedVegas && High[1]>MedVegas)         newSL_S=Fb7;
   if(High[1]<=(MedVegas+Fb6)/2 && High[1]>Fb6)      newSL_S=MedVegas;
   if(High[1]<=Fb6  && High[1]>Fb5)                  newSL_S=MedVegas;
   if(High[1]<=Fb5  && High[1]>Fb4)                  newSL_S=Fb6;
   if(High[1]<=Fb4  && High[1]>Fb3)                  newSL_S=Fb5;
   if(High[1]<=Fb3  && High[1]>Fb2)                  newSL_S=Fb4;
   if(High[1]<=Fb2  && High[1]>(Fb2+Fb1)/2)          newSL_S=(Fb2+Fb3)/2;
   if(High[1]<(Fb2+Fb1)/2   && High[1]>Fb1)          newSL_S=Fb2;
   if(High[1]<Fb1)                                   newSL_S=(Fb2+Fb1)/2;
   }
//+------------------------------------------------------------------+

Il serait approprié d'ajouter la fonction de calcul des niveaux de LevelFibo Fibonacci à chacune des deux fonctions de dépendance mentionnées. Cela a été fait dans les fichiers de démonstration ci-joints.

Maintenant, concernant la combinaison de deux fonctions ou plutôt l'activation de la fonction de calcul des niveaux LevelFibo() dans la fonction d'identification des niveaux Stop Loss focalisée sur ces niveaux. Cette combinaison est logique, car les fonctions fonctionnent ensemble. Par conséquent, le nombre d'appels de fonctions pendant la suivie sera réduit - il n'en restera qu'un au lieu de deux.

Après avoir été combinés, ils se présenteront comme suit :

//+----------------------------------------------------------------------+
//| Function (table) for specifying Stop Loss values for BUY position    |
//| by Fibo levels according to the lowest value of the first candle     |
//+----------------------------------------------------------------------+
   void StoplevelFiboBuy()
   {
   double Fb1,Fb2,Fb3,Fb4,Fb5,Fb6,Fb7,Fb8,Fb9,Fb10,Fb11,Fb12,Fb13;
   double Ma144_1 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,1);
   double Ma169_1 = iMA(NULL,0,169,0,MODE_EMA,PRICE_CLOSE,1);
   double MedVegas=NormalizeDouble((Ma144_1+Ma169_1)/2,Digits); 
   Fb1=MedVegas-377*Point;     Fb12=MedVegas+377*Point;
   Fb2=MedVegas-233*Point;     Fb11=MedVegas+233*Point;
   Fb3=MedVegas-144*Point;     Fb10=MedVegas+144*Point;
   Fb4=MedVegas-89*Point;      Fb9=MedVegas+89*Point;
   Fb5=MedVegas-55*Point;      Fb8=MedVegas+55*Point;
   Fb6=MedVegas-34*Point;      Fb7=MedVegas+34*Point;
   if(Low[1]>Fb12)                                newSL_B=Fb12-100*Point;
   if(Low[1]<=Fb12 && Low[1]>(Fb12+Fb11)/2)       newSL_B=(Fb12+Fb11)/2;
   if(Low[1]<=(Fb12+Fb11)/2 && Low[1]>Fb11)       newSL_B=Fb11;
   if(Low[1]<=Fb11 && Low[1]>(Fb11+Fb10)/2)       newSL_B=(Fb11+Fb10)/2;
   if(Low[1]<=(Fb10+Fb11)/2 && Low[1]>Fb10)       newSL_B=Fb10;
   if(Low[1]<=Fb10 && Low[1]>(Fb10+Fb9)/2)        newSL_B=Fb9;
   if(Low[1]<=(Fb10+Fb9)/2 && Low[1]>Fb9)         newSL_B=Fb8;
   if(Low[1]<=Fb9  && Low[1]>Fb8)                 newSL_B=Fb7;
   if(Low[1]<=Fb8  && Low[1]>Fb7)                 newSL_B=(Fb7+MedVegas)/2;
   if(Low[1]<=Fb7  && Low[1]>MedVegas)            newSL_B=Fb6;
   if(Low[1]<=MedVegas && Low[1]>(MedVegas+Fb6)/2)newSL_B=Fb6;
   if(Low[1]<=(MedVegas+Fb6)/2 && Low[1]>Fb6)     newSL_B=Fb5;
   if(Low[1]<=Fb6  && Low[1]>Fb5)                 newSL_B=Fb4;
   if(Low[1]<=Fb5  && Low[1]>Fb4)                 newSL_B=(Fb3+Fb4)/2;
   if(Low[1]<=Fb4  && Low[1]>Fb3)                 newSL_B=Fb3;
   if(Low[1]<=Fb3  && Low[1]>(Fb3+Fb2)/2)         newSL_B=(Fb3+Fb2)/2;
   if(Low[1]<=(Fb3+Fb2)/2  && Low[1]>Fb2)         newSL_B=Fb2;
   if(Low[1]<=Fb2  && Low[1]>(Fb2+Fb1)/2)         newSL_B=(Fb1+Fb2)/2;
   if(Low[1]<=(Fb2+Fb1)/2 && Low[1]>Fb1)          newSL_B=Fb1;
   if(Low[1]<=Fb1)                                newSL_B=Fb1-100*Point;
   }
// ----------------------------------------------------------------------+

Le code de commande principal des positions de suivi est représenté sous la forme d'un fragment Expert Advisor avec la séquence d'actions pour l'exécution des fonctions mentionnées ci-dessus en fonction du prix valeurs des barres courantes. Le suivi étape par étape commence après qu'un ordre ouvert approprié a été sélectionné.

Un petit fragment de code de fin est affiché ci-dessous :

//+------------------------------------------------------------------+
//| TRAILING OPEN POSITIONS                                          |
//+------------------------------------------------------------------+
for(int i=OrdersTotal()-1; i>=0; i--)
  {
   if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
     {Print("Order selection error = ",GetLastError());}
   if(OrderSymbol()==Symbol())
     {
      if(OrderType()==OP_BUY)
        {
         if(OrderMagicNumber()==Magic)
           {
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=SL_B*Point && OrderLots()==0.2)Close_B_lot();
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())/Point>=100 && OrderLots()==0.1 && OrderStopLoss()<OrderOpenPrice())
              {
               Print(" 1 - StopLoss shift");
               if(!OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+2*Point,OrderTakeProfit(),0,Aqua))
                 {
                  Print(" at Modif.ord.# ",OrderTicket()," Error # ",GetLastError());
                 }
               return;
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=120*Point && OrderOpenPrice()>Ma144_1-144*Point)
              {
               StoplevelFiboBuy();
               newSL_B=newSL_B+21*Point;
               if((Bid-newSL_B)/Point<StopLevel)newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print("2nd shift of StopLoss ");
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=200*Point && (High[1]-OrderOpenPrice())<=250*Point)
              {
               StoplevelFiboBuy();
               if((Bid-newSL_B)/Point<StopLevel)newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print(" 3rd shift by level order # ",OrderTicket());
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=250*Point && OrderOpenPrice()>Ma144_1-144*Point)
              {
               StoplevelFiboBuy();
               newSL_B=newSL_B+10*Point;
               if((Bid-newSL_B)/Point<StopLevel) newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print(" 4th shift by level order # ",OrderTicket());
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=300*Point && (High[1]-OrderOpenPrice())<=350*Point)
              {
               StoplevelFiboBuy();
               newSL_B=newSL_B+20*Point;
               if((Bid-newSL_B)/Point<StopLevel) newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print(" 5th shift by level order # ",OrderTicket());
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            ...
           }
        }
     }
  }

La séquence de suivi étape par étape se compose de 8 étapes dans la version ci-jointe de la démo Expert Advisor.

Ci-dessous se trouve la capture d'écran affichant les étapes de fonctionnement de la démo Expert Advisor pour le suivi du position acheter. La position a été ouverte du fait que « l'absorption de trois chandeliers» le modèle a été formé. D'ailleurs, le «marteau inversé» fait partie des chandeliers absorbés. Ce fait renforce la force du signal pour ouvrir une position d'achat.


Fig. 6. Exemple de suivi de position d'achat

L'indicateur «Vegas» doit être utilisé pour voir les lignes Fibo comme sur une capture d'écran claire. Il est visible sur le site MQL4 :https://www.mql5.com/fr/code/7148

La même petite capture d'écran étirée de l'écran «sombre»:

Fig. 7. Capture d'écran de l'écran du moniteur (version de démonstration pour Acheter)

Fig. 8. Exemple de suivi de position de vente

Des paramètres de test temporaires doivent être installés pour afficher le travail des Expert Advisors de démonstration, comme illustré à la Fig. 9-10 ci-dessous :


Fig. 9. Paramètres de test de Demo_trail_Buy.mql Expert Advisor


Fig. 10. Paramètres de test de Demo_trail_Sell.mql Expert Advisor

Remarque : Des fichiers avec des Experts Advisors de démonstration sont joints à l'article, en tant que mini-robots pour suivre les positions d'achat et de vente. Les positions sont ouvertes en double lot ici. Mais lorsque le Stop Loss est déplacé à un niveau d'équilibre, il y a confiance dans le mouvement futur des prix dans la bonne direction et il est possible d'ajouter une autre position.


Conclusion

Les exemples présentés d'ordres de suivis montrent que la méthode de déplacement des ordres Stop Loss axée sur les niveaux dynamiques de Fibo peut donner des résultats positifs. La méthode décrite peut être recommandée pour une utilisation pratique dans le commerce.

Niveaux dynamiques de Fibo identifiant les fonctions :

  • LevelFiboKgd.mq4
  • StopLevelFiboBuy.mq4
  • StopLevelFiboSell.mq4
  • Fichiers de démonstration :
  • Demo_trail_Buy_v1.mq4 - Fichier de démonstration pour acheter
  • Demo_trail_Sell_v1.mq4 - Fichier de démonstration pour vendre


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

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.
Aller à la discussion
Sur les méthodes d'analyse technique et de prévision du marché Sur les méthodes d'analyse technique et de prévision du marché
L'article démontre les capacités et le potentiel d'une méthode mathématique bien connue associée à une pensée visuelle et à des perspectives de marché « out of the box ». D'une part, il sert à attirer l'attention d'un large public car il peut amener les esprits créatifs à reconsidérer le paradigme de trading en tant que tel. Et d'autre part, il peut donner lieu à des développements alternatifs et à des implémentations de code de programme concernant un large éventail d'outils d'analyse et de prévision.
Technique de test (optimisation) et quelques critères de sélection des paramètres de l'Expert Advisor Technique de test (optimisation) et quelques critères de sélection des paramètres de l'Expert Advisor
Il n'y a aucun mal à trouver le Graal de l'épreuve, il est cependant bien plus difficile de s'en débarrasser. Cet article traite de la sélection des paramètres de fonctionnement de l'Expert Advisor avec un traitement de groupe automatisé des résultats d'optimisation et de test lors d'une utilisation maximale des capacités de performance du terminal et d'une charge minimale de l'utilisateur final.
Le MQL5 Cookbook : Ordres ОСО Le MQL5 Cookbook : Ordres ОСО
L’activité de trading de tout trader implique divers mécanismes et interrelations, y compris les relations entre les ordres. Cet article suggère une solution de traitement des ordres OCO. Les classes de bibliothèque standard sont largement impliquées, et de nouveaux types de données sont créés ici.
Étudier la classe CCanvas. Comment dessiner des objets transparents Étudier la classe CCanvas. Comment dessiner des objets transparents
Avez-vous besoin de plus que des graphiques maladroits de moyennes mobiles ? Voulez-vous dessiner quelque chose de plus beau qu'un simple rectangle rempli dans votre terminal ? Des graphiques attrayants peuvent être dessinés dans le terminal. Cela peut être implémenté via la classe CСanvas, qui est utilisée pour créer des graphiques personnalisés. Avec cette classe, vous pouvez implémenter la transparence, mélanger les couleurs et produire l'illusion de la transparence au moyen de superpositions et de mélanges de couleurs.