======= 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?

Please see the implementation.

>
> | 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