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

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

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

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

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

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