Re: fixed point vs floating point

[dewar@merv.cs.nyu.edu (Robert Dewar)]

Joe says

<<The fixed point arithmetic in the Ada83 compilers that we used and tested
  in those days didn't work well or even correctly in many cases, so we
  never used it.  I don't offhand recall doing an Ada job that didn't use
  floating point; Ada83 was mostly used on the larger computers, such as
  VAXes and Silicon Graphics boxes, so the issue never came up.   The
  exception may have been XD Ada from System Designers (where are they now?)
  on the 68020.>>

While I can't speak for all Ada 83 compilers, I certainly know many of them
that did fixed-point just fine. It has actually been my experience that in
most cases where users thought Ada 83 compilers were doing things wrong, it
was because they did not understand the Ada 83 fixed-point semantics properly,
so it would be interesting to know specifically what Joe is referring to.

<<So, why do we prefer floating point, speed aside?  Because it's easier to
  program with, as scaling issues go away, and so it's much easier to get
  right.  Remember, the traditional comparison was with manually-implemented
  scaled binary.  The fact that floating point arithmetic is approximate
  isn't much of an issue for most physics-based mathematical code, and those
  places that are exceptions are still *much* less trouble to deal with than
  the traditional scaled binary.>>

So how do we square this with Robert Eachus claim that it is *easier* to
analyze fixed-point code. Simple actually, it depends on what you are doing.
If you are writing code casually, without careful error analysis, then it is
indeed true that floating-point is easier, but if you are doing careful
error analysis, then fixed-point is usually easier. Joe's offhand comment
about errors not being an issue for most physics-based mathematical code
(I do not agree!) clearly indicates that we are dealing with the casual
approach here, so in that context Joe's comment makes good sense.

<<With Ada95 (which I assume has fixed the Ada83 problems with fixed-point
  arithmetic)>>

I really don't know what problems might be fixed, since I don't know of
problems in Ada 83, at least not ones that are likely to be what Joe is
referring to, so I can't say whether these problems have been fixed!
Certainly to the extent that Joe was seeing compiler bugs in compilers
I am unfamiliar with, this seems to have no relationship to Ada 95.