Re: The disturbing myth of Eiffel portability

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

Kaz says

"Any computer scientist worth his salt knows that floating point numbers are
only approximations of real quantities. Well written numerical analysis code
takes this into consideration, and can be made portable.

You cannot expect bit for bit equality from portable floating point code, but
you can write the program in such a way that it will produce well-behaved
approximations, and so that it will produce better and better approximations on
more and more capable numerical processors.   The fact is that forcing each
implementation of a language to do floating point math precisely the same way
is completey impractical, because it would impose a *huge* performance hit
which is often not acceptable in number crunching."


Many computer scientists have this view of floating-point, but at least in
the IEEE world, this is an incorrect view. IEEE arithmetic is NOT an
approximation of real arithmetic, but rather an EXACT implementation of
a very well defined arithmetic, whose axioms are well understood. 

The idea that it is wrong to test for exact equality is quite incorrect,
there are many algorithms where it is perfectly legitimate to test for
exact equality if you know you are dealing with IEEE arithmetic.

This *huge* performance hit occurs on fewer and fewer machines, nearly all
machines now support IEEE arithmetic, and the decision to require this
semantis in Java represents a final nail in the coffin for weird (and often
badly designed) non-IEEE arithmetic systems.