On Monday, 24 August 2015 at 19:23:44 UTC, Steven Schveighoffer
wrote:
On 8/24/15 1:43 PM, bachmeier wrote:
On Monday, 24 August 2015 at 16:52:54 UTC, Márcio Martins
wrote:
I'm posting this here for visibility. This was silently
corrupting our
data, and might be doing the same for others as well.
import std.stdio;
void main() {
double x = 1.2;
writeln(cast(ulong)(x * 10.0));
double y = 1.2 * 10.0;
writeln(cast(ulong)y);
}
Output:
11
12
to!ulong instead of the cast does the right thing, and is a
viable
work-around.
Issue: https://issues.dlang.org/show_bug.cgi?id=14958)
I would not describe to!ulong as a "work-around". You just
discovered
one of the reasons to! exists: it is the right way to do it and
cast(ulong) is the wrong way. As the others have noted,
floating point
is tricky business, and you need to use the right tools for
the job.
real y = x * 10.0;
writeln(y.to!ulong); // 11
to! does not do anything different than cast. What is happening
here is the implicit cast from real to double. D treats the
result of x * 10.0 as type double, but it's done at real
precision. In that conversion, the error is hidden by a
rounding automatically done by the processor I think.
-Steve
Whatever the issue is, it is not unavoidable, because as has been
shown, other languages do it correctly.
From the data presented so far, it seems like the issue is that
the mul is performed in 80-bit precision, storing it before the
cast forces a truncation down to 64-bit. Similarly, passing it to
a function will also truncate to 64-bit, due to ABIs. This is why
to! works as expected.
Please do keep in mind that the issue is not one of precision,
but one of inconsistency. They are not the same thing. The result
being 11 or 12 is irrelevant to this issue. It should just be the
same for two instances of the same expression.
In an attempt to make things more obvious, consider this example,
which also illustrates why to! works, despite apparently doing
nothing extra at all.
double noop(double z) {
return z;
}
void main() {
double x = 1.2;
writeln(cast(ulong)(x * 10.0));
writeln(cast(ulong)noop(x * 10.0));
}
Outputs:
11
12
