# Re: Nitpick with FLOOR etc.

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.

``` | Date: Wed, 27 Jul 2005 08:55:59 -0700 (PDT)
| From: bear <bear@xxxxxxxxx>
|
| In practical terms, I think that "infinity" as it's being
| discussed here is properly an error object rather than a
| numeric value, and I would be satisfied with a scheme
| where numeric operations returned an error object if asked
| to do anything involving a range overflow, underflow, or
| where an argument were an error object.

0/0. is an error object (SRFI-70 calls it an error waiting to happen),
but +/0. and -/0. behave differently from error objects when inverted:
(/ +/0.) ==> 0.0; and in numerical comparisons.

| But naming an error object "infinity" is misleading, since the
| value the user sees may be nine or ninety operations further down
| the pipeline after the "overflow" has been divided, subtracted,
| inverted, etc.

Inverting +/0. or -/0. returns 0.0.  So the name "error object"
wouldn't seem to apply either.

| This brings up an important distinction in "infinities;"
| When you divide by exact zero you get an absolute infinity.
| (which, perversely, is neither positive nor negative, because
| exact zero isn't positive or negative.) Call this EO1.

We have already covered this ground.  Division by zero is undefined;
SRFI-70 extends division by returning infinities in these cases:
(/ -5. 0) ==> -/0.; (/ 1. 0) ==> +/0., which are consistent with
the one-sided limits:

(limit / 0 1.0e-9)                              ==> +/0.
(limit / 0 -1.0e-9)                             ==> -/0.

| When you divide 1 by (say) 5e-323, you get a different kind of
| EO, which is "results too large to represent" but which
| is often mistaken for an actual infinity.   Call this EO2.

The result of division by zero was chosen to be the same as the result
of (/ 1 5e-323).  We could split +/0 into any number of regions.  One
was chosen, which happens to be supported by IEEE-754.

```