X-Git-Url: http://git.hcoop.net/bpt/guile.git/blobdiff_plain/d40681ec4b2431422917796912905906f856e704..ff62c16828d41955455805dd1b427966944b7d27:/test-suite/tests/numbers.test

diff --git a/test-suite/tests/numbers.test b/test-suite/tests/numbers.test
index 195194284..9cf9202bf 100644
--- a/test-suite/tests/numbers.test
+++ b/test-suite/tests/numbers.test
@@ -1,10 +1,10 @@
 ;;;; numbers.test --- tests guile's numbers     -*- scheme -*-
-;;;; Copyright (C) 2000, 2001, 2003 Free Software Foundation, Inc.
+;;;; Copyright (C) 2000, 2001, 2003, 2004, 2005, 2006, 2009, 2010, 2011 Free Software Foundation, Inc.
 ;;;;
 ;;;; This library is free software; you can redistribute it and/or
 ;;;; modify it under the terms of the GNU Lesser General Public
 ;;;; License as published by the Free Software Foundation; either
-;;;; version 2.1 of the License, or (at your option) any later version.
+;;;; version 3 of the License, or (at your option) any later version.
 ;;;; 
 ;;;; This library is distributed in the hope that it will be useful,
 ;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -13,9 +13,12 @@
 ;;;; 
 ;;;; You should have received a copy of the GNU Lesser General Public
 ;;;; License along with this library; if not, write to the Free Software
-;;;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
-(use-modules (ice-9 documentation))
+(define-module (test-suite test-numbers)
+  #:use-module (test-suite lib)
+  #:use-module (ice-9 documentation)
+  #:use-module (srfi srfi-11))  ; let-values
 
 ;;;
 ;;; miscellaneous
@@ -33,6 +36,206 @@
 (define fixnum-min most-negative-fixnum)
 (define fixnum-max most-positive-fixnum)
 
+;; Divine the number of bits in the mantissa of a flonum.
+;; We look for when 2.0^i+1.0 gets rounded, ie. the difference between that
+;; value and 2.0^k is not 1.0.
+;; Of course this assumes flonums have a fixed precision mantissa, but
+;; that's the case now and probably into the forseeable future.
+;; On an IEEE system, which means pretty much everywhere, the value here is
+;; the usual 53.
+;;
+(define dbl-mant-dig
+  (let more ((i 1)
+	     (d 2.0))
+    (if (> i 1024)
+	(error "Oops, cannot determine number of bits in mantissa of inexact"))
+    (let* ((sum  (+ 1.0 d))
+	   (diff (- sum d)))
+      (if (= diff 1.0)
+	  (more (1+ i) (* 2.0 d))
+	  i))))
+
+;; like ash, but working on a flonum
+(define (ash-flo x n)
+  (while (> n 0)
+    (set! x (* 2.0 x))
+    (set! n (1- n)))
+  (while (< n 0)
+    (set! x (* 0.5 x))
+    (set! n (1+ n)))
+  x)
+
+;; `quotient' but rounded towards -infinity, like `modulo' or `ash' do
+;; note only positive D supported (that's all that's currently required)
+(define-public (quotient-floor n d)
+  (if (negative? n)
+      (quotient (- n d -1) d)  ;; neg/pos
+      (quotient n d)))         ;; pos/pos
+
+;; return true of X is in the range LO to HI, inclusive
+(define (within-range? lo hi x)
+  (and (>= x (min lo hi))
+       (<= x (max lo hi))))
+
+;; return true if GOT is within +/- 0.01 of GOT
+;; for a complex number both real and imaginary parts must be in that range
+(define (eqv-loosely? want got)
+  (and (within-range? (- (real-part want) 0.01)
+		      (+ (real-part want) 0.01)
+		      (real-part got))
+       (within-range? (- (imag-part want) 0.01)
+		      (+ (imag-part want) 0.01)
+		      (imag-part got))))
+
+;; return true if OBJ is negative infinity
+(define (negative-infinity? obj)
+  (and (real? obj)
+       (negative? obj)
+       (inf? obj)))
+
+;;
+;; Tolerance used by test-eqv? for inexact numbers.
+;;
+(define test-epsilon 1e-10)
+
+;;
+;; Like eqv?, except that inexact finite numbers need only be within
+;; test-epsilon (1e-10) to be considered equal.  An exception is made
+;; for zeroes, however.  If X is zero, then it is tested using eqv?
+;; without any allowance for imprecision.  In particular, 0.0 is
+;; considered distinct from -0.0.  For non-real complex numbers,
+;; each component is tested according to these rules.  The intent
+;; is that the known-correct value will be the first parameter.
+;;
+(define (test-eqv? x y)
+  (cond ((real? x)
+	 (and (real? y) (test-real-eqv? x y)))
+	((complex? x)
+	 (and (not (real? y))
+	      (test-real-eqv? (real-part x) (real-part y))
+	      (test-real-eqv? (imag-part x) (imag-part y))))
+	(else (eqv? x y))))
+
+;; Auxiliary predicate used by test-eqv?
+(define (test-real-eqv? x y)
+  (cond ((or (exact? x) (zero? x) (nan? x) (inf? x))
+	 (eqv? x y))
+	(else (and (inexact? y) (> test-epsilon (abs (- x y)))))))
+
+(define const-e    2.7182818284590452354)
+(define const-e^2  7.3890560989306502274)
+(define const-1/e  0.3678794411714423215)
+
+
+;;;
+;;; 1+
+;;;
+
+(with-test-prefix/c&e "1+"
+
+  (pass-if "documented?"
+    (documented? 1+))
+
+  (pass-if "0"   (eqv? 1 (1+ 0)))
+  (pass-if "-1"   (eqv? 0 (1+ -1)))
+  (pass-if "100"  (eqv? 101 (1+ 100)))
+  (pass-if "-100" (eqv? -99 (1+ -100)))
+
+  ;; The maximum fixnum on a 32-bit architecture: 2^29 - 1.
+  (pass-if "1+ fixnum = bignum (32-bit)"
+    (eqv? 536870912 (1+ 536870911)))
+
+  ;; The maximum fixnum on a 64-bit architecture: 2^61 - 1.
+  (pass-if "1+ fixnum = bignum (64-bit)"
+    (eqv? 2305843009213693952 (1+ 2305843009213693951))))
+
+;;;
+;;; 1-
+;;;
+
+(with-test-prefix/c&e "1-"
+
+  (pass-if "documented?"
+    (documented? 1-))
+
+  (pass-if "0"    (eqv? -1 (1- 0)))
+  (pass-if "1"    (eqv? 0 (1- 1)))
+  (pass-if "100"  (eqv? 99 (1- 100)))
+  (pass-if "-100" (eqv? -101 (1- -100)))
+
+  ;; The minimum fixnum on a 32-bit architecture: -2^29.
+  (pass-if "1- fixnum = bignum (32-bit)"
+    (eqv? -536870913 (1- -536870912)))
+
+  ;; The minimum fixnum on a 64-bit architecture: -2^61.
+  (pass-if "1- fixnum = bignum (64-bit)"
+    (eqv? -2305843009213693953 (1- -2305843009213693952))))
+
+;;;
+;;; ash
+;;;
+
+(with-test-prefix "ash"
+
+  (pass-if "documented?"
+    (documented? ash))
+
+  (pass-if (eqv? 0 (ash 0 0)))
+  (pass-if (eqv? 0 (ash 0 1)))
+  (pass-if (eqv? 0 (ash 0 1000)))
+  (pass-if (eqv? 0 (ash 0 -1)))
+  (pass-if (eqv? 0 (ash 0 -1000)))
+
+  (pass-if (eqv? 1 (ash 1 0)))
+  (pass-if (eqv? 2 (ash 1 1)))
+  (pass-if (eqv? 340282366920938463463374607431768211456 (ash 1 128)))
+  (pass-if (eqv? 0 (ash 1 -1)))
+  (pass-if (eqv? 0 (ash 1 -1000)))
+
+  (pass-if (eqv? -1 (ash -1 0)))
+  (pass-if (eqv? -2 (ash -1 1)))
+  (pass-if (eqv? -340282366920938463463374607431768211456 (ash -1 128)))
+  (pass-if (eqv? -1 (ash -1 -1)))
+  (pass-if (eqv? -1 (ash -1 -1000)))
+
+  (pass-if (eqv? -3 (ash -3 0)))
+  (pass-if (eqv? -6 (ash -3 1)))
+  (pass-if (eqv? -1020847100762815390390123822295304634368 (ash -3 128)))
+  (pass-if (eqv? -2 (ash -3 -1)))
+  (pass-if (eqv? -1 (ash -3 -1000)))
+
+  (pass-if (eqv? -6 (ash -23 -2)))
+
+  (pass-if (eqv? most-positive-fixnum       (ash most-positive-fixnum 0)))
+  (pass-if (eqv? (* 2 most-positive-fixnum) (ash most-positive-fixnum 1)))
+  (pass-if (eqv? (* 4 most-positive-fixnum) (ash most-positive-fixnum 2)))
+  (pass-if
+      (eqv? (* most-positive-fixnum 340282366920938463463374607431768211456)
+	    (ash most-positive-fixnum 128)))
+  (pass-if (eqv? (quotient most-positive-fixnum 2)
+		 (ash most-positive-fixnum -1)))
+  (pass-if (eqv? 0 (ash most-positive-fixnum -1000)))
+
+  (let ((mpf4 (quotient most-positive-fixnum 4)))
+    (pass-if (eqv? (* 2 mpf4) (ash mpf4 1)))
+    (pass-if (eqv? (* 4 mpf4) (ash mpf4 2)))
+    (pass-if (eqv? (* 8 mpf4) (ash mpf4 3))))
+
+  (pass-if (eqv? most-negative-fixnum       (ash most-negative-fixnum 0)))
+  (pass-if (eqv? (* 2 most-negative-fixnum) (ash most-negative-fixnum 1)))
+  (pass-if (eqv? (* 4 most-negative-fixnum) (ash most-negative-fixnum 2)))
+  (pass-if
+      (eqv? (* most-negative-fixnum 340282366920938463463374607431768211456)
+	    (ash most-negative-fixnum 128)))
+  (pass-if (eqv? (quotient-floor most-negative-fixnum 2)
+		 (ash most-negative-fixnum -1)))
+  (pass-if (eqv? -1 (ash most-negative-fixnum -1000)))
+
+  (let ((mnf4 (quotient-floor most-negative-fixnum 4)))
+    (pass-if (eqv? (* 2 mnf4) (ash mnf4 1)))
+    (pass-if (eqv? (* 4 mnf4) (ash mnf4 2)))
+    (pass-if (eqv? (* 8 mnf4) (ash mnf4 3)))))
+
 ;;;
 ;;; exact?
 ;;;
@@ -67,7 +270,41 @@
       (eq? #f (exact? (sqrt (- (expt fixnum-max 2) 1)))))
 
     (pass-if "sqrt ((fixnum-max+1)^2 - 1)"
-      (eq? #f (exact? (sqrt (- (expt (+ fixnum-max 1) 2) 1)))))))
+      (eq? #f (exact? (sqrt (- (expt (+ fixnum-max 1) 2) 1)))))
+
+    (pass-if (not (exact? +inf.0)))
+    (pass-if (not (exact? -inf.0)))
+    (pass-if (not (exact? +nan.0)))))
+
+;;;
+;;; exp
+;;;
+
+(with-test-prefix "exp"
+  (pass-if "documented?"
+    (documented? exp))
+
+  (pass-if-exception "no args" exception:wrong-num-args
+    (exp))
+  (pass-if-exception "two args" exception:wrong-num-args
+    (exp 123 456))
+
+  (pass-if (eqv? 0.0 (exp -inf.0)))
+  (pass-if (eqv-loosely? 1.0 (exp 0)))
+  (pass-if (eqv-loosely? 1.0 (exp 0.0)))
+  (pass-if (eqv-loosely? const-e   (exp 1.0)))
+  (pass-if (eqv-loosely? const-e^2 (exp 2.0)))
+  (pass-if (eqv-loosely? const-1/e (exp -1)))
+
+  (pass-if "exp(pi*i) = -1"
+    (eqv-loosely? -1.0 (exp 0+3.14159i)))
+  (pass-if "exp(-pi*i) = -1"
+    (eqv-loosely? -1.0 (exp 0-3.14159i)))
+  (pass-if "exp(2*pi*i) = +1"
+    (eqv-loosely? 1.0 (exp 0+6.28318i)))
+
+  (pass-if "exp(2-pi*i) = -e^2"
+    (eqv-loosely? (- const-e^2) (exp 2.0-3.14159i))))
 
 ;;;
 ;;; odd?
@@ -77,13 +314,13 @@
   (pass-if (documented? odd?))  
   (pass-if (odd? 1))
   (pass-if (odd? -1))
-  (expect-fail (odd? 0))
-  (expect-fail (odd? 2))
-  (expect-fail (odd? -2))
+  (pass-if (not (odd? 0)))
+  (pass-if (not (odd? 2)))
+  (pass-if (not (odd? -2)))
   (pass-if (odd? (+ (* 2 fixnum-max) 1)))
-  (expect-fail (odd? (* 2 fixnum-max)))
+  (pass-if (not (odd? (* 2 fixnum-max))))
   (pass-if (odd? (- (* 2 fixnum-min) 1)))
-  (expect-fail (odd? (* 2 fixnum-min))))
+  (pass-if (not (odd? (* 2 fixnum-min)))))
 
 ;;;
 ;;; even?
@@ -94,13 +331,45 @@
   (pass-if (even? 2))
   (pass-if (even? -2))
   (pass-if (even? 0))
-  (expect-fail (even? 1))
-  (expect-fail (even? -1))
-  (expect-fail (even? (+ (* 2 fixnum-max) 1)))
+  (pass-if (not (even? 1)))
+  (pass-if (not (even? -1)))
+  (pass-if (not (even? (+ (* 2 fixnum-max) 1))))
   (pass-if (even? (* 2 fixnum-max)))
-  (expect-fail (even? (- (* 2 fixnum-min) 1)))
+  (pass-if (not (even? (- (* 2 fixnum-min) 1))))
   (pass-if (even? (* 2 fixnum-min))))
 
+;;;
+;;; finite?
+;;;
+
+(with-test-prefix "finite?"
+  (pass-if (documented? finite?))
+  (pass-if (not (finite? (inf))))
+  (pass-if (not (finite? +inf.0)))
+  (pass-if (not (finite? -inf.0)))
+  (pass-if-exception
+   "complex numbers not in domain of finite?"
+   exception:wrong-type-arg
+   (finite? +inf.0+1i))
+  (pass-if-exception
+   "complex numbers not in domain of finite? (2)"
+   exception:wrong-type-arg
+   (finite? +1+inf.0i))
+  (pass-if-exception
+   "complex numbers not in domain of finite? (3)"
+   exception:wrong-type-arg
+   (finite? +1+1i))
+  (pass-if (finite? 3+0i))
+  (pass-if (not (finite? (nan))))
+  (pass-if (not (finite? +nan.0)))
+  (pass-if (finite? 0))
+  (pass-if (finite? 0.0))
+  (pass-if (finite? -0.0))
+  (pass-if (finite? 42.0))
+  (pass-if (finite? 1/2))
+  (pass-if (finite? (+ fixnum-max 1)))
+  (pass-if (finite? (- fixnum-min 1))))
+
 ;;;
 ;;; inf? and inf
 ;;;
@@ -111,10 +380,15 @@
   ;; FIXME: what are the expected behaviors?
   ;; (pass-if (inf? (/ 1.0 0.0))
   ;; (pass-if (inf? (/ 1 0.0))
-  (expect-fail (inf? 0))
-  (expect-fail (inf? 42.0))
-  (expect-fail (inf? (+ fixnum-max 1)))
-  (expect-fail (inf? (- fixnum-min 1))))
+  (pass-if-exception
+   "complex numbers not in domain of inf?"
+   exception:wrong-type-arg
+   (inf? +1+inf.0i))
+  (pass-if (inf? +inf.0+0i))
+  (pass-if (not (inf? 0)))
+  (pass-if (not (inf? 42.0)))
+  (pass-if (not (inf? (+ fixnum-max 1))))
+  (pass-if (not (inf? (- fixnum-min 1)))))
 
 ;;;
 ;;; nan? and nan
@@ -124,10 +398,10 @@
   (pass-if (documented? nan?))
   (pass-if (nan? (nan)))
   ;; FIXME: other ways we should be able to generate NaN?
-  (expect-fail (nan? 0))
-  (expect-fail (nan? 42.0))
-  (expect-fail (nan? (+ fixnum-max 1)))
-  (expect-fail (nan? (- fixnum-min 1))))
+  (pass-if (not (nan? 0)))
+  (pass-if (not (nan? 42.0)))
+  (pass-if (not (nan? (+ fixnum-max 1))))
+  (pass-if (not (nan? (- fixnum-min 1)))))
 
 ;;;
 ;;; abs
@@ -140,9 +414,13 @@
   (pass-if (= 1 (abs -1)))
   (pass-if (= (+ fixnum-max 1) (abs (+ fixnum-max 1))))
   (pass-if (= (+ (- fixnum-min) 1) (abs (- fixnum-min 1))))  
-  (pass-if (positive? (abs 1.0)))
-  (pass-if (positive? (abs -1.0))))
-  
+  (pass-if (= 0.0 (abs 0.0)))
+  (pass-if (= 1.0 (abs 1.0)))
+  (pass-if (= 1.0 (abs -1.0)))
+  (pass-if (nan? (abs +nan.0)))
+  (pass-if (= +inf.0 (abs +inf.0)))
+  (pass-if (= +inf.0 (abs -inf.0))))
+
 ;;;
 ;;; quotient
 ;;;
@@ -288,7 +566,17 @@
       (eqv? 1 (quotient fixnum-min fixnum-min)))
 
     (pass-if "n = fixnum-min - 1"
-      (eqv? 0 (quotient fixnum-min (- fixnum-min 1)))))
+      (eqv? 0 (quotient fixnum-min (- fixnum-min 1))))
+
+    (pass-if "n = - fixnum-min - 1"
+      (eqv? -1 (quotient fixnum-min (1- (- fixnum-min)))))
+
+    ;; special case, normally inum/big is zero
+    (pass-if "n = - fixnum-min"
+      (eqv? -1 (quotient fixnum-min (- fixnum-min))))
+
+    (pass-if "n = - fixnum-min + 1"
+      (eqv? 0 (quotient fixnum-min (1+ (- fixnum-min))))))
 
   (with-test-prefix "(fixnum-min - 1) / n"
 
@@ -476,7 +764,17 @@
       (eqv? 0 (remainder fixnum-min fixnum-min)))
 
     (pass-if "n = fixnum-min - 1"
-      (eqv? fixnum-min (remainder fixnum-min (- fixnum-min 1)))))
+      (eqv? fixnum-min (remainder fixnum-min (- fixnum-min 1))))
+
+    (pass-if "n = - fixnum-min - 1"
+      (eqv? -1 (remainder fixnum-min (1- (- fixnum-min)))))
+
+    ;; special case, normally inum%big is the inum
+    (pass-if "n = - fixnum-min"
+      (eqv? 0 (remainder fixnum-min (- fixnum-min))))
+
+    (pass-if "n = - fixnum-min + 1"
+      (eqv? fixnum-min (remainder fixnum-min (1+ (- fixnum-min))))))
 
   (with-test-prefix "(fixnum-min - 1) / n"
 
@@ -731,15 +1029,128 @@
 
   )
 
+;;;
+;;; modulo-expt
+;;;
+
+(with-test-prefix "modulo-expt"
+   (pass-if (= 1 (modulo-expt 17 23 47)))
+   
+   (pass-if (= 1 (modulo-expt 17 -23 47)))
+   
+   (pass-if (= 17 (modulo-expt 17 -22 47)))
+   
+   (pass-if (= 36 (modulo-expt 17 22 47)))
+   
+   (pass-if (= 183658794479969134816674175082294846241553725240 (modulo-expt 111122223333444455556666 111122223333444455556666 1153478690012629968439432872520758982731022934717)))
+
+   (pass-if-exception
+    "Proper exception with 0 modulus"
+    exception:numerical-overflow
+    (modulo-expt 17 23 0))
+
+   (pass-if-exception
+    "Proper exception when result not invertible"
+    exception:numerical-overflow
+    (modulo-expt 10 -1 48))
+
+   (pass-if-exception
+    "Proper exception with wrong type argument"
+    exception:wrong-type-arg
+    (modulo-expt "Sam" 23 10))
+
+   (pass-if-exception
+    "Proper exception with wrong type argument"
+    exception:wrong-type-arg
+    (modulo-expt 17 9.9 10))
+   
+    (pass-if-exception
+    "Proper exception with wrong type argument"
+    exception:wrong-type-arg
+    (modulo-expt 17 23 'Ethel)))
+
+;;;
+;;; numerator
+;;;
+
+(with-test-prefix "numerator"
+  (pass-if "0"
+    (eqv? 0 (numerator 0)))
+  (pass-if "1"
+    (eqv? 1 (numerator 1)))
+  (pass-if "2"
+    (eqv? 2 (numerator 2)))
+  (pass-if "-1"
+    (eqv? -1 (numerator -1)))
+  (pass-if "-2"
+    (eqv? -2 (numerator -2)))
+
+  (pass-if "0.0"
+    (eqv? 0.0 (numerator 0.0)))
+  (pass-if "1.0"
+    (eqv? 1.0 (numerator 1.0)))
+  (pass-if "2.0"
+    (eqv? 2.0 (numerator 2.0)))
+  (pass-if "-1.0"
+    (eqv? -1.0 (numerator -1.0)))
+  (pass-if "-2.0"
+    (eqv? -2.0 (numerator -2.0)))
+
+  (pass-if "0.5"
+    (eqv? 1.0 (numerator 0.5)))
+  (pass-if "0.25"
+    (eqv? 1.0 (numerator 0.25)))
+  (pass-if "0.75"
+    (eqv? 3.0 (numerator 0.75))))
+
+;;;
+;;; denominator
+;;;
+
+(with-test-prefix "denominator"
+  (pass-if "0"
+    (eqv? 1 (denominator 0)))
+  (pass-if "1"
+    (eqv? 1 (denominator 1)))
+  (pass-if "2"
+    (eqv? 1 (denominator 2)))
+  (pass-if "-1"
+    (eqv? 1 (denominator -1)))
+  (pass-if "-2"
+    (eqv? 1 (denominator -2)))
+
+  (pass-if "0.0"
+    (eqv? 1.0 (denominator 0.0)))
+  (pass-if "1.0"
+    (eqv? 1.0 (denominator 1.0)))
+  (pass-if "2.0"
+    (eqv? 1.0 (denominator 2.0)))
+  (pass-if "-1.0"
+    (eqv? 1.0 (denominator -1.0)))
+  (pass-if "-2.0"
+    (eqv? 1.0 (denominator -2.0)))
+
+  (pass-if "0.5"
+    (eqv? 2.0 (denominator 0.5)))
+  (pass-if "0.25"
+    (eqv? 4.0 (denominator 0.25)))
+  (pass-if "0.75"
+    (eqv? 4.0 (denominator 0.75))))
+
 ;;;
 ;;; gcd
 ;;;
 
 (with-test-prefix "gcd"
 
-  (expect-fail "documented?"
+  (pass-if "documented?"
     (documented? gcd))
 
+  (with-test-prefix "(n)"
+
+    (pass-if "n = -2"
+      (eqv? 2 (gcd -2))))
+
   (with-test-prefix "(0 n)"
 
     (pass-if "n = 0"
@@ -917,7 +1328,7 @@
 (with-test-prefix "lcm"
   ;; FIXME: more tests?
   ;; (some of these are already in r4rs.test)
-  (expect-fail (documented? lcm))
+  (pass-if (documented? lcm))
   (pass-if (= (lcm) 1))
   (pass-if (= (lcm 32 -36) 288))
   (let ((big-n 115792089237316195423570985008687907853269984665640564039457584007913129639936) ; 2 ^ 256
@@ -940,7 +1351,43 @@
     (pass-if (= (+ fixnum-max 1) (num->str->num (+ fixnum-max 1) 10)))
     (pass-if (= (- fixnum-min 1) (num->str->num (- fixnum-min 1) 10)))
     (pass-if (= (inf) (num->str->num (inf) 10)))
-    (pass-if (= 1.3 (num->str->num 1.3 10)))))
+    (pass-if (= 1.3 (num->str->num 1.3 10)))
+
+    ;; XXX - some results depend on whether Guile is compiled optimzed
+    ;; or not.  It is clearly undesirable to have number->string to be
+    ;; influenced by this.
+
+    (pass-if (string=? (number->string 35.25 36) "z.9"))
+    (pass-if (or (string=? (number->string 0.25 2) "0.01")
+		 (string=? (number->string 0.25 2) "0.010")))
+    (pass-if (string=? (number->string 255.0625 16) "ff.1"))
+    (pass-if (string=? (number->string (/ 1 3) 3) "1/10"))
+
+    (pass-if (string=? (number->string 10) "10"))
+    (pass-if (string=? (number->string 10 11) "a"))
+    (pass-if (string=? (number->string 36 36) "10"))
+    (pass-if (= (num->str->num 36 36) 36))
+    (pass-if (= (string->number "z" 36) 35))
+    (pass-if (= (string->number "Z" 36) 35))
+    (pass-if (not (string->number "Z" 35)))
+    (pass-if (string=? (number->string 35 36) "z"))
+    (pass-if (= (num->str->num 35 36) 35))
+
+    ;; Numeric conversion from decimal is not precise, in its current
+    ;; implementation, so 11.333... and 1.324... can't be expected to
+    ;; reliably come out to precise values.  These tests did actually work
+    ;; for a while, but something in gcc changed, affecting the conversion
+    ;; code.
+    ;;
+    ;; (pass-if (or (string=? (number->string 11.33333333333333333 12)
+    ;;                        "B.4")
+    ;;              (string=? (number->string 11.33333333333333333 12)
+    ;;                        "B.400000000000009")))
+    ;; (pass-if (or (string=? (number->string 1.324e44 16)
+    ;;                        "5.EFE0A14FAFEe24")
+    ;;              (string=? (number->string 1.324e44 16)
+    ;;                        "5.EFE0A14FAFDF8e24")))
+    ))
   
 ;;;
 ;;; string->number
@@ -948,7 +1395,7 @@
 
 (with-test-prefix "string->number"
 
-  (pass-if "string->number"
+  (pass-if "documented?"
     (documented? string->number))
 
   (pass-if "non number strings"
@@ -965,8 +1412,11 @@
     (for-each (lambda (couple)
                 (apply
                  (lambda (x y)
-                   (let ((x (string->number x)))
-                     (if (or (eq? x #f) (not (eqv? x y))) (throw 'fail))))
+                   (let ((xx (string->number x)))
+                     (if (or (eq? xx #f) (not (eqv? xx y)))
+			 (begin 
+			   (pk x y)
+			   (throw 'fail)))))
                  couple))
               `(;; Radix:
                 ("#b0" 0) ("#B0" 0) ("#b1" 1) ("#B1" 1) ("#o0" 0) ("#O0" 0)
@@ -984,14 +1434,15 @@
                 ("#d1234567890" 1234567890)
                 ("#x1234567890abcdef" 1311768467294899695)
                 ;; Exactness:
-                ("#e1" 1) ("#e1.2" 1) ("#i1.1" 1.1) ("#i1" 1.0)
+                ("#e1" 1) ("#e1.2" 12/10)
+		("#i1.1" 1.1) ("#i1" 1.0)
                 ;; Integers:
                 ("1" ,(1+ 0)) ("23" ,(+ 9 9 5)) ("-1" ,(- 0 1)) 
                 ("-45" ,(- 0 45)) ("2#" 20.0) ("2##" 200.0) ("12##" 1200.0)
                 ("#b#i100" 4.0)
-                ;; Rationals:
-                ("1/1" 1) ("1/2" 0.5) ("-1/2" -0.5) ("1#/1" 10.0)
-                ("10/1#" 1.0) ("1#/1#" 1.0) ("#e9/10" 1) ("#e10/1#" 1)
+                ;; Fractions:
+                ("1/1" 1) ("1/2" 1/2) ("-1/2" -1/2) ("1#/1" 10.0)
+                ("10/1#" 1.0) ("1#/1#" 1.0) ("#e9/10" 9/10) ("#e10/1#" 1)
                 ("#i6/8" 0.75) ("#i1/1" 1.0)
                 ;; Decimal numbers:
                 ;; * <uinteger 10> <suffix>
@@ -1011,12 +1462,24 @@
                 ("1@0" 1.0) ("1@+0" 1.0) ("1@-0" 1.0)
                 ("2+3i" ,(+ 2 (* 3 +i))) ("4-5i" ,(- 4 (* 5 +i)))
                 ("1+i" 1+1i) ("1-i" 1-1i) ("+1i" 0+1i) ("-1i" 0-1i)
-                ("+i" +1i) ("-i" -1i)))
+                ("+i" +1i) ("-i" -1i)
+		("1.0+.1i" 1.0+0.1i)
+		("1.0-.1i" 1.0-0.1i)
+		(".1+.0i" 0.1)
+		("1.+.0i" 1.0)
+		(".1+.1i" 0.1+0.1i)
+		("1e1+.1i" 10+0.1i)
+		))
     #t)
 
   (pass-if-exception "exponent too big"
     exception:out-of-range
-    (string->number "12.13e141414")))
+    (string->number "12.13e141414"))
+
+  ;; in guile 1.6.7 and earlier, bad polar forms (where the conversion of
+  ;; the angle gave #f) caused a segv
+  (pass-if "1@a"
+    (eq? #f (string->number "1@a"))))
 
 ;;;
 ;;; number?
@@ -1031,13 +1494,13 @@
   (pass-if (number? (+ 1 fixnum-max)))
   (pass-if (number? (- 1 fixnum-min)))
   (pass-if (number? 3+4i))
-  (expect-fail (number? #\a))
-  (expect-fail (number? "a"))
-  (expect-fail (number? (make-vector 0)))
-  (expect-fail (number? (cons 1 2)))
-  (expect-fail (number? #t))
-  (expect-fail (number? (lambda () #t)))
-  (expect-fail (number? (current-input-port))))
+  (pass-if (not (number? #\a)))
+  (pass-if (not (number? "a")))
+  (pass-if (not (number? (make-vector 0))))
+  (pass-if (not (number? (cons 1 2))))
+  (pass-if (not (number? #t)))
+  (pass-if (not (number? (lambda () #t))))
+  (pass-if (not (number? (current-input-port)))))
 
 ;;;
 ;;; complex?
@@ -1052,13 +1515,13 @@
   (pass-if (complex? (- 1 fixnum-min)))
   (pass-if (complex? 1.3))
   (pass-if (complex? 3+4i))
-  (expect-fail (complex? #\a))
-  (expect-fail (complex? "a"))
-  (expect-fail (complex? (make-vector 0)))
-  (expect-fail (complex? (cons 1 2)))
-  (expect-fail (complex? #t))
-  (expect-fail (complex? (lambda () #t)))
-  (expect-fail (complex? (current-input-port))))
+  (pass-if (not (complex? #\a)))
+  (pass-if (not (complex? "a")))
+  (pass-if (not (complex? (make-vector 0))))
+  (pass-if (not (complex? (cons 1 2))))
+  (pass-if (not (complex? #t)))
+  (pass-if (not (complex? (lambda () #t))))
+  (pass-if (not (complex? (current-input-port)))))
 
 ;;;
 ;;; real?
@@ -1072,17 +1535,22 @@
   (pass-if (real? (+ 1 fixnum-max)))
   (pass-if (real? (- 1 fixnum-min)))
   (pass-if (real? 1.3))
-  (expect-fail (real? 3+4i))
-  (expect-fail (real? #\a))
-  (expect-fail (real? "a"))
-  (expect-fail (real? (make-vector 0)))
-  (expect-fail (real? (cons 1 2)))
-  (expect-fail (real? #t))
-  (expect-fail (real? (lambda () #t)))
-  (expect-fail (real? (current-input-port))))
+  (pass-if (real? +inf.0))
+  (pass-if (real? -inf.0))
+  (pass-if (real? +nan.0))
+  (pass-if (not (real? +inf.0-inf.0i)))
+  (pass-if (not (real? +nan.0+nan.0i)))
+  (pass-if (not (real? 3+4i)))
+  (pass-if (not (real? #\a)))
+  (pass-if (not (real? "a")))
+  (pass-if (not (real? (make-vector 0))))
+  (pass-if (not (real? (cons 1 2))))
+  (pass-if (not (real? #t)))
+  (pass-if (not (real? (lambda () #t))))
+  (pass-if (not (real? (current-input-port)))))
 
 ;;;
-;;; rational? (same as real? right now)
+;;; rational?
 ;;;
 
 (with-test-prefix "rational?"
@@ -1093,14 +1561,19 @@
   (pass-if (rational? (+ 1 fixnum-max)))
   (pass-if (rational? (- 1 fixnum-min)))
   (pass-if (rational? 1.3))
-  (expect-fail (rational? 3+4i))
-  (expect-fail (rational? #\a))
-  (expect-fail (rational? "a"))
-  (expect-fail (rational? (make-vector 0)))
-  (expect-fail (rational? (cons 1 2)))
-  (expect-fail (rational? #t))
-  (expect-fail (rational? (lambda () #t)))
-  (expect-fail (rational? (current-input-port))))
+  (pass-if (not (rational? +inf.0)))
+  (pass-if (not (rational? -inf.0)))
+  (pass-if (not (rational? +nan.0)))
+  (pass-if (not (rational? +inf.0-inf.0i)))
+  (pass-if (not (rational? +nan.0+nan.0i)))
+  (pass-if (not (rational? 3+4i)))
+  (pass-if (not (rational? #\a)))
+  (pass-if (not (rational? "a")))
+  (pass-if (not (rational? (make-vector 0))))
+  (pass-if (not (rational? (cons 1 2))))
+  (pass-if (not (rational? #t)))
+  (pass-if (not (rational? (lambda () #t))))
+  (pass-if (not (rational? (current-input-port)))))
 
 ;;;
 ;;; integer?
@@ -1115,15 +1588,18 @@
   (pass-if (integer? (- 1 fixnum-min)))
   (pass-if (and (= 3+0i (round 3+0i)) (integer? 3+0i)))
   (pass-if (and (= 1.0 (round 1.0)) (integer? 1.0)))
-  (expect-fail (integer? 1.3))
-  (expect-fail (integer? 3+4i))
-  (expect-fail (integer? #\a))
-  (expect-fail (integer? "a"))
-  (expect-fail (integer? (make-vector 0)))
-  (expect-fail (integer? (cons 1 2)))
-  (expect-fail (integer? #t))
-  (expect-fail (integer? (lambda () #t)))
-  (expect-fail (integer? (current-input-port))))
+  (pass-if (not (integer? 1.3)))
+  (pass-if (not (integer? +inf.0)))
+  (pass-if (not (integer? -inf.0)))
+  (pass-if (not (integer? +nan.0)))
+  (pass-if (not (integer? 3+4i)))
+  (pass-if (not (integer? #\a)))
+  (pass-if (not (integer? "a")))
+  (pass-if (not (integer? (make-vector 0))))
+  (pass-if (not (integer? (cons 1 2))))
+  (pass-if (not (integer? #t)))
+  (pass-if (not (integer? (lambda () #t))))
+  (pass-if (not (integer? (current-input-port)))))
 
 ;;;
 ;;; inexact?
@@ -1131,38 +1607,196 @@
 
 (with-test-prefix "inexact?"
   (pass-if (documented? inexact?))
-  (expect-fail (inexact? 0))
-  (expect-fail (inexact? 7))
-  (expect-fail (inexact? -7))
-  (expect-fail (inexact? (+ 1 fixnum-max)))
-  (expect-fail (inexact? (- 1 fixnum-min)))
+  (pass-if (not (inexact? 0)))
+  (pass-if (not (inexact? 7)))
+  (pass-if (not (inexact? -7)))
+  (pass-if (not (inexact? (+ 1 fixnum-max))))
+  (pass-if (not (inexact? (- 1 fixnum-min))))
   (pass-if (inexact? 1.3))
   (pass-if (inexact? 3.1+4.2i))
-  (expect-fail (inexact? #\a))
-  (expect-fail (inexact? "a"))
-  (expect-fail (inexact? (make-vector 0)))
-  (expect-fail (inexact? (cons 1 2)))
-  (expect-fail (inexact? #t))
-  (expect-fail (inexact? (lambda () #t)))
-  (expect-fail (inexact? (current-input-port))))
+  (pass-if (inexact? +inf.0))
+  (pass-if (inexact? -inf.0))
+  (pass-if (inexact? +nan.0))
+  (pass-if-exception "char"
+		     exception:wrong-type-arg
+		     (not (inexact? #\a)))
+  (pass-if-exception "string"
+		     exception:wrong-type-arg
+		     (not (inexact? "a")))
+  (pass-if-exception "vector"
+		     exception:wrong-type-arg
+		     (not (inexact? (make-vector 0))))
+  (pass-if-exception "cons"
+		     exception:wrong-type-arg
+		     (not (inexact? (cons 1 2))))
+  (pass-if-exception "bool"
+		     exception:wrong-type-arg
+		     (not (inexact? #t)))
+  (pass-if-exception "procedure"
+		     exception:wrong-type-arg
+		     (not (inexact? (lambda () #t))))
+  (pass-if-exception "port"
+		     exception:wrong-type-arg
+		     (not (inexact? (current-input-port)))))
+
+;;;
+;;; equal?
+;;;
+
+(with-test-prefix "equal?"
+  (pass-if (documented? equal?))
+
+  ;; The following test will fail on platforms
+  ;; without distinct signed zeroes 0.0 and -0.0.
+  (pass-if (not (equal? 0.0 -0.0)))
+
+  (pass-if (equal? 0 0))
+  (pass-if (equal? 7 7))
+  (pass-if (equal? -7 -7))
+  (pass-if (equal? (+ 1 fixnum-max) (+ 1 fixnum-max)))
+  (pass-if (equal? (- fixnum-min 1) (- fixnum-min 1)))
+  (pass-if (equal?  0.0  0.0))
+  (pass-if (equal? -0.0 -0.0))
+  (pass-if (not (equal? 0 1)))
+  (pass-if (not (equal? 0 0.0)))
+  (pass-if (not (equal? 1 1.0)))
+  (pass-if (not (equal? 0.0 0)))
+  (pass-if (not (equal? 1.0 1)))
+  (pass-if (not (equal? -1.0 -1)))
+  (pass-if (not (equal? fixnum-max (+ 1 fixnum-max))))
+  (pass-if (not (equal? (+ 1 fixnum-max) fixnum-max)))
+  (pass-if (not (equal? (+ 1 fixnum-max) (+ 2 fixnum-max))))
+  (pass-if (not (equal? fixnum-min (- fixnum-min 1))))
+  (pass-if (not (equal? (- fixnum-min 1) fixnum-min)))
+  (pass-if (not (equal? (- fixnum-min 1) (- fixnum-min 2))))
+  (pass-if (not (equal? (+ fixnum-max 1) (- fixnum-min 1))))
+
+  (pass-if (not (equal? (ash 1 256) +inf.0)))
+  (pass-if (not (equal? +inf.0 (ash 1 256))))
+  (pass-if (not (equal? (ash 1 256) -inf.0)))
+  (pass-if (not (equal? -inf.0 (ash 1 256))))
+
+  ;; in gmp prior to 4.2, mpz_cmp_d ended up treating Inf as 2^1024, make
+  ;; sure we've avoided that
+  (pass-if (not (equal? (ash 1 1024) +inf.0)))
+  (pass-if (not (equal? +inf.0 (ash 1 1024))))
+  (pass-if (not (equal? (- (ash 1 1024)) -inf.0)))
+  (pass-if (not (equal? -inf.0 (- (ash 1 1024)))))
+
+  (pass-if (equal? +nan.0 +nan.0))
+  (pass-if (equal? +nan.0 +nan.0))
+  (pass-if (not (equal? +nan.0 0.0+nan.0i)))
+
+  (pass-if (not (equal? 0 +nan.0)))
+  (pass-if (not (equal? +nan.0 0)))
+  (pass-if (not (equal? 1 +nan.0)))
+  (pass-if (not (equal? +nan.0 1)))
+  (pass-if (not (equal? -1 +nan.0)))
+  (pass-if (not (equal? +nan.0 -1)))
+
+  (pass-if (not (equal? (ash 1 256) +nan.0)))
+  (pass-if (not (equal? +nan.0 (ash 1 256))))
+  (pass-if (not (equal? (- (ash 1 256)) +nan.0)))
+  (pass-if (not (equal? +nan.0 (- (ash 1 256)))))
+
+  (pass-if (not (equal? (ash 1 8192) +nan.0)))
+  (pass-if (not (equal? +nan.0 (ash 1 8192))))
+  (pass-if (not (equal? (- (ash 1 8192)) +nan.0)))
+  (pass-if (not (equal? +nan.0 (- (ash 1 8192)))))
+
+  ;; in gmp prior to 4.2, mpz_cmp_d ended up treating NaN as 3*2^1023, make
+  ;; sure we've avoided that
+  (pass-if (not (equal? (ash 3 1023) +nan.0)))
+  (pass-if (not (equal? +nan.0 (ash 3 1023)))))
+
+;;;
+;;; eqv?
+;;;
+
+(with-test-prefix "eqv?"
+  (pass-if (documented? eqv?))
+
+  ;; The following test will fail on platforms
+  ;; without distinct signed zeroes 0.0 and -0.0.
+  (pass-if (not (eqv? 0.0 -0.0)))
+
+  (pass-if (eqv? 0 0))
+  (pass-if (eqv? 7 7))
+  (pass-if (eqv? -7 -7))
+  (pass-if (eqv? (+ 1 fixnum-max) (+ 1 fixnum-max)))
+  (pass-if (eqv? (- fixnum-min 1) (- fixnum-min 1)))
+  (pass-if (eqv?  0.0  0.0))
+  (pass-if (eqv? -0.0 -0.0))
+  (pass-if (not (eqv? 0 1)))
+  (pass-if (not (eqv? 0 0.0)))
+  (pass-if (not (eqv? 1 1.0)))
+  (pass-if (not (eqv? 0.0 0)))
+  (pass-if (not (eqv? 1.0 1)))
+  (pass-if (not (eqv? -1.0 -1)))
+  (pass-if (not (eqv? fixnum-max (+ 1 fixnum-max))))
+  (pass-if (not (eqv? (+ 1 fixnum-max) fixnum-max)))
+  (pass-if (not (eqv? (+ 1 fixnum-max) (+ 2 fixnum-max))))
+  (pass-if (not (eqv? fixnum-min (- fixnum-min 1))))
+  (pass-if (not (eqv? (- fixnum-min 1) fixnum-min)))
+  (pass-if (not (eqv? (- fixnum-min 1) (- fixnum-min 2))))
+  (pass-if (not (eqv? (+ fixnum-max 1) (- fixnum-min 1))))
+
+  (pass-if (not (eqv? (ash 1 256) +inf.0)))
+  (pass-if (not (eqv? +inf.0 (ash 1 256))))
+  (pass-if (not (eqv? (ash 1 256) -inf.0)))
+  (pass-if (not (eqv? -inf.0 (ash 1 256))))
+
+  ;; in gmp prior to 4.2, mpz_cmp_d ended up treating Inf as 2^1024, make
+  ;; sure we've avoided that
+  (pass-if (not (eqv? (ash 1 1024) +inf.0)))
+  (pass-if (not (eqv? +inf.0 (ash 1 1024))))
+  (pass-if (not (eqv? (- (ash 1 1024)) -inf.0)))
+  (pass-if (not (eqv? -inf.0 (- (ash 1 1024)))))
+
+  (pass-if (eqv? +nan.0 +nan.0))
+  (pass-if (not (eqv? +nan.0 0.0+nan.0i)))
+
+  (pass-if (not (eqv? 0 +nan.0)))
+  (pass-if (not (eqv? +nan.0 0)))
+  (pass-if (not (eqv? 1 +nan.0)))
+  (pass-if (not (eqv? +nan.0 1)))
+  (pass-if (not (eqv? -1 +nan.0)))
+  (pass-if (not (eqv? +nan.0 -1)))
+
+  (pass-if (not (eqv? (ash 1 256) +nan.0)))
+  (pass-if (not (eqv? +nan.0 (ash 1 256))))
+  (pass-if (not (eqv? (- (ash 1 256)) +nan.0)))
+  (pass-if (not (eqv? +nan.0 (- (ash 1 256)))))
+
+  (pass-if (not (eqv? (ash 1 8192) +nan.0)))
+  (pass-if (not (eqv? +nan.0 (ash 1 8192))))
+  (pass-if (not (eqv? (- (ash 1 8192)) +nan.0)))
+  (pass-if (not (eqv? +nan.0 (- (ash 1 8192)))))
+
+  ;; in gmp prior to 4.2, mpz_cmp_d ended up treating NaN as 3*2^1023, make
+  ;; sure we've avoided that
+  (pass-if (not (eqv? (ash 3 1023) +nan.0)))
+  (pass-if (not (eqv? +nan.0 (ash 3 1023)))))
 
 ;;;
 ;;; =
 ;;;
 
 (with-test-prefix "="
-  (expect-fail (documented? =))
+  (pass-if (documented? =))
   (pass-if (= 0 0))
   (pass-if (= 7 7))
   (pass-if (= -7 -7))
   (pass-if (= (+ 1 fixnum-max) (+ 1 fixnum-max)))
-  (pass-if (= (- 1 fixnum-min) (- 1 fixnum-min)))
-  (expect-fail (= 0 1))
-  (expect-fail (= fixnum-max (+ 1 fixnum-max)))
-  (expect-fail (= (+ 1 fixnum-max) fixnum-max))
-  (expect-fail (= fixnum-min (- fixnum-min 1)))
-  (expect-fail (= (- fixnum-min 1) fixnum-min))
-  (expect-fail (= (+ fixnum-max 1) (- fixnum-min 1)))
+  (pass-if (= (- fixnum-min 1) (- fixnum-min 1)))
+  (pass-if (not (= 0 1)))
+  (pass-if (not (= fixnum-max (+ 1 fixnum-max))))
+  (pass-if (not (= (+ 1 fixnum-max) fixnum-max)))
+  (pass-if (not (= (+ 1 fixnum-max) (+ 2 fixnum-max))))
+  (pass-if (not (= fixnum-min (- fixnum-min 1))))
+  (pass-if (not (= (- fixnum-min 1) fixnum-min)))
+  (pass-if (not (= (- fixnum-min 1) (- fixnum-min 2))))
+  (pass-if (not (= (+ fixnum-max 1) (- fixnum-min 1))))
 
   (pass-if (not (= (ash 1 256) +inf.0)))
   (pass-if (not (= +inf.0 (ash 1 256))))
@@ -1197,7 +1831,35 @@
   ;; in gmp prior to 4.2, mpz_cmp_d ended up treating NaN as 3*2^1023, make
   ;; sure we've avoided that
   (pass-if (not (= (ash 3 1023) +nan.0)))
-  (pass-if (not (= +nan.0 (ash 3 1023)))))
+  (pass-if (not (= +nan.0 (ash 3 1023))))
+
+  (pass-if (= 1/2 0.5))
+  (pass-if (not (= 1/3 0.333333333333333333333333333333333)))
+  (pass-if (not (= 2/3 0.5)))
+  (pass-if (not (= 0.5 (+ 1/2 (/ 1 (ash 1 1000))))))
+
+  (pass-if (= 1/2 0.5+0i))
+  (pass-if (not (= 0.333333333333333333333333333333333 1/3)))
+  (pass-if (not (= 2/3 0.5+0i)))
+  (pass-if (not (= 1/2 0+0.5i)))
+
+  (pass-if (= 0.5 1/2))
+  (pass-if (not (= 0.5 2/3)))
+  (pass-if (not (= (+ 1/2 (/ 1 (ash 1 1000))) 0.5)))
+
+  (pass-if (= 0.5+0i 1/2))
+  (pass-if (not (= 0.5+0i 2/3)))
+  (pass-if (not (= 0+0.5i 1/2)))
+
+  ;; prior to guile 1.8, inum/flonum comparisons were done just by
+  ;; converting the inum to a double, which on a 64-bit would round making
+  ;; say inexact 2^58 appear equal to exact 2^58+1
+  (pass-if (= (ash-flo 1.0 58) (ash 1 58)))
+  (pass-if (not (= (ash-flo 1.0 58) (1+ (ash 1 58)))))
+  (pass-if (not (= (ash-flo 1.0 58) (1- (ash 1 58)))))
+  (pass-if (= (ash 1 58) (ash-flo 1.0 58)))
+  (pass-if (not (= (1+ (ash 1 58)) (ash-flo 1.0 58))))
+  (pass-if (not (= (1- (ash 1 58)) (ash-flo 1.0 58)))))
 
 ;;;
 ;;; <
@@ -1205,7 +1867,7 @@
 
 (with-test-prefix "<"
 
-  (expect-fail "documented?"
+  (pass-if "documented?"
     (documented? <))
 
   (with-test-prefix "(< 0 n)"
@@ -1573,7 +2235,95 @@
   (pass-if (not (< (1- (ash 3 1023)) +nan.0)))
   (pass-if (not (< +nan.0 (ash 3 1023))))
   (pass-if (not (< +nan.0 (1+ (ash 3 1023)))))
-  (pass-if (not (< +nan.0 (1- (ash 3 1023))))))
+  (pass-if (not (< +nan.0 (1- (ash 3 1023)))))
+
+  (with-test-prefix "inum/frac"
+    (pass-if (< 2 9/4))
+    (pass-if (< -2 9/4))
+    (pass-if (< -2 7/4))
+    (pass-if (< -2 -7/4))
+    (pass-if (eq? #f (< 2 7/4)))
+    (pass-if (eq? #f (< 2 -7/4)))
+    (pass-if (eq? #f (< 2 -9/4)))
+    (pass-if (eq? #f (< -2 -9/4))))
+
+  (with-test-prefix "bignum/frac"
+    (let ((x (ash 1 2048)))
+      (pass-if (< x (* 4/3 x)))
+      (pass-if (< (- x) (* 4/3 x)))
+      (pass-if (< (- x) (* 2/3 x)))
+      (pass-if (< (- x) (* -2/3 x)))
+      (pass-if (eq? #f (< x (* 2/3 x))))
+      (pass-if (eq? #f (< x (* -2/3 x))))
+      (pass-if (eq? #f (< x (* -4/3 x))))
+      (pass-if (eq? #f (< (- x) (* -4/3 x))))))
+
+  (with-test-prefix "flonum/frac"
+    (pass-if (< 0.75 4/3))
+    (pass-if (< -0.75 4/3))
+    (pass-if (< -0.75 2/3))
+    (pass-if (< -0.75 -2/3))
+    (pass-if (eq? #f (< 0.75 2/3)))
+    (pass-if (eq? #f (< 0.75 -2/3)))
+    (pass-if (eq? #f (< 0.75 -4/3)))
+    (pass-if (eq? #f (< -0.75 -4/3)))
+
+    (pass-if (< -inf.0 4/3))
+    (pass-if (< -inf.0 -4/3))
+    (pass-if (eq? #f (< +inf.0 4/3)))
+    (pass-if (eq? #f (< +inf.0 -4/3)))
+
+    (pass-if (eq? #f (< +nan.0 4/3)))
+    (pass-if (eq? #f (< +nan.0 -4/3))))
+
+  (with-test-prefix "frac/inum"
+    (pass-if (< 7/4 2))
+    (pass-if (< -7/4 2))
+    (pass-if (< -9/4 2))
+    (pass-if (< -9/4 -2))
+    (pass-if (eq? #f (< 9/4 2)))
+    (pass-if (eq? #f (< 9/4 -2)))
+    (pass-if (eq? #f (< 7/4 -2)))
+    (pass-if (eq? #f (< -7/4 -2))))
+
+  (with-test-prefix "frac/bignum"
+    (let ((x (ash 1 2048)))
+      (pass-if (< (* 2/3 x) x))
+      (pass-if (< (* -2/3 x) x))
+      (pass-if (< (* -4/3 x) x))
+      (pass-if (< (* -4/3 x) (- x)))
+      (pass-if (eq? #f (< (* 4/3 x) x)))
+      (pass-if (eq? #f (< (* 4/3 x) (- x))))
+      (pass-if (eq? #f (< (* 2/3 x) (- x))))
+      (pass-if (eq? #f (< (* -2/3 x) (- x))))))
+
+  (with-test-prefix "frac/flonum"
+    (pass-if (< 2/3 0.75))
+    (pass-if (< -2/3 0.75))
+    (pass-if (< -4/3 0.75))
+    (pass-if (< -4/3 -0.75))
+    (pass-if (eq? #f (< 4/3 0.75)))
+    (pass-if (eq? #f (< 4/3 -0.75)))
+    (pass-if (eq? #f (< 2/3 -0.75)))
+    (pass-if (eq? #f (< -2/3 -0.75)))
+
+    (pass-if (< 4/3 +inf.0))
+    (pass-if (< -4/3 +inf.0))
+    (pass-if (eq? #f (< 4/3 -inf.0)))
+    (pass-if (eq? #f (< -4/3 -inf.0)))
+
+    (pass-if (eq? #f (< 4/3 +nan.0)))
+    (pass-if (eq? #f (< -4/3 +nan.0))))
+
+  (with-test-prefix "frac/frac"
+    (pass-if (< 2/3 6/7))
+    (pass-if (< -2/3 6/7))
+    (pass-if (< -4/3 6/7))
+    (pass-if (< -4/3 -6/7))
+    (pass-if (eq? #f (< 4/3 6/7)))
+    (pass-if (eq? #f (< 4/3 -6/7)))
+    (pass-if (eq? #f (< 2/3 -6/7)))
+    (pass-if (eq? #f (< -2/3 -6/7)))))
 
 ;;;
 ;;; >
@@ -1606,12 +2356,12 @@
 (with-test-prefix "zero?"
   (expect-fail (documented? zero?))
   (pass-if (zero? 0))
-  (expect-fail (zero? 7))
-  (expect-fail (zero? -7))
-  (expect-fail (zero? (+ 1 fixnum-max)))
-  (expect-fail (zero? (- 1 fixnum-min)))
-  (expect-fail (zero? 1.3))
-  (expect-fail (zero? 3.1+4.2i)))
+  (pass-if (not (zero? 7)))
+  (pass-if (not (zero? -7)))
+  (pass-if (not (zero? (+ 1 fixnum-max))))
+  (pass-if (not (zero? (- 1 fixnum-min))))
+  (pass-if (not (zero? 1.3)))
+  (pass-if (not (zero? 3.1+4.2i))))
 
 ;;;
 ;;; positive?
@@ -1622,10 +2372,10 @@
   (pass-if (positive? 1))
   (pass-if (positive? (+ fixnum-max 1)))
   (pass-if (positive? 1.3))
-  (expect-fail (positive? 0))
-  (expect-fail (positive? -1))
-  (expect-fail (positive? (- fixnum-min 1)))
-  (expect-fail (positive? -1.3)))
+  (pass-if (not (positive? 0)))
+  (pass-if (not (positive? -1)))
+  (pass-if (not (positive? (- fixnum-min 1))))
+  (pass-if (not (positive? -1.3))))
 
 ;;;
 ;;; negative?
@@ -1633,10 +2383,10 @@
 
 (with-test-prefix "negative?"
   (expect-fail (documented? negative?))
-  (expect-fail (negative? 1))
-  (expect-fail (negative? (+ fixnum-max 1)))
-  (expect-fail (negative? 1.3))
-  (expect-fail (negative? 0))
+  (pass-if (not (negative? 1)))
+  (pass-if (not (negative? (+ fixnum-max 1))))
+  (pass-if (not (negative? 1.3)))
+  (pass-if (not (negative? 0)))
   (pass-if (negative? -1))
   (pass-if (negative? (- fixnum-min 1)))
   (pass-if (negative? -1.3)))
@@ -1646,26 +2396,83 @@
 ;;;
 
 (with-test-prefix "max"
-  (pass-if (= 456.0 (max 123.0 456.0)))
-  (pass-if (= 456.0 (max 456.0 123.0)))
+  (pass-if-exception "no args" exception:wrong-num-args
+    (max))
+
+  (pass-if-exception "one complex" exception:wrong-type-arg
+    (max 1+i))
+
+  (pass-if-exception "inum/complex" exception:wrong-type-arg
+    (max 123 1+i))
+  (pass-if-exception "big/complex" exception:wrong-type-arg
+    (max 9999999999999999999999999999999999999999 1+i))
+  (pass-if-exception "real/complex" exception:wrong-type-arg
+    (max 123.0 1+i))
+  (pass-if-exception "frac/complex" exception:wrong-type-arg
+    (max 123/456 1+i))
+
+  (pass-if-exception "complex/inum" exception:wrong-type-arg
+    (max 1+i 123))
+  (pass-if-exception "complex/big" exception:wrong-type-arg
+    (max 1+i 9999999999999999999999999999999999999999))
+  (pass-if-exception "complex/real" exception:wrong-type-arg
+    (max 1+i 123.0))
+  (pass-if-exception "complex/frac" exception:wrong-type-arg
+    (max 1+i 123/456))
 
   (let ((big*2 (* fixnum-max 2))
         (big*3 (* fixnum-max 3))
         (big*4 (* fixnum-max 4))
         (big*5 (* fixnum-max 5)))
-    
-    (pass-if (= +inf.0 (max big*5  +inf.0)))
-    (pass-if (= +inf.0 (max +inf.0 big*5)))
-    (pass-if (= big*5  (max big*5  -inf.0)))
-    (pass-if (= big*5  (max -inf.0 big*5)))
 
-    (pass-if (nan? (max 123 +nan.0)))
-    (pass-if (nan? (max big*5 +nan.0)))
-    (pass-if (nan? (max 123.0 +nan.0)))
-    (pass-if (nan? (max +nan.0 123)))
-    (pass-if (nan? (max +nan.0 big*5)))
-    (pass-if (nan? (max +nan.0 123.0)))
-    (pass-if (nan? (max +nan.0 +nan.0))))
+    (with-test-prefix "inum / frac"
+      (pass-if (= 3 (max 3 5/2)))
+      (pass-if (= 5/2 (max 2 5/2))))
+
+    (with-test-prefix "frac / inum"
+      (pass-if (= 3 (max 5/2 3)))
+      (pass-if (= 5/2 (max 5/2 2))))
+
+    (with-test-prefix "inum / real"
+      (pass-if (nan? (max 123 +nan.0))))
+
+    (with-test-prefix "real / inum"
+      (pass-if (nan? (max +nan.0 123))))
+
+    (with-test-prefix "big / frac"
+      (pass-if (= big*2 (max big*2 5/2)))
+      (pass-if (= 5/2 (max (- big*2) 5/2))))
+
+    (with-test-prefix "frac / big"
+      (pass-if (= big*2 (max 5/2 big*2)))
+      (pass-if (= 5/2 (max 5/2 (- big*2)))))
+
+    (with-test-prefix "big / real"
+      (pass-if (nan? (max big*5 +nan.0)))
+      (pass-if (eqv? (exact->inexact big*5)  (max big*5 -inf.0)))
+      (pass-if (eqv? (exact->inexact big*5)  (max big*5 1.0)))
+      (pass-if (eqv? +inf.0                  (max big*5 +inf.0)))
+      (pass-if (eqv? 1.0                     (max (- big*5) 1.0))))
+
+    (with-test-prefix "real / big"
+      (pass-if (nan? (max +nan.0 big*5)))
+      (pass-if (eqv? (exact->inexact big*5)  (max -inf.0 big*5)))
+      (pass-if (eqv? (exact->inexact big*5)  (max 1.0 big*5)))
+      (pass-if (eqv? +inf.0                  (max +inf.0 big*5)))
+      (pass-if (eqv? 1.0                     (max 1.0 (- big*5)))))
+
+    (with-test-prefix "frac / frac"
+      (pass-if (= 2/3 (max 1/2 2/3)))
+      (pass-if (= 2/3 (max 2/3 1/2)))
+      (pass-if (= -1/2 (max -1/2 -2/3)))
+      (pass-if (= -1/2 (max -2/3 -1/2))))
+
+    (with-test-prefix "real / real"
+      (pass-if (nan? (max 123.0 +nan.0)))
+      (pass-if (nan? (max +nan.0 123.0)))
+      (pass-if (nan? (max +nan.0 +nan.0)))
+      (pass-if (= 456.0 (max 123.0 456.0)))
+      (pass-if (= 456.0 (max 456.0 123.0)))))
 
   ;; in gmp prior to 4.2, mpz_cmp_d ended up treating Inf as 2^1024, make
   ;; sure we've avoided that
@@ -1675,9 +2482,9 @@
 	      (pass-if (list +inf.0 b)
 		(= +inf.0 (max b +inf.0)))
 	      (pass-if (list b -inf.0)
-		(= b (max b -inf.0)))
+		(= (exact->inexact b) (max b -inf.0)))
 	      (pass-if (list -inf.0 b)
-		(= b (max b -inf.0))))
+		(= (exact->inexact b) (max b -inf.0))))
 	    (list (1- (ash 1 1024))
 		  (ash 1 1024)
 		  (1+ (ash 1 1024))
@@ -1697,15 +2504,36 @@
 ;; FIXME: unfinished...
 
 (with-test-prefix "min"
-  (pass-if (= 123.0 (min 123.0 456.0)))
-  (pass-if (= 123.0 (min 456.0 123.0)))
+  (pass-if-exception "no args" exception:wrong-num-args
+    (min))
+
+  (pass-if-exception "one complex" exception:wrong-type-arg
+    (min 1+i))
+
+  (pass-if-exception "inum/complex" exception:wrong-type-arg
+    (min 123 1+i))
+  (pass-if-exception "big/complex" exception:wrong-type-arg
+    (min 9999999999999999999999999999999999999999 1+i))
+  (pass-if-exception "real/complex" exception:wrong-type-arg
+    (min 123.0 1+i))
+  (pass-if-exception "frac/complex" exception:wrong-type-arg
+    (min 123/456 1+i))
+
+  (pass-if-exception "complex/inum" exception:wrong-type-arg
+    (min 1+i 123))
+  (pass-if-exception "complex/big" exception:wrong-type-arg
+    (min 1+i 9999999999999999999999999999999999999999))
+  (pass-if-exception "complex/real" exception:wrong-type-arg
+    (min 1+i 123.0))
+  (pass-if-exception "complex/frac" exception:wrong-type-arg
+    (min 1+i 123/456))
 
   (let ((big*2 (* fixnum-max 2))
         (big*3 (* fixnum-max 3))
         (big*4 (* fixnum-max 4))
         (big*5 (* fixnum-max 5)))
-    
-    (expect-fail (documented? max))
+
+    (pass-if (documented? min))
     (pass-if (= 1 (min 7 3 1 5)))
     (pass-if (= 1 (min 1 7 3 5)))
     (pass-if (= 1 (min 7 3 5 1)))
@@ -1721,27 +2549,64 @@
         (= (- fixnum-min 1) (min (- fixnum-min 1) 2 4 3 (* 2 fixnum-max))))
     (pass-if
         (= (- fixnum-min 1) (min 2 4 3 (* 2 fixnum-max) (- fixnum-min 1))))
-    
-    (pass-if (= big*5  (min big*5  +inf.0)))
-    (pass-if (= big*5  (min +inf.0 big*5)))
-    (pass-if (= -inf.0 (min big*5  -inf.0)))
-    (pass-if (= -inf.0 (min -inf.0 big*5)))
-
-    (pass-if (nan? (min 123 +nan.0)))
-    (pass-if (nan? (min big*5 +nan.0)))
-    (pass-if (nan? (min 123.0 +nan.0)))
-    (pass-if (nan? (min +nan.0 123)))
-    (pass-if (nan? (min +nan.0 big*5)))
-    (pass-if (nan? (min +nan.0 123.0)))
-    (pass-if (nan? (min +nan.0 +nan.0))))
-  
+
+    (with-test-prefix "inum / frac"
+      (pass-if (= 5/2 (min 3 5/2)))
+      (pass-if (= 2   (min 2 5/2))))
+
+    (with-test-prefix "frac / inum"
+      (pass-if (= 5/2 (min 5/2 3)))
+      (pass-if (= 2   (min 5/2 2))))
+
+    (with-test-prefix "inum / real"
+      (pass-if (nan? (min 123 +nan.0))))
+
+    (with-test-prefix "real / inum"
+      (pass-if (nan? (min +nan.0 123))))
+
+    (with-test-prefix "big / frac"
+      (pass-if (= 5/2       (min big*2 5/2)))
+      (pass-if (= (- big*2) (min (- big*2) 5/2))))
+
+    (with-test-prefix "frac / big"
+      (pass-if (= 5/2       (min 5/2 big*2)))
+      (pass-if (= (- big*2) (min 5/2 (- big*2)))))
+
+    (with-test-prefix "big / real"
+      (pass-if (nan? (min big*5 +nan.0)))
+      (pass-if (eqv? (exact->inexact big*5)      (min big*5  +inf.0)))
+      (pass-if (eqv? -inf.0                      (min big*5  -inf.0)))
+      (pass-if (eqv? 1.0                         (min big*5 1.0)))
+      (pass-if (eqv? (exact->inexact (- big*5))  (min (- big*5) 1.0))))
+
+    (with-test-prefix "real / big"
+      (pass-if (nan? (min +nan.0 big*5)))
+      (pass-if (eqv? (exact->inexact big*5)      (min +inf.0 big*5)))
+      (pass-if (eqv? -inf.0                      (min -inf.0 big*5)))
+      (pass-if (eqv? 1.0                         (min 1.0 big*5)))
+      (pass-if (eqv? (exact->inexact (- big*5))  (min 1.0 (- big*5)))))
+
+    (with-test-prefix "frac / frac"
+      (pass-if (= 1/2 (min 1/2 2/3)))
+      (pass-if (= 1/2 (min 2/3 1/2)))
+      (pass-if (= -2/3 (min -1/2 -2/3)))
+      (pass-if (= -2/3 (min -2/3 -1/2))))
+
+    (with-test-prefix "real / real"
+      (pass-if (nan? (min 123.0 +nan.0)))
+      (pass-if (nan? (min +nan.0 123.0)))
+      (pass-if (nan? (min +nan.0 +nan.0)))
+      (pass-if (= 123.0 (min 123.0 456.0)))
+      (pass-if (= 123.0 (min 456.0 123.0)))))
+
+
   ;; in gmp prior to 4.2, mpz_cmp_d ended up treating Inf as 2^1024, make
   ;; sure we've avoided that
   (for-each (lambda (b)
 	      (pass-if (list b +inf.0)
-		(= b (min b +inf.0)))
+		(= (exact->inexact b) (min b +inf.0)))
 	      (pass-if (list +inf.0 b)
-		(= b (min b +inf.0)))
+		(= (exact->inexact b) (min b +inf.0)))
 	      (pass-if (list b -inf.0)
 		(= -inf.0 (min b -inf.0)))
 	      (pass-if (list -inf.0 b)
@@ -1762,81 +2627,197 @@
 ;;; +
 ;;;
 
-(with-test-prefix "+"
+(with-test-prefix/c&e "+"
 
-  (expect-fail "documented?"
+  (pass-if "documented?"
     (documented? +))
 
-  (with-test-prefix "wrong type argument"
+  ;; The maximum fixnum on a 32-bit architecture: 2^29 - 1.
+  (pass-if "fixnum + fixnum = bignum (32-bit)"
+    (eqv? 536870912 (+ 536870910 2)))
 
-    (pass-if-exception "1st argument string"
-      exception:wrong-type-arg
-      (+ "1" 2))
+  ;; The maximum fixnum on a 64-bit architecture: 2^61 - 1.
+  (pass-if "fixnum + fixnum = bignum (64-bit)"
+    (eqv? 2305843009213693952 (+ 2305843009213693950 2)))
+
+  (pass-if "bignum + fixnum = fixnum"
+    (eqv? 0 (+ (1+ most-positive-fixnum) most-negative-fixnum))))
 
-    (pass-if-exception "2nd argument bool"
-      exception:wrong-type-arg
-      (+ 1 #f))))
 ;;;
 ;;; -
 ;;;
 
-(with-test-prefix "-"
+(with-test-prefix/c&e "-"
+
+  (pass-if "double-negation of fixnum-min: ="
+    (=      fixnum-min (- (- fixnum-min))))
+  (pass-if "double-negation of fixnum-min: eqv?"
+    (eqv?   fixnum-min (- (- fixnum-min))))
+  (pass-if "double-negation of fixnum-min: equal?"
+    (equal? fixnum-min (- (- fixnum-min))))
+
+  (pass-if "binary double-negation of fixnum-min: ="
+    (=      fixnum-min (- 0 (- 0 fixnum-min))))
+  (pass-if "binary double-negation of fixnum-min: eqv?"
+    (eqv?   fixnum-min (- 0 (- 0 fixnum-min))))
+  (pass-if "binary double-negation of fixnum-min: equal?"
+    (equal? fixnum-min (- 0 (- 0 fixnum-min))))
 
   (pass-if "-inum - +bignum"
     (= #x-100000000000000000000000000000001
-       (- -1 #x100000000000000000000000000000000))))
+       (- -1 #x100000000000000000000000000000000)))
+  
+  (pass-if "big - inum"
+    (= #xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+       (- #x100000000000000000000000000000000 1)))
+  
+  (pass-if "big - -inum"
+    (= #x100000000000000000000000000000001
+       (- #x100000000000000000000000000000000 -1)))
+
+  ;; The mininum fixnum on a 32-bit architecture: -2^29.
+  (pass-if "fixnum - fixnum = bignum (32-bit)"
+    (eqv? -536870912 (- -536870910 2)))
+
+  ;; The minimum fixnum on a 64-bit architecture: -2^61.
+  (pass-if "fixnum - fixnum = bignum (64-bit)"
+    (eqv? -2305843009213693952 (- -2305843009213693950 2)))
+
+  (pass-if "bignum - fixnum = fixnum"
+    (eqv? most-positive-fixnum (- (1+ most-positive-fixnum) 1))))
 
 ;;;
 ;;; *
 ;;;
 
+(with-test-prefix "*"
+
+  (with-test-prefix "double-negation of fixnum-min"
+    (pass-if (=      fixnum-min (* -1 (* -1 fixnum-min))))
+    (pass-if (eqv?   fixnum-min (* -1 (* -1 fixnum-min))))
+    (pass-if (equal? fixnum-min (* -1 (* -1 fixnum-min))))
+    (pass-if (=      fixnum-min (* (* fixnum-min -1) -1)))
+    (pass-if (eqv?   fixnum-min (* (* fixnum-min -1) -1)))
+    (pass-if (equal? fixnum-min (* (* fixnum-min -1) -1))))
+
+  (with-test-prefix "inum * bignum"
+
+    (pass-if "0 * 2^256 = 0"
+      (eqv? 0 (* 0 (ash 1 256)))))
+
+  (with-test-prefix "inum * flonum"
+
+    (pass-if "0 * 1.0 = 0"
+      (eqv? 0 (* 0 1.0))))
+
+  (with-test-prefix "inum * complex"
+
+    (pass-if "0 * 1+1i = 0"
+      (eqv? 0 (* 0 1+1i))))
+
+  (with-test-prefix "inum * frac"
+
+    (pass-if "0 * 2/3 = 0"
+      (eqv? 0 (* 0 2/3))))
+
+  (with-test-prefix "bignum * inum"
+
+    (pass-if "2^256 * 0 = 0"
+      (eqv? 0 (* (ash 1 256) 0))))
+
+  (with-test-prefix "flonum * inum"
+
+    ;; in guile 1.6.8 and 1.8.1 and earlier this returned inexact 0.0
+    (pass-if "1.0 * 0 = 0"
+      (eqv? 0 (* 1.0 0))))
+
+  (with-test-prefix "complex * inum"
+
+    ;; in guile 1.6.8 and 1.8.1 and earlier this returned inexact 0.0
+    (pass-if "1+1i * 0 = 0"
+      (eqv? 0 (* 1+1i 0))))
+
+  (pass-if "complex * bignum"
+    (let ((big (ash 1 90)))
+      (= (make-rectangular big big)
+	 (* 1+1i big))))
+
+  (with-test-prefix "frac * inum"
+
+    (pass-if "2/3 * 0 = 0"
+      (eqv? 0 (* 2/3 0)))))
+
 ;;;
 ;;; /
 ;;;
 
 (with-test-prefix "/"
 
-  (expect-fail "documented?"
+  (with-test-prefix "double-negation of fixnum-min"
+    (pass-if (=      fixnum-min (/ (/ fixnum-min -1) -1)))
+    (pass-if (eqv?   fixnum-min (/ (/ fixnum-min -1) -1)))
+    (pass-if (equal? fixnum-min (/ (/ fixnum-min -1) -1))))
+
+  (pass-if "documented?"
     (documented? /))
 
   (with-test-prefix "division by zero"
 
     (pass-if-exception "(/ 0)"
-      exception:numerical-overflow
+	exception:numerical-overflow
       (/ 0))
 
     (pass-if "(/ 0.0)"
       (= +inf.0 (/ 0.0)))
 
     (pass-if-exception "(/ 1 0)"
-      exception:numerical-overflow
+	exception:numerical-overflow
       (/ 1 0))
 
     (pass-if "(/ 1 0.0)"
       (= +inf.0 (/ 1 0.0)))
 
     (pass-if-exception "(/ bignum 0)"
-      exception:numerical-overflow
+	exception:numerical-overflow
       (/ (+ fixnum-max 1) 0))
 
     (pass-if "(/ bignum 0.0)"
       (= +inf.0 (/ (+ fixnum-max 1) 0.0)))
 
     (pass-if-exception "(/ 1.0 0)"
-      exception:numerical-overflow
+	exception:numerical-overflow
       (/ 1.0 0))
 
     (pass-if "(/ 1.0 0.0)"
       (= +inf.0 (/ 1.0 0.0)))
 
     (pass-if-exception "(/ +i 0)"
-      exception:numerical-overflow
+	exception:numerical-overflow
       (/ +i 0))
 
     (pass-if "(/ +i 0.0)"
       (= +inf.0 (imag-part (/ +i 0.0)))))
 
-  (with-test-prefix "complex division"
+  (with-test-prefix "1/complex"
+
+    (pass-if "0+1i"
+      (eqv? 0-1i (/ 0+1i)))
+
+    ;; in guile 1.6 through 1.6.7 this incorrectly resulted in nans
+    (pass-if "0-1i"
+      (eqv? 0+1i (/ 0-1i)))
+
+    (pass-if "1+1i"
+      (eqv? 0.5-0.5i (/ 1+1i)))
+
+    (pass-if "1-1i"
+      (eqv? 0.5+0.5i (/ 1-1i)))
+
+    (pass-if "-1+1i"
+      (eqv? -0.5-0.5i (/ -1+1i)))
+
+    (pass-if "-1-1i"
+      (eqv? -0.5+0.5i (/ -1-1i)))
 
     (pass-if "(/ 3+4i)"
       (= (/ 3+4i) 0.12-0.16i))
@@ -1844,20 +2825,24 @@
     (pass-if "(/ 4+3i)"
       (= (/ 4+3i) 0.16-0.12i))
 
-    (pass-if "(/ 25+125i 3+4i)"
-      (= (/ 25+125i 3+4i) 23.0+11.0i))
+    (pass-if "(/ 1e200+1e200i)"
+      (= (/ 1e200+1e200i) 5.0e-201-5.0e-201i)))
 
-    (pass-if "(/ 25+125i 4+3i)"
-      (= (/ 25+125i 4+3i) 19.0+17.0i))
+  (with-test-prefix "inum/complex"
 
     (pass-if "(/ 25 3+4i)"
       (= (/ 25 3+4i) 3.0-4.0i))
 
     (pass-if "(/ 25 4+3i)"
-      (= (/ 25 4+3i) 4.0-3.0i))
+      (= (/ 25 4+3i) 4.0-3.0i)))
 
-    (pass-if "(/ 1e200+1e200i)"
-      (= (/ 1e200+1e200i) 5.0e-201-5.0e-201i))))
+  (with-test-prefix "complex/complex"
+
+    (pass-if "(/ 25+125i 3+4i)"
+      (= (/ 25+125i 3+4i) 23.0+11.0i))
+
+    (pass-if "(/ 25+125i 4+3i)"
+      (= (/ 25+125i 4+3i) 19.0+17.0i))))
 
 ;;;
 ;;; truncate
@@ -1887,12 +2872,239 @@
   (pass-if (=  0 (round  0.0)))
   (pass-if (=  0 (round -0.5)))
   (pass-if (= -1 (round -1.25)))
-  (pass-if (= -2 (round -1.5))))
+  (pass-if (= -2 (round -1.5)))
+
+  (with-test-prefix "inum"
+    (pass-if "0"
+      (and (= 0    (round 0))
+	   (exact? (round 0))))
+
+    (pass-if "1"
+      (and (= 1    (round 1))
+	   (exact? (round 1))))
+
+    (pass-if "-1"
+      (and (= -1   (round -1))
+	   (exact? (round -1)))))
+
+  (with-test-prefix "bignum"
+    (let ((x (1+ most-positive-fixnum)))
+      (pass-if "(1+ most-positive-fixnum)"
+	(and (= x    (round x))
+	     (exact? (round x)))))
+
+    (let ((x (1- most-negative-fixnum)))
+      (pass-if "(1- most-negative-fixnum)"
+	(and (= x    (round x))
+	     (exact? (round x))))))
+
+  (with-test-prefix "frac"
+    (define (=exact x y)
+      (and (= x y)
+	   (exact? y)))
+
+    (pass-if (=exact -2 (round -7/3)))
+    (pass-if (=exact -2 (round -5/3)))
+    (pass-if (=exact -1 (round -4/3)))
+    (pass-if (=exact -1 (round -2/3)))
+    (pass-if (=exact  0 (round -1/3)))
+    (pass-if (=exact  0 (round  1/3)))
+    (pass-if (=exact  1 (round  2/3)))
+    (pass-if (=exact  1 (round  4/3)))
+    (pass-if (=exact  2 (round  5/3)))
+    (pass-if (=exact  2 (round  7/3)))
+
+    (pass-if (=exact -3 (round -17/6)))
+    (pass-if (=exact -3 (round -16/6)))
+    (pass-if (=exact -2 (round -15/6)))
+    (pass-if (=exact -2 (round -14/6)))
+    (pass-if (=exact -2 (round -13/6)))
+    (pass-if (=exact -2 (round -11/6)))
+    (pass-if (=exact -2 (round -10/6)))
+    (pass-if (=exact -2 (round  -9/6)))
+    (pass-if (=exact -1 (round  -8/6)))
+    (pass-if (=exact -1 (round  -7/6)))
+    (pass-if (=exact -1 (round  -5/6)))
+    (pass-if (=exact -1 (round  -4/6)))
+    (pass-if (=exact  0 (round  -3/6)))
+    (pass-if (=exact  0 (round  -2/6)))
+    (pass-if (=exact  0 (round  -1/6)))
+    (pass-if (=exact  0 (round   1/6)))
+    (pass-if (=exact  0 (round   2/6)))
+    (pass-if (=exact  0 (round   3/6)))
+    (pass-if (=exact  1 (round   4/6)))
+    (pass-if (=exact  1 (round   5/6)))
+    (pass-if (=exact  1 (round   7/6)))
+    (pass-if (=exact  1 (round   8/6)))
+    (pass-if (=exact  2 (round   9/6)))
+    (pass-if (=exact  2 (round  10/6)))
+    (pass-if (=exact  2 (round  11/6)))
+    (pass-if (=exact  2 (round  13/6)))
+    (pass-if (=exact  2 (round  14/6)))
+    (pass-if (=exact  2 (round  15/6)))
+    (pass-if (=exact  3 (round  16/6)))
+    (pass-if (=exact  3 (round  17/6))))
+
+  (with-test-prefix "real"
+    (pass-if "0.0"
+      (and (= 0.0    (round 0.0))
+	   (inexact? (round 0.0))))
+
+    (pass-if "1.0"
+      (and (= 1.0    (round 1.0))
+	   (inexact? (round 1.0))))
+
+    (pass-if "-1.0"
+      (and (= -1.0   (round -1.0))
+	   (inexact? (round -1.0))))
+
+    (pass-if "-3.1"
+      (and (= -3.0   (round -3.1))
+	   (inexact? (round -3.1))))
+
+    (pass-if "3.1"
+      (and (= 3.0    (round 3.1))
+	   (inexact? (round 3.1))))
+
+    (pass-if "3.9"
+      (and (= 4.0    (round 3.9))
+	   (inexact? (round 3.9))))
+
+    (pass-if "-3.9"
+      (and (= -4.0   (round -3.9))
+	   (inexact? (round -3.9))))
+
+    (pass-if "1.5"
+      (and (= 2.0    (round 1.5))
+	   (inexact? (round 1.5))))
+
+    (pass-if "2.5"
+      (and (= 2.0    (round 2.5))
+	   (inexact? (round 2.5))))
+
+    (pass-if "3.5"
+      (and (= 4.0    (round 3.5))
+	   (inexact? (round 3.5))))
+
+    (pass-if "-1.5"
+      (and (= -2.0   (round -1.5))
+	   (inexact? (round -1.5))))
+
+    (pass-if "-2.5"
+      (and (= -2.0   (round -2.5))
+	   (inexact? (round -2.5))))
+
+    (pass-if "-3.5"
+      (and (= -4.0   (round -3.5))
+	   (inexact? (round -3.5))))
+
+    ;; prior to guile 1.6.5, on an IEEE system an inexact 2^53-1 (ie. a
+    ;; float with mantissa all ones) came out as 2^53 from `round' (except
+    ;; on i386 and m68k systems using the coprocessor and optimizing, where
+    ;; extra precision hid the problem)
+    (pass-if "2^53-1"
+      (let ((x (exact->inexact (1- (ash 1 53)))))
+	(and (= x      (round x))
+	     (inexact? (round x)))))
+    (pass-if "-(2^53-1)"
+      (let ((x (exact->inexact (- (1- (ash 1 53))))))
+	(and (= x      (round x))
+	     (inexact? (round x)))))))
 
 ;;;
 ;;; exact->inexact
 ;;;
 
+(with-test-prefix "exact->inexact"
+  
+  ;; Test "(exact->inexact n)", expect "want".
+  ;; "i" is a index, for diagnostic purposes.
+  (define (try-i i n want)
+    (with-test-prefix (list i n want)
+      (with-test-prefix "pos"
+	(let ((got (exact->inexact n)))
+	  (pass-if "inexact?" (inexact? got))
+	  (pass-if (list "=" got) (= want got))))
+      (set! n    (- n))
+      (set! want (- want))
+      (with-test-prefix "neg"
+	(let ((got (exact->inexact n)))
+	  (pass-if "inexact?" (inexact? got))
+	  (pass-if (list "=" got) (= want got))))))
+  
+  (with-test-prefix "2^i, no round"
+    (do ((i    0   (1+ i))
+	 (n    1   (* 2 n))
+	 (want 1.0 (* 2.0 want)))
+	((> i 100))
+      (try-i i n want)))
+  
+  (with-test-prefix "2^i+1, no round"
+    (do ((i    1   (1+ i))
+	 (n    3   (1- (* 2 n)))
+	 (want 3.0 (- (* 2.0 want) 1.0)))
+	((>= i dbl-mant-dig))
+      (try-i i n want)))
+  
+  (with-test-prefix "(2^i+1)*2^100, no round"
+    (do ((i    1   (1+ i))
+	 (n    3   (1- (* 2 n)))
+	 (want 3.0 (- (* 2.0 want) 1.0)))
+	((>= i dbl-mant-dig))
+      (try-i i (ash n 100) (ash-flo want 100))))
+  
+  ;; bit pattern: 1111....11100.00
+  ;;              <-mantdig-><-i->
+  ;;
+  (with-test-prefix "mantdig ones then zeros, no rounding"
+    (do ((i    0  (1+ i))
+	 (n    (- (ash     1   dbl-mant-dig) 1)   (* 2 n))
+	 (want (- (ash-flo 1.0 dbl-mant-dig) 1.0) (* 2.0 want)))
+	((> i 100))
+      (try-i i n want)))
+  
+  ;; bit pattern: 1111....111011..1
+  ;;              <-mantdig-> <-i->
+  ;; This sort of value was incorrectly rounded upwards in Guile 1.6.4 when
+  ;; i >= 11 (that's when the total is 65 or more bits).
+  ;;
+  (with-test-prefix "mantdig ones then 011..11, round down"
+    (do ((i    0  (1+ i))
+	 (n    (- (ash     1   (+ 1 dbl-mant-dig)) 2)   (+ 1 (* 2 n)))
+	 (want (- (ash-flo 1.0 (+ 1 dbl-mant-dig)) 2.0) (* 2.0 want)))
+	((> i 100))
+      (try-i i n want)))
+  
+  ;; bit pattern: 1111....111100..001
+  ;;              <-mantdig-> <--i->
+  ;;
+  (with-test-prefix "mantdig ones then 100..001, round up"
+    (do ((i    0  (1+ i))
+	 (n    (- (ash     1   (+ 2 dbl-mant-dig)) 1)  (1- (* 2 n)))
+	 (want    (ash-flo 1.0 (+ 2 dbl-mant-dig))     (* 2.0 want)))
+	((> i 100))
+      (try-i i n want)))
+  
+  ;; bit pattern: 1000....000100..001
+  ;;              <-mantdig-> <--i->
+  ;;
+  (with-test-prefix "2^mantdig then 100..001, round up"
+    (do ((i    0  (1+ i))
+	 (n    (- (ash     1   (+ 2 dbl-mant-dig)) 1)   (1- (* 2 n)))
+	 (want (+ (ash-flo 1.0 (+ 2 dbl-mant-dig)) 4.0) (* 2.0 want)))
+	((> i 100))
+      (try-i i n want)))
+
+  (pass-if "frac big/big"
+    (let ((big (ash 1 256)))
+      (= 1.0 (exact->inexact (/ (1+ big) big)))))
+
+  ;; In guile 1.8.0 this failed, giving back "nan" because it tried to
+  ;; convert the num and den to doubles, resulting in infs.
+  (pass-if "frac big/big, exceeding double"
+    (let ((big (ash 1 4096)))
+      (= 1.0 (exact->inexact (/ (1+ big) big))))))
+
 ;;;
 ;;; floor
 ;;;
@@ -1906,10 +3118,38 @@
 ;;;
 
 (with-test-prefix "expt"
-  (pass-if "(= 1 (expt 0 0))" (= 1 (expt 0 0)))
-  (pass-if "(= 1 (expt 0 0.0))" (= 1 (expt 0 0.0)))
-  (pass-if "(= 1 (expt 0.0 0))" (= 1 (expt 0.0 0)))
-  (pass-if "(= 1 (expt 0.0 0.0))" (= 1 (expt 0.0 0.0))))
+  (pass-if-exception "non-numeric base" exception:wrong-type-arg
+                     (expt #t 0))
+  (pass-if (eqv? 1 (expt 0 0)))
+  (pass-if (eqv? 1 (expt 0.0 0)))
+  (pass-if (eqv? 1.0 (expt 0 0.0)))
+  (pass-if (eqv? 1.0 (expt 0.0 0.0)))
+  (pass-if (nan? (expt 0 -1)))
+  (pass-if (nan? (expt 0 -1.0)))
+  (pass-if (nan? (expt 0.0 -1)))
+  (pass-if (nan? (expt 0.0 -1.0)))
+  (pass-if (eqv? 0 (expt 0 3)))
+  (pass-if (= 0 (expt 0 4.0)))
+  (pass-if (eqv? 0.0 (expt 0.0 5)))
+  (pass-if (eqv? 0.0 (expt 0.0 6.0)))
+  (pass-if (eqv? -2742638075.5 (expt -2742638075.5 1)))
+  (pass-if (eqv? (* -2742638075.5 -2742638075.5)
+                 (expt -2742638075.5 2)))
+  (pass-if (eqv? 4.0 (expt -2.0 2.0)))
+  (pass-if (eqv? -1/8 (expt -2 -3)))
+  (pass-if (eqv? -0.125 (expt -2.0 -3)))
+  (pass-if (eqv? -0.125 (expt -2 -3.0)))
+  (pass-if (eqv? -0.125 (expt -2.0 -3.0)))
+  (pass-if (eqv? 0.25 (expt 2.0 -2.0)))
+  (pass-if (eqv? (* -1.0 12398 12398) (expt +12398i 2.0)))
+  (pass-if (eqv-loosely? +i (expt -1 0.5)))
+  (pass-if (eqv-loosely? +i (expt -1 1/2)))
+  (pass-if (eqv-loosely? 1.0+1.7320508075688i (expt -8 1/3)))
+  (pass-if (eqv? +inf.0 (expt 2 +inf.0)))
+  (pass-if (eqv? +inf.0 (expt 2.0 +inf.0)))
+  (pass-if (eqv? 0.0 (expt 2 -inf.0)))
+  (pass-if (eqv? 0.0 (expt 2.0 -inf.0))))
+
 
 ;;;
 ;;; asinh
@@ -1982,10 +3222,73 @@
 ;;; angle
 ;;;
 
+(with-test-prefix "angle"
+  (define pi 3.14159265358979323846)
+  (define (almost= x y)
+    (> 0.01 (magnitude (- x y))))
+  
+  (pass-if "inum +ve"   (=        0 (angle 1)))
+  (pass-if "inum -ve"   (almost= pi (angle -1)))
+
+  (pass-if "bignum +ve" (=        0 (angle (1+ fixnum-max))))
+  (pass-if "bignum -ve" (almost= pi (angle (1- fixnum-min))))
+
+  (pass-if "flonum +ve" (=        0 (angle 1.5)))
+  (pass-if "flonum -ve" (almost= pi (angle -1.5))))
+
 ;;;
 ;;; inexact->exact
 ;;;
 
+(with-test-prefix "inexact->exact"
+  
+  (pass-if-exception "+inf" exception:out-of-range
+    (inexact->exact +inf.0))
+  
+  (pass-if-exception "-inf" exception:out-of-range
+    (inexact->exact -inf.0))
+  
+  (pass-if-exception "nan" exception:out-of-range
+    (inexact->exact +nan.0))
+  
+  (with-test-prefix "2.0**i to exact and back"
+    (do ((i 0   (1+ i))
+	 (n 1.0 (* 2.0 n)))
+	((> i 100))
+      (pass-if (list i n)
+	(= n (inexact->exact (exact->inexact n)))))))
+
+;;;
+;;; integer-expt
+;;;
+
+(with-test-prefix "integer-expt"
+
+  (pass-if-exception "non-numeric base" exception:wrong-type-arg
+                     (integer-expt #t 0))
+  (pass-if-exception "2^+inf" exception:wrong-type-arg
+    (integer-expt 2 +inf.0))
+  (pass-if-exception "2^-inf" exception:wrong-type-arg
+    (integer-expt 2 -inf.0))
+  (pass-if-exception "2^nan" exception:wrong-type-arg
+    (integer-expt 2 +nan.0))
+
+  (pass-if (eqv? 1 (integer-expt 0 0)))
+  (pass-if (eqv? 1 (integer-expt 0.0 0)))
+  (pass-if (nan? (integer-expt 0 -1)))
+  (pass-if (nan? (integer-expt 0.0 -1)))
+  (pass-if (eqv? 0 (integer-expt 0 3)))
+  (pass-if (eqv? 0.0 (integer-expt 0.0 5)))
+  (pass-if (eqv? -2742638075.5 (integer-expt -2742638075.5 1)))
+  (pass-if (eqv? (* -2742638075.5 -2742638075.5)
+                 (integer-expt -2742638075.5 2)))
+  (pass-if (eqv? 4.0 (integer-expt -2.0 2)))
+  (pass-if (eqv? -1/8 (integer-expt -2 -3)))
+  (pass-if (eqv? -0.125 (integer-expt -2.0 -3)))
+  (pass-if (eqv? 0.25 (integer-expt 2.0 -2)))
+  (pass-if (eqv? (* -1.0 12398 12398) (integer-expt +12398.0i 2))))
+
+
 ;;;
 ;;; integer-length
 ;;;
@@ -2013,6 +3316,97 @@
       (pass-if n
 	(= i (integer-length n))))))
 
+;;;
+;;; log
+;;;
+
+(with-test-prefix "log"
+  (pass-if "documented?"
+    (documented? log))
+
+  (pass-if-exception "no args" exception:wrong-num-args
+    (log))
+  (pass-if-exception "two args" exception:wrong-num-args
+    (log 123 456))
+
+  (pass-if (negative-infinity? (log 0)))
+  (pass-if (negative-infinity? (log 0.0)))
+  (pass-if (eqv? 0.0 (log 1)))
+  (pass-if (eqv? 0.0 (log 1.0)))
+  (pass-if (eqv-loosely? 1.0  (log const-e)))
+  (pass-if (eqv-loosely? 2.0  (log const-e^2)))
+  (pass-if (eqv-loosely? -1.0 (log const-1/e)))
+
+  (pass-if (eqv-loosely? 1.0+1.57079i (log 0+2.71828i)))
+  (pass-if (eqv-loosely? 1.0-1.57079i (log 0-2.71828i)))
+
+  (pass-if (eqv-loosely? 0.0+3.14159i (log -1.0)))
+  (pass-if (eqv-loosely? 1.0+3.14159i (log -2.71828)))
+  (pass-if (eqv-loosely? 2.0+3.14159i (log (* -2.71828 2.71828)))))
+
+;;;
+;;; log10
+;;;
+
+(with-test-prefix "log10"
+  (pass-if "documented?"
+    (documented? log10))
+
+  (pass-if-exception "no args" exception:wrong-num-args
+    (log10))
+  (pass-if-exception "two args" exception:wrong-num-args
+    (log10 123 456))
+
+  (pass-if (negative-infinity? (log10 0)))
+  (pass-if (negative-infinity? (log10 0.0)))
+  (pass-if (eqv? 0.0 (log10 1)))
+  (pass-if (eqv? 0.0 (log10 1.0)))
+  (pass-if (eqv-loosely? 1.0  (log10 10.0)))
+  (pass-if (eqv-loosely? 2.0  (log10 100.0)))
+  (pass-if (eqv-loosely? -1.0 (log10 0.1)))
+
+  (pass-if (eqv-loosely? 1.0+0.68218i (log10 0+10.0i)))
+  (pass-if (eqv-loosely? 1.0-0.68218i (log10 0-10.0i)))
+
+  (pass-if (eqv-loosely? 0.0+1.36437i (log10 -1)))
+  (pass-if (eqv-loosely? 1.0+1.36437i (log10 -10)))
+  (pass-if (eqv-loosely? 2.0+1.36437i (log10 -100))))
+
+;;;
+;;; logbit?
+;;;
+
+(with-test-prefix "logbit?"
+  (pass-if (eq? #f (logbit?  0 0)))
+  (pass-if (eq? #f (logbit?  1 0)))
+  (pass-if (eq? #f (logbit? 31 0)))
+  (pass-if (eq? #f (logbit? 32 0)))
+  (pass-if (eq? #f (logbit? 33 0)))
+  (pass-if (eq? #f (logbit? 63 0)))
+  (pass-if (eq? #f (logbit? 64 0)))
+  (pass-if (eq? #f (logbit? 65 0)))
+
+  ;; prior to guile 1.6.5, testing bit 32, 64 etc of value 1 would wrap
+  ;; around and return #t where it ought to be #f
+  (pass-if (eq? #t (logbit?  0 1)))
+  (pass-if (eq? #f (logbit?  1 1)))
+  (pass-if (eq? #f (logbit? 31 1)))
+  (pass-if (eq? #f (logbit? 32 1)))
+  (pass-if (eq? #f (logbit? 33 1)))
+  (pass-if (eq? #f (logbit? 63 1)))
+  (pass-if (eq? #f (logbit? 64 1)))
+  (pass-if (eq? #f (logbit? 65 1)))
+  (pass-if (eq? #f (logbit? 128 1)))
+
+  (pass-if (eq? #t (logbit?  0 -1)))
+  (pass-if (eq? #t (logbit?  1 -1)))
+  (pass-if (eq? #t (logbit? 31 -1)))
+  (pass-if (eq? #t (logbit? 32 -1)))
+  (pass-if (eq? #t (logbit? 33 -1)))
+  (pass-if (eq? #t (logbit? 63 -1)))
+  (pass-if (eq? #t (logbit? 64 -1)))
+  (pass-if (eq? #t (logbit? 65 -1))))
+
 ;;;
 ;;; logcount
 ;;;
@@ -2040,3 +3434,220 @@
       (pass-if n
 	(= i (logcount n))))))
 
+;;;
+;;; logior
+;;;
+
+(with-test-prefix "logior"
+  (pass-if (eqv? -1 (logior (ash -1 1) 1)))
+
+  ;; check that bignum or bignum+inum args will reduce to an inum
+  (let ()
+    (define (test x y)
+      (pass-if (list x y '=> -1)
+	(eqv? -1 (logior x y)))
+      (pass-if (list y x '=> -1)
+	(eqv? -1 (logior y x))))
+    (test (ash -1 8) #xFF)
+    (test (ash -1 28) #x0FFFFFFF)
+    (test (ash -1 29) #x1FFFFFFF)
+    (test (ash -1 30) #x3FFFFFFF)
+    (test (ash -1 31) #x7FFFFFFF)
+    (test (ash -1 32) #xFFFFFFFF)
+    (test (ash -1 33) #x1FFFFFFFF)
+    (test (ash -1 60) #x0FFFFFFFFFFFFFFF)
+    (test (ash -1 61) #x1FFFFFFFFFFFFFFF)
+    (test (ash -1 62) #x3FFFFFFFFFFFFFFF)
+    (test (ash -1 63) #x7FFFFFFFFFFFFFFF)
+    (test (ash -1 64) #xFFFFFFFFFFFFFFFF)
+    (test (ash -1 65) #x1FFFFFFFFFFFFFFFF)
+    (test (ash -1 128) #xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)))
+
+;;;
+;;; lognot
+;;;
+
+(with-test-prefix "lognot"
+  (pass-if (= -1 (lognot 0)))
+  (pass-if (= 0  (lognot -1)))
+  (pass-if (= -2 (lognot 1)))
+  (pass-if (= 1  (lognot -2)))
+  
+  (pass-if (= #x-100000000000000000000000000000000
+	      (lognot #xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)))
+  (pass-if (= #xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+	      (lognot #x-100000000000000000000000000000000))))
+
+;;;
+;;; sqrt
+;;;
+
+(with-test-prefix "sqrt"
+  (pass-if "documented?"
+    (documented? sqrt))
+
+  (pass-if-exception "no args" exception:wrong-num-args
+    (sqrt))
+  (pass-if-exception "two args" exception:wrong-num-args
+    (sqrt 123 456))
+
+  (pass-if (eqv? 0.0 (sqrt 0)))
+  (pass-if (eqv? 0.0 (sqrt 0.0)))
+  (pass-if (eqv? 1.0 (sqrt 1.0)))
+  (pass-if (eqv-loosely? 2.0   (sqrt 4.0)))
+  (pass-if (eqv-loosely? 31.62 (sqrt 1000.0)))
+
+  (pass-if (eqv? +1.0i (sqrt -1.0)))
+  (pass-if (eqv-loosely? +2.0i   (sqrt -4.0)))
+  (pass-if (eqv-loosely? +31.62i (sqrt -1000.0)))
+
+  (pass-if "+i swings back to 45deg angle"
+    (eqv-loosely? +0.7071+0.7071i (sqrt +1.0i)))
+
+  ;; Note: glibc 2.3 csqrt() had a bug affecting this test case, so if it
+  ;; fails check whether that's the cause (there's a configure test to
+  ;; reject it, but when cross-compiling we assume the C library is ok).
+  (pass-if "-100i swings back to 45deg down"
+    (eqv-loosely? +7.071-7.071i (sqrt -100.0i))))
+
+;;;
+;;; euclidean/
+;;; euclidean-quotient
+;;; euclidean-remainder
+;;; centered/
+;;; centered-quotient
+;;; centered-remainder
+;;;
+
+(with-test-prefix "Number-theoretic division"
+
+  ;; Tests that (lo <= x < hi),
+  ;; but allowing for imprecision
+  ;; if x is inexact.
+  (define (test-within-range? lo hi x)
+    (if (exact? x)
+        (and (<= lo x) (< x hi))
+        (let ((lo (- lo test-epsilon))
+              (hi (+ hi test-epsilon)))
+          (<= lo x hi))))
+
+  (define (safe-euclidean-quotient x y)
+    (cond ((not (and (real? x) (real? y))) (throw 'wrong-type-arg))
+          ((zero? y) (throw 'divide-by-zero))
+          ((nan?  y) (nan))
+          ((positive? y) (floor   (/ x y)))
+          ((negative? y) (ceiling (/ x y)))
+          (else (throw 'unknown-problem))))
+
+  (define (safe-euclidean-remainder x y)
+    (- x (* y (safe-euclidean-quotient x y))))
+
+  (define (safe-euclidean/ x y)
+    (let ((q (safe-euclidean-quotient x y))
+          (r (safe-euclidean-remainder x y)))
+      (if (not (and (eq? (exact? q) (exact? r))
+                    (eq? (exact? q) (and (exact? x) (exact? y)))
+                    (test-real-eqv? r (- x (* q y)))
+                    (or (and (integer? q)
+                             (test-within-range? 0 (abs y) r))
+                        (not (finite? x))
+                        (not (finite? y)))))
+          (throw 'safe-euclidean/-is-broken (list x y q r))
+          (values q r))))
+
+  (define (safe-centered-quotient x y)
+    (cond ((not (and (real? x) (real? y))) (throw 'wrong-type-arg))
+          ((zero? y) (throw 'divide-by-zero))
+          ((nan?  y) (nan))
+          ((positive? y) (floor   (+  1/2 (/ x y))))
+          ((negative? y) (ceiling (+ -1/2 (/ x y))))
+          (else (throw 'unknown-problem))))
+
+  (define (safe-centered-remainder x y)
+    (- x (* y (safe-centered-quotient x y))))
+
+  (define (safe-centered/ x y)
+    (let ((q (safe-centered-quotient x y))
+          (r (safe-centered-remainder x y)))
+      (if (not (and (eq? (exact? q) (exact? r))
+                    (eq? (exact? q) (and (exact? x) (exact? y)))
+                    (test-real-eqv? r (- x (* q y)))
+                    (or (and (integer? q)
+                             (test-within-range? (* -1/2 (abs y))
+                                                 (* +1/2 (abs y))
+                                                 r))
+                        (not (finite? x))
+                        (not (finite? y)))))
+          (throw 'safe-centered/-is-broken (list x y q r))
+          (values q r))))
+
+  (define test-numerators
+    (append
+     (list  123  125  127  130  3  5  10  123.2  125.0
+            -123 -125 -127 -130 -3 -5 -10 -123.2 -125.0
+            127.2  130.0  123/7  125/7  127/7  130/7
+            -127.2 -130.0 -123/7 -125/7 -127/7 -130/7
+            0 +0.0 -0.0 +inf.0 -inf.0 +nan.0
+            most-negative-fixnum (1+ most-positive-fixnum)
+            (1- most-negative-fixnum))
+     (apply append
+            (map (lambda (x) (list (* x (+ 1 most-positive-fixnum))
+                                   (* x (+ 2 most-positive-fixnum))))
+                 '( 123  125  127  130  3  5  10
+                   -123 -125 -127 -130 -3 -5 -10)))))
+
+  (define test-denominators
+    (list   10  5  10/7  127/2  10.0  63.5
+            -10 -5 -10/7 -127/2 -10.0 -63.5
+            +inf.0 -inf.0 +nan.0 most-negative-fixnum
+            (+ 1 most-positive-fixnum) (+ -1 most-negative-fixnum)
+            (+ 2 most-positive-fixnum) (+ -2 most-negative-fixnum)))
+
+  (define (do-tests-1 op-name real-op safe-op)
+    (for-each (lambda (d)
+                (for-each (lambda (n)
+                            (run-test (list op-name n d) #t
+                                      (lambda ()
+                                        (test-eqv? (real-op n d)
+                                                   (safe-op n d)))))
+                          test-numerators))
+              test-denominators))
+
+  (define (do-tests-2 op-name real-op safe-op)
+    (for-each (lambda (d)
+                (for-each (lambda (n)
+                            (run-test (list op-name n d) #t
+                                      (lambda ()
+                                        (let-values
+                                            (((q  r)  (safe-op n d))
+                                             ((q1 r1) (real-op n d)))
+                                          (and (test-eqv? q q1)
+                                               (test-eqv? r r1))))))
+                          test-numerators))
+              test-denominators))
+
+  (with-test-prefix "euclidean-quotient"
+    (do-tests-1 'euclidean-quotient
+                euclidean-quotient
+                safe-euclidean-quotient))
+  (with-test-prefix "euclidean-remainder"
+    (do-tests-1 'euclidean-remainder
+                euclidean-remainder
+                safe-euclidean-remainder))
+  (with-test-prefix "euclidean/"
+    (do-tests-2 'euclidean/
+                euclidean/
+                safe-euclidean/))
+
+  (with-test-prefix "centered-quotient"
+    (do-tests-1 'centered-quotient
+                centered-quotient
+                safe-centered-quotient))
+  (with-test-prefix "centered-remainder"
+    (do-tests-1 'centered-remainder
+                centered-remainder
+                safe-centered-remainder))
+  (with-test-prefix "centered/"
+    (do-tests-2 'centered/
+                centered/
+                safe-centered/)))