Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

MQL5 · Codes d’erreur

Zero divide en MQL5 : éliminer la division par zéro d’un EA

L’erreur critique zero divide arrête l’EA, souvent dans le calcul du lot, d’un ratio ou d’un indicateur. Les divisions à risque et le code MQL5 pour les sécuriser.

Mis à jour le 23 octobre 2026Lecture : 6 minPar Alix, OptiBot Trading

« Zero divide » est l’erreur critique produite lorsqu’un programme MQL5 divise par zéro. La documentation la classe, avec le dépassement de tableau et le pointeur incorrect, parmi les erreurs qui terminent immédiatement l’exécution : l’EA ou l’indicateur s’arrête, et l’onglet Experts affiche un message de la forme zero divide in 'MonEA.mq5' (87,25), indiquant le fichier, la ligne et la colonne. En trading algorithmique, le coupable est presque toujours un calcul dont le diviseur dépend des données de marché : distance de stop, valeur du tick, ATR, amplitude d’une bougie. La prévention est simple et systématique : tester le diviseur avant chaque division dont il n’est pas garanti qu’il soit non nul.

Cette page recense les divisions à risque d’un EA, montre comment les sécuriser et comment retrouver la division fautive. Elle fait partie de la rubrique Codes d’erreur et de retour MQL5.

Pourquoi le diviseur vaut-il zéro ?

Dans un code de trading, un diviseur nul est rarement une faute de frappe. C’est une donnée qui, dans une situation particulière, prend une valeur que le développeur n’avait pas imaginée :

  • une propriété de symbole lue trop tôt, avant que le terminal ne l’ait reçue du serveur, et qui vaut encore 0 ;
  • un marché parfaitement plat pendant quelques bougies, où le plus haut égale le plus bas ;
  • un indicateur de volatilité qui renvoie 0 au début de l’historique ;
  • un compteur qui n’a pas encore été incrémenté, par exemple aucun trade perdant dans une statistique.

Ces situations sont rares, ce qui explique que l’EA fonctionne pendant des semaines avant de s’arrêter brutalement un jour de marché calme ou juste après un redémarrage.

Les divisions à risque dans un EA

CalculDiviseurQuand il vaut zéro
Taille de lot selon le risqueDistance du stop × valeur du pointStop non défini, valeur du tick pas encore disponible
Conversion de points en argentSYMBOL_TRADE_TICK_SIZE, SYMBOL_TRADE_TICK_VALUEPropriétés lues avant la synchronisation du symbole
Stop ou objectif en multiple d’ATRValeur de l’ATR (dans un ratio)Début d’historique, marché figé
Position du prix dans une bougiePlus haut − plus basBougie sans amplitude (doji parfait, marché fermé)
Oscillateur maison type %KPlus haut − plus bas sur N périodesPériode sans mouvement
Ratio de performance dans OnTester()Perte brute, nombre de tradesAucun trade, aucune perte
Moyenne d’une sérieNombre d’élémentsTableau vide

Le premier cas est le plus fréquent et le plus grave, parce qu’il survient au moment précis où l’EA s’apprête à ouvrir une position. Le calcul complet de la taille de lot est présenté dans Calculer et normaliser la taille de lot.

Sécuriser un calcul de lot

input double InpRiskPct = 1.0;   // risque par trade en % du capital

//+------------------------------------------------------------------+
//| Lot pour risquer InpRiskPct % sur une distance de stop (prix)    |
//| Renvoie 0.0 si le calcul est impossible : l'appelant s'abstient  |
//+------------------------------------------------------------------+
double LotsForRisk(const string symbol, const double stopDistance)
  {
   double tickSize  = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
   double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
   double equity    = AccountInfoDouble(ACCOUNT_EQUITY);

   // Garde-fous : aucun diviseur ne doit être nul ou négatif
   if(stopDistance <= 0.0 || tickSize <= 0.0 || tickValue <= 0.0)
     {
      PrintFormat("LotsForRisk impossible : stop=%.5f tickSize=%.5f tickValue=%.5f",
                  stopDistance, tickSize, tickValue);
      return 0.0;
     }

   double riskMoney   = equity * InpRiskPct / 100.0;
   double lossPerLot  = (stopDistance / tickSize) * tickValue;   // perte pour 1 lot
   if(lossPerLot <= 0.0)
      return 0.0;

   double lots = riskMoney / lossPerLot;
   if(!MathIsValidNumber(lots))       // filet de sécurité supplémentaire
      return 0.0;
   return lots;                       // à normaliser ensuite selon le pas de volume
  }

Chaque division est précédée d’un test explicite. La fonction renvoie 0 au lieu de deviner une valeur : c’est à l’appelant de décider qu’en l’absence de calcul fiable, on ne trade pas. Le volume obtenu doit encore être aligné sur le pas du symbole, comme expliqué dans 10014 Volume invalide.

Une fonction de division sûre

Pour les calculs d’indicateurs ou de statistiques, où un résultat neutre est acceptable, une petite fonction utilitaire évite de répéter les tests :

//+------------------------------------------------------------------+
//| Division protégée : renvoie fallback si le diviseur est ~0       |
//+------------------------------------------------------------------+
double SafeDiv(const double num, const double den, const double fallback = 0.0)
  {
   if(MathAbs(den) < 1e-12)
      return fallback;
   return num / den;
  }

// Position de la clôture dans la bougie (0 = au plus bas, 1 = au plus haut)
double ClosePosition(const MqlRates &bar)
  {
   return SafeDiv(bar.close - bar.low, bar.high - bar.low, 0.5);   // bougie plate : milieu
  }

// Ratio gains/pertes dans OnTester, sans plantage si aucune perte
double OnTester()
  {
   double profit = TesterStatistics(STAT_GROSS_PROFIT);
   double loss   = MathAbs(TesterStatistics(STAT_GROSS_LOSS));
   return SafeDiv(profit, loss, 0.0);    // aucune perte : critère neutre plutôt qu'un arrêt
  }

Le choix de la valeur de repli est une décision de conception, pas un détail. Pour la position dans une bougie plate, 0,5 est neutre. Pour un critère d’optimisation, renvoyer 0 en l’absence de pertes évite de récompenser des passes qui n’ont pris qu’un ou deux trades chanceux ; c’est un sujet développé dans OnTester : critère personnalisé.

Entiers et réels : deux pièges distincts

Une division entre deux entiers en MQL5 donne un entier : 7 / 2 vaut 3, et 1 / 3 vaut 0. Si ce résultat sert ensuite de diviseur, vous obtenez une division par zéro inattendue. Écrivez 1.0 / 3 pour forcer un calcul en réel.

Avec des nombres réels, un diviseur très petit mais non nul ne provoque pas d’arrêt, mais peut produire un résultat démesuré : un lot de plusieurs milliers d’unités parce que la distance de stop valait 0,00000001. C’est pourquoi les tests ci-dessus comparent à un seuil plutôt qu’à zéro strict lorsque cela a du sens, et pourquoi MathIsValidNumber() sert de dernier filet pour écarter les valeurs non numériques. La table des erreurs d’exécution mentionne d’ailleurs un code distinct, 4019 (ERR_MATH_OVERFLOW, « Overflow occurred when calculating math function »), qui concerne les débordements des fonctions mathématiques et non la division par zéro.

Passer son code en revue

Une recherche du caractère / dans vos fichiers sources est un exercice fastidieux mais très rentable. Pour chaque division trouvée, posez trois questions :

  1. D’où vient le diviseur ? Une constante écrite dans le code est sans risque ; une donnée de marché, une propriété du symbole, un paramètre d’entrée ou un compteur ne l’est pas.
  2. Peut-il valoir zéro, même rarement ? Pensez au premier tick après le lancement, aux week-ends, aux symboles exotiques, aux paramètres que l’optimiseur peut choisir. Un paramètre d’entrée de période ou de multiplicateur que l’utilisateur peut fixer à 0 est un diviseur potentiel.
  3. Que doit faire le programme dans ce cas ? S’abstenir de trader, renvoyer une valeur neutre, ou signaler une configuration invalide dès OnInit() en renvoyant INIT_PARAMETERS_INCORRECT.

Cette revue prend une heure sur un EA de taille moyenne et supprime une catégorie entière de pannes. Refaites-la après chaque ajout de fonctionnalité qui introduit de nouveaux calculs.

Retrouver la division fautive

Le message indique la ligne et la colonne : allez-y dans MetaEditor et identifiez le diviseur de l’expression. S’il s’agit d’une variable, remontez à l’endroit où elle est calculée et demandez-vous dans quelle situation de marché elle peut valoir zéro. Pour confirmer, rejouez la période concernée dans le testeur en mode visuel, ou ajoutez un PrintFormat() temporaire qui affiche le diviseur juste avant la division.

Testez aussi les situations limites volontairement : démarrage de l’EA sur un symbole qui vient d’être ajouté au Market Watch, backtest sur une période très calme, optimisation avec des paramètres extrêmes. Ce sont elles qui révèlent les diviseurs nuls.

Un EA arrêté par une division par zéro ne gère plus ses positions ouvertes. Le trading à effet de levier comporte un risque élevé de perte : protégez chaque position par un stop placé chez le courtier et surveillez l’onglet Experts en production.

Questions fréquentes

Peut-on attraper une division par zéro avec GetLastError ?

Non. La documentation indique que cette erreur termine immédiatement le programme. Il faut tester le diviseur avant d’effectuer la division.

Pourquoi l’erreur apparaît-elle seulement après un redémarrage ?

Des propriétés comme SYMBOL_TRADE_TICK_VALUE peuvent valoir zéro tant que le symbole n’est pas synchronisé. Un calcul de lot lancé au tout premier tick peut alors diviser par zéro. Testez ces valeurs et reportez le calcul si elles sont nulles.

Faut-il remplacer le diviseur nul par une petite valeur ?

Non : remplacer 0 par 0,0000001 transforme l’arrêt en un résultat absurde, par exemple un lot gigantesque. Il vaut mieux renvoyer une valeur neutre explicite ou renoncer à l’action.

Pourquoi 1 / 3 donne-t-il 0 dans mon code ?

Parce que la division de deux entiers produit un entier, sans partie décimale. Écrivez au moins un des opérandes sous forme réelle, par exemple 1.0 / 3, ou convertissez-le avec (double). Ce piège crée souvent des diviseurs nuls inattendus dans les calculs suivants.

Une division par zéro dans OnTester arrête-t-elle l’optimisation ?

Elle arrête la passe concernée, dont le résultat devient inexploitable. Protégez les ratios calculés dans OnTester(), notamment pour les passes sans trade ou sans perte.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.