# Re: comparison operators and *typos

This page is part of the web mail archives of SRFI 70 from before July 7th, 2015. The new archives for SRFI 70 contain all messages, not just those from before July 7th, 2015.

```> How will your system represent ((lambda (x) (+ 4. (/ (abs x) x))) 0.)?

- It can't, it only attempts to deal with an ambiguous sign, not magnitude.

(but have been convinced it's not worth the bother)

> Mathematically there is no reciprocal of zero.  It can be argued that
> (/ 1.0 0.0) should return #i0/0 or signal an error.  But (/ 1.0 +0.0)
> should return #i1/0 if +0.0 is greater than 0.

- if the convention that non-signed values are presumed positive, then
by definition 0.0 is +0.0, and to eliminate any ordering ambiguity,
there must be only 3 zeros: inexact -0.0, exact 0, inexact +0.0 (0.0)
with the three corresponding reciprocals -1/0, 0/0, +1/0; where all exact
zero's are equivalent: +0 => 0, -0 => 0, +0/0 => 0/0, -0/0 => 0/0, and
only like signed inexact zero's are non-ambiguous: (+ +0.0 +0.0) => +0.0,
(+ -0.0 -0.0) => -0.0, (+ -0.0 +0.0) => 0/0, (+ -1/0 +1/0) => 0/0

> The inexact real field must have an additive identity:
>
>   ForAll[x] x + 0.0 = x
>
> If -0.0 + 0.0 is not -0.0, then 0.0 is not the additive identity.
> What is it in your system?

All zero's are non-accumulating, therefore all additive identities for
values other than inexact zero's, however only exact 0 is an additive
identify for all values.

```