"Bill Page" <[EMAIL PROTECTED]> writes:
[...]
| > | However as I understand it, values in the domain FLOAT are
| > | to be taken as exact rationals that approximate real numbers in
| > | a well defined manner. Is this an accurate view? Are there specific
| > | changes that should be made to these floating point domains that
| > | would make their associated algebra more obvious?
| >
| > As far as I know all floating point systems define a subset of
| > rational numbers as approximation to the reals; they come with
| > projections (rounding mode) for delivering result of computations.
| > Also, see Language Independent Arithmetic, part 1.
| >
|
| Well in the context of this thread a specific example might be -0. As
| I understand it, the reason that this value is not included in the
| domain Float is because the representation used there has no room for
| it. Instead, the values in Float are *exactly* the numbers
|
| mantissa*base^exponent
|
| where base=2 and mantissa and exponent are values from domain Integer.
One of the differences between that representation and the one in IEEE
is that in IEEE's system, you always get a sign component in {-1,+1}.
In the Float's representation, you also get a sign component, but in
{-1,0,+1}, and when the sign projection goes to -1 or +1, the mantissa is
required to be non-zero (whereas it can be zero in the IEEE system).
It is not accurate that there is "no room" to represent -0.
There is plenty room -- it is just required to be ignored, therefore
the implementation takes advantages of that. Notices that I'm trying
to make a distinction between a specification and an implementation --
I don't take implementations as `God given'.
| These rational values always have an exact representation in the
| domain Fraction Integer and form a specific subset of the real
| numbers. Among other things, this makes equality in Float fully
| transitive, where as in some other floating point systems this might
| not be the case.
I do not understand what you mean by that. In the IEEE's system,
-0 compare equal to +0. The only way you get the sign is when you ask
for it.
| Simiarly, %plusInfinity and %minusInfinity are not
| values in Float.
|
| IEEE floats however are something different - wouldn't you agree?
It is as different as short integer is different from long long
interger :-) Note that floating point systems are parameterized, and
not all of them are algebraically closed. The IEEE system, as an
algebra, is closed.
| What I was supposing is the maybe the domain DoubleFloat (which currently
| looks more or less just like a fixed precision version of Float)
| should be given semantics that more closely resembles IEEE 754-2008.
In OpenAxiom, DoubleFloat is supposed to reflect a (64-bit) double
precision IEEE-754 floating point datatype. Only Lisp misabstractions
get in the way; but thankfully SBCL and ECL provides some (limited)
ways to get around thise overabstractions.
Which reminds me that I need to get Bemol up and running, so that I
can dump the Lisp stuff.
-- Gaby
-------------------------------------------------------------------------
This SF.Net email is sponsored by the Moblin Your Move Developer's challenge
Build the coolest Linux based applications with Moblin SDK & win great prizes
Grand prize is a trip for two to an Open Source event anywhere in the world
http://moblin-contest.org/redirect.php?banner_id=100&url=/
_______________________________________________
open-axiom-devel mailing list
open-axiom-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/open-axiom-devel
