précision de float

Hello.

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

Citation:

---

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:

---

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.

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:

---

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:

---

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 :)

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

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.