Casting double to ulong weirdness

[Steven Schveighoffer via Digitalmars-d]

On 8/24/15 2:38 PM, Steven Schveighoffer wrote:
> On 8/24/15 2:06 PM, rumbu wrote:
>> BTW, 1.2 and 12.0 are directly representable as double
>>
>> In C++:
>>
>> printf("%.20f\r\n", 1.2);
>> printf("%.20f\r\n", 12.0);
>>
>> will output:
>>
>> 1.20000000000000000000
>> 12.00000000000000000000
>>
>> Either upcasting to real is the wrong decision here, either the writeln
>> string conversion is wrong.
>
> I don't think they are directly representable as floating point, because
> they are have factors other than 2 in the decimal portion. From my
> understanding, anything that only has to do with powers of 2 are
> representable in floating point, just like you cannot represent 1/3 in
> decimal exactly.
>
> But there is definitely something weird going on with the casting.
>
> I wrote this program:
>
> testfp.d:
> extern(C) void foo(double x);
> void main() {
>      double x = 1.2;
>      foo(x);
> }
>
> testfp2.d:
> extern(C) void foo(double x)
> {
>      import std.stdio;
>      writeln(cast(ulong)(x * 10.0));
> }
>
> testfp2.c:
> #include <stdio.h>
>
> void foo(double x)
> {
>      printf("%lld\n", (unsigned long long)(x * 10));
> }
>
>
> If I link testfp.d against testfp2.c, then it outputs 12. If I link
> against testfp2.d, it outputs 11.
>

More data:

It definitely has something to do with the representation of 1.2 * 10.0 
in *real*.

I changed the code so that it writes the result of the multiplication to 
a shared double.

In this case it *works* and prints 12, just like C does.

This also works:

double x = 1.2;
double y = x * 10.0;
writeln(cast(ulong)y); // 12

However, change y to a real, and you get 11.

Note that if I first convert from real to double, then convert to ulong, 
it works.

This code:

     double x = 1.2;
     double x2 = x * 10.0;
     real y = x * 10.0;
     real y2 = x2;
     double y3 = y;
     writefln("%a, %a, %a", y, y2, cast(real)y3);


outputs:

0xb.ffffffffffffep+0, 0xcp+0, 0xcp+0

So some rounding happens in the conversion from real to double, that 
doesn't happen in the conversion from real to ulong.

All this gets down to: FP cannot accurately represent decimal. Should 
this be fixed? Can it be fixed? I don't know. But I would be very 
cautious about converting anything FP to integers without some epsilon.

-Steve