Stratégie de trading Heads or Tails analyse du code du robot de trading.

La stratégie commerciale « Face ou pile » appartient à la catégorie des approches commerciales à court terme et à haut risque, utilisées principalement sur les marchés d’actions et du Forex. Son nom est lié au caractère aléatoire de la prise de décisions, similaire au lancer d'une pièce (« face » pour acheter un actif, « pile » pour le vendre ). Cette stratégie se fonde exclusivement sur des décisions intuitives ou des signaux aléatoires et ignore les facteurs fondamentaux d'analyse du marché.

Le code source de la stratégie commerciale a été ajouté dans la base de codes :

MetaTrader 5: https://www.mql5.com/fr/code/11637

#property copyright "Copyright 2025, Trading-Go." // Définir le droit d'auteur
#property link      "https://www.mql5.com/en/channels/tradingo-go-en"  // Lien vers la ressource du développeur
#property version   "26.010" // Version du programme

Ce bloc représente des directives compilateur pour un programme écrit comme un conseiller expert (Expert Advisor) ou un indicateur dans la plateforme MetaTrader en langage MQL4/MQL5.

Nous allons examiner chaque ligne séparément :

Cette instruction définit les droits légaux sur le code source de l'expert ou de l'indicateur. Elle indique le propriétaire des droits d’auteur et permet de marquer l'appartenance du produit à une organisation spécifique (« Trading-Go »). Cette information sera affichée dans la fenêtre des propriétés de l'expert/indicateur dans le terminal client MetaTrader.

Cette ligne permet de définir un lien vers une ressource Web associée au développeur. Quand les traders utilisent cet expert ou indicateur, ce lien sera disponible dans ses propriétés. Ceci est utile aux développeurs car cela leur permet de rediriger les utilisateurs vers des pages de support, de documentation ou des communautés reliées au produit.

Ici, nous fixons la version du logiciel. Les développeurs indiquent généralement la version sous la forme « XX.XX », où le premier chiffre représente la version principale, le deuxième la version mineure et le troisième le niveau de correction. La version aide les utilisateurs à suivre facilement les mises à jour et maintenir la compatibilité entre les outils.

#include 

 // Inclure la bibliothèque Trade.mqh
CTrade        trade; // Objet de classe CTrade pour gérer les opérations de trading

#include 

 // Inclure la bibliothèque PositionInfo.mqh
CPositionInfo posit; // Objet de classe CPositionInfo pour traiter les positions

Cette partie inclut des bibliothèques et crée des objets qui permettent de gérer les opérations de trading et de traiter les positions dans la plateforme MetaTrader.

Examinons chaque composant individuellement :

Cette directive inclut le fichier d'en-tête (Trade.mqh) contenant la définition de la classe CTrade. Ce fichier est situé dans le répertoire /Trade, ce qui signifie qu'il fait partie de la bibliothèque standard des opérations de trading fournie par MetaTrader. La classe CTrade est utilisée pour interagir commodément avec le trading, y compris l'ouverture de positions, la fermeture de transactions, la modification des ordres et la récupération d'informations sur les transactions en cours.

Un objet nommé « trade » de la classe CTrade est créé. Grâce à cet objet, vous pouvez contrôler tous les aspects du trading, tels que l'ouverture de nouvelles positions, la fixation des stops-losses et des take-profits, la fermeture des positions existantes et bien plus encore.

Une autre directive inclut un autre fichier d'en-tête (PositionInfo.mqh) situé dans le même répertoire (/Trade). Ce fichier contient la définition de la classe CPositionInfo, destinée à traiter les informations relatives aux positions actuellement ouvertes sur le compte. Par cette classe, il est possible d'extraire des données précises concernant chaque position ouverte, telles que le volume de la transaction, le prix d'entrée, le profit ou la perte, etc.

Un objet nommé « posit » de la classe CPositionInfo est créé. En utilisant cet objet, vous pouvez obtenir des informations complètes sur toutes les positions actives de votre compte de trading, ce qui est utile pour analyser l'état actuel de votre portefeuille et prendre des décisions basées sur ces informations.

But général :

Ces deux bibliothèques constituent la base nécessaire pour automatiser le processus de trading grâce à une interface programmation d'application (API) de haut niveau. Elles permettent aux développeurs de se concentrer directement sur la logique de la stratégie plutôt que sur les aspects techniques de communication avec le serveur du courtier.

input double  iLots         = 0.10; // Paramètre d'entrée pour la taille du lot (volume de la transaction)
input int     iTakeProfit   = 450;  // Paramètre d'entrée pour le niveau de fixation des gains (Take Profit)
input int     iStopLoss     = 390;  // Paramètre d'entrée pour le niveau limite des pertes (Stop Loss)
input int     iMagicNumber  = 227; // Paramètre d'entrée pour le numéro unique de la transaction (Magic Number)
input int     iSlippage     = 30; // Paramètre d'entrée pour la tolérance maximale de glissement des prix

string sy = ""; // Variable pour stocker le symbole de l'instrument financier
double pt = 0; // Variable pour calculer l'étape de changement du point
int    dt = 0; // Variable pour compter le nombre de chiffres après la virgule

Chaque élément du bloc de code ci-dessus sert à configurer l'environnement de trading et prépare la scène pour l'automate Expert Advisor (EA) dans la plateforme MetaTrader. Voyons chacun de ces éléments en détail :

Paramètres d'entrée :

C'est un paramètre de type double qui définit la taille du lot (volume de la transaction). Sa valeur par défaut est de 0.10. La taille du lot régit le nombre d'actifs achetés ou vendus lors d'un commerce unique. Par exemple, si l'instrument est EURUSD, alors un lot de 0.1 correspond à 10 000 unités de monnaie de base (comme l'euro).

Un paramètre entier qui définit le niveau de fixation des gains (Take Profit). Valeur par défaut : 450. Le Take Profit ferme automatiquement la position quand le prix du marché atteint le niveau de profit spécifié par rapport au prix d'entrée dans la transaction. Le niveau est exprimé en points (pips).

Un paramètre entier qui définit le niveau limite des pertes (Stop Loss). Valeur par défaut : 390. Le Stop Loss ferme automatiquement la position si le marché bouge contre votre position et que les pertes atteignent le niveau prédéterminé. Les pertes sont également mesurées en points.

Un paramètre entier servant de numéro unique d'identification (Magic Number) pour les transactions. Chaque événement (ouverture de position, fermeture, etc.) reçoit un numéro unique qui permet de filtrer les transactions par ce critère. La valeur par défaut est 227.

Un paramètre entier qui limite la différence maximale permise entre le prix de l'ordre et le prix exécuté. Si le prix réel diffère trop fortement du prix attendu, la transaction ne sera pas effectuée. La valeur par défaut est de 30 points. Cela protège contre des variations excessives des prix.

Variables locales :

Variable de type chaîne de caractères qui stocke le symbole de l'instrument financier (exemple : "EURUSD") utilisé dans le trading. À l'origine vide.

Variable de type double utilisée pour calculer la taille du point (unité de variation du prix). Valeur initiale : 0.

Variable de type entier destinée à compter le nombre de chiffres après la virgule dans les cotations de l'instrument choisi. Nombre de décimales important pour calculer précisément le profit et le stop-loss, ainsi que d'autres métriques. Valeur initiale : 0.

Cette section initialise les paramètres initiaux et prépare l'environnement pour l'automate Expert Advisor dans MetaTrader. Les paramètres d'entrée offrent une flexibilité pour adapter le comportement de l'EA avant le début du trading.

   sy = _Symbol; // Récupérer le symbole courant de l'instrument de trading
   pt = _Point; // Récupérer la taille minimale d'unité de changement
   dt = _Digits; // Récupérer le nombre de chiffres après la virgule dans le prix

   trade.SetExpertMagicNumber(iMagicNumber); // Définir le numéro unique de la transaction

   trade.SetDeviationInPoints(iSlippage); // Définir la tolérance maximale de différence de prix

   trade.SetTypeFillingBySymbol(sy); // Définir le type d'exécution des ordres conformément aux paramètres de l'instrument

   trade.SetMarginMode(); // Définir le mode de marge

Cette section montre les étapes d'initialisation essentielles pour assurer le bon fonctionnement d’un Expert Advisor (EA) dans la plateforme MetaTrader. Nous examinerons chaque commande en détail :

Configuration des variables d'environnement :

Attribue à la variable globale sy le nom de l'instrument financier actuellement traité. _Symbol est une constante intégrée qui retourne le nom de l'actif sélectionné dans le terminal. Cela donne accès au nom de l'instrument nécessaire pour les calculs ultérieurs et le travail avec lui.

Définit la variable pt comme la taille minimale de changement du prix de l'instrument (_Point). Il s'agit d'une unité de base pour mesurer les variations de prix, indispensable pour interpréter correctement les signaux du système et corriger les ordres.

Stocke dans la variable dt le nombre de chiffres après la virgule pour les cotations de l'instrument actuel. Étant donné que différents instruments peuvent avoir un nombre différent de chiffres après la virgule (par exemple, USDJPY a deux chiffres, EURUSD en a quatre), cette variable est importante pour arrondir correctement les valeurs et effectuer des calculs précis.

Configuration de l'objet de trading :

Définit un numéro unique (Magic Number) pour toutes les transactions effectuées par cet EA. Le Magic Number identifie les transactions réalisées par un EA particulier et facilite le filtrage des positions par ce critère. Un numéro unique garantit l'absence de confusion entre diverses stratégies robotisées.

Limite la différence maximale autorisée entre le prix d'exécution de l'ordre et le prix souhaité. Une valeur fixée empêche l'exécution des transactions si le prix réel diffère trop fortement. Cela protège contre des glissements de prix excessifs.

Configure le type d'exécution des ordres en fonction des caractéristiques propres à l'instrument. Certains instruments nécessitent une exécution immédiate (« Market Execution »), tandis que d'autres acceptent une exécution différée (« Instant Execution »). Cette commande choisit automatiquement le mode approprié en fonction des spécifications de l'instrument.

Configure le mode de marge. La gestion des marges varie en fonction de l'instrument et du mode de trading. Une configuration adéquate affecte le montant de capitaux libres nécessaires pour maintenir une position et minimise le risque de clôture forcée de la position en raison d'un manque de capitaux.

   double stepvol = SymbolInfoDouble(sy, SYMBOL_VOLUME_STEP); // Récupérer l'étape de changement de la taille du lot pour le symbole sélectionné
   if(stepvol > 0.0) // Si l'étape de changement de la taille du lot est positive, appliquer le calcul de la taille du lot corrigée
      lt = stepvol * (MathFloor(iLots / stepvol) - 1); // Arrondi vers le bas de la taille du lot à la valeur de l'étape et diminution d'une étape
//---
   double minvol = SymbolInfoDouble(sy, SYMBOL_VOLUME_MIN); // Récupérer la taille minimale autorisée du lot pour le symbole spécifié
   if(lt < minvol) // Si la taille du lot corrigée est inférieure à la valeur minimale possible, remettre à zéro
      lt = 0.0;

   ::MathSrand(GetTickCount()); // Générer un nombre initial pour le générateur aléatoire

Le bloc de code présenté ici met en œuvre une régulation dynamique du volume des transactions (lots) dans le cadre d'un instrument financier donné (devise, action, contrat, etc.). Le but principal est de régler la taille du lot conformément aux règles imposées par l’échange tout en évitant les erreurs lors de l'ouverture de positions et en assurant la sécurité des transactions.

Voyons chacune des étapes en détail :

Étape 1 : Détermination de l'étape de changement de la taille du lot :

La commande SymbolInfoDouble() récupère l'étape de changement de la taille du lot pour le symbole sélectionné (SYMBOL_VOLUME_STEP). Cette étape définit l'intervalle minimal de changement de la taille du lot. Par exemple, certains instruments ont un pas de 0,01, ce qui signifie que les transactions doivent être effectuées par multiples de centièmes de lots.

Étape 2 : Vérifier la positivité de l'étape :

Vérifie si l'étape de changement est strictement positive. Si elle est nulle ou négative, les calculs suivants seraient inutiles.

Étape 3 : Arrondi et diminution de la taille du lot d'une étape :

L'algorithme diminue la taille du lot saisie par l'utilisateur (iLots) d'une étape entière.

Voici comment ça fonctionne intérieurement :

Étape 4 : Récupération de la taille minimale du lot :

Commande SymbolInfoDouble() qui récupère la taille minimale autorisée du lot pour le symbole donné (SYMBOL_VOLUME_MIN). L'échange peut limiter les tailles minimales de lots, rendant impossible toute transaction en dessous de cette valeur.

Étape 5 : Vérification de la limite minimale :

Si la taille de lot corrigée est inférieure à la taille minimale autorisée par l'échange, la taille de lot est réinitialisée à zéro pour éviter les violations.

Étape 6 : Génération du nombre initial pour le générateur aléatoire :

Initialise le générateur de nombres aléatoires avec le nombre de tic actuel fourni par GetTickCount(). Cela améliore la fiabilité des résultats aléatoires.

   int total = ::PositionsTotal(), b = 0, s = 0; // Compter le nombre total de positions ouvertes et les compteurs d'achat/vente

   double Bid = ::SymbolInfoDouble(sy, SYMBOL_BID); // Prix actuel de vente (prix BID)
   double Ask = ::SymbolInfoDouble(sy, SYMBOL_ASK); // Prix actuel d'achat (prix ASK)

   double new_sl = 0, new_tp = 0, old_sl = 0, old_tp = 0; // Nouveaux et anciens niveaux de stop-loss et take-profit

   if(Bid <= 0 || Ask <= 0) // Si les prix sont erronés
      return; // Sortie anticipée de la fonction

Ce bloc de code effectue plusieurs actions préliminaires avant d'exécuter la logique supplémentaire de trading dans l'Expert Advisor (EA) de la plateforme MetaTrader. Voici une analyse détaillée de chaque action :

Étape 1 : Compte total des positions ouvertes :

Récupère le nombre total de positions ouvertes sur le compte indépendamment de la direction et de l'instrument. Ces données sont importantes pour une analyse ultérieure et une optimisation potentielle des positions.

Étape 2 : Initialisation des compteurs d'achat et de vente :

Les variables b et s sont initialisées respectivement comme compteurs d'achat et de vente. Ils sont initialement mis à zéro et augmentent lors de l'analyse des positions.

Étape 3 : Récupération des prix actuels du marché :

Prix de vente (BID) :

Demande le prix de vente actuel (BID) pour l'instrument courant (sy). Le prix BID reflète le meilleur prix du marché auquel un trader peut vendre l'instrument immédiatement.

Prix d'achat (ASK) :

Similairement, demande le prix d'achat actuel (ASK) pour le même instrument. Le prix ASK montre le meilleur prix auquel il est possible d'acheter l'instrument immédiatement.

Étape 4 : Décision des niveaux de stop-loss et take-profit :

Prépare les variables pour les niveaux de stop-loss et take-profit (anciens et nouveaux). Zéro signifie l'absence de niveaux pour le moment.

Étape 5 : Sécurité et validation des prix :

Effectue une vérification rapide de la validité des prix. Si le prix BID ou ASK est nul ou négatif, la fonction sort prématurément pour éviter des opérations erronées.

 for(int i = 0; i < total; i++) // Boucle sur les positions ouvertes
      if(posit.SelectByIndex(i)) // Sélectionner la position par son indice
         if(posit.Symbol() == sy) // Vérifier l'instrument de la position
            if(posit.Magic() == iMagicNumber) // Vérifier le numéro unique de la position
              {

               old_sl = ::NormalizeDouble(posit.StopLoss(),   dt); // Conversion de l'ancien stop-loss en précision requise
               old_tp = ::NormalizeDouble(posit.TakeProfit(), dt); // Conversion de l'ancien take-profit en précision requise

               if(posit.PositionType() == POSITION_TYPE_BUY) // Si la position est une achat (BUY)
                 {
                  new_sl = ::NormalizeDouble(Ask - iStopLoss   * pt, dt); // Nouveau stop-loss sous le prix actuel d'achat
                  new_tp = ::NormalizeDouble(Ask + iTakeProfit * pt, dt); // Nouveau take-profit au-dessus du prix actuel d'achat
                  b++;                                                 // Incrémenter le compteur d'achat
                 }

               if(posit.PositionType() == POSITION_TYPE_SELL) // Si la position est une vente (SELL)
                 {
                  new_sl = ::NormalizeDouble(Bid + iStopLoss   * pt, dt); // Nouveau stop-loss au-dessus du prix actuel de vente
                  new_tp = ::NormalizeDouble(Bid - iTakeProfit * pt, dt); // Nouveau take-profit sous le prix actuel de vente
                  s++; // Incrémenter le compteur de vente
                 }

               if(old_sl == 0 || old_tp == 0) // Si les niveaux sont différents des anciens
                  trade.PositionModify(posit.Ticket(), new_sl, new_tp);// Modifier la position avec les nouveaux niveaux de SL et TP
              }

Ce bloc de code illustre la procédure de passage en revue des positions ouvertes sur le compte et la mise à jour des niveaux de stop-loss (SL) et take-profit (TP) pour les positions concernées. Examinons chaque opération en détail :

Passage en revue des positions ouvertes :

Parcourt séquentiellement toutes les positions ouvertes stockées interne­ment.

Sélection de la position :

Tente de sélectionner une position par son indice dans la liste. Seulement les positions récupérées avec succès continuent dans le processus.

Validation de l'instrument et de l'identificateur :

Assure que la position récupérée correspond bien à l'instrument visé (sy) et possède le numéro unique attendu (Magic Number).

Mise à jour des niveaux stop-loss et take-profit :

Pour les positions d'achat (BUY) :

Met à jour les niveaux SL et TP pour les positions d'achat.

Pour les positions de vente (SELL) :

Met à jour les niveaux SL et TP pour les positions de vente.

Application des modifications :

Modifie les niveaux stop-loss et take-profit si les nouveaux niveaux diffèrent des anciens.

   if((b + s) == 0) // Si aucune position active n'existe
      if(::MathRand() % 2 == 0) // Choix aléatoire de la direction d'ouverture de la position
        {
         if(trade.CheckVolume(sy, lt, Ask, ORDER_TYPE_BUY)) // Vérification de la disponibilité des fonds pour l'opération de trading
            if(trade.Buy(lt)) // Ouverture d'une position longue (BUY)
               return; // Fin de l'exécution de la fonction
        }
      else
         if(trade.CheckVolume(sy, lt, Bid, ORDER_TYPE_SELL)) // Vérification de la disponibilité des fonds pour l'opération de trading
            if(trade.Sell(lt)) // Ouverture d'une position courte (SELL)
               return; // Fin de l'exécution de la fonction

Ce bloc de code décrit le processus d'ouverture aléatoire soit d'une position longue (BUY), soit d'une position courte (SELL) lorsqu’il n’y a aucune position active sur le compte. Examinons chaque étape en détail :

Vérification des positions actives :

Vérifie si aucune position active existe sur le compte. Si aucune position n’est trouvée, le processus continue avec l'ouverture d'une nouvelle position.

Choix aléatoire de la direction :

Utilise la fonction MathRand() modulée par 2 pour choisir aléatoirement entre l'ouverture d'une position longue (BUY) ou courte (SELL).

Ouverture de la position longue (BUY) :

Vérifie la disponibilité des fonds nécessaires pour effectuer la transaction demandée. Si les fonds sont suffisants, la position longue est ouverte.

Ouverture de la position courte (SELL) :

Procède de manière analogue pour l'ouverture d'une position courte. Après vérification des fonds disponibles, la position courte est ouverte si possible.

Fin de l'exécution :

Termine l'exécution de la fonction une fois la position ouverte avec succès.

void OnDeinit(const int reason) // Fonction de désinitialisation
  {

  }

La fonction OnDeinit reste vide si aucune tâche de nettoyage spécifique n'est nécessaire. Cependant, même si elle est vide, elle rappelle aux développeurs la possibilité d'y implémenter des actions de nettoyage si besoin.