Bonjour,
Je développe avec DevCpp (toutes les options de compilation par défaut), et je rencontre le problème suivant: Quand j'incrémente une variable avec une valeur réelle (+0.1), puis la décrémente (-0.1), je ne reviens pas à 0, mais à une valeur très petite, du genre 6E-14.
 
Mon code est le suivant
 

Le problème survient également en utilisant des "double"
Quelqu'un a-t-il déjà rencontré ce problème ?
 
Merci de votre aide

C'est un problème classique du a la gestion des nombres flottants dans les ordinateurs, le problème existe dans tous les calculs sur des flottants dans tous les langages

float j = (float)0.1;  -> float j = 0.1f;

Oui, c'est parce que à chaque fois que tu fais un calcul sur un flottant, le FPU fait une infime erreur. Ca se voit dans tous les langages, sur tous les CPUs, et c'est très chiant à gérer parfois...

le fpu fait pas d'erreur, il calcule comme on a décidé qu'il devait calculer.

j'ai dit ça par soucis de simplification, je t'avoue que je ne suis pas très au fait de ce genre de choses donc je suis bien incapable d'expliquer en détails d'où ça vient...

« What every computer scientist should know about floating-point arithmetic »
 
en gros comment tu veux représenter l'ensemble des réesl |R avec n bits, n étant fini ?

Ca je l'avais compris . Qu'il fasse des approximations c'est évident, mais que ça implique des "erreurs" au moindre calcul ayant un résultat exact et fini c'est plus embêtant, même si c'est tout aussi inévitable à cause de la maniere dont sont stockées les valeurs. Pour aborder ça d'un point de vue electronique, et pour faire une analogie on rejoint la notion de Quantum des CAN/CNA : on ne peut coder qu'un nombre limitées de valeurs (2^n), qui ne comprennent pas les nombres flottants "finis"... (je suis pas sûr d'être clair )

(note bien la présence des guillemets autour d'erreur cette fois ci . J'entend erreur dans le résultat par rapport à ce qui était escompté, pas dans le fonctionnement même du fpu)

« au moindre calcul ayant un résultat exact et fini c'est plus embêtant » parce qu'à part les calculs de limites, tu vois des calculs qui n'ont pas un résultat exact et fini ?

j'entendais par là quelques décimales, tu joues pas un peu sur les mots là ?

non, justement. la projection de |R sur [0; 2**n[ est imparfaite et irrégulière. si certains nombres ont une représentation exacte, c'est juste à cause de leur affinité avec la base 2 et le mode de représentation choisie.

je sais . C'est bien de ça que je parlais, mais je suis conscient de ne pas avoir été clair sur toutes la ligne.
Mon post précédent signifait résultat ayant un nombre de décimales apres la virgule fini (et non pas une valeur finie, pardon pour l'ambiguité).  
 
Comme la résolution d'un double ou d'un float (ou de n'importe quelle valeur codée sur quelque nombre de bits que ce soit) n'est pas infinie, impossible effectivement de retrouver cette exactitude sur un systeme informatique, sauf effectivement si ce nombre est inscriptible en base 2.
 
J'espere que c'est un peu plus clair. Je n'ai pas la prétention de t'apprendre quoi que ce soit hein . C'est juste pour clarifier ma réponse.
 
En somme tout ça poru dire que c'est normal qu'on trouve ce genre d'approximations dès qu'on fait des calculs sur des flottants.

lis le pdf don't je t'ai parlé

merci du conseil, ça peut etre enrichissant .

http://www.google.com/search?num=5 [...] %7Clang_fr
c'est lequel ? (il y en a pas mal de différents )

le goldberg

c'est ce qu'il me semblait.

en fait qd on fait :
i = 0.1f, i ne vaut pas exactement 0.1, mais
(1+5033165*2^-23)/16, ce qui fait environ : 0,1000000015

Pour ton bout de programme, tu peux peut-être essayer autrement : au lieu de

 
essaie :

 
je sais pas si ça marche mais logiquement...