Re: GNAT Optimization of Constant Expressions

["Randy Brukardt" <randy@rrsoftware.com>]

"Ray Blaak" <rAYblaaK@STRIPCAPStelus.net> wrote in message
news:u1whep09x.fsf@STRIPCAPStelus.net...
> "Randy Brukardt" <randy@rrsoftware.com> writes:
> > One example is:
> >      Y := (X - 0.5) - 0.5;
> >
> > You might think that replacing this with
> >     Y := X - 1.0;
> > would be a good idea, but actually it reduces the accuracy of the result
>
> I don't understand this. Both 0.5 and 1.0 have "exact" binary
representations
> right?
>
> Can you give a value of X where this would hold?

I'm not a numerical analysist, I only play at one when implementing
compilers... ;-) but let me give my understanding.

If the machine does not keep extra precision between operations (that is,
the floating point registers are the same size as the in-memory
representation), and abs X is < 1.0, then
    (X - 0.5) - 0.5
will have one more bit of precision than
    X - 1.0
will. That occurs because in order to add or subtract, the smaller value has
to be shifted to match the larger value, which will cause bits to fall off
the end of the smaller value. 1.0 requires more shifting than 0.5 does. This
sort of expression is common in trig. libraries (for instance, in a software
implementation of Sin). And a trig. library is the last place that you would
want a hair-brained optimizer losing accuracy!

It should be pointed out that on Intel hardware, the original condition does
not hold (extra precision *may* be kept between operations). However, it
still might hold if common subexpressions are preevaluated into memory (as
in the OP's program with the unused constants). Thus, the optimizer still
has to be wary of reordering (and most optimizers are designed to work on a
variety of hardware, not just Intel chips.).

                           Randy.