Discussion :

[Hakim93210]

Bonsoir,

Je développe actuellement avec une JDK 1.4 sous Eclipse 3.1.
J'ai le bout de code suivant :
double puissance = Math.pow(10, 5);
Double res = new Double(puissance*64.1);

Lorsque je passe en mode debug et que je regarde la valeur de puissance*64.1, il me trouve que cela fait 640999.9999...
En regardant un peu sur le net, il semblerait qu'il s'agisse d'un pb de taille des type primitifs de Java et certains préconisent d'utiliser un long.
Pourtant les long aussi bien que les double sont stockés sur 8 octets...

En gros, j'aimerais savoir comment obtenir 6410000, car là je ne vois pas.
Merci d'avance pour votre aide.

[CyberChouan]

Tu peux :
- utiliser un DecimalFormat pour ne garder que la partie entière
- utiliser les méthodes de la classe java.lang.Math

[Hakim93210]

Pourrais-tu être un peu plus précis stp???

[Uther]

Le plus simple dans ton cas est tout simplement de faire:

Code :

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

Double res = new Double(6.41e6);

Mais sache que les Float/Double sont des nombres à virgule flottante. Si tu les utilises, il faut être conscient que tu la plupart des calcul peuvent aboutir finissent sur une valeur approchée, même certains calculs qui sembleraient naturellement donner une valeur exacte pour un nombre décimal(car les nombre même en virgule flottante sont traités en binaires)

Si tu veux des calculs avec des nombres décimaux, regarde du coté de la classe BigDécimal.

[tchize_]

Pourtant les long aussi bien que les double sont stockés sur 8 octets...

Ils peuvent donc tous les deux prendre le même nombre de valeurs différentes. Cependant, un long peux prendre des valeurs situées entre 2^63-1 et -2^64, par pas de 1. Les calculs dans ce range, en nombres entiers sont toujours exacts.

un double peux prendre des valeurs situées presque entre 2^1024 et -2^1024, le tout en pouvant atteindre des chiffres derrière la virgule aussi petit que 2^-1074. La valeur stockées dans le double est toujours la valeur la plus proche possible de la valeur demandé, ce qui implique, pour chaque calcul, une approxmation, car on a jamais la garantie que le résultat d'un calcul peux être stocké de manière exacte dans un double (nos mathématiques travaillent sur base décimal, les floats sur base binaire). Exemple de code:

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
18
19
 
		double d;
		NumberFormat nf = new DecimalFormat("##.############################");
		System.out.println("avec float");
		System.out.println("Valeur de 1/2: "+nf.format(0.5f));
		System.out.println("Valeur de 0.1: "+nf.format(0.1f));
		System.out.println("Valeur de 0.3: "+nf.format(0.3f));
		System.out.println("Valeur de 0.7: "+nf.format(0.7f));
		System.out.println("Valeur de 100000.1: "+nf.format(100000.1f));
		System.out.println("Valeur de 100000.3: "+nf.format(100000.3f));
		System.out.println("Valeur de 100000.7: "+nf.format(100000.7f));
		System.out.println("Valeur de 1000000000.1-1000000000: "+nf.format(1000000000.1f-1000000000f));
		System.out.println("Valeur de 100000000000000000000000000000000000000.1f: "+nf.format(100000000000000000000000000000000000000.1f));
		System.out.println("avec double");
		System.out.println("Valeur de 1/2: "+nf.format(0.5));
		System.out.println("Valeur de 0.1: "+nf.format(0.1));
		System.out.println("Valeur de 0.3: "+nf.format(0.3));
		System.out.println("Valeur de 1000000000.1-1000000000: "+nf.format(1000000000.1-1000000000));
		System.out.println("Valeur de 100000000000000000000000000000000000000.1: "+nf.format(100000000000000000000000000000000000000.1));

avec sa sortie

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
avec float
Valeur de 1/2: 0,5
Valeur de 0.1: 0,10000000149011612
Valeur de 0.3: 0,30000001192092896
Valeur de 0.7: 0,699999988079071
Valeur de 100000.1: 100000,1015625
Valeur de 100000.3: 100000,296875
Valeur de 100000.7: 100000,703125
Valeur de 1000000000.1-1000000000: 0
Valeur de 100000000000000000000000000000000000000.1f: 99999996802856920000000000000000000000
avec double
Valeur de 1/2: 0,5
Valeur de 0.1: 0,1
Valeur de 0.3: 0,3
Valeur de 1000000000.1-1000000000: 0,10000002384185791
Valeur de 100000000000000000000000000000000000000.1: 100000000000000000000000000000000000000

j'ai utilisé des float pour montrer l'appoximation de stockage de la valeur (c'est le même en double, mais comme il y a beaucoup plus de décimale, impossible de l'afficher avec numberformat :p). Par contre tu notera que les erreurs de calculs apparaissent dans les deux cas. En pratique, avec les double si tu fais correctement tes calculs en tenant compte des précisions à chaque fois, l'arrondi d'affichage devrait suffire. J'ai dit devrais

[Hakim93210]

Salut à tous,

Tout d'abord, merci pour vos réponses... Et merci à toi tchize_ pour cette comparaison entre les float et les double et leur stockage.
Pourtant en utilisant correctement les double, j'ai tjs du mal a cerner pourquoi lorsque je fais
System.out.println(new Double(14.1+5.023).toString());
j'obtiens 19.122999999999999888

Comment faire pour obtenir tout simplement 19.123??lol
J'ai beau passer par des BigDecimal, ben ca marche pas

J'ai fais
System.out.println(new BigDecimal(14.1+5.023).toString());
et j'obtiens le même résultat.

[adiGuba]

Salut,

Pourtant en utilisant correctement les double, j'ai tjs du mal a cerner pourquoi lorsque je fais
System.out.println(new Double(14.1+5.023).toString());
j'obtiens 19.122999999999999888

Parce que toString() n'effectue aucun arrondi et affiche la valeur brut.

Pour arrondir tu peux simplement utiliser ceci :

Code :

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

1
2
3
	double d = 14.1 + 5.023;
	NumberFormat nf = new DecimalFormat("0.000"); // 3 chiffres après la virgule
	System.out.println(nf.format(d));

J'ai beau passer par des BigDecimal, ben ca marche pas

J'ai fais
System.out.println(new BigDecimal(14.1+5.023).toString());
et j'obtiens le même résultat.

Parce que tu utilises un BigDecimal initialisé avec un double, et donc tu conserve l'approximation...

Si tu veux un résultat correct il faut à la base avoir des données corrects, donc soit utiliser des types précis (int/long) soit utiliser une String qui sera correctement décodé par le BigDecimal :

Code :

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

1
2
	BigDecimal number = new BigDecimal("14.1").add(new BigDecimal("5.023"));
	System.out.println(number);

a++