Discussion :

[Lelio1407]

Bonjour,

Le but de mon programme est de convertir un float (qui peut aller jusqu'à 9 chiffres après la virgule) pour écriture dans un fichier binaire.
Afin de ne pas m'embêter avec la virgule du float, je me suis dit qu'il me suffisait de le multiplier par 10 exp.9 et de convertir cet UInt32 en Byte[4].
Tout fonctionne bien si j'ai effectivement 9 chiffres après la virgule. Si par contre, mon float = 0.1, alors 0.1*Math.Pow(10,9) = 100000001! Idem si je fais : 0.1*1000000000 = 100000001.
Quelqu'un peut-il m'expliquer cet effet de bord?
Je vous remercie...

[BenoitM]

Le float a une précision de 7 chiffres après la virgule
Le double a une précision de 15 chiffres après la virgule

Code :

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

1
2
            float val;
            val =(float) (0.1 * Math.Pow(10, 9));

J'obtient la bonne valeur

Peut-être afficher ton code (déclaration des variables, et le calcul), et j'ai pas compris l'histoire du byte[4]...

[SaumonAgile]

Tu peux aussi utiliser des decimal au lieu des float si possible, ça évitera ce genre de problèmes.

[Lelio1407]

Merci pour vos réponse.
Le probleme est que je souhaite me passer de la virgule.
Le résultat de ma multiplication est donc stocké dans un UInt32.
Voici le code complet :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public void SetParametersBinary()
{
     _parametersBinary_CoeffA = new Byte[4];
     UInt32 parametersBinary_CoeffA_Temp = (UInt32)(CoeffA *Math.Pow(10,9));
     _parametersBinary_CoeffA[0] = (Byte)(parametersBinary_CoeffA_Temp & 0xFF);
     _parametersBinary_CoeffA[1] = (Byte)((parametersBinary_CoeffA_Temp & 0xFF00) >> 8);
     _parametersBinary_CoeffA[2] = (Byte)((parametersBinary_CoeffA_Temp & 0xFF0000) >> 16);
     _parametersBinary_CoeffA[3] = (Byte)((parametersBinary_CoeffA_Temp & 0xFF000000) >> 24);
}

C'est lorsque j'ai CoeffA = 0.1 (par exemple) que :
UInt32 parametersBinary_CoeffA_Temp = 0.1*Math.Pow(10,9) = 100000001 alors qu'il devrait être égal à : 100000000
NB : je ne peut utiliser l'opérande & avec un float ou un décimal.

Sinon, si quelqu'un sait convertir float -> byte[4] directement...;-)

[Sehnsucht]

Bonjour,

Je te suggère de regarder du côté de la classe BitConverter et plus particulièrement ses méthodes statiques GetBytes(float) et ToSingle(byte[], int)

Cordialement !

[Lelio1407]

Merci. Effectivement, pour "binariser" des floats, la méthode BitConverter.GetBytes(myFloat) fonctionne très bien!

[kheironn]

Si par contre, mon float = 0.1, alors 0.1*Math.Pow(10,9) = 100000001! Idem si je fais : 0.1*1000000000 = 100000001.
Quelqu'un peut-il m'expliquer cet effet de bord?
Je vous remercie...

0.1 n'existe pas réellement en Float. Ce sera un truc du genre 0.100000001 qui sera stocké.

Les nombres à virgule flottante n'ont pas de bonne précision du fait même de leur nature. FAire des produits ou des quotients avec ces derniers est un bon moyen de se tirer une balle dans le pied. D'où le fait qu'en monétaire on n'utilise JAMAIS ces types. Un décimal, avec une précision de 0.00001 est conseillé et ne génère AUCUNE erreur d'approximation. Inconvéniant, c'est un poil moins rapide. Mais l'exactitude des données n'est-elle pas à privilégier sur un gain de vitesse de quelques microsecondes ?

[DonQuiche]

S'il s'agit d'une sérialisation binaire, pourquoi ne pas tout simplement utiliser BinaryWriter.Write(float) ?

Sinon, en unsafe... uint someInteger= *(uint*)(&someFloat); Autrement dit, on récupère l'adresse du float, on la traite comme l'adresse d'un entier puis récupère le contenu du pointeur. Les bits de someFloat et someInt sont alors identiques. Note: il faut intercaler un cast vers void* si le compilateur C# joue son pointilleux.

Sinon, pour l'effet de bord comme tu disais... Il faut comprendre que les réels (float ou double) sont stockés sous la forme : A*2^B.
Notamment : 0.1 (décimal) = 1/16 + 1/32 + 1/256 + ... = 0.000110011.. (binaire). Ici, A = 1.10011 et B = -100 (-4 en décimal)

En réalité, dans la norme IEEE pour les virgules flottantes, ce sera plutôt A = 110011... (23 bits) et B = 106 (décimal) avec A*2^(B - 127). Puisque 106 + 23 - 4 = 127

[kheironn]

pour les float et double, je ne connaissais pas la formule exacte, mais j'avais une idéee s'y rapprocahnt ...

merci bien !