Discussion :

[loukoum82]

j'ai une erreur de calcul en Javascript incompréhensible :

Code :

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

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?

[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+

[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.

[SpaceFrog]

la desormais classique "virgule flottante"

une petite recherche sur le forum avec ce terme et aussi "arrondi" te donneront la solution

[Arnaud F.]

Plus simple encore : la FAQ : http://javascript.developpez.com/faq...ript#NBDecimal

[nouknouk]

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:

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 :

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

if (i == 8.0)

faire:

Code :

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

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

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

[loukoum82]

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

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...

[nouknouk]

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.