C # Float ifadesi: sonuç float'ı int'e dönüştürürken garip davranış

Aşağıdaki basit koda sahibim:

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

speed1ve speed2aynı değere sahip olmalı, ama aslında:

speed1 = 61
speed2 = 62

Muhtemelen döküm yerine Math.Round kullanmam gerektiğini biliyorum, ancak değerlerin neden farklı olduğunu anlamak istiyorum.

Oluşturulan bayt koduna baktım, ancak bir mağaza ve bir yük dışında işlem kodları aynı.

Aynı kodu java'da da denedim ve 62 ve 62'yi doğru bir şekilde aldım.

Biri bunu açıklayabilir mi?

Düzenleme: Gerçek kodda, doğrudan 6.2f * 10 değil, bir işlev çağrısı * sabittir. Aşağıdaki bayt koduna sahibim:

için 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

için 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

işlenenlerin float olduğunu ve tek farkın stloc/ldloc.

Sanal makineye gelince, aynı sonuçlarla Mono / Win7, Mono / MacOS ve .NET / Windows ile denedim.

Her şeyden önce, bunu bildiğinizi varsayıyorum 6.2f * 10 kayan nokta yuvarlamasından dolayı tam olarak 62 olmadığını (aslında a olarak ifade edildiğinde 61.99999809265137 değeri double) ve sorunuz sadece görünüşte aynı olan iki hesaplamanın neden yanlış değerle sonuçlandığıyla ilgili.

Cevap şu durumda: (int)(6.2f * 10) , sen götürüyorsun doubledeğerini 61,99999809265137 ve 61 verir bir tamsayı, bunu kesiliyor.

Bu durumda float f = 6.2f * 10, çift değeri 61.99999809265137'yi alıp en yakın değere yuvarlarsınız .float 62. Ardından söz konusu kesmek olan floatbir tam sayıya ve sonuç 62'dir.

Alıştırma: Aşağıdaki işlem sırasının sonuçlarını açıklayın.

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

Güncelleme: açıklamalarda belirtildiği gibi, ifade 6.2f * 10resmen olduğu floatikinci parametre beri bir örtülü dönüşüm vardır floathangi daha iyi a'dır double.

Asıl sorun, derleyicinin resmi türden (bölüm 11.2.2) daha yüksek hassasiyete sahip bir ara ürünü kullanmasına izin verilmesidir (ancak zorunlu değildir ) . Bu nedenle farklı sistemlerde farklı davranışlar görüyorsunuz: İfadede (int)(6.2f * 10), derleyicinin değeri tutma seçeneği vardır.6.2f * 10 dönüştürmeden önce yüksek hassasiyetli bir ara formdaint . Varsa, sonuç 61'dir. Aksi takdirde, sonuç 62'dir.

İkinci örnekte, floatyuvarlamayı tam sayıya dönüştürmeden önce gerçekleşmeye zorlayan açık atama .

Açıklama

Kayan sayılar nadiren tamdır. 6.2fgibi bir şey 6.1999998.... Bunu bir int'e çevirirseniz, keser ve bu * 10, 61 ile sonuçlanır.

Jon Skeets DoubleConvertersınıfına bakın. Bu sınıfla, bir kayan sayının değerini dize olarak gerçekten görselleştirebilirsiniz. Doublevefloat her ikisi de kayan sayılardır , ondalık değildir (sabit bir noktalı sayıdır).

Örneklem

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

Daha fazla bilgi

• Jon Skeet'in DoubleConverter sınıfı
• Assert.AreEqual () ile System.Double gerçekten kafa karıştırıcı hale geliyor
• Kayan Nokta Aritmetiği Hakkında Her Bilgisayar Bilim Adamının Bilmesi Gerekenler

IL'ye bakın:

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

Derleyici, derleme zamanı sabiti ifadelerini sabit değerlerine indirger ve sabiti dönüştürdüğünde bir noktada yanlış bir yaklaşım yaptığını düşünüyorum int. Durumda speed2, bu dönüşüm derleyici tarafından değil, CLR tarafından yapılır ve farklı kurallar uyguluyor gibi görünüyorlar ...

Tahminim şudur ki 6.2f, float hassasiyetli gerçek temsil, 6.1999999while 62fise muhtemelen benzer bir şeydir 62.00000001. (int)çevrim her zaman ondalık değeri keser bu yüzden bu davranışı elde edersiniz.

DÜZENLEME : Yorumlara göre, intçok daha kesin bir tanıma göre döküm davranışını yeniden ifade ettim .

Bu kodu derledim ve demonte ettim (Win7 / .NET 4.0 üzerinde). Derleyicinin kayan sabit ifadeyi double olarak değerlendirdiğini tahmin ediyorum.

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 

Singlesadece 7 basamaklı bir yer tutar ve bunu bir Int32derleyiciye çevirirken tüm kayan noktalı basamakları keser. Dönüştürme sırasında bir veya daha fazla önemli basamak kaybolabilir.

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

619999980 sonucunu verir, böylece (Int32) (6.2f * 10), 61 verir.

İki Single çarpıldığında farklıdır, bu durumda kesik işlem yoktur, sadece yaklaşık değer vardır.

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

intAyrıştırmak yerine yazı yazmanızın bir nedeni var mı ?

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

sonra okurdu

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

Aradaki fark büyük olasılıkla yuvarlamayla ilgilidir: eğer doubleona çevirirseniz muhtemelen 61.78426 gibi bir şey elde edeceksiniz.

Lütfen aşağıdaki çıktıya dikkat edin

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

Bu yüzden farklı değerler alıyorsunuz!