# Re: comparison operators and *typos

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

```======= At 2005-06-20, 10:06:21 Aubrey Jaffer wrote: =======

> | procedure: = z1 z2 z3 ...
> | procedure: < x1 x2 x3 ...
> | procedure: > x1 x2 x3 ...
> | procedure: <= x1 x2 x3 ...
> | procedure: >= x1 x2 x3 ...
> |     These procedures return #t if their arguments are (respectively):
> |     equal, monotonically increasing, monotonically decreasing,
> |     monotonically nondecreasing, or monotonically nonincreasing.
> |
> | ...
> | (= 0 -0)                        ==>  #t
> |
> |     For any finite positive number x:
> |
> | (< #e-1/0 -x -0 0 x 1/0))       ==>  #t
> |
> |     These predicates are required to be transitive.
>
>A sequence cannot be both equal and monotonically increasing.
>(= -0 0) conflicts with (< -0 0).
>

My fault. (= -0 0) should be #f.

> | library procedure: infinite? z
>
>"Infinite" means not finite.  R5RS has `ZERO?' but not `NONZERO?';
>`POSITIVE?', but not `NONPOSITIVE?'; `NEGATIVE?' but not `NONNEGATIVE?'
>`FINITE?' is more in keeping with R5RS procedure names.

The reason I define "infinite?" instead of "finite?" is that:

(cond ((infinite? x) ...)
((zero? x) ...)
...)

As I understand the problem, we always use a predicator to select a
minority (with some single character) (instead of a big part that can
be further divided) form the whole.

>
> | library procedure: zero? z
> | library procedure: positive? x
> | library procedure: negative? x
> | library procedure: odd? n
> | library procedure: even? n
> |     These numerical predicates test a number for a particular
> |     property, returning #t or #f. See note above.
> |
> | (positive? #e1/0)             ==>  #t
> | (negative? #e-1/0)            ==>  #t
> | (infinite? #e-1/0)            ==>  #t
> | (infinite? #e0/0)             ==>  #t
> | (positive? 0)                 ==>  #f
> | (negative? -0)                ==>  #f
>
>What does (zero? -0) return?
>
>If (negative? -0) returns #f, and (= -0 0) returns #t, how does one
>test for `-0'?

(zero? -0) ==> #t

>
> | procedure: numerator q
> | procedure: denominator q
> |     These procedures return the numerator or denominator of their
> |     argument; the result is computed as if the argument was
> |     represented as a fraction in lowest terms.  The denominator is
> |     always positive or zero.  The denominator of 0 is defined to be
> |     1.
> |
> | (numerator (/ 6 4))                    ==>  3
> | (denominator (/ 6 4))                  ==>  2
> | (denominator
> |   (exact->inexact (/ 6 4)))            ==> 2.0
> |
>*| (denominator #e1/0)                    ==>  1
>*| (denominator #e-1/0)                   ==>  -1
>*| (numerator #e1/0)                      ==>  0
>*| (numerator #e-1/0)                     ==>  0
>
>*Should numerator and denominator be swapped in the last 4 lines?

Yes. My fault.

>
>What does (exact? -0) return?
>What does (integer? -0) return?
>What does (rational? -0) return?
>What does (numerator -0) return?
>What does (denominator -0) return?
>
>What does (floor -0) return?
>What does (ceiling -0) return?
>
>What does (* -0 -0) return?
>What does (sqrt 0) return?

>
> | procedure: - z1 z2
> | procedure: - z
> | optional procedure: - z1 z2 ...
> | procedure: / z1 z2
> | procedure: / z
> | optional procedure: / z1 z2 ...
> |     With one argument, these procedures return the additive or
> |     multiplicative inverse of their argument.
> |
> |     With two or more arguments:
> |
> |     (- z1 . z2)   =>   (apply + z1 (map - z2))
> |     (/ z1 . z2)   =>   (apply * z1 (map / z2))
> |
> | (- 0)                                  ==>  -0
> | (- -0)                                 ==>  0
> | (- #e1/0)                              ==>  #e-1/0
> | (- #-e1/0)                             ==>  #e1/0
> | (- 3)                                  ==>  -3
> |
> | (/ 0)                                  ==>  #e1/0
> | (/ -0)                                 ==>  #e-1/0
>*| (/ #e1/0)                              ==>  #0
>*| (/ #e-1/0)                             ==>  #-0
> | (/ 3)                                  ==>  1/3
>
>*Should `==>  #' be replaced with `==>  #e'?

Typo.

(/ #e1/0)                              ==>  0
(/ #e-1/0)                             ==>  -0

>
> | Implementation
> |
> | Here is my implementation, which is based on a Scheme implementation
> | that supports arbitrary-big integer arithmetic as well as exact
> | rational number computation.  To avoid confusion with identifies in
> | base-Scheme, all procedures defined in this SRFI (except infinite?)
> | and prefixed with "my" or "my-".  This reference implementation also
> | requires SRFI-9, SRFI-13, SRFI-16, and SRFI-23.
> |
> | (separate file attached)
>
>There is no link to the implementation file.
>

It is at http://srfi.schemers.org/srfi-73/exact.scm

Sorry that I have made so many typos. A revised verions has been send to
Mike Sperber.

-
Chongkai Zhu

```