Travailler avec des nombres décimaux en programmation peut sembler simple… jusqu’au moment où vous obtenez des résultats inattendus. Des opérations comme 0.1 + 0.2 qui donnent 0.30000000000000004 sont courantes. Comprendre pourquoi cela se produit et comment gérer les décimales correctement est essentiel pour écrire du code fiable.

1. Pourquoi les nombres décimaux posent problème

Les nombres décimaux (float, double) sont stockés en binaire, et certaines fractions décimales simples (0.1, 0.2) ne peuvent pas être représentées exactement.

Exemple en Python :

print(0.1 + 0.2) 
# Affiche : 0.30000000000000004

Ce n’est pas un bug du langage, mais une limitation de la représentation binaire.

2. Les conséquences

Comparaisons incorrectes : 0.1 + 0.2 == 0.3 peut renvoyer False.

Calculs financiers imprécis : les erreurs s’accumulent si vous utilisez des floats pour l’argent.

Résultats inattendus dans les statistiques ou les algorithmes scientifiques.

3. Comment manipuler les décimales correctement
3.1 Utiliser des types précis

Python : decimal.Decimal

Java : BigDecimal

C# : decimal

Exemple en Python :

from decimal import Decimal

a = Decimal('0.1')
b = Decimal('0.2')
print(a + b)  # Affiche exactement 0.3

Ces types sont plus lents mais garantissent une précision totale.

3.2 Arrondir au besoin

Pour des affichages ou des comparaisons simples :

x = 0.1 + 0.2
x = round(x, 2)
print(x)  # Affiche 0.3

Cela réduit les petites erreurs liées aux floats.

3.3 Comparer avec une tolérance

Plutôt que de vérifier l’égalité directe :

import math

math.isclose(0.1 + 0.2, 0.3)  # True

Vous définissez une marge d’erreur (epsilon) pour tenir compte des imprécisions.

3.4 Éviter les floats pour les valeurs exactes

Pour compter des objets ou manipuler de l’argent : utilisez des entiers ou des types précis (decimal), plutôt que des floats.

4. Bonnes pratiques

Connaître le type et sa précision.

Ne jamais comparer directement deux floats pour l’égalité.

Utiliser des types précis pour l’argent ou des calculs exacts.

Arrondir ou comparer avec tolérance pour les floats.