Understanding the given calculation (cast + multiplication)

Question

(int)((float)10.9 * 10)

is evaluated to 108. Why?

IMO the (int)-cast should be evaluated after the multiplication.

Answer 1

Amusingly enough, the issue here is that the expression is calculated at compile time, apparently using single precision math as expected. This happens in both debug and release builds:

    // this replaces the whole operation
    IL_0001: ldc.i4.s 108
    IL_0003: stloc.0
    IL_0004: ldloc.0
    IL_0005: call void [mscorlib]System.Console::WriteLine(int32)

While the case var f =((float)10.9 * 10);int i = (int)f; is still optimized for the multiplication, but using double precision. Because the cast is done in a separate step I guess it confuses the compiler (??):

    IL_000b: ldc.r4 109      // 109 result for the first part
    IL_0010: stloc.1
    IL_0011: ldloc.1
    IL_0012: conv.i4         // separate conversion to int
    IL_0013: stloc.2
    // rest is printing it
    IL_0014: ldloc.1
    IL_0015: box [mscorlib]System.Single
    IL_001a: ldstr " "
    IL_001f: ldloc.2
    IL_0020: box [mscorlib]System.Int32
    IL_0025: call string [mscorlib]System.String::Concat(object, object, object)
    IL_002a: call void [mscorlib]System.Console::WriteLine(string)

Honestly I'd say the compiler is generating wrong code in the second case, which is probably why C++ avoids optimizing floating point code like the plague. Luckily, this is only an issue for this kind of test code which can be done fully at compile time, actual variable multiplication would be fine.

I actually tried this too:

Console.WriteLine((int)(float.Parse(Console.ReadLine()) * int.Parse(Console.ReadLine())));

and gave it 10.9 and 10, and the result was 108 as expected.

Answer 2

That is exactly the case. It's just that 10.9 is slightly less than 10.9 due to the way floating point numbers are represented (10.9 cannot be represented exactly, so you get an approximation, which in this case is something like 10.89999999...). The cast then truncates any digits following the decimal point. So you get 108.

Exact values are as follows here (obtained with Jon Skeet's DoubleConverter class):

10.9         -> 10.9000000000000003552713678800500929355621337890625
(float) 10.9 -> 10.8999996185302734375

Multiplying that float by 10 and then cutting off all decimal places will obviously result in 108.

Answer 3

Your float result, before casting to int, is 108.9999 because 109.0000 can't be represented in floating point. (As mentioned in comments, that's wrong; 109 can be represented just fine, but somehow the expression results in 108.9999 -- the following still applies)

The int value will be 108. Why? Casting from floating point (double or float) to int truncates the decimal part. It doesn't round. So it cuts off the .9999 and you get 108.

To round, replace the cast by Math.Round() or Convert.ToInt32().

Convert.ToInt32((float) 10.9 * 10);