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.
« 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
| Calcul | Diviseur | Quand il vaut zéro |
|---|---|---|
| Taille de lot selon le risque | Distance du stop × valeur du point | Stop non défini, valeur du tick pas encore disponible |
| Conversion de points en argent | SYMBOL_TRADE_TICK_SIZE, SYMBOL_TRADE_TICK_VALUE | Propriétés lues avant la synchronisation du symbole |
| Stop ou objectif en multiple d’ATR | Valeur de l’ATR (dans un ratio) | Début d’historique, marché figé |
| Position du prix dans une bougie | Plus haut − plus bas | Bougie sans amplitude (doji parfait, marché fermé) |
| Oscillateur maison type %K | Plus haut − plus bas sur N périodes | Période sans mouvement |
Ratio de performance dans OnTester() | Perte brute, nombre de trades | Aucun trade, aucune perte |
| Moyenne d’une série | Nombre d’éléments | Tableau 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 :
- 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.
- 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.
- 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 renvoyantINIT_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.
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.
- Erreurs de compilation MQL5
- Invalid pointer access
- GetLastError et gestion des erreurs
- Codes de retour du serveur de trading
- 10004 Requote
- 10006 Requête rejetée
- 10013 Requête invalide
- 10014 Volume invalide
- 10015 Prix invalide
- 10016 Stops invalides
- 10017 Trading désactivé
- 10018 Marché fermé
- 10019 Fonds insuffisants
- 10021 Pas de cotations
- 10024 Trop de requêtes
- 10027 Trading automatique désactivé
- 10030 Mode de remplissage non supporté
- 4756 Échec d’envoi de la requête
- Array out of range
