Re: floating point comparison

[dewar@merv.cs.nyu.edu (Robert Dewar)]

Lynn says

<<I did something like this a few years back, to show someone the problem
- and was very surprised when the results was equal, even though
(x/10.0) has no exact representation on a binary-based computer. Then I
looked at the generated code - and the COMPILER had optimised away all
the operations and just set x=y=1.0. There weren't any computations. I
think it was in someone's C (either Borland or Microsoft), but it's too
far back to remember the language/compiler details.
>>


Note that such an optimization MUST give EXACTLY the same result as
would be obtained at run-time, or the compiler is violating a specific
requirement of the IEEE standard.

However, in Ada, watch out! The rules for static expressions conflict
with this requirement. So be careful using constants in Ada, you may
be requiring over-precise evaluation at compile time.

But if only variables are involved, an optimizer is being naughty if
it violates these rules. Similar optimizations that are verboten are:

    x := y / constant1;   =>   x := y * (1.0 / constant1);

Actually this is an interesting case, the Ada RM allows this transformation
if the model interval of the result is the same, but the IEEE standard
only permits the optimization if the results are bit for bit identical.

GNAT follows the IEEE standard here, or at least intends to, if you find
a counterexample, it is a bug, please submit it (we know of no such bugs,
and indeed the  gcc backend goes out of its way to avoid incorrect
optimizations of this type)

Robert Dewar
Ada Core Technologies