# Re: infinity notations

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: Mon, 04 Jul 2005 15:01:28 -0400
| From: Paul Schlie <schlie@xxxxxxxxxxx>
|
| > Some new possibilities have come to light.  Here are all the possible
| > Scheme infinity notations that I know of:
| > Notations C and G use a trailing `.' to indicate inexactness as K
| > does.  This requires a small extension to R5RS number syntax, as
| > rational notation (`1/0') does not currently allow a trailing period.
|
| - however may not be necessary if +Inf is symbolically defined as +1/0.

[R5RS] ... in all implementations a sequence of letters, digits, and
"extended alphabetic characters" that begins with a character that
cannot begin a number is an identifier.  In addition, `+', `-', and
`...' are identifiers.

Since `+' can begin a number, +Inf would not be an identifier unless
it was made one of the "In addition" cases; which is also a syntax
extension.

| And I'll concede my perceived necessity to denote an ambiguously
| signed infinity in exchange for the prevention of incorrectly
| signed infinities, which means that the region about 0 must be
| considered correspondingly invalid, (i.e. both are considered NaN
| or 0/0). yielding:
|
|
|           /  NaN  \         or equivalently:          /  0/0  \
|          /    |    \                                 /    |    \
|         -Inf  |  +Inf                               -1/0  |  +1/0
|         ------+------- (reciprocal projection axis) ------+------
|         -0.0  |   0.0                               -0.0  |  +0.0
|          \    |    /                                 \    |    /
|           \  NaN  /                                   \  0/0  /
|               |                                           |
|               0                                           0
|   (negative projection axis)                  (negative projection axis)
|
| (where NaN and +-Inf may be thought of as symbols defined as 0/0
| and +-1/0)
|
| Which helps eliminates the ordering concern, although it's likely
| still a good idea to define (= -0.0 0 +0.0) => #t, and (< -0.0 0
| +0.0) => #t, etc.

The perceived asymmetry driving all these shades of zero is not a
consequence of infinities, but of mathematical units.  `1/0' is an
extension of division to zero divisors.  But it includes the unit `1'.

If we pick finite, nonzero numerators at random, then n_i/0 will be
negative roughly half of the time.  So there is no imbalance in the
expected proportion of signs of resulting from division by unsigned
zero.

| However then 0/0 denotes all ambiguities in either sign or value,
| even those which may be very small, then Therefore:
|
| (+ +0.0 -0.0) => 0/0 [aka NaN]
|
| as otherwise:
|
|  (/ (+ +0.0 -0.0 +0.0)) :: (/ (+ 0 +0.0)) :: (/ +0.0) => +Inf
|
| [which would be incorrect]
|
| Thereby one can argue that this is actually good, as then the
| iterative sum of alternating infinitely small value about 0 is
| considered ambiguous, which would typically be the case. and
| correspondingly yield 0/0 for all ambiguities in either sign or
| significant magnitude.
|
| (tan pi/2) => 0/0
| (/ 0.0 0.0) => 0/0
|
| and as it may not be obvious, the difference between any two
| equivalently valued inexact value is an exact 0. I.e.:
|
| (- 1.5 1.5) => 0

This violates R5RS; it also is not true for SRFI-70 inexacts, which
represent real intervals.

| as there is no inexact 0, as that would imply a value about 0 with
| an ambiguous sign, which would both have a value range which
| overlaps +0.0, 0, and +0.0; and who's reciprocal was not self
| consistent. (or if one chooses, an exact 0 is equivalent to an
| inexact 0, both mean absolute 0.)

```