Re: Fixed point constants issue

["Vinzent Hoefler" <nntp-2010-09@t-domaingrabbing.de>]

On Mon, 13 Sep 2010 21:05:58 +0200, Niklas Holsti  
<niklas.holsti@tidorum.invalid> wrote:

> Vinzent Hoefler wrote:
>
>  > I would expect the compiler to evaluate the expression
>  > "HEIGHT * FEET_PER_METER" [for TEN_FEET_2] _before_
>  > converting it to the appropriate fixed point type.
>
> The declaration of TEN_FEET_2 is an object declaration with type  
> Altitude, therefore the right-hand-side expression is expected to be of  
> type Altitude and so the "*" will be resolved to the Altitude  
> multiplication operator "*" (Left, Right : Altitude) return Altitude,  
> with result zero.

That's what I suspected. So, although the result is seriously wrong  
compared
to the mathematical result of the given static expression, the compiler is
still correct? :(

> I agree that this is a bit nasty and counter-intuitive. Perhaps the  
> compiler should warn that the conversion of the universal_real number  
> 0.3048 to Altitude is seriously inexact, but then, what is "seriously"?

Well, GNAT warns with a "static fixed-point value is not a multiple of
Small", but this one is quite useless, because that warning is issued for
virtually every expression in the example, so it's hard to identify the
real problematic cases.

>> And, obviously it does this that when evaluating
>>    TEN_FEET_4 : constant Altitude := Altitude (HEIGHT * FEET_PER_METER);
>
> Here the right-hand side expression is a type conversion, in fact a
> value conversion, and so the operand HEIGHT * FEET_PER_METER is expected
> to be of any numeric type. At first sight the multiplication could be
> resolved to the root "*" or to the Altitude "*", which would thus be
> ambiguous. However, RM 8.6(29) says that the ambiguity is resolved by
> using the root "*", giving the more precise result.

Right. That was the part of the ARM I didn't read. Obviously I was too
focused on the fixed point arithmetic model in Annex G 2.3.

So, it's the other compiler that does it wrong (according to my colleague,
only GNAT gives the "wrong" results)? I may run a short test tomorrow to
confirm that this is really the case.

There isn't any paragraph in the ARM that would allow the compiler to
arbitrarily choose any of both interpretations, is there?


Vinzent.

-- 
There is no signature.