Expression C # Float: comportement étrange lors de la conversion du résultat float en int

J'ai le code simple suivant:

int speed1 = (int)(6.2f * 10);
float tmp = 6.2f * 10;
int speed2 = (int)tmp;

speed1et speed2devrait avoir la même valeur, mais en fait, j'ai:

speed1 = 61
speed2 = 62

Je sais que je devrais probablement utiliser Math.Round au lieu de cast, mais j'aimerais comprendre pourquoi les valeurs sont différentes.

J'ai regardé le bytecode généré, mais à part un magasin et une charge, les opcodes sont les mêmes.

J'ai également essayé le même code en java, et j'obtiens correctement 62 et 62.

Quelqu'un peut-il expliquer cela?

Edit: Dans le vrai code, ce n'est pas directement 6.2f * 10 mais un appel de fonction * une constante. J'ai le bytecode suivant:

pour speed1:

IL_01b3:  ldloc.s    V_8
IL_01b5:  callvirt   instance float32 myPackage.MyClass::getSpeed()
IL_01ba:  ldc.r4     10.
IL_01bf:  mul
IL_01c0:  conv.i4
IL_01c1:  stloc.s    V_9

pour speed2:

IL_01c3:  ldloc.s    V_8
IL_01c5:  callvirt   instance float32 myPackage.MyClass::getSpeed()
IL_01ca:  ldc.r4     10.
IL_01cf:  mul
IL_01d0:  stloc.s    V_10
IL_01d2:  ldloc.s    V_10
IL_01d4:  conv.i4
IL_01d5:  stloc.s    V_11

nous pouvons voir que les opérandes sont des flottants et que la seule différence est le stloc/ldloc.

Pour ce qui est de la machine virtuelle, j'ai essayé avec Mono / Win7, Mono / MacOS et .NET / Windows, avec les mêmes résultats.

Tout d'abord, je suppose que vous savez que ce 6.2f * 10n'est pas exactement 62 en raison de l'arrondissement en virgule flottante (c'est en fait la valeur 61,99999809265137 lorsqu'elle est exprimée en a double) et que votre question porte uniquement sur la raison pour laquelle deux calculs apparemment identiques aboutissent à la mauvaise valeur.

La réponse est que dans le cas de (int)(6.2f * 10), vous prenez la doublevaleur 61,99999809265137 et la tronquez en un entier, ce qui donne 61.

Dans le cas de float f = 6.2f * 10, vous prenez la valeur double 61,99999809265137 et arrondissez au plus proche float, qui est 62. Vous tronquez ensuite cela floatà un entier, et le résultat est 62.

Exercice: Expliquez les résultats de la séquence d'opérations suivante.

double d = 6.2f * 10;
int tmp2 = (int)d;
// evaluate tmp2

Mise à jour: comme indiqué dans les commentaires, l'expression 6.2f * 10est formellement a floatpuisque le deuxième paramètre a une conversion implicite vers floatlaquelle est meilleure que la conversion implicite en double.

Le problème réel est que le compilateur est autorisé (mais pas obligatoire) à utiliser un intermédiaire qui est plus précis que le type formel (section 11.2.2) . C'est pourquoi vous voyez un comportement différent sur différents systèmes: dans l'expression (int)(6.2f * 10), le compilateur a la possibilité de conserver la valeur 6.2f * 10sous une forme intermédiaire de haute précision avant la conversion en int. Si tel est le cas, le résultat est 61. Si ce n'est pas le cas, le résultat est 62.

Dans le deuxième exemple, l'affectation explicite à floatforce l'arrondi avant la conversion en entier.

La description

Les nombres flottants sont rarement exacts. 6.2fest quelque chose comme 6.1999998.... Si vous transtypez ceci en un entier, cela le tronquera et cela * 10 donnera 61.

Découvrez la DoubleConverterclasse Jon Skeets . Avec cette classe, vous pouvez vraiment visualiser la valeur d'un nombre flottant sous forme de chaîne. Doubleet floatsont tous deux des nombres flottants , décimal ne l'est pas (c'est un nombre à virgule fixe).

Échantillon

DoubleConverter.ToExactString((6.2f * 10))
// output 61.9999980926513671875

Plus d'information

• Classe DoubleConverter de Jon Skeet
• Assert.AreEqual () avec System.Double devient vraiment déroutant
• Ce que tout informaticien doit savoir sur l'arithmétique à virgule flottante

Regardez l'IL:

IL_0000:  ldc.i4.s    3D              // speed1 = 61
IL_0002:  stloc.0
IL_0003:  ldc.r4      00 00 78 42     // tmp = 62.0f
IL_0008:  stloc.1
IL_0009:  ldloc.1
IL_000A:  conv.i4
IL_000B:  stloc.2

Le compilateur réduit les expressions constantes au moment de la compilation à leur valeur constante, et je pense qu'il fait une mauvaise approximation à un moment donné lorsqu'il convertit la constante en int. Dans le cas de speed2, cette conversion n'est pas effectuée par le compilateur, mais par le CLR, et ils semblent appliquer des règles différentes ...

Je pense que la 6.2freprésentation réelle avec une précision de flotteur est 6.1999999en 62fest probablement quelque chose de similaire à 62.00000001. (int)le cast tronque toujours la valeur décimale , c'est pourquoi vous obtenez ce comportement.

EDIT : Selon les commentaires, j'ai reformulé le comportement du intcasting pour une définition beaucoup plus précise.

J'ai compilé et désassemblé ce code (sur Win7 / .NET 4.0). Je suppose que le compilateur évalue l'expression constante flottante comme double.

int speed1 = (int)(6.2f * 10);
   mov         dword ptr [rbp+8],3Dh       //result is precalculated (61)

float tmp = 6.2f * 10;
   movss       xmm0,dword ptr [000004E8h]  //precalculated (float format, xmm0=0x42780000 (62.0))
   movss       dword ptr [rbp+0Ch],xmm0 

int speed2 = (int)tmp;
   cvttss2si   eax,dword ptr [rbp+0Ch]     //instrunction converts float to Int32 (eax=62)
   mov         dword ptr [rbp+10h],eax 

Singlene contient que 7 chiffres et lors de sa conversion en un, Int32le compilateur tronque tous les chiffres à virgule flottante. Lors de la conversion, un ou plusieurs chiffres significatifs peuvent être perdus.

Int32 speed0 = (Int32)(6.2f * 100000000); 

donne le résultat de 619999980 donc (Int32) (6.2f * 10) donne 61.

C'est différent lorsque deux Single sont multipliés, dans ce cas, il n'y a pas d'opération tronquée mais seulement une approximation.

Voir http://msdn.microsoft.com/en-us/library/system.single.aspx

Y a-t-il une raison pour laquelle vous tapez un cast au intlieu d'analyser?

int speed1 = (int)(6.2f * 10)

lirait alors

int speed1 = Int.Parse((6.2f * 10).ToString()); 

La différence est probablement doubleliée à l'arrondi: si vous lancez, vous obtiendrez probablement quelque chose comme 61.78426.

Veuillez noter la sortie suivante

int speed1 = (int)(6.2f * 10);//61
double speed2 = (6.2f * 10);//61.9999980926514

C'est pourquoi vous obtenez des valeurs différentes!