C # Float-Ausdruck: Seltsames Verhalten beim Umwandeln des Ergebnisses float in int

Ich habe den folgenden einfachen Code:

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

speed1und speed2sollte den gleichen Wert haben, aber in der Tat habe ich:

speed1 = 61
speed2 = 62

Ich weiß, ich sollte wahrscheinlich Math.Round anstelle von Casting verwenden, aber ich würde gerne verstehen, warum die Werte unterschiedlich sind.

Ich habe mir den generierten Bytecode angesehen, aber bis auf einen Speicher und eine Ladung sind die Opcodes dieselben.

Ich habe den gleichen Code auch in Java ausprobiert und erhalte 62 und 62 korrekt.

Kann das jemand erklären?

Bearbeiten: Im realen Code ist es nicht direkt 6.2f * 10, sondern ein Funktionsaufruf * eine Konstante. Ich habe folgenden Bytecode:

für 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

für 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

wir können sehen, dass Operanden Floats sind und dass der einzige Unterschied der ist stloc/ldloc.

Was die virtuelle Maschine betrifft, habe ich es mit Mono / Win7, Mono / MacOS und .NET / Windows versucht, mit den gleichen Ergebnissen.

Zunächst 6.2f * 10gehe ich davon aus, dass Sie wissen, dass dies aufgrund der Gleitkomma-Rundung nicht genau 62 ist (es ist tatsächlich der Wert 61.99999809265137, ausgedrückt als a double), und dass Ihre Frage nur lautet, warum zwei scheinbar identische Berechnungen zu einem falschen Wert führen.

Die Antwort ist, dass Sie im Fall von (int)(6.2f * 10)den doubleWert 61.99999809265137 nehmen und ihn auf eine Ganzzahl kürzen, die 61 ergibt.

Im Fall von nehmen float f = 6.2f * 10Sie den doppelten Wert 61.99999809265137 und runden auf den nächsten Wert float(62). Sie kürzen diesen Wert dann floatauf eine Ganzzahl, und das Ergebnis ist 62.

Übung: Erläutern Sie die Ergebnisse der folgenden Abfolge von Operationen.

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

Update: Wie in den Kommentaren erwähnt, ist der Ausdruck 6.2f * 10formal ein, floatda der zweite Parameter eine implizite Konvertierung aufweist, in floatdie besser ist als die implizite Konvertierung in double.

Das eigentliche Problem ist, dass der Compiler ein Zwischenprodukt verwenden darf (aber nicht muss), das eine höhere Genauigkeit als der formale Typ aufweist (Abschnitt 11.2.2) . Aus diesem Grund sehen Sie auf verschiedenen Systemen ein unterschiedliches Verhalten: Im Ausdruck (int)(6.2f * 10)hat der Compiler die Möglichkeit, den Wert 6.2f * 10vor der Konvertierung in eine hochpräzise Zwischenform zu halten int. Wenn dies der Fall ist, ist das Ergebnis 61. Wenn dies nicht der Fall ist, ist das Ergebnis 62.

Im zweiten Beispiel floaterzwingt die explizite Zuweisung zu , dass die Rundung vor der Konvertierung in eine Ganzzahl erfolgt.

Beschreibung

Schwebende Zahlen sind selten genau. 6.2fist so etwas wie 6.1999998.... Wenn Sie dies in ein int umwandeln, wird es abgeschnitten und diese * 10 ergibt 61.

Schauen Sie sich die Jon Skeets- DoubleConverterKlasse an. Mit dieser Klasse können Sie den Wert einer schwebenden Zahl wirklich als Zeichenfolge visualisieren. Doubleund floatsind beide Gleitkommazahlen , Dezimalzahlen nicht (es ist eine Festkommazahl).

Stichprobe

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

Mehr Informationen

• Jon Skeets DoubleConverter-Klasse
• Assert.AreEqual () mit System.Double wird wirklich verwirrend
• Was jeder Informatiker über Gleitkomma-Arithmetik wissen sollte

Schauen Sie sich die IL an:

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

Der Compiler reduziert konstante Ausdrücke zur Kompilierungszeit auf ihren konstanten Wert, und ich denke, er macht irgendwann eine falsche Annäherung, wenn er die Konstante in konvertiert int. Im Fall von speed2wird diese Konvertierung nicht vom Compiler, sondern von der CLR vorgenommen, und sie scheinen unterschiedliche Regeln anzuwenden ...

Ich vermute, dass eine 6.2fechte Darstellung mit Float-Präzision 6.1999999dabei 62fwahrscheinlich etwas Ähnliches ist 62.00000001. (int)Beim Casting wird der Dezimalwert immer abgeschnitten, sodass Sie dieses Verhalten erhalten.

EDIT : Laut Kommentaren habe ich das Verhalten des intCastings in eine viel genauere Definition umformuliert .

Ich habe diesen Code kompiliert und disassembliert (unter Win7 / .NET 4.0). Ich denke, dass der Compiler den schwebenden konstanten Ausdruck als doppelt bewertet.

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 

Singleenthält nur 7 Ziffern und beim Umwandeln in einen schneidet Int32der Compiler alle Gleitkommaziffern ab. Während der Konvertierung können eine oder mehrere signifikante Ziffern verloren gehen.

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

ergibt das Ergebnis von 619999980, also ergibt (Int32) (6.2f * 10) 61.

Es ist anders, wenn zwei Single multipliziert werden. In diesem Fall gibt es keine abgeschnittene Operation, sondern nur eine Annäherung.

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

Gibt es einen Grund, warum Sie Typ Casting intanstelle von Parsing verwenden?

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

würde dann lesen

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

Der Unterschied liegt wahrscheinlich in der Rundung: Wenn Sie auf werfen, erhalten doubleSie wahrscheinlich so etwas wie 61.78426.

Bitte beachten Sie die folgende Ausgabe

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

Deshalb bekommen Sie unterschiedliche Werte!