Discussion :

[jeha]

bonjour,

j'ai ce petit code qui doit retourner 10 mais j'ai comme résultat 9.999999999999998 !!!!!!!!!!!!!!!!!!!!!

Code :

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

1
2
3
4
5
6
7
8
 
    public static void main(String[] args) {
        // TODO code application logic here
         double amont= 22.72 - 12.72 ;
 
 
        System.out.println("Amont :"+amont );
    }

merci pour votre aide et votre suggestion

[tupac25]

C'est à cause de la représentation des floats. Tu trouveras surement ta réponse dans ce topic:
http://www.developpez.net/forums/d34...-calcul-float/

[jeha]

merci chef pour votre réponse, donc la solution est:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
    public static void main(String[] args) {
        // TODO code application logic here
 
        BigDecimal valeur1 = new BigDecimal("22.72");
        BigDecimal valeur2 = new BigDecimal("12.72");
 
        BigDecimal resSoustraction = valeur1.subtract(valeur2);
 
 
 
 
        System.out.println("Amount :"+resSoustraction );
    }

[thelvin]

Ou alors, garder les floats (ou plutôt des double) et les faire afficher avec deux décimales maximum.

Ou alors, calculer avec des ints et insérer une virgule avant les deux derniers chiffres à l'affichage.

C'est quand même pas très pratique BigDecimal.

[jeha]

Ou alors, garder les floats (ou plutôt des double) et les faire afficher avec deux décimales maximum.

Ou alors, calculer avec des ints et insérer une virgule avant les deux derniers chiffres à l'affichage.

C'est quand même pas très pratique BigDecimal.

c'est quoi donc la solution si la valeur retourner est faux, le 10 n'est pas le 9.999999999 !!!!!

y a t'il une autre solution pour ce probleme de calcule

[thelvin]

Si tu affiches l'arrondi à deux décimales, ça fera bel et bien 10.

Tu as vraiment besoin d'une précision à 9 décimales ?

[YannPeniguel]

http://www.java-tips.org/java-se-tip...-a-double.html

[thelvin]

http://www.java-tips.org/java-se-tip...-a-double.html

Dans le cas présent, je pensais plutôt à un DecimalFormat. Si c'est pour faire ça, autant jongler dès le départ avec des BigDecimal et éluder le problème.

[YannPeniguel]

A voir selon d'où viennent ces doubles. Dans le code présent, ils sont instanciés par le dev dans le main, mais il s'agit d'un code exemple.

Dans un vrai soft, ils peuvent provenir d'une fonction qu'on appelle dans une librairie, donc on n'a pas le choix d'obtenir un double en retour de cette fonction.

Après, c'est sur que quand c'est possible, autant utiliser les bons types de données dès le départ, mais c'est un autre débat ^^

[tchize_]

Le bigdecimal ne résoudront pas le problème. La précision du type de données n'est pas en cause. Tes chiffres ne peuvent pas être réprésentés correctement dans un nombre binaire car en fraction binaire ils ont une réprésentation avec un nombre infini de décimal. C'est donc la conversion humain (décimal) / machine (binaire) qui introduit un légère erreur, légère erreur que l'on trouve dans le résultat.

Dans ton cas, la seule manière de travailler est de réduire le nombre de décimale à l'affichage. Pour faire une analogie. Si on "vivait" en base 3 et que les ordinateurs étaient en base 10.

On se dirait "1/3+1/3+1/3=1, naturelement". Mais quand on passerais sur un ordinateur on trouverais en fait "0.333333333"+0.333333333"+0.333333333" = "0.999999999". Dans notre cas, pour avoir 1 il faudrait arrondir le nombre, à 5 décomale, par exemple, et ca donnerais "1".

Code d'exemple

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
         double amont= 22.72 - 12.72 ;
         boolean result = amont==10.0;
         System.out.println("Amont "+amont+ "==10.0?"+result);
         amont= 22.72d - 12.72d ;
         System.out.println("Amont "+amont+ "==10.0?"+result);
         result = ((float)amont)==10.0;
         System.out.println("Amont "+amont+ "==10.0?"+result);
         BigDecimal bd = new BigDecimal(22.72).subtract(new BigDecimal(12.72));
         result = bd.doubleValue()==10.0;
         System.out.println("Amont "+bd.doubleValue()+ "==10.0?"+result);
         bd = new BigDecimal(22.72, new MathContext(5000)).subtract(new BigDecimal(12.72, new MathContext(5000)));
         result = bd.doubleValue()==10.0;
         System.out.println("Amont "+bd.doubleValue()+ "==10.0?"+result);
         bd = bd.round(new MathContext(15));
         result = bd.doubleValue()==10.0;
         System.out.println("Amont "+bd+ "==10.0?"+result);

Code :

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

1
2
3
4
5
6
Amont 9.999999999999998==10.0?false
Amont 9.999999999999998==10.0?false
Amont 9.999999999999998==10.0?true
Amont 9.999999999999998==10.0?false
Amont 9.999999999999998==10.0?false
Amont 10.0000000000000==10.0?true

[thelvin]

Le bigdecimal ne résoudront pas le problème.

Tout de même, leur manie de tout stocker dans un BigInteger d'une part, et de stocker l'emplacement de la virgule dans int d'autre part, élude pas mal le problème.

L'exemple de jeha marche très bien et marchera en toute circonstances.

L'ennui c'est qu'il faut partir des BigDecimal, calculer en BigDecimal et finir en BigDecimal, et que c'est chiant à manipuler ces bêtes-là, sans parler des performances si on en fait beaucoup.

Code :

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

1
2
3
4
5
6
Amont 9.999999999999998==10.0?false
Amont 9.999999999999998==10.0?false
Amont 9.999999999999998==10.0?true
Amont 9.999999999999998==10.0?false
Amont 9.999999999999998==10.0?false
Amont 10.0000000000000==10.0?true

Oui, enfin, pour ces raisons ou pour une autre, vérifier l'égalité des flottants, c'est pas fiable.
C'est presque comme vérifier si deux nombres uniformément choisis au hasard entre 0 et 1 sont égaux. Par définition, ils ne peuvent pas l'être.

[tchize_]

Effectivement, mon texte est ambigu. Big décimal utilise une virgule fixe et une base 10 oui, mais si tu lit mon message d'origine, le problème n'est pas la virgule, c'est la base (binaire). Hors bigdecimal, ben tu lui passe un double, donc le mal est déjà fait. Maintenant, j'ai pas testé, mais si tu remplace le code par

Code :

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

1
2
         BigDecimal bd = new BigDecimal("22.72").subtract(new BigDecimal("12.72"));
         result = bd.doubleValue()==10.0;

c'est à dire en passant des String, là tu t'affranchis de la conversion Mais comme l'a dit jeha, il utilise déjà des double pour ses données, il est donc coincé de ce coté là.

[jeha]

Merci tout le monde pour vos messages et vos petites attentions!