deux nombres qui semblent égaux mais en fait non

Bonjour à tous.

J'utilise Python pour écrire des scripts dans un logiciel de géomodélisation.
Dans un de mes scripts, j'utilise une boucle while qui modifie un nombre b jusqu'à ce que celui-ci devienne entier.
Pour ça, j'utilise le test while b != math.floor(b)
Mais à ma grande surprise la boucle continue de tourner même une fois que b est devenu entier.
Mon incomprehension est encore plus grande lorsque j'ajoute à la fin de ma boucle : print b
print math.floor(b)
print b-math.floor(b)
En effet, il s'affiche alors des résultats étonnants comme
2.0
2.0
2.6645352591e-015
En gros, 2.0-2.0 = 2.6645352591e-015.
J'ai d'abord pensé à un pb de type mais b et sa partie entière sont bien tous deux des float.

Merci de m'expliquer ce qui se passe, et comment je puis faire pour que ma boucle s'arrête dès que b soit entier.

Question de représentation: voir wikipython.flibuste.net

Code:

---

1 2 3

>>> a=math.floor(2) >>> 2-a 0.0

---

No problemo

Code:

---

1 2	>>> cmp(2,a) 0 # les objets sont identiques

---

No problemo

Code:

---

1 2	>>> 2.0-a 0.0

---

No problemo

Code:

---

1 2 3 4 5 6

>>> print 2.0-a 0.0 >>> print 2-a 0.0 >>> print cmp(2, a) 0

---

No problemo

En conclusion le problème vient d'ailleurs, peux tu nous donner le code de ta boucle?

C'est un problème classique d'erreur numérique lorque l'on travaille avec des flottants. Avec d'autres langages (avec le C par ex.) tu aurais le même problème.

Même si mathématiquement parlant ton algorithme converge exactement : sans rentrer dans les détails du fait qu'il existe des micros erreurs de calcul (dut au format de réprésentation des floats ou doubles en mémoire) ton b n'est pas exactement égal à 2.0 mais 2.000000000000000000001...
Un simple print n'affiche que les premiers chiffres significatifs, mais le 0.000000000000000001 est bien là.

Solution : se fixer une constante epsilon à peut prés égal à ce que tu considère comme l'erreur max acceptable, typiquement d'aprés ton exemple :

Code:

---

1 2 3

epsilon = 1e-14 while math.fabs(b - math.floor(b)) > epsilon: ....

---

Bonjour,

L'utilisation de "print" cache un peu le problème, parce qu'il "arrange" l'affichage.

Si par contre, on utilise repr() ou le format "%r", on affiche quelque chose de plus proche de la représentation en mémoire:

print 0.1, str(0.1), "%s" % 0.1
0.1 0.1 0.1

print repr(0.1), "%r" % 0.1
0.10000000000000001 0.10000000000000001

Tyrtamos

Oui c'est ça, vous avez raison, c'est excatement le problème décrit dans wikipython.flibuste.net.

J'ai réglé le problème en utilisant le test while str(b) != str( math.floor(b) ) mais la technique de l'epsilon près doit fonctionner aussi.

Merci d'avoir résolu mon souci.

Ce qui est drôle, c'est que le même code écrit en TCL fonctionne sans creer de problèmes.

Je ne connais pas assez Tcl pour savoir pourquoi, mais peut-être que :

- il utilise des rationnels : aucune erreur numérique
ou, plus surement :
- il utilise moins de chiffres significatifs pour la représentation de ses flottants : par exemple, un 'float' en python est en réalité équivalent à un double en C (alors que peut-être qu'un pour Tcl c'est un simple float C)