Re: conversions between fixed-point types

[Adam Beneschan <adam@irvine.com>]

On Sep 18, 2:35 pm, Dirk Herrmann <fight_s...@invalid.invalid> wrote:
> Hi,
>
> I am currently trying to learn about Ada's fixed-point types, and there
> are some points that I couldn't find any statement about, or which I
> simply could not understand.
>
> (Background: At my company there is a lot of code that makes heavy use
> of fixed-point calculations in a proprietary language.  This language
> offers special support for fixed-point arithmetics.  I am investigating
> whether Ada would be a better choice, and thus the fixed-point handling
> is important.  Note that the decision to use fixed-point arithmetics is
> due to the fact that the target processors do not have a floating point
> unit - and this will remain this way for some time.)
>
> The first set of questions I have is about conversions between different
> fixed-point types.
>
> I realized that with GNAT for the following example types
>     type FpA is delta 0.5 range -10.0 .. +10.0;
>     for FpA'Small use 0.5;
>     type FpB is delta 0.4 range -10.0 .. +10.0;
>     for FpB'Small use 0.4;
> conversions from FpA to FpB work as follows:
>
>     FpA       FpB
>     -1.5 ---> -1.2
>     -1.0 ---> -0.8
>     -0.5 ---> -0.4
>     -0.0 ---> -0.0
>     +0.5 ---> +0.4
>     +1.0 ---> +0.8
>     +1.5 ---> +1.2
>
> That is, the conversion is performed similar to a truncation (always
> choosing the closest value towards zero).  However, in principle there
> are other possibilities how the conversion could be done:
>
>                truncation  floor  ceiling  round
>     -1.5 --->  -1.2        -1.6   -1.2     -1.6
>     -1.0 --->  -0.8        -1.2   -0.8     -1.2
>     -0.5 --->  -0.4        -0.8   -0.4     -0.4
>      0.0 --->   0.0         0.0    0.0      0.0
>     +0.5 --->  +0.4        +0.4   +0.8     +0.4
>     +1.0 --->  +0.8        +0.8   +1.2     +1.2
>     +1.5 --->  +1.2        +1.2   +1.6     +1.6
>
> First question:
>
> There does not seem to be any definite statement in the reference manual
> of Ada 2005 about how exactly the conversion has to be performed.  All
> of the above (and probably more options) seem to be legal, and GNAT just
> chooses truncation.  Is that right, or have I already missed something?

I think you're right, even if the implementation supports the Numerics
Annex (based on G.2.3(10,24)).

> I have not even found a statement that a compiler has to be consistent
> with respect to the strategy it chooses.  It might be possible that for
> different conversions within the same program different strategies are
> chosen.  Regarding GNAT, I could not find any statement in the GNAT
> documentation about whether GNAT will do it the same way throughout.
>
> Second question:
>
> Is there any way to control how the conversion is performed?  Maybe I
> have missed something and the language itself offers some possibility?
> Is there, for example, some attribute S'Round(X : some fixed point type)
>   that rounds X to the nearest value of S?  I could not find anything
> like that.
>
> Or, if this is not the case, do any libraries exist that provide generic
> conversion functions to achieve some or all of the "truncate", "floor",
> "ceil" or "round" behaviours?  As I mentioned at the top of the mail,
> any solutions that would require conversions between fixed-point and
> floating-point to implement these conversions would probably not be
> acceptable for our systems.

The following seems to work if you want to round:

   X : FpA;
   Y : FpB;

   Y := Integer (X / FpB'Small) * FpB'Small;

The conversion to Integer will round (4.6(33)).  I didn't check the
resulting code, but this shouldn't use any floating-point operations.

Unfortunately, I can't think of a good solution if you want to insist
(portably) on truncation, even though GNAT does this by default.
Floor and Ceiling probably require you to write a conditional that
behaves differently depending on whether X is < 0 or > 0, but on most
processors that is probably about as efficient as if support for this
existed in the language and the compiler generated the code itself.

                                    -- Adam