Discussion :

[Dazdh]

Bonjour,

Je souhaite faire le calcul suivant:
((((56459264-56165032)-(56459264-56351904))*27000000)/(((1018407817*300)+207)-((1018404453*300)+299)))*8

Voila ce que me donne la calculatrice Google:
((((56 459 264 - 56 165 032) - (56 459 264 - 56 351 904)) * 27 000 000) / (((1 018 407 817 * 300) + 207) - ((1 018 404 453 * 300) + 299))) * 8 = 40 000 031.7
et qui me semble etre le bon resultat.

Mais en Java, quand je fais le calcul en utilisant uniquement des types float, voila le resultat:
3.97362E7

Et quand j'utilise uniquement des types long, voila le resultat:
40000024

Avez vous une idee de ce qu'il se passe?
Comment retrouver le bon resultat? (D'ailleurs lequel est le bon?)

Merci,

Dazdh

[dinobogan]

Le bon résultat est celui donné par Google.
Lorsque des doubles sont utilisé, le résultat est correct en Java.
Avec des long, le résultat est erroné car les divisions ne sont pas entières.
Avec des float, le résultat est également erroné car la granularité dans les grandes valeurs augmente. Exemple simpliste :

Code :

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

1
2
if( Float.MAX_VALUE == Float.MAX_VALUE - 1 ) { System.out.println( "egal" ); }
else { System.out.println( "pas egal" ); }

affichera :

Code :

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

egal

Le type double connait le même "problème", mais avec des valeurs bien supérieures, ce qui explique qu'en double on a le bon résultat.

Note bien que ce fonctionnement est commun à tout les langages et n'a rien à voir avec Java. Cela provient du mode de représentation interne des types au niveau matériel.

[Dazdh]

Merci.

Tres interressant cet exemple. A lire comme ca, on dirait qu'il y a un gros bug! Mais tu as raison, c'est la representation interne qui change.

Ok pour les doubles, je vais utiliser ca.

A+

[nouknouk]

+1 avec dinobogan.

A noter qu'en java, tu peux utiliser les classes BigDecimal et BigInteger pour manipuler des très grand nombres et/ou des nombres décimaux en avec une précision garantie.

[hasalex]

Il y a déjà eu des discussions sur ce sujet. Si bug il y a, il n'est pas du à java, pais au fonctionnement en virgule flottante. Les mêmes résultats seront observable en C, par exemple. De plus, il faut aussi se méfier des résultats avec les double.

J'avais recensé des résultats assez spectaculaires sur mon wiki. La conclusion de tout ça, c'est que BigDecimal est utile même pour des nombres de taille limitée.