Bug C++ Builder 6 ? - "while" et doubles

Version imprimable

23/10/2006, 16h26
majke

Bug C++ Builder 6 ? - "while" et doubles
Bonjour, soit c'est un bug dans C++ Builder soit dans ma tête 8O

Alors, il s'agit de la boucle tant-que de base avec les doubles, par exemple :
Code:

1 2 3 4 5 6 7 double i = 0.6; while (i < 0.8) { i += 0.1; }
La variable i devrait avoir la valeur 0.8 à la sortie de la boucle tantque, or ce n'est pas le cas ! A la troisième vérification quand i = 0.8, la condition 0.8 < 0.8 n'arrête pas la boucle mais fait passer encore une fois et la valeur de i à la sortie est 0.9 !!!

J'ai fait des tests et les conditions en dessous de 0.8 fonctionnent : testez par exemple avec while (i < 0.7) et vous verrez...

Alors, que se passe-t-il ?

Merci pour vos reponses.
23/10/2006, 17h53
blondelle
majke a ecrit:

Citation:

Bonjour, soit c'est un bug dans C++ Builder soit dans ma tête

Alors, il s'agit de la boucle tant-que de base avec les doubles, par exemple :

Code :

double i = 0.6;

while (i < 0.8)
{
i += 0.1;
}
La variable i devrait avoir la valeur 0.8 à la sortie de la boucle tantque, or ce n'est pas le cas ! A la troisième vérification quand i = 0.8, la condition 0.8 < 0.8 n'arrête pas la boucle mais fait passer encore une fois et la valeur de i à la sortie est 0.9 !!!

J'ai fait des tests et les conditions en dessous de 0.8 fonctionnent : testez par exemple avec while (i < 0.7) et vous verrez...

Alors, que se passe-t-il ?

Merci pour vos reponses.

Je pense qu'il faut ecrire ta fonction comme ceci.
Code:

1 2 3 4 5 6 7 double i = 0.6; while (i <= 0.8) // <--- Modif { i += 0.1; }
23/10/2006, 18h46
Pasqualini
Je pense que 0.6 + 0.1 + 0.1 ne fait pas 0.8.
Il ne faut pas oublier que les double n'ont pas une infinité de décimales.
Alors 0.6 + 0.1 +0.1 cela fait peut-être 0.79999999. Et il y a une boucle de plus.

Pour faire des comparaisons avec des nombre double il faudrait mettre une condition supplémentaire. Par exemple :
Code:

1 2 3 double i = 0.6; double
23/10/2006, 18h50
Pasqualini
e pense que 0.6 + 0.1 + 0.1 ne fait pas 0.8.J
Il ne faut pas oublier que les double n'ont pas une infinité de décimales.
Alors 0.6 + 0.1 +0.1 cela fait peut-être 0.79999999. Et il y a une boucle de plus.

Pour faire des comparaisons avec des nombre double il faudrait mettre une condition supplémentaire. Par exemple :
Code:

1 2 3 4 5 6 7 double i = 0.6; double err = 0.00001; while (i <(0.8 - err)) { i += 0.1; }
24/10/2006, 10h29
majke

Citation:

Envoyé par Pasqualini

Je pense que 0.6 + 0.1 + 0.1 ne fait pas 0.8.
Il ne faut pas oublier que les double n'ont pas une infinité de décimales.
Alors 0.6 + 0.1 +0.1 cela fait peut-être 0.79999999. Et il y a une boucle de plus.

Je suis d'accord avec toi, mais il s'agit de l'informatique, et 0.999999999 peut devenir 1.0 que si on le veut, et il existe des fonctions pour le faire, sans ça 0.999999999 reste 0.999999999 et dons différent de 1.000000000 ...

L'outil tel que C++ Builder 6 devrait me le montrer, non ?

Donc, un bug ?
24/10/2006, 10h46
blondelle

Salut majke.
A tu essaye la modif que je t'ai donnee?
24/10/2006, 11h33
Pasqualini

"Je suis d'accord avec toi, mais il s'agit de l'informatique, et 0.999999999 peut devenir 1.0 que si on le veut, et il existe des fonctions pour le faire, sans ça 0.999999999 reste 0.999999999 et dons différent de 1.000000000 ...

L'outil tel que C++ Builder 6 devrait me le montrer, non ?

Donc, un bug ?"

Il ne s'agit pas d'un bug. Il n'y a aucune raison, si on travaille avec des double qu'un compilateur quelconque transforme un 0.999999 en 1.000000, pourquoi pas en 0;999998 ?

Il est dangereux de mettre des conditions d'égalité sur des nombres qui ne sont pas des int
24/10/2006, 13h05
Interruption13h

Salut !

Ton problème l'a expliqué blondelle :roll:

A+
24/10/2006, 13h43
blondelle

Merci Interruption13h.
La fonction tel qu'el est ecrite dit si i est strictement superieur a 0.8 (while (i < 0.8))
Pour qu'elle fonctionne selon le souhait de majke il faut ecrire si i est superieur ou equal a 0.8 (while (i <= 0.8))

Salut Pasqualini.
Le fait d'avoir utilise des doubles ne signifie pas que les valeur doivent avoir obligatoirement de nombreuses decimales, majke a initialise sa variable a i = 0.6 et non pas a i = 5.9999 ou i = 6.00111 ses valeurs non rien a voir avec ton explication le choix qu'il a fait d'utiliser des doubles est compatible avec ce qu'il a programme a son erreur de teste pret.
24/10/2006, 15h40
Pasqualini

Le nombre 0.6 n'a pas, en binaire, un nombre fini de décimales. C'est donc obligatoirement un approximation de 0.6 qui est créée.
24/10/2006, 17h05
ksly

Citation:

Envoyé par blondelle

Pour qu'elle fonctionne selon le souhait de majke il faut ecrire si i est superieur ou equal a 0.8 (while (i <= 0.8))

Non :)
Relis bien le premier post.

La condition est i<0.8 et on passe bien dans la boucle.
Et ce qu'on veut c'est ne pas passer dans cette boucle.

Sylvain
24/10/2006, 17h22
yarp

Je ne sais pas si cela à un rapport mais à chaque fois que je manipule des constantes décimales, j'utilise la notation suivante:

f = 0.6f;

(j'utilise de préférence les floats aux double donc j'illustre mon exemple avec ce que je connais, je ne suis pas sur de la notation en double mais il me semble qu'elle est identique).
Je crois aussi avoir eux des mauvaises surprises comme celle de majke qui ont été résolues par cette méthose.

Je vous livre ces réflexions telles quelles, basées seulement sur mon expérience et des souvenirs. En tout cas le "f" ne peux pas faire de mal.

Yarp
www.senosoft.com
24/10/2006, 17h48
Crayon

Je sais que ma réflexion ne va pas vraiment aidé à comprendre le problème, mais pourquoi tu ne multiplie pas par 10 et tu traites tout les valeurs comme des entiers :D
24/10/2006, 18h17
mat.M

J'ai essayé avec VC++6.0 et i dans la boucle vaut 0.60000000000000.
Ce n'est pas un bug de BCB alors je te rassure :mrgreen:
Donc effectivement c'est un problème de précision; il faudrait arrondir ou bien utiliser la technique des entiers de Crayon
24/10/2006, 18h24
majke
Citation:

Envoyé par Crayon

Je sais que ma réflexion ne va pas vraiment aidé à comprendre le problème, mais pourquoi tu ne multiplie pas par 10 et tu traites tout les valeurs comme des entiers :D

Hé hé hé, c'est pas faux, mais l'exemple que j'ai donné est là pour essayer de comprendre le problème de base, j'espère donc trouver la réponse à ma question : bug dans Builder ou pas ?
Jusque là j'ai compris que while n'a rien à voir là dedans (Malheuresment j'ai nommé la discussion Bug C++ Builder 6 ? - "while" et doubles)

Donc, pour avancer je vais reformuler ma question ainsi :
Code:

1 2 3 4 5 6 7 8 double a = 0.7; double b = 0.1; double c = a + b; double d = 0.8; if (c == d) ShowMessage("OK");
Et puis voilà, le problème est le même : l'addition 0.7 + 0.1 donne 0.8 (le compilateur le montre aussi) mais après ce même c=0.8 est différent de d=0.8 !!! Le message n'est pas affiché !

Et si l'on fait comme ça :
Code:

1 2 3 4 5 6 7 8 double a = 0.6; double b = 0.1; double c = a + b; double d = 0.7; if (c == d) ShowMessage("OK");
Le message est affiché. Pas de problème.

0.6 + 0.1 donne 0.7 et
0.7 + 0.1 donne quoi ?

J'attends que quelqu'un teste chez lui l'exemple donné sur C++ Builder 5 ou 6, et pourquoi pas Visual C++

p.s. Merci pour le réflexions de Yarp, je vais l'essayer, mais avant tout il faut que je sois sûr que le compilateur ne me montre pas de bêtises. Il faut comprendre la différence entre un float et un double.
p.p.s. Pasqualini t'as raison en partie, mais si c'est comme ça je veux que la machine (le compilateur) me le montre, je peux pas savoir ce qui se passe derrière.
p.p.p.s Peux tu essayer mat.M avec ces exemples d'addition aussi stp.
24/10/2006, 18h42
Crayon

J'ai trouvé post sur un goupe de discussion qui parle de comment comparer deux double : http://groups.google.com/group/micro...94acad1?hl=en&

En voici un extrait:

Citation:

C++ way is

if (x == y) {...}

Smart engineer's way is

if (fabs(x - y) < eps) {...}

where eps is a small number, carefully chosen by aforementioned smart
engineer based on his/her accuracy requirements and error accumulation
estimates.

Je pense qu'il n'y a pas de moyen parfait, il faut arrondire et avoir un certain range d'erreur.
24/10/2006, 22h17
mat.M

Citation:

Envoyé par majke

p.p.p.s Peux tu essayer mat.M avec ces exemples d'addition aussi stp.

ça va couter cher :mouarf:

c et d valent 0.80000000000000 mais l'égalité ne se vérifie pas ..:roll:

Si on déclare double d = 0.8f;
d vaut 0.80000001192093 en déboguage pas-à-pas :roll:
25/10/2006, 11h43
majke

Citation:

Envoyé par mat.M

ça va coûter cher :mouarf:

Tu acceptes les €uros ? ;)

Citation:

Envoyé par mat.M

c et d valent 0.80000000000000 mais l'égalité ne se vérifie pas ..:roll:

Oui, voilà donc il s'avère que le compilateur de VC++6.0 et de BCB 6.0 fonctionnent de même manière. Sauf que pour un double déclaré comme ça :

Code:

double d = 0.8;

, le débogage pas-à-pas de VC++ montre 0.80000000000000 et celui de BCB montre 0.8.
Puis l'égalité ne se vérifie pas, effectivement il y'a une approximation (qui est comprehensible car le stockage et manipulation de valeur décimales dans la mémoire n'est pas simple) mais ceci nous n'est pas montrée lors de débogage !
Par contre pour les float la situation est aussi compliquée mais nettement plus claire lors de débogage comme le montre mat.M dans VC++ :

Citation:

Envoyé par mat.M

Si on déclare double d = 0.8f;
d vaut 0.80000001192093 en débogage pas-à-pas :roll:

Pour être plus clair, si dans BCB 6.0 je déclare un float comme ceci :

Code:

float a = 0.8;

, le déboggeur de BCB 6.0 me montre que a vaut 0.80000001192 et si j'affiche cette valeur :

Code:

ShowMessage( FloatToStr(a) );

je peux voir la valeur effective : 0.800000011920929 car la précision de float en BCB 6.0 est sur 15 chiffres (écrit dans l'aide).
Les questions que je me pose :
- pourquoi il y a une différence entre un float et un double ? (ShowMessage d'un double montre toujours ce qu'on a déclaré càd 0.8 et dans le cas d'addition 0.7+0.1 c'est aussi 0.8 même si l'égalité de deux 0.8 ne se vérifie pas...)
- pourquoi lors de débogage un float 0.8 est montré sur 11 décimales alors que ça valeur réele après l'approximation est sur 15 décimales. Je dois faire un ShowMessage ou Ansistring s = FloatToStr(a); pour voir ça valeur réele. Là on peut parler d'un bug d'affichage dans le débogage pas à pas de BCB 6.0 ...
25/10/2006, 12h05
majke
J'ai fait le test suivant avec les float et l'égalité se vérifie bien :mrgreen: , pas comme avec les double :
Code:

1 2 3 4 5 6 7 8 float a = 0.7; float b = 0.1; float c = a + b; float d = 0.8; if (c == d) ShowMessage("OK");
Voici les valeurs montrées lors de débogage (sur 11 chiffres) puis les valeurs réelles (sur 15 chiffres) :
Code:

1 2 3 4 5 6 7 8 9 a 0,69999998808 b 0,10000000149 c 0,80000001192 d 0,80000001192 a 0,699999988079071 b 0,100000001490116 c 0,800000011920929 d 0,800000011920929
On peut voir que lors de l'affichage la valeur de a est arrondie à 11 décimales, il n'y a pas que 4 dernières chiffres qui sont enlevées !
Et puis en maths 0,699999988079071 + 0,100000001490116 = 0,799999989569187 mais c'est une autre histoire, il faut revoir ses cours d'architecture d'ordinateurs pour voir comment l'addition fonctionne (je les avais pas pris au sérieux à l'époque ;) )

Donc comparer deux float est plus facile que deux double, il faut voir le lien que Crayon a passé.
Et concernant l'affichage de compilateur je vais lancer un sujet sur le forum de Borland. Peut être qu'il y a de mises à jour à faire...