Re: float with 24-bit resolution

[Ludovic Brenta <ludovic.brenta@insalien.org>]

Mark Johnson <mark_h_johnson@raytheon.com> writes:
> Actually, if you look at it carefully, binary can be an acceptable
> alternative - but you must use it in a different manner. For example,
> representing a number with two decimal digits of precision as an integer
> can be done where
>   042 (a value in memory / register)
> is interpreted as
>   0.42
> in calculations and for display to the user. We generated data of that
> type (ages ago) on a machine that had no packed decimal types (nor
> floating point). That machine then sent the data to a "display computer"
> where a software divide by 10 routine (no hardware divide) was used to
> generate the values to display to the user. That method did a few more
> calculations to conserve scarce I/O resources.
> 
> For machines where packed decimal is supported, what you say is true,
> but it is not the only alternative. This other way of looking at fixed
> types in general is simply to treat like integers - with a specified
> value as the LSB (not one). In the example above, the LSB is 0.01. The
> compiler still has to work out all the arithmetic operations and side
> effects, but it is feasible. 

What you describe is a second-best solution, and by your own accord
you only used it because the target hardware did not support
packed-decimal representations.  Your divide-by-10 routine was the
weak point; 10 happens not to be a power of two, and therefore any
division of a binary number by 10 is bound to introduce rounding and
imprecision.  You may minimise the impact of that by doing the
division as late as possible, e.g. for display purposes; this is
probably what made the solution acceptable to you.  However, if your
program must write to a text file that serves as input to another
program (and then another, etc.), then the loss of precision quickly
becomes unacceptable.

Well, all of this is off-topic; here's a nice way to come back to Ada:

ARM B.4(13), package Interfaces.COBOL:

type Decimal_Element  is mod implementation-defined;
type Packed_Decimal is
   array (Positive range <>) of Decimal_Element;
pragma Pack(Packed_Decimal);

:)

-- 
Ludovic Brenta.