Discussion :

[hpavavar]

Hello.

Je me demande pourquoi dans les nombres qui suivent, certains n'ont pas la même précision.

param[0] 0.0
param[1] 0.0010
param[2] 0.0020
param[3] 0.0030
param[4] 0.0040
param[5] 0.0050000004
param[6] 0.0060
param[7] 0.0070
param[8] 0.0080
param[9] 0.009000001
param[10] 0.010000001
param[11] 0.011000001
param[12] 0.012
param[13] 0.013
param[14] 0.014
param[15] 0.015000001

Voici le code :

Code :

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

1
2
3
4
5
6
 
 float[] param = new float[16];
        for (int i = 0; i < 16; i++) {
            param[i] = (float) 0.001*i;
            System.out.println("param["+i+"] " + param[i] );
        }

Merci de m'éclaircir les idées sur ce propos.

[®om]

C'est assez compliqué de voir exactement ce qui se passe au niveau des arrondis.
Si tu veux juste avoir un affichage correct, utilise DecimalFormat pour afficher des doubles/floats.

Si tu veux mieux comprendre ce qui se passe, tu peux afficher les mantisses :

Code :

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

1
2
3
4
5
6
7
		for (int i = 1; i < 16; i++) {
			float f = .001f * i;
			System.out.println("f -> " + 0.001f*i);
			String s = Integer.toBinaryString(Float.floatToIntBits(f));
			String mantisse = s.substring(Math.min(0, s.length() - 23));
			System.out.println(mantisse);
		}

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
20
21
22
23
24
25
26
27
28
29
30
f -> 0.0010
111010100000110001001001101111
f -> 0.0020
111011000000110001001001101111
f -> 0.0030
111011010001001001101110100110
f -> 0.0040
111011100000110001001001101111
f -> 0.0050000004
111011101000111101011100001011
f -> 0.0060
111011110001001001101110100110
f -> 0.0070
111011111001010110000001000010
f -> 0.0080
111100000000110001001001101111
f -> 0.009000001
111100000100110111010010111101
f -> 0.010000001
111100001000111101011100001011
f -> 0.011000001
111100001101000011100101011001
f -> 0.012
111100010001001001101110100110
f -> 0.013
111100010101001111110111110100
f -> 0.014
111100011001010110000001000010
f -> 0.015000001
111100011101011100001010010000

Après tu fais le calcul de l'erreur d'arrondi (à la main forcément, tu ne peux pas le calculer en machine, sinon il n'y aurait pas d'erreur).
Et à mon avis ceux qui n'ont pas plein de chiffres sont plus proches de la valeur exacte

[Sanguko]

Ca vient du codage des float en binaire.

Un float est decrit par une mantisse (en gros les chiffres),un exposant et un signe. Pour la definition de mantisse, voir ici

Sur les 32bits, il y a donc un certain de bits pour la mantisse, pour l'exposant, et 1 pour le signe.

Avec un nombre limité de bits pour la mantisse, tu ne peux donc par représenter parfaitement tous les nombres, seulement avec une "bonne" précision.

Pour une explication plus complète et rigoureuse, voir ici

[hpavavar]

Ok !

J'aurais du m'en douté (l'a étudié l'année dernière).

Mais j'avais pas fait le lien.

Ce qui ma surpris c'est que j'ai fais ça juste avant de passer le tableau à une fonction c qui affiche chaque case du tableau. Et en c j'avais que des nombres "attendus" à 4 chiffres après virgule.

Merci à tous les deux.