Discussion :

[Saturnin123]

Bonjour,

J'écris un petit programme en pyOpengGL pour apprendre l'OpenGL et le python.
Après de nombreuses galères, j'ai identifié ce qui me bloque et je l'ai résumé ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
monnombre = -1.0
while monnombre < 0.1:
  monnombre+=0.1
  print monnombre
input()

Ce petit bout de code renvoit :

-0.9
-0.8
-0.7
-0.6
-0.5
-0.4
-0.3
-0.2
-0.1
-1.381354646 e-16
0.1
0.2

Question : pourquoi est ce que l'on ne passe pas de -0.1 à 0.0 ?

Merci d'avance

[mont29]

Parce que les nombres flottants sont intrinsèquement imprécis*! C’est en général négligeable (10^-16 est, normalement, une approximation acceptable de 0.0), mais cela peut effectivement parfois poser problème –*il n’y a pas grand chose d’autre à faire dans ce cas que d’en tenir compte au moment de la programmation…

[Saturnin123]

merci pour ta réponse mont29.
Je suis un peu blasé d'avoir perdu autant de temps pour un truc aussi idiot :s mais au moins je sais ce qu'il en est !

Je n'avais jamais rencontré cela, est-ce spécifique à python ?
Quelqu'un connait-il le pourquoi de cet "imprécision intrinsèque" ?

[Sve@r]

Comme l'a dit mont29, les flottants (mêmes décimaux donc pour nous "finis") sont imprécis à cause de la façon dont un ordi code un flottant en binaire. Le codage consiste à multiplier par 2 et à garder la partie entière et à s'arrêter quand le décimal arrive à 0. Mais parfois ça n'arrive pas
Prend par exemple 0.6.
0.6 * 2 = 1.2 => on garde 1 et il reste 0.2
0.2 * 2 = 0.4 => on garde 0 et il reste 0.4
0.4 * 2 = 0.8 => on garde 0 et il reste 0.8
0.8 * 2 = 1.6 => on garde 1 et il reste 0.6
0.6 * 2 = 1.2 ...
Donc 0.6 se code en binaire 1001 1001 1001 1001 ...... etc etc etc à l'infini. Et au décodage binaire => décimal ben tu retrouves pas tout à fait 0.6. Et donc si tu tapes 0.6 dans une console Python, le système te renvoie 0.59999999 (et ce n'est pas spécifique à Python mais au processeur donc ça arrivera dans tous les langages bas niveaux comme C ou C++ ou Pascal)

Généralement on fait avec parce que généralement l'imprécision aussi minime ne gêne pas. Mais si ça gêne vraiment (comme par exemple dans un calcul bancaire), alors faut utiliser des outils dédiés comme par exemple la librairie decimal. Cette librairie est plus longue que le calcul natif car elle décortique et calcule un flottant chiffre par chiffre (comme au primaire) mais elle garantit en retour des calculs rigoureusement exacts

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
import decimal
a=decimal.Decimal("0.6")
print a, a*a, a*a*a   => 0.6 0.36 0.216

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
import decimal
monnombre = decimal.Decimal("-1.0")
while monnombre < decimal.Decimal("0.1"):
  monnombre+=decimal.decimal("0.1")
  print monnombre
input()

il n’y a pas grand chose d’autre à faire dans ce cas que d’en tenir compte au moment de la programmation…

Ben justement non !!!

[Saturnin123]

Merci pour les précision Sve@r !

Ce n'est pas que j'ai besoin d'une grande précision, car je n'utilise que des chiffres avec 1 ou 2 nombres après la virgules, mais je les compares à 0 !

donc, si mon calcule du genre 0.1 -= 0.1 ne me renvoi pas 0, ma fonction n'entre pas dans le test :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
if (mvt_gauche==1) :
    if (dirz >= 0 and dirx > 0) :
      dirx -= 0.1
      dirz += 0.1
    elif (dirz > 0 and dirx < 0) :
      dirx -= 0.1
      dirz -= 0.1
    elif (dirz <= 0 and dirx < 0) :
      dirx += 0.1
      dirz -= 0.1
    elif (dirz < 0 and dirx >= 0) :
      dirx += 0.1
      dirz += 0.1

[Sve@r]

Ce n'est pas que j'ai besoin d'une grande précision, car je n'utilise que des chiffres avec 1 ou 2 nombres après la virgules

La précision ne dépend pas forcément du nombre de chiffres après la virgule. Dans mon exemple, 0.6 n'a qu'un chiffre après la virgule mais malgré ça, tu n'arriveras pas à récupérer 0.6 en utilisant le calcul natif flottant. Et imagine ton compte bancaire perdre qq centimes à chaque opération, j'aimerais voir ta tronche si ton banquier te répond "pas besoin de précision vu qu'il n'y a que 2 décimales"...

, mais je les compares à 0 !


donc, si mon calcule du genre 0.1 -= 0.1 ne me renvoi pas 0, ma fonction n'entre pas dans le test :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
if (mvt_gauche==1) :
    if (dirz >= 0 and dirx > 0) :
      dirx -= 0.1
      dirz += 0.1
    elif (dirz > 0 and dirx < 0) :
      dirx -= 0.1
      dirz -= 0.1
    elif (dirz <= 0 and dirx < 0) :
      dirx += 0.1
      dirz -= 0.1
    elif (dirz < 0 and dirx >= 0) :
      dirx += 0.1
      dirz += 0.1

Ben en programmation, on prend vite l'habitude de ne jamais faire d'égalités strictes entre les flottants parce que justement on n'est pas certain d'avoir l'égalité. Si on doit comparer par exemple un nombre x avec un nombre y, on remplacera if x == y par if abs(x-y) < 1e-10...

[Saturnin123]