Re: fixed point vs floating point

[gwinn@res.ray.com (Joe Gwinn)]

In article <dewar.881006262@merv>, dewar@merv.cs.nyu.edu (Robert Dewar) wrote:

> Joe said
> 
> <<Who said we expected Ada83 fixed point types to solve all problems?  What
> we hoped for was that conversion between scalings and normalizations after
> arithmetic would be handled, and they weren't.  This, one could expect a
> language to do.>>
> 
> Well we are still unclear as to what are language issues here, and what
> are issues of bad implementation (i.e. bugs or bad implemenation choices
> in the compiler), and so are you :-) In fact we still have no convincing
> evidence that there were *any* compiler problems from what you have recalled
> so far.

I neither know nor care if this is an Ada language design issue.  I don't
buy and use language designs or even languages, I buy and use compilers. 
It doesn't much matter if we are today convinced or not; the decision was
made then, based on the compilers then available.  It may be different
today, but I don't see many people using fixed point where floating point
is available.


> As to expecting the language to do scaling autoamtically, I think this is
> a mistake for fixed-point. PL/1 tried and failed, and COBOL certainly
> does not succeed (a common coding rule in COBOL is never to use the
> COMPUTE verb, precisely because the scaling is not well defined).

Whoa.  Read my words again.  "Scalings" are nouns, not verbs.  In this
context, a "scaling" is the (human) decision of where to put the binary
point, and what the value of the least significant bit shall be.  Scalings
are static, done as part of code design, and documented in Interface
Control Documents and Interface Design Documents.  Remember, this is 1960s
era stuff.  

This information can in theory be declared to a suitably designed
compiler, which can then deal with the details of normalization, a boring
mechanical process that humans aren't very good at.  


> I think any attempt to automatically determine the scaling of intermediate
> results in multiplications and divisions in fixed-point is doomed to failure.
> This just *has* to be left up to the programmer, since it is highly
> implementation dependent.

No, it isn't hopeless.  It's quite simple and mechanical, actually.  If it
were imposssible, why then did Ada83 attempt it?  It's exactly the same
rules we were taught in grade school for the handling of decimal points
after arithmetic on decimals, especially multiplication and division. 
Ada83 should have been able to do it, given the information provided when
the various variables types were defined.


> I have no idea what you mean by "normalizations". This term makes no sense
> to me at all in a fixed-point context.

Normalization is also known as rescaling, typically done by right-shifting
the result of a multiplication to put the binary point back where it
belongs in the desired output variable's scaling.  A rounding may also be
done.

Joe Gwinn