MQL5 · Bases du langage
NormalizeDouble en MQL5 : arrondir et comparer les prix correctement
Normaliser les prix, les stops et les volumes avant de les envoyer au serveur : fonctionnement exact de NormalizeDouble, pas de cotation, pas de volume et comparaison fiable de deux prix.
NormalizeDouble(valeur, chiffres) arrondit un nombre réel au nombre de décimales indiqué, de 0 à 8. Sa signature documentée est double NormalizeDouble(double value, int digits). En trading, elle sert surtout à préparer les prix envoyés au serveur : la documentation précise que les niveaux de stop loss, de take profit et les prix d’ouverture des ordres en attente doivent être normalisés à la précision renvoyée par Digits(), c’est-à-dire _Digits. Deux limites sont à connaître. D’abord, le résultat reste un double binaire et peut s’afficher avec des décimales parasites. Ensuite, arrondir au nombre de décimales ne suffit pas toujours : sur certains instruments, le prix doit aussi être un multiple du pas de cotation (SYMBOL_TRADE_TICK_SIZE).
Cette page fait partie de la rubrique Les bases du langage MQL5. La nature des nombres réels est présentée dans Types de données en MQL5.
Pourquoi normaliser un prix
Un double est une approximation binaire d’un nombre décimal. Un calcul aussi simple que ask - 300 * _Point produit généralement un nombre dont les dernières décimales binaires ne correspondent pas exactement au prix « rond » attendu. Le serveur de trading, lui, attend un prix conforme à la précision du symbole. Envoyer un prix non normalisé peut entraîner un refus de la requête, avec des codes comme 10015 Prix invalide ou 10016 Stops invalides.
La normalisation intervient donc à la dernière étape, juste avant de remplir la requête : on calcule le prix avec toute la précision disponible, puis on l’arrondit.
Ce que fait exactement NormalizeDouble
La fonction arrondit au nombre de décimales demandé. La documentation donne l’exemple de pi : NormalizeDouble(M_PI, 3) renvoie une valeur qui s’affiche 3.1419999999999999, et non 3.142. Ce n’est pas un bug : la valeur arrondie est la meilleure approximation binaire de 3,142, mais elle ne peut pas être représentée exactement. La documentation cite un autre exemple : un nombre normalisé à 76,671 peut s’afficher 76.67100000000001 avec Print(), alors que DoubleToString(a, 8) donne 76.67100000.
Conséquence pratique : NormalizeDouble ne sert pas à l’affichage. Pour afficher un prix, utilisez DoubleToString(prix, _Digits) ou PrintFormat("%.*f", _Digits, prix). Réservez NormalizeDouble() aux valeurs que vous envoyez au serveur ou que vous comparez.
Le paramètre digits doit être compris entre 0 et 8. Pour un prix, utilisez toujours _Digits (ou SymbolInfoInteger(symbole, SYMBOL_DIGITS) pour un autre symbole que celui du graphique), jamais une valeur codée en dur comme 5 : le même EA peut tourner sur EURUSD (5 décimales), USDJPY (3 décimales) ou un indice (0 à 2 décimales).
Le pas de cotation : arrondir au tick
Sur la plupart des paires de devises, le pas de cotation est égal au point : arrondir à _Digits décimales suffit. Mais certains instruments (indices, contrats à terme, métaux chez certains courtiers) ne cotent que par incréments plus grands que le point. Un indice coté avec deux décimales peut par exemple n’accepter que des prix multiples de 0,25 ou de 0,5. Dans ce cas, un prix comme 18 250,13 est correctement arrondi à deux décimales, mais il n’est pas un prix valide.
La propriété SYMBOL_TRADE_TICK_SIZE, lue avec SymbolInfoDouble(), donne ce pas minimal de variation du prix. L’arrondi au pas de cotation se fait en divisant le prix par le pas, en arrondissant à l’entier le plus proche avec MathRound(), puis en remultipliant ; un NormalizeDouble() final à _Digits élimine les résidus binaires. C’est ce que fait la fonction NormaliserPrix() de l’exemple ci-dessous. La lecture des propriétés d’un symbole est détaillée dans SymbolInfoDouble, SymbolInfoInteger.
Normaliser un volume
Les volumes obéissent à une logique comparable, mais avec d’autres propriétés : SYMBOL_VOLUME_MIN (lot minimal), SYMBOL_VOLUME_MAX (lot maximal) et SYMBOL_VOLUME_STEP (pas de volume). Un lot calculé selon le risque, par exemple 0,137, doit être ramené à un multiple du pas, puis borné entre le minimum et le maximum. Pour un volume, on arrondit généralement vers le bas avec MathFloor(), afin de ne jamais dépasser le risque prévu. Un volume non conforme provoque l’erreur 10014 (volume invalide). Le calcul complet est traité dans Calculer et normaliser la taille de lot.
Comparer deux prix
La documentation des types réels déconseille fortement de comparer deux double avec ==. Elle propose deux méthodes :
- vérifier que l’écart absolu est inférieur à une tolérance, qui ne peut pas être inférieure à
DBL_EPSILON; - normaliser la différence et la comparer à zéro :
NormalizeDouble(a - b, 8) == 0.
En trading, la tolérance naturelle est une fraction du point : deux prix sont considérés égaux si leur écart est inférieur à un demi-point. C’est la méthode utilisée par la fonction PrixEgaux() de l’exemple. Elle est utile, par exemple, pour éviter d’envoyer une modification de stop loss identique au stop existant, ce que le serveur refuse.
Exemple complet : normaliser prix, stops et volume
//+------------------------------------------------------------------+
//| Script : normalisation des prix, des stops et du volume |
//+------------------------------------------------------------------+
#property script_show_inputs
input int InpStopPts = 250; // Stop loss (points)
input int InpTpPts = 500; // Take profit (points)
input double InpLotBrut = 0.137; // Lot calcule (avant normalisation)
//--- Arrondit un prix au pas de cotation du symbole, puis a _Digits decimales
double NormaliserPrix(double prix)
{
double tick = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
if(tick > 0.0)
prix = MathRound(prix / tick) * tick;
return(NormalizeDouble(prix, _Digits));
}
//--- Ramene un volume au pas autorise, borne par le minimum et le maximum
double NormaliserVolume(double lot)
{
double vMin = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
double vMax = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
double vStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
if(vStep <= 0.0)
return(0.0);
lot = MathFloor(lot / vStep) * vStep; // arrondi vers le bas : risque non depasse
if(lot < vMin)
return(0.0); // trop petit : pas de trade
lot = MathMin(lot, vMax);
return(NormalizeDouble(lot, 8)); // supprime les residus binaires
}
//--- Compare deux prix avec une tolerance d'un demi-point
bool PrixEgaux(double a, double b)
{
return(MathAbs(a - b) < _Point / 2.0);
}
void OnStart()
{
MqlTick tick;
if(!SymbolInfoTick(_Symbol, tick))
{
Print("Prix indisponibles, erreur ", GetLastError());
return;
}
// Achat : entree a l'ask, stop sous l'ask, objectif au-dessus
double sl = NormaliserPrix(tick.ask - InpStopPts * _Point);
double tp = NormaliserPrix(tick.ask + InpTpPts * _Point);
double lot = NormaliserVolume(InpLotBrut);
PrintFormat("Ask %s | SL %s | TP %s | lot %.2f (brut %.3f)",
DoubleToString(tick.ask, _Digits), DoubleToString(sl, _Digits),
DoubleToString(tp, _Digits), lot, InpLotBrut);
// Illustration de l'affichage d'un double normalise
double n = NormalizeDouble(M_PI, 3);
Print("Print brut : ", n, " | DoubleToString : ", DoubleToString(n, 3));
// Comparaison avec tolerance plutot qu'avec ==
double slActuel = sl + 0.1 * _Point; // simule un ecart infime
Print("Stop a modifier ? ", PrixEgaux(sl, slActuel) ? "non (identique)" : "oui");
}
Exécutez ce script sur une paire de devises puis sur un indice : vous verrez que l’arrondi au pas de cotation modifie parfois le stop calculé, alors que l’arrondi au nombre de décimales seul l’aurait laissé tel quel.
Où placer la normalisation dans un EA
Dans un robot structuré, la normalisation se concentre en un seul endroit : une fonction utilitaire appelée juste avant chaque envoi ou modification d’ordre. Cette organisation présente trois avantages. Le reste du code calcule librement en pleine précision, sans se soucier des arrondis. Toute correction (par exemple l’ajout de l’arrondi au pas de cotation après un passage sur un nouvel instrument) se fait une seule fois. Enfin, la fonction peut journaliser le prix brut et le prix normalisé, ce qui facilite le diagnostic d’un refus du serveur.
Si vous utilisez la classe CTrade de la bibliothèque standard, la même règle s’applique : normalisez vos prix et vos volumes avant de les transmettre à ses méthodes, pour garder la maîtrise des valeurs réellement envoyées.
Pièges fréquents
- Décimales codées en dur :
NormalizeDouble(prix, 5)donne un prix faux sur un symbole à 3 ou 2 décimales. Utilisez_Digits. - Normaliser trop tôt : arrondir des valeurs intermédiaires accumule les erreurs. Normalisez le résultat final.
- Oublier le pas de cotation : sur les indices et certains contrats, un prix arrondi à
_Digitspeut rester invalide. - Utiliser NormalizeDouble pour afficher : l’affichage peut montrer des décimales parasites. Utilisez
DoubleToString(). - Comparer avec == : même après normalisation des deux côtés, préférez une tolérance.
- Arrondir un volume vers le haut : le risque réel dépasse alors le risque prévu. Arrondissez vers le bas et vérifiez le minimum.
La notion de point et de pip, souvent source de confusion dans ces calculs, est abordée dans Calculer la taille de position.
FAQ
Pourquoi NormalizeDouble affiche-t-il encore beaucoup de décimales ?
Parce que le résultat reste un double, c’est-à-dire une approximation binaire. La valeur est correctement arrondie, mais Print() peut en afficher la représentation complète. Pour l’affichage, utilisez DoubleToString(valeur, _Digits).
Faut-il normaliser le stop loss et le take profit ?
Oui. La documentation indique que les niveaux de stop loss, de take profit et les prix des ordres en attente doivent être normalisés à la précision renvoyée par Digits(). Sur les instruments dont le pas de cotation dépasse le point, arrondissez aussi au multiple de SYMBOL_TRADE_TICK_SIZE.
Combien de décimales NormalizeDouble accepte-t-elle ?
De 0 à 8, selon la documentation. Pour un prix, passez toujours _Digits ou la valeur SYMBOL_DIGITS du symbole concerné.
Comment comparer deux prix en MQL5 ?
Évitez l’égalité stricte. Testez si l’écart absolu est inférieur à une tolérance, par exemple un demi-point, ou utilisez NormalizeDouble(a – b, 8) == 0 comme le suggère la documentation.
- Types de données en MQL5
- Variables, constantes et portée
- Paramètres input et sinput
- Opérateurs et expressions
- Conditions if, else et switch
- Boucles for, while et do while
- Écrire ses propres fonctions
- Tableaux statiques et dynamiques
- ArraySetAsSeries et indexation des séries
- Manipuler les chaînes de caractères
- Dates, heures et fuseaux
- Structures (struct) et MqlRates, MqlTick
- Énumérations (enum) personnalisées
- #include, #define et #property
- Les fonctions événementielles
- Print, Comment, Alert : déboguer avec le journal
- SymbolInfoDouble, SymbolInfoInteger
- AccountInfoDouble : lire les informations du compte
- Bien utiliser MetaEditor
