calcul entre réels et résultat faux

Version imprimable

01/12/2009, 11h38
loukoum82

calcul entre réels et résultat faux
j'ai une erreur de calcul en Javascript incompréhensible :
Code:

1 2 3 4 5 if (val1<=val2*poids) alert('true'); else alert('false');
val1 est égal à 8.05
val2 est égal à 3.5
poids est égal à 2.3
et il se trouve que 2.3*3.5=8.05 donc cette condition devrait m'afficher 'true'.
Et ce n'est pas le cas, et j'ai regardé de plus près, il se trouve que javascript me renvoie comme résultat de 2.3*3.5 = 8.0499999999
Une idée?
01/12/2009, 11h50
E.Bzz

Bonjour,
sans voir tout le code (fonction entière + initialisation des variables/paramètres) on ne peut pas te dire grand chose ;)

A+
01/12/2009, 12h31
loukoum82

Je suis désolé mais ça risque d'être compliqué car ce bout de code fait partie une application Web contenant 10000 ligne de javascript sans compter les pages html et le moment de l'initialisation des variables est perdu au milieu, je peux juste dire que j'ai suivi les variables avec firebug et que jusqu'au bout leur valeur ne change pas, il s'agit juste du calcul. Je voulais juste essayer de trouver quelqu'un ayant eu le cas.
01/12/2009, 12h44
SpaceFrog

la desormais classique "virgule flottante"

une petite recherche sur le forum avec ce terme et aussi "arrondi" te donneront la solution
01/12/2009, 12h49
Arnaud F.

Plus simple encore : la FAQ : http://javascript.developpez.com/faq...ript#NBDecimal
01/12/2009, 12h50
nouknouk

Citation:

Envoyé par loukoum82

il se trouve que 2.3*3.5=8.05 donc cette condition devrait m'afficher 'true'.

C'est un souci inhérent à la façon dont sont stockés les nombres décimaux dans un nombre dit "à virgule flottante".

En javascript, les valuers décimales sont effectivement stockées dans les nombres à virgule flottante 'double précision (ie. codés sur 64 bits), cf. ceci:

Citation:

Les nombres en JavaScript sont « des valeurs au format IEEE 754 en double précision 64 bits »

Et comme le précise wikipédia dans les précautions d'emploi, cette façon de coder les nombres induit parfois des petites pertes de précision qui peuvent (au fur et à mesure de l'enchaînement des calculs) devenir significatives.

Une solution serait éventuellement de ne pas tester l'égalité exacte, mais un intervalle incluant une imprécision 'acceptable', genre:

au lieu de:

Code:

if (i == 8.0)

faire:

Code:

if ( Math.abs(i-8.0) < 0.001 )

EDIT: bon ben je me suis fait multi griller sur ce coup là :aie:
01/12/2009, 14h30
loukoum82

Citation:

Envoyé par nouknouk

EDIT: bon ben je me suis fait multi griller sur ce coup là :aie:

En fait non, car il n'y a que toi qui réponds vraiment à ma question, sauf que mon problème c'est que je dois être très précis dans mon cas, donc impossible de prévoir une marge d'erreur, d'autant plus que les nombres n'auront pas forcément le même ordre de grandeur selon les cas, (ça peut aller de 2000 à 0.003 par exemple.) mais si il n'y a pas de solution miracle tant pis. Je ferai sans.
Mais c'est quand même très très étrange...
01/12/2009, 14h40
nouknouk

Citation:

En fait non, car il n'y a que toi qui réponds vraiment à ma question

Oui et non: comme l'ont précisé Arnaud F. et SpaceFrog ci-dessus, ce genre de problématique est un grand 'classique'. Une recherche sur le forum te donnera certainement beaucoup de réponses et d'idées pertinentes.

Sinon, pour moi tu as deux solutions:

1- soit définir une précision fixe (ie. valable pour tous tes nombres) et les manipuler ensuite en tant qu'entiers.

Par exemple, si tu dois être précis au millième près et que tu veux stocker 12.345, alors tu stockes 12.345 * 1000 = 12345.

Ainsi toutes tes opérations se feront sur des entiers, donc pas de perte de précision. A la fin, quand tu dois afficher le résultat à l'écran, tu peux toujours convertir l'entier en chaîne de caractère et la manipuler pour rajouter la virgule.

Le +: les opérations se feront sur des entiers, donc à priori ce sera relativement rapide (plus que la solution n°2).

Le -: attention aux limites des entiers en javascript (de -2^63 à 2^63 ?) : si (ton plus grand nombre * ( 1 / la précision)) dépasse ces limites, alors la solution n'est plus envisageable.

Note: Cette technique est d'ailleurs utilisée dans un autre domaine: quand on travaille sur des nombres décimaux avec un hardware qui ne les supporte pas ou 'mal' (ie. qui les traite aussi vite qu'une tortue au pas de course, genre les CPU MIPS). Tu peux faire quelques recherches sur la notion de fixed-point number.

2- soit faire des recherches sur une hypothétique librairie javascript déjà existante pour manipuler de tels nombres et pouvoir y appliquer des calculs exacts. J'imagine que le mot-clef 'big numbers' (qui à l'origine pointe plutôt pour des solutions pour stocker de très grands entiers) devrait également te permettre de dénicher des librairies supportant les nombres décimaux. Exemple.

Le +: probablement moins de limites que la solution 1 pour les très grands / très petits nombres

Le -: les performances seront largement revues à la baisse.