diff --git a/data/array-tests.lisp b/data/array-tests.lisp
index 63e25139ad46a3dc3e52cdaf06d6f0369b95aa52..94846a50fc9558c06d59690c8cc0ddaef775b79c 100644
--- a/data/array-tests.lisp
+++ b/data/array-tests.lisp
@@ -1,6 +1,6 @@
 ;; Tests of array functions 
 ;; Liam Healy 2008-10-20 22:41:48EDT array-tests.lisp
-;; Time-stamp: <2008-12-26 12:23:58EST array-tests.lisp>
+;; Time-stamp: <2008-12-31 21:40:17EST array-tests.lisp>
 ;; $Id: $
 
 ;;; Generate each file with #'write-test-to-file, e.g.
@@ -141,7 +141,6 @@
  (let ((m1 (array-default '(3 3))))
    (mmax m1)))
 
-#| Temporarily commented out twos-complement answer for SIGNED-BYTE-8 and SIGNED-BYTE-16
 (generate-all-array-tests vector-min :no-complex
  (let ((v1 (array-default 3)))
    (mmin v1)))
@@ -149,7 +148,6 @@
 (generate-all-array-tests matrix-min :no-complex
  (let ((m1 (array-default '(3 3))))
    (mmin m1)))
-|#
 
 (generate-all-array-tests vector-minmax :no-complex
  (let ((v1 (array-default 3)))
diff --git a/data/combination.lisp b/data/combination.lisp
index cdc915f7e57ff5800c91a53c7de8539fc81c1ee5..17e5ee41a98010f6ee93714d792ea5a040f91fad 100644
--- a/data/combination.lisp
+++ b/data/combination.lisp
@@ -1,6 +1,6 @@
 ;; Combinations
 ;; Liam Healy, Sun Mar 26 2006 - 11:51
-;; Time-stamp: <2008-12-28 16:36:24EST combination.lisp>
+;; Time-stamp: <2008-12-31 21:10:06EST combination.lisp>
 ;; $Id$
 
 (in-package :gsl)
@@ -12,8 +12,8 @@
 (defclass combination (mobject foreign-array)
   ((element-type
     :initform
-    #+sizet-64 '(unsigned-byte 64)
-    #+sizet-32 '(unsigned-byte 32)
+    #+int64 '(unsigned-byte 64)
+    #+int32 '(unsigned-byte 32)
     :reader element-type :allocation :class)
    (choice-of :initarg :choice-of :reader choice-of :type (integer 0)
 	      :documentation "Maximum possible value; n in the (n k) notation."))
diff --git a/data/permutation.lisp b/data/permutation.lisp
index 7099d58d2a6f6cb4b1e8e77d957d44c4c24c365c..8cfed933fd9dfffd5590a9684ce7a3ac4afd59df 100644
--- a/data/permutation.lisp
+++ b/data/permutation.lisp
@@ -1,6 +1,6 @@
 ;; Permutations
 ;; Liam Healy, Sun Mar 26 2006 - 11:51
-;; Time-stamp: <2008-12-28 16:40:35EST permutation.lisp>
+;; Time-stamp: <2008-12-31 21:10:05EST permutation.lisp>
 ;; $Id$
 
 (in-package :gsl)
@@ -12,8 +12,8 @@
 (defclass permutation (mobject foreign-array)
   ((element-type
     :initform
-    #+sizet-64 '(unsigned-byte 64)
-    #+sizet-32 '(unsigned-byte 32)
+    #+int64 '(unsigned-byte 64)
+    #+int32 '(unsigned-byte 32)
     :reader element-type :allocation :class))
   (:documentation "GSL permutations."))
 
diff --git a/floating-point/ieee-modes.lisp b/floating-point/ieee-modes.lisp
index a7f80a0fc6412e41c12a01a08665eaeae1fbb795..654247761f700a9b81f9cec4339273edc143a746 100644
--- a/floating-point/ieee-modes.lisp
+++ b/floating-point/ieee-modes.lisp
@@ -1,6 +1,6 @@
 ;; IEEE 754 Modes and masks
 ;; Liam Healy 2008-01-29 21:35:50EST ieee-modes.lisp
-;; Time-stamp: <2008-12-28 20:59:16EST ieee-modes.lisp>
+;; Time-stamp: <2008-12-31 18:36:26EST ieee-modes.lisp>
 ;; $Id$
 
 (in-package :gsl)
@@ -30,6 +30,3 @@
    ((cffi:foreign-enum-value 'ieee-mask exception-mask) :int))
   :documentation
   "Set the IEEE 754 precision, rounding mode, and exception mask.")
-
-#+clisp
-(setf sys::*inhibit-floating-point-underflow* t)
diff --git a/gsll-tests.asd b/gsll-tests.asd
index d4fbc5909f9418bb5c3933c6cfbba39e3af7b8e6..8a6f75b638d0ad54f316552348f1308c154f3a09 100644
--- a/gsll-tests.asd
+++ b/gsll-tests.asd
@@ -1,6 +1,6 @@
 ;; Definition of GSLL system 
 ;; Liam Healy
-;; Time-stamp: <2008-11-16 13:29:58EST gsll-tests.asd>
+;; Time-stamp: <2008-12-31 21:53:55EST gsll-tests.asd>
 ;; $Id$
 
 (asdf:defsystem "gsll-tests"
@@ -92,6 +92,7 @@
 	     (:file "matrix-max-index")
 	     (:file "matrix-max")
 	     (:file "matrix-mean")
+	     (:file "matrix-min")
 	     (:file "matrix-min-index")
 	     (:file "matrix-minmax-index")
 	     (:file "matrix-minmax")
@@ -159,6 +160,7 @@
 	     (:file "vector-max-index")
 	     (:file "vector-max")
 	     (:file "vector-mean")
+	     (:file "vector-min")
 	     (:file "vector-min-index")
 	     (:file "vector-minmax-index")
 	     (:file "vector-minmax")
diff --git a/gsll.asd b/gsll.asd
index 4dfd81f7098f215d04db1f28e05b7abd31908b8b..64163579c62bf05c6b8a2889afdff3205f990855 100644
--- a/gsll.asd
+++ b/gsll.asd
@@ -1,6 +1,6 @@
 ;; Definition of GSLL system 
 ;; Liam Healy
-;; Time-stamp: <2008-12-29 13:35:30EST gsll.asd>
+;; Time-stamp: <2008-12-31 21:10:22EST gsll.asd>
 ;; $Id$
 
 (asdf:defsystem "gsll"
@@ -16,7 +16,8 @@
 	    ((:file "init")
 	     (:file "conditions" :depends-on (init))
 	     (:file "mobject" :depends-on (init))
-	     (:file "element-types" :depends-on (init))
+	     (:file "types" :depends-on (init))
+	     (:file "element-types" :depends-on (init types))
 	     (:file "number-conversion" :depends-on (init))
 	     (:file "interface"
 		    :depends-on (init conditions element-types number-conversion))
diff --git a/init/conditions.lisp b/init/conditions.lisp
index 0cf14fbdd393df184ff752c08f11d9e6b6e7fa00..54ecd51ae74d6b9f149a3a5d6c055b36b268ad1c 100644
--- a/init/conditions.lisp
+++ b/init/conditions.lisp
@@ -1,6 +1,6 @@
 ;; GSL errors                                
 ;; Liam Healy Sat Mar  4 2006 - 18:33
-;; Time-stamp: <2008-12-27 16:42:45EST conditions.lisp>
+;; Time-stamp: <2008-12-31 18:32:09EST conditions.lisp>
 ;; $Id$
 
 (in-package :gsl)
@@ -38,7 +38,8 @@
 
 (defmacro define-gsl-condition (keyword number text &rest superclasses)
   `(progn
-    (define-condition ,keyword (gsl-condition ,@superclasses)
+    (define-condition
+	  ,keyword ,(or superclasses '(gsl-condition))
       ((error-number :initform ,number :reader error-number :allocation :class)
        (error-text :initform ,text :reader error-text :allocation :class))
       (:documentation
@@ -64,7 +65,7 @@
 (define-gsl-condition exceeded-maximum-iterations
     11 "Exceeded max number of iterations")
 (define-gsl-condition gsl-division-by-zero
-    12 "Tried to divide by zero" division-by-zero)
+    12 "Tried to divide by zero" gsl-condition division-by-zero)
 (define-gsl-condition invalid-tolerance 13 "User specified an invalid tolerance")
 (define-gsl-condition failure-to-reach-tolerance
     14 "Failed to reach the specified tolerance")
@@ -93,6 +94,7 @@
     30 "Cannot reach the specified tolerance in X")
 (define-gsl-condition failure-to-reach-tolerance-g
     31 "Cannot reach the specified tolerance in gradient")
+;; not a subclass of gsl-condition
 (define-gsl-condition gsl-eof 32 "End of file" end-of-file)
 ;;; It is possible to return +positive-infinity+
 ;;; by defining a handler for 'overflow.
diff --git a/init/element-types.lisp b/init/element-types.lisp
index 4650b9b779c51746010fd0606e590cc57a2fbfb5..5122ae9d28fb11ce02cdca19cd3ce98c840e2169 100644
--- a/init/element-types.lisp
+++ b/init/element-types.lisp
@@ -1,6 +1,6 @@
 ;; Mapping of element type names
 ;; Liam Healy 2008-04-13 11:22:46EDT element-types.lisp
-;; Time-stamp: <2008-11-11 21:34:47EST element-types.lisp>
+;; Time-stamp: <2008-12-31 21:10:07EST element-types.lisp>
 ;; $Id$
 
 ;;; The different element type forms:
@@ -39,9 +39,9 @@
     :short :unsigned-short
     :int :unsigned-int
     :long :unsigned-long
-    #-cffi-features:no-long-long
+    #+int64
     :long-long
-    #-cffi-features:no-long-long
+    #+int64
     :unsigned-long-long)
   ;; http://common-lisp.net/project/cffi/manual/html_node/Built_002dIn-Types.html
   "List of integer types supported by CFFI, from the CFFI docs.")
@@ -313,21 +313,3 @@
     (:doubles *double-types*)
     (t element-types)))
 
-;;;;****************************************************************************
-;;;; Types for CFFI (will eventually be in CFFI)
-;;;;****************************************************************************
-
-(defvar *sizet-type* nil
-  "The CL type for size_t.")
-
-(case
-  (cffi:foreign-type-size :long)
-  (8
-   (push :sizet-64 *features*)
-   (setf *sizet-type* '(unsigned-byte 64))
-   (cffi:defctype sizet :uint64))
-  (4
-   (push :sizet-32 *features*)
-   (setf *sizet-type* '(unsigned-byte 32))
-   (cffi:defctype sizet :uint32))
-  (t (error "Size of :long unrecognized")))
diff --git a/init/types.lisp b/init/types.lisp
new file mode 100644
index 0000000000000000000000000000000000000000..e1d41fe3ef23726223143109b9286176fb07d25a
--- /dev/null
+++ b/init/types.lisp
@@ -0,0 +1,27 @@
+;; Permissible types
+;; Liam Healy 2008-12-31 21:06:34EST types.lisp
+;; Time-stamp: <2008-12-31 21:52:33EST types.lisp>
+;; $Id: $
+
+(in-package :gsl)
+
+;;;;****************************************************************************
+;;;; Types for CFFI (will eventually be in CFFI)
+;;;;****************************************************************************
+
+(defvar *sizet-type* nil
+  "The CL type for size_t.")
+
+(case
+  (cffi:foreign-type-size :long)
+  (8
+   (push :int64 *features*)
+   (setf *sizet-type* '(unsigned-byte 64))
+   (cffi:defctype sizet :uint64))
+  (4
+   (push :int32 *features*)
+   (setf *sizet-type* '(unsigned-byte 32))
+   (cffi:defctype sizet :uint32))
+  (t (error "Size of :long unrecognized")))
+
+;; cffi-features:no-long-long doesn't work for me, but ought to be checked? 
diff --git a/mathematical.lisp b/mathematical.lisp
index 264331e8ba7b3173851b5269342b704e725887c6..bbfb2a7066fa278b484eb9af5fbc19d163e72d2d 100644
--- a/mathematical.lisp
+++ b/mathematical.lisp
@@ -1,6 +1,6 @@
 ;; Mathematical functions
 ;; Liam Healy, Wed Mar  8 2006 - 22:09
-;; Time-stamp: <2008-10-25 19:09:09EDT mathematical.lisp>
+;; Time-stamp: <2008-12-31 18:44:26EST mathematical.lisp>
 ;; $Id$
 
 (in-package :gsl)
@@ -14,6 +14,8 @@
 ;;;   Maximum and Minimum functions
 ;;; Does CL need the small integer powers?
 
+#+clisp (setf sys::*inhibit-floating-point-underflow* t)
+
 ;;;;****************************************************************************
 ;;; Infinities and Not-a-number
 ;;;;****************************************************************************
diff --git a/tests/column.lisp b/tests/column.lisp
index cea707af1171deefabbc0ca32696c9b71c85585e..5ad05e2d5526b23feaa9b5e3ad84fa32b7617b26 100644
--- a/tests/column.lisp
+++ b/tests/column.lisp
@@ -189,6 +189,7 @@
                                                              (CL-ARRAY
                                                               (COLUMN COL M1
                                                                       1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
@@ -211,6 +212,7 @@
                                                              (CL-ARRAY
                                                               (COLUMN COL M1
                                                                       1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
diff --git a/tests/matrix-add-scalar.lisp b/tests/matrix-add-scalar.lisp
index 2faa18436de9f48640490d033d2773c21aaab633..64a5fc01a21b6de26d5942a4ece256b4e9236910 100644
--- a/tests/matrix-add-scalar.lisp
+++ b/tests/matrix-add-scalar.lisp
@@ -81,6 +81,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (CL-ARRAY (M+C M1 18.19d0)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-45 -49 89) (-72 70 8) (91 13 141)))
                         (MULTIPLE-VALUE-LIST
@@ -90,6 +91,7 @@
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
                            (CL-ARRAY (M+C M1 18.19d0)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((85 62 207) (134 181 158) (179 233 116)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-copy.lisp b/tests/matrix-copy.lisp
index d9ac3bd666c9c020a2511f0a3ccd3ce97d3bda67..5dbee57cb77c5d2c57438985458b12d4b6bead87 100644
--- a/tests/matrix-copy.lisp
+++ b/tests/matrix-copy.lisp
@@ -154,6 +154,7 @@
                                              '(3 3))))
                            (COPY M2 M1)
                            (CL-ARRAY M2))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-64 -68 71) (-91 52 -10) (73 -5 123)))
                         (MULTIPLE-VALUE-LIST
@@ -167,6 +168,7 @@
                                              '(3 3))))
                            (COPY M2 M1)
                            (CL-ARRAY M2))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((67 44 189) (116 163 140) (161 215 98)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-div.lisp b/tests/matrix-div.lisp
index 7bde9bb194085cb50cded5702b1ed96489f2b457..e3b7fe9bbc11d9c27d47fb2030070e63ec7b49f7 100644
--- a/tests/matrix-div.lisp
+++ b/tests/matrix-div.lisp
@@ -122,6 +122,7 @@
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
                            (CL-ARRAY (M/ M1 M2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1)))
                         (MULTIPLE-VALUE-LIST
@@ -136,6 +137,7 @@
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
                            (CL-ARRAY (M/ M1 M2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((2 4 9) (4 0 0) (4 1 0)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-m+.lisp b/tests/matrix-m+.lisp
index b582e2e4f79da92d68f04dc0b9d14ebaaf4dd495..7095f7590cd703c7f97b4731bbf6f88b47a9c303 100644
--- a/tests/matrix-m+.lisp
+++ b/tests/matrix-m+.lisp
@@ -120,6 +120,7 @@
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
                            (CL-ARRAY (M+ M1 M2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191)))
                         (MULTIPLE-VALUE-LIST
@@ -134,6 +135,7 @@
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
                            (CL-ARRAY (M+ M1 M2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((95 54 208) (144 341 357) (197 324 320)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-m-.lisp b/tests/matrix-m-.lisp
index ddd4e08e3e60086313f371a4652c73e5673672c4..93d94f482450f4b675865f2dbf6db3a661fb6b2f 100644
--- a/tests/matrix-m-.lisp
+++ b/tests/matrix-m-.lisp
@@ -126,6 +126,7 @@
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
                            (CL-ARRAY (M- M1 M2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55)))
                         (MULTIPLE-VALUE-LIST
@@ -140,6 +141,7 @@
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
                            (CL-ARRAY (M- M1 M2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((39 34 170)
diff --git a/tests/matrix-max-index.lisp b/tests/matrix-max-index.lisp
index 8b6e1ce7827b67e86a6b54531794814840550bc6..143af3737df0f9fd12daa7f4763336f114c66a39 100644
--- a/tests/matrix-max-index.lisp
+++ b/tests/matrix-max-index.lisp
@@ -119,6 +119,7 @@
                                                                      (161 215
                                                                       98)))))
                                                              (MAX-INDEX M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
@@ -133,6 +134,7 @@
                                                                      (73 -5
                                                                       123)))))
                                                              (MAX-INDEX M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
diff --git a/tests/matrix-max.lisp b/tests/matrix-max.lisp
index 3d0377a6b6d93d0feee0b333b92412551dd1d1c8..93504dc4682506fd84727b01d3e579ed4eaa4f0f 100644
--- a/tests/matrix-max.lisp
+++ b/tests/matrix-max.lisp
@@ -119,6 +119,7 @@
                                                                      (161 215
                                                                       98)))))
                                                              (MMAX M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
@@ -133,6 +134,7 @@
                                                                      (73 -5
                                                                       123)))))
                                                              (MMAX M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
diff --git a/tests/matrix-mean.lisp b/tests/matrix-mean.lisp
index c460c00bfc5ff8e594e16d7eea339813f44e5e2b..d6a320fc8d933ba493dbe007be0bb9d64c216794 100644
--- a/tests/matrix-mean.lisp
+++ b/tests/matrix-mean.lisp
@@ -97,6 +97,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (MEAN M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
@@ -111,6 +112,7 @@
                                                                      (73 -5
                                                                       123)))))
                                                              (MEAN M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 132.55555555555554d0)
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-min-index.lisp b/tests/matrix-min-index.lisp
index 87923e4c2a6aa2581d85fbc26544a032d10ec27c..c66bb4d0750738400bd0dc581d5fbc055fd4b7d9 100644
--- a/tests/matrix-min-index.lisp
+++ b/tests/matrix-min-index.lisp
@@ -119,6 +119,7 @@
                                                                      (161 215
                                                                       98)))))
                                                              (MIN-INDEX M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
@@ -133,6 +134,7 @@
                                                                      (73 -5
                                                                       123)))))
                                                              (MIN-INDEX M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
diff --git a/tests/matrix-min.lisp b/tests/matrix-min.lisp
new file mode 100644
index 0000000000000000000000000000000000000000..05281e9117f37fa8a3fe73e3cd2c3d9bb44e9643
--- /dev/null
+++ b/tests/matrix-min.lisp
@@ -0,0 +1,152 @@
+;; Regression test MATRIX-MIN for GSLL, automatically generated
+
+(in-package :gsl)
+
+(LISP-UNIT:DEFINE-TEST MATRIX-MIN
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((M1
+                                                                  (MAKE-MARRAY
+                                                                   'SINGLE-FLOAT
+                                                                   :INITIAL-CONTENTS
+                                                                   '((-34.5
+                                                                      8.24
+                                                                      3.29)
+                                                                     (-8.93
+                                                                      34.12
+                                                                      -6.15)
+                                                                     (49.27
+                                                                      -13.49
+                                                                      32.5)))))
+                                                             (MMIN M1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((M1
+                                                                  (MAKE-MARRAY
+                                                                   'DOUBLE-FLOAT
+                                                                   :INITIAL-CONTENTS
+                                                                   '((-34.5d0
+                                                                      8.24d0
+                                                                      3.29d0)
+                                                                     (-8.93d0
+                                                                      34.12d0
+                                                                      -6.15d0)
+                                                                     (49.27d0
+                                                                      -13.49d0
+                                                                      32.5d0)))))
+                                                             (MMIN M1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((M1
+                                                                  (MAKE-MARRAY
+                                                                   '(SIGNED-BYTE
+                                                                     8)
+                                                                   :INITIAL-CONTENTS
+                                                                   '((-64 -68
+                                                                      71)
+                                                                     (-91 52
+                                                                      -10)
+                                                                     (73 -5
+                                                                      123)))))
+                                                             (MMIN M1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((M1
+                                                                  (MAKE-MARRAY
+                                                                   '(UNSIGNED-BYTE
+                                                                     8)
+                                                                   :INITIAL-CONTENTS
+                                                                   '((67 44
+                                                                      189)
+                                                                     (116 163
+                                                                      140)
+                                                                     (161 215
+                                                                      98)))))
+                                                             (MMIN M1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((M1
+                                                                  (MAKE-MARRAY
+                                                                   '(SIGNED-BYTE
+                                                                     16)
+                                                                   :INITIAL-CONTENTS
+                                                                   '((-64 -68
+                                                                      71)
+                                                                     (-91 52
+                                                                      -10)
+                                                                     (73 -5
+                                                                      123)))))
+                                                             (MMIN M1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((M1
+                                                                  (MAKE-MARRAY
+                                                                   '(UNSIGNED-BYTE
+                                                                     16)
+                                                                   :INITIAL-CONTENTS
+                                                                   '((67 44
+                                                                      189)
+                                                                     (116 163
+                                                                      140)
+                                                                     (161 215
+                                                                      98)))))
+                                                             (MMIN M1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((M1
+                                                                  (MAKE-MARRAY
+                                                                   '(SIGNED-BYTE
+                                                                     32)
+                                                                   :INITIAL-CONTENTS
+                                                                   '((-64 -68
+                                                                      71)
+                                                                     (-91 52
+                                                                      -10)
+                                                                     (73 -5
+                                                                      123)))))
+                                                             (MMIN M1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((M1
+                                                                  (MAKE-MARRAY
+                                                                   '(UNSIGNED-BYTE
+                                                                     32)
+                                                                   :INITIAL-CONTENTS
+                                                                   '((67 44
+                                                                      189)
+                                                                     (116 163
+                                                                      140)
+                                                                     (161 215
+                                                                      98)))))
+                                                             (MMIN M1))))
+		       #+int64
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((M1
+                                                                  (MAKE-MARRAY
+                                                                   '(SIGNED-BYTE
+                                                                     64)
+                                                                   :INITIAL-CONTENTS
+                                                                   '((-64 -68
+                                                                      71)
+                                                                     (-91 52
+                                                                      -10)
+                                                                     (73 -5
+                                                                      123)))))
+                                                             (MMIN M1))))
+		       #+int64
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((M1
+                                                                  (MAKE-MARRAY
+                                                                   '(UNSIGNED-BYTE
+                                                                     64)
+                                                                   :INITIAL-CONTENTS
+                                                                   '((67 44
+                                                                      189)
+                                                                     (116 163
+                                                                      140)
+                                                                     (161 215
+                                                                      98)))))
+                                                             (MMIN M1)))))
+
diff --git a/tests/matrix-minmax-index.lisp b/tests/matrix-minmax-index.lisp
index 18b169736a1ceef305c6bb2fedba4da2c03ae446..db9ea914733e7cc0049dc2d3d58ae302970fd2d5 100644
--- a/tests/matrix-minmax-index.lisp
+++ b/tests/matrix-minmax-index.lisp
@@ -127,6 +127,7 @@
                                                                       98)))))
                                                              (MINMAX-INDEX
                                                               M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
@@ -142,6 +143,7 @@
                                                                       123)))))
                                                              (MINMAX-INDEX
                                                               M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
diff --git a/tests/matrix-minmax.lisp b/tests/matrix-minmax.lisp
index 9981dc424fc31e3a4b2c718ca05a863f03d3e727..577ee660d38e83916e9f946f398de28484a97866 100644
--- a/tests/matrix-minmax.lisp
+++ b/tests/matrix-minmax.lisp
@@ -112,6 +112,7 @@
                                                                      (161 215
                                                                       98)))))
                                                              (MINMAX M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
@@ -126,6 +127,7 @@
                                                                      (73 -5
                                                                       123)))))
                                                              (MINMAX M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
diff --git a/tests/matrix-mult-scalar.lisp b/tests/matrix-mult-scalar.lisp
index ae897a9f2fe5e1dfce8a73dee0c64b98827e0660..a1ac216714c3d95c9de8f530ff795fb986d8076e 100644
--- a/tests/matrix-mult-scalar.lisp
+++ b/tests/matrix-mult-scalar.lisp
@@ -80,6 +80,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (CL-ARRAY (M*C M1 1.39d0)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-88 -94 98) (-126 72 -13) (101 -6 170)))
                         (MULTIPLE-VALUE-LIST
@@ -89,6 +90,7 @@
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
                            (CL-ARRAY (M*C M1 1.39d0)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((93 61 262) (161 226 194) (223 298 136)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-mult.lisp b/tests/matrix-mult.lisp
index 2ba53be3611107e8f6770abe4a0718ba787cb3b3..36dfccc7aa11f4f853bc1864a708284f5d3a188d 100644
--- a/tests/matrix-mult.lisp
+++ b/tests/matrix-mult.lisp
@@ -132,6 +132,7 @@
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
                            (CL-ARRAY (M* M1 M2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((-2048 -1904 2130)
@@ -149,6 +150,7 @@
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
                            (CL-ARRAY (M* M1 M2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((1876 440 3591)
diff --git a/tests/matrix-set-all-m+.lisp b/tests/matrix-set-all-m+.lisp
index a15b49074d49160a82b8ef79d91ccfa0ee63d18e..a9d9335d82d152573a02f7fbdf41c2144ef28ba3 100644
--- a/tests/matrix-set-all-m+.lisp
+++ b/tests/matrix-set-all-m+.lisp
@@ -111,6 +111,7 @@
                                                (161 215 98)))))
                            (SET-ALL M1 28)
                            (CL-ARRAY (M+ M1 M2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-32 -36 103) (-59 84 22) (105 27 155)))
                         (MULTIPLE-VALUE-LIST
@@ -124,6 +125,7 @@
                                                (73 -5 123)))))
                            (SET-ALL M1 32)
                            (CL-ARRAY (M+ M1 M2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((95 72 217) (144 191 168) (189 243 126)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-set-zero.lisp b/tests/matrix-set-zero.lisp
index d26658f46786b2fb4a7e31f7d62a8b285c097bce..6f8a9436b8725c08b87b4ffda4a3cffed11f7f98 100644
--- a/tests/matrix-set-zero.lisp
+++ b/tests/matrix-set-zero.lisp
@@ -120,6 +120,7 @@
                                                (161 215 98)))))
                            (SET-ZERO M1)
                            (CL-ARRAY M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
                         (MULTIPLE-VALUE-LIST
@@ -130,6 +131,7 @@
                                                (73 -5 123)))))
                            (SET-ZERO M1)
                            (CL-ARRAY M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-standard-deviation-with-fixed-mean.lisp b/tests/matrix-standard-deviation-with-fixed-mean.lisp
index 7e58a2798a7738dff106e94096a152d94a5e20ae..f62634e086e29e982cabf4040116a0fe55bf4b34 100644
--- a/tests/matrix-standard-deviation-with-fixed-mean.lisp
+++ b/tests/matrix-standard-deviation-with-fixed-mean.lisp
@@ -74,6 +74,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 70.39570693980959d0)
                         (MULTIPLE-VALUE-LIST
@@ -83,6 +84,7 @@
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
                            (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 53.10599696437538d0)
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-standard-deviation-with-mean.lisp b/tests/matrix-standard-deviation-with-mean.lisp
index ccc0649b315a8b4a6120318d2cb93da418eae5cb..6c75d75042a2aab791f3831f3c41f2a67737a913 100644
--- a/tests/matrix-standard-deviation-with-mean.lisp
+++ b/tests/matrix-standard-deviation-with-mean.lisp
@@ -74,6 +74,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (STANDARD-DEVIATION M1 (MEAN M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 74.66592261534039d0)
                         (MULTIPLE-VALUE-LIST
@@ -83,6 +84,7 @@
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
                            (STANDARD-DEVIATION M1 (MEAN M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 56.32741586277306d0)
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-standard-deviation.lisp b/tests/matrix-standard-deviation.lisp
index b487bc58e9f71a3012db5c2276d3d6d1f26d9338..5b9953cdab72fb654202cbf28dd7550c66514e2b 100644
--- a/tests/matrix-standard-deviation.lisp
+++ b/tests/matrix-standard-deviation.lisp
@@ -74,6 +74,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (STANDARD-DEVIATION M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 74.66592261534039d0)
                         (MULTIPLE-VALUE-LIST
@@ -83,6 +84,7 @@
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
                            (STANDARD-DEVIATION M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 56.32741586277306d0)
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-swap.lisp b/tests/matrix-swap.lisp
index 58f8c590153d31387021d9830ab2f98e063ded79..90a79cc53f75e7e02483858454660cffd14f5fdd 100644
--- a/tests/matrix-swap.lisp
+++ b/tests/matrix-swap.lisp
@@ -217,6 +217,7 @@
                                                (36 109 222)))))
                            (SWAP M2 M1)
                            (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68))
@@ -234,6 +235,7 @@
                                                (-15 -22 68)))))
                            (SWAP M2 M1)
                            (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          (LIST #2A((28 10 19) (28 178 217) (36 109 222))
diff --git a/tests/matrix-transpose-copy.lisp b/tests/matrix-transpose-copy.lisp
index 9112f395179266589b95765805a6fb9dbce00603..250bb7441ce3314f26d18cbb710b0977c179372d 100644
--- a/tests/matrix-transpose-copy.lisp
+++ b/tests/matrix-transpose-copy.lisp
@@ -144,6 +144,7 @@
                                 (MAKE-MARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
                                              '(3 3))))
                            (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
                         (MULTIPLE-VALUE-LIST
@@ -156,6 +157,7 @@
                                 (MAKE-MARRAY '(SIGNED-BYTE 64) :DIMENSIONS
                                              '(3 3))))
                            (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-transpose.lisp b/tests/matrix-transpose.lisp
index 67d16a5ab0400b57b8ad5c802c7af2d8be261992..5c5ffae7d0e82dab30169c19a9d1a13c28de0b67 100644
--- a/tests/matrix-transpose.lisp
+++ b/tests/matrix-transpose.lisp
@@ -116,6 +116,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (CL-ARRAY (MATRIX-TRANSPOSE M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
                         (MULTIPLE-VALUE-LIST
@@ -125,6 +126,7 @@
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
                            (CL-ARRAY (MATRIX-TRANSPOSE M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-variance-with-fixed-mean.lisp b/tests/matrix-variance-with-fixed-mean.lisp
index bdcb0d8f853adee76068f6c845e559eec323a1d5..739f120724ed1b3275be3fce39f69cc67458885c 100644
--- a/tests/matrix-variance-with-fixed-mean.lisp
+++ b/tests/matrix-variance-with-fixed-mean.lisp
@@ -74,6 +74,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 4955.555555555556d0)
                         (MULTIPLE-VALUE-LIST
@@ -83,6 +84,7 @@
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
                            (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 2820.246913580247d0)
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-variance-with-mean.lisp b/tests/matrix-variance-with-mean.lisp
index 53fc2b7fd81586c499f8e2e52e99c5914ae37fa1..ac9ba80e3caf4ddcf700756e46c40538ff258535 100644
--- a/tests/matrix-variance-with-mean.lisp
+++ b/tests/matrix-variance-with-mean.lisp
@@ -96,6 +96,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (VARIANCE M1 (MEAN M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
@@ -112,6 +113,7 @@
                                                              (VARIANCE M1
                                                                        (MEAN
                                                                         M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 3172.777777777778d0)
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/matrix-variance.lisp b/tests/matrix-variance.lisp
index 895922eca03db65aa5716e5fe4dbbfc42c3a4add..261d434087145c4f3abbc69be2ab41dca4fe5961 100644
--- a/tests/matrix-variance.lisp
+++ b/tests/matrix-variance.lisp
@@ -90,6 +90,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (VARIANCE M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
@@ -104,6 +105,7 @@
                                                                      (73 -5
                                                                       123)))))
                                                              (VARIANCE M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 3172.777777777778d0)
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/row.lisp b/tests/row.lisp
index 2d59c6ac45b59e024e4ce5e9e3eb4849c8a776c5..8d84aa0951b84f138ab31506b9aff892f60e81a9 100644
--- a/tests/row.lisp
+++ b/tests/row.lisp
@@ -190,6 +190,7 @@
                                                              (CL-ARRAY
                                                               (ROW ROW M1
                                                                    1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 52 -10))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
@@ -212,6 +213,7 @@
                                                              (CL-ARRAY
                                                               (ROW ROW M1
                                                                    1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(116 163 140))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((M1
diff --git a/tests/set-basis.lisp b/tests/set-basis.lisp
index 8c96e54f43339677558c3145130d6eeac6f12327..ba26a56ac619b1bd812846e4a65b164ae58c9a9c 100644
--- a/tests/set-basis.lisp
+++ b/tests/set-basis.lisp
@@ -106,6 +106,7 @@
                                              '(67 44 189 116 163 140 161 215))))
                            (SET-BASIS V1 2)
                            (CL-ARRAY V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(0 0 1 0 0 0 0 0))
                         (MULTIPLE-VALUE-LIST
@@ -115,6 +116,7 @@
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (SET-BASIS V1 2)
                            (CL-ARRAY V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(0 0 1 0 0 0 0 0))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/set-identity.lisp b/tests/set-identity.lisp
index 1bc870845b0223be0a7287beeb74377e33b8615d..9dd692c8f8c6f34bb4e9aa921f0e8dbd041c93dc 100644
--- a/tests/set-identity.lisp
+++ b/tests/set-identity.lisp
@@ -110,6 +110,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (CL-ARRAY (SET-IDENTITY M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
                         (MULTIPLE-VALUE-LIST
@@ -119,6 +120,7 @@
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
                            (CL-ARRAY (SET-IDENTITY M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/setf-column.lisp b/tests/setf-column.lisp
index 927ae38ed8229c99be13ca2379c4b7e2d441aee2..3afbee695b7e08bb5c7fce048b59862d2e1f264c 100644
--- a/tests/setf-column.lisp
+++ b/tests/setf-column.lisp
@@ -160,6 +160,7 @@
                                              :INITIAL-CONTENTS '(28 10 19))))
                            (SETF (COLUMN M1 2) COL)
                            (CL-ARRAY M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30)))
                         (MULTIPLE-VALUE-LIST
@@ -173,6 +174,7 @@
                                              :INITIAL-CONTENTS '(32 28 30))))
                            (SETF (COLUMN M1 2) COL)
                            (CL-ARRAY M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((67 44 28) (116 163 10) (161 215 19)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/setf-row.lisp b/tests/setf-row.lisp
index d303d8df7c0cef77417873995ba010673739b3d7..d325a4e6a4246cef8c69f44f8beec53d93c18a11 100644
--- a/tests/setf-row.lisp
+++ b/tests/setf-row.lisp
@@ -160,6 +160,7 @@
                                              :INITIAL-CONTENTS '(28 10 19))))
                            (SETF (ROW M1 2) ROW)
                            (CL-ARRAY M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30)))
                         (MULTIPLE-VALUE-LIST
@@ -173,6 +174,7 @@
                                              :INITIAL-CONTENTS '(32 28 30))))
                            (SETF (ROW M1 2) ROW)
                            (CL-ARRAY M1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((67 44 189) (116 163 140) (28 10 19)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/sort-matrix-largest.lisp b/tests/sort-matrix-largest.lisp
index 4c4d93219bc24296663ac730b033e56efbc4e928..d00151d9a46bac382ade0e2f1f96644d4a77c1cd 100644
--- a/tests/sort-matrix-largest.lisp
+++ b/tests/sort-matrix-largest.lisp
@@ -97,6 +97,7 @@
                                 (MAKE-MARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
                                              '(2 3))))
                            (CL-ARRAY (SORT-LARGEST M2 M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((123 73 71) (52 -5 -10)))
                         (MULTIPLE-VALUE-LIST
@@ -109,6 +110,7 @@
                                 (MAKE-MARRAY '(SIGNED-BYTE 64) :DIMENSIONS
                                              '(2 3))))
                            (CL-ARRAY (SORT-LARGEST M2 M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((215 189 163) (161 140 116)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/sort-matrix-smallest.lisp b/tests/sort-matrix-smallest.lisp
index 91c393273b73bdb79b6be98bdb69fbe21bcbdc07..e174e301123ba7985ad45a7f6ebc1fa0b1b435d3 100644
--- a/tests/sort-matrix-smallest.lisp
+++ b/tests/sort-matrix-smallest.lisp
@@ -98,6 +98,7 @@
                                 (MAKE-MARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
                                              '(2 3))))
                            (CL-ARRAY (SORT-SMALLEST M2 M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-91 -68 -64) (-10 -5 52)))
                         (MULTIPLE-VALUE-LIST
@@ -110,6 +111,7 @@
                                 (MAKE-MARRAY '(SIGNED-BYTE 64) :DIMENSIONS
                                              '(2 3))))
                            (CL-ARRAY (SORT-SMALLEST M2 M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((44 67 98) (116 140 161)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/sort-matrix.lisp b/tests/sort-matrix.lisp
index 046fc2cb32e50af6cc0c882b20894a47339a3106..5b2efdcf364ecc393c3cb0fce147ea8a57367291 100644
--- a/tests/sort-matrix.lisp
+++ b/tests/sort-matrix.lisp
@@ -80,6 +80,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (CL-ARRAY (MSORT M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
                         (MULTIPLE-VALUE-LIST
@@ -89,6 +90,7 @@
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
                            (CL-ARRAY (MSORT M1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/sort-vector-index.lisp b/tests/sort-vector-index.lisp
index 6be366261837f8e452177604e0e56e170d60a7fb..24014290aaf6de429763994a9fd7083a1bc5db74 100644
--- a/tests/sort-vector-index.lisp
+++ b/tests/sort-vector-index.lisp
@@ -83,6 +83,7 @@
                                              '(67 44 189 116 163 140 161 215))))
                            (SORT-VECTOR-INDEX PERM V1)
                            (CL-ARRAY PERM))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(3 1 0 5 7 4 2 6))
                         (MULTIPLE-VALUE-LIST
@@ -93,6 +94,7 @@
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (SORT-VECTOR-INDEX PERM V1)
                            (CL-ARRAY PERM))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(1 0 3 5 6 4 2 7))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/sort-vector-largest-index.lisp b/tests/sort-vector-largest-index.lisp
index 6da02c82909f70b24dcdfb2b0f37653e128d3775..ef15e98ec16b349bf43f6a576a310203484d4eb8 100644
--- a/tests/sort-vector-largest-index.lisp
+++ b/tests/sort-vector-largest-index.lisp
@@ -140,6 +140,7 @@
                                                              (CL-ARRAY
                                                               (SORT-VECTOR-LARGEST-INDEX
                                                                COMB V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((COMB
@@ -156,6 +157,7 @@
                                                              (CL-ARRAY
                                                               (SORT-VECTOR-LARGEST-INDEX
                                                                COMB V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((COMB
diff --git a/tests/sort-vector-largest.lisp b/tests/sort-vector-largest.lisp
index 8cb149f6af1db3d77ffdca3bf2187117a3331d24..ad22a9f92588c81e28541c5f58dceef560a471fa 100644
--- a/tests/sort-vector-largest.lisp
+++ b/tests/sort-vector-largest.lisp
@@ -149,6 +149,7 @@
                                                              (CL-ARRAY
                                                               (SORT-VECTOR-LARGEST
                                                                V2 V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -169,6 +170,7 @@
                                                              (CL-ARRAY
                                                               (SORT-VECTOR-LARGEST
                                                                V2 V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/sort-vector-smallest-index.lisp b/tests/sort-vector-smallest-index.lisp
index 137805d46ba693beaac9e9ead9ce02935e7e059b..bf0f377cd870067946444d19d01fe20d90d71c45 100644
--- a/tests/sort-vector-smallest-index.lisp
+++ b/tests/sort-vector-smallest-index.lisp
@@ -140,6 +140,7 @@
                                                              (CL-ARRAY
                                                               (SORT-VECTOR-SMALLEST-INDEX
                                                                COMB V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((COMB
@@ -156,6 +157,7 @@
                                                              (CL-ARRAY
                                                               (SORT-VECTOR-SMALLEST-INDEX
                                                                COMB V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((COMB
diff --git a/tests/sort-vector-smallest.lisp b/tests/sort-vector-smallest.lisp
index 497e4e0d1af7ea4c1c1e968a873d415329144608..dae3dd36b333afc8f64860aa43cb9ff2a3339547 100644
--- a/tests/sort-vector-smallest.lisp
+++ b/tests/sort-vector-smallest.lisp
@@ -149,6 +149,7 @@
                                                              (CL-ARRAY
                                                               (SORT-VECTOR-SMALLEST
                                                                V2 V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -169,6 +170,7 @@
                                                              (CL-ARRAY
                                                               (SORT-VECTOR-SMALLEST
                                                                V2 V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/sort-vector.lisp b/tests/sort-vector.lisp
index a372802549553cf4c5bc1f4e21883e6473752491..0f83e35af8250bea860abdb544020233df578a75 100644
--- a/tests/sort-vector.lisp
+++ b/tests/sort-vector.lisp
@@ -70,6 +70,7 @@
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
                            (CL-ARRAY (SORT-VECTOR V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(-91 -68 -64 -10 -5 52 71 73))
                         (MULTIPLE-VALUE-LIST
@@ -78,6 +79,7 @@
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (CL-ARRAY (SORT-VECTOR V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(44 67 116 140 161 163 189 215))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/swap-columns.lisp b/tests/swap-columns.lisp
index 7e5421c0476558ad9e8795af88ebf2d43a7a80a7..1b058eed6fe5852a9c4b491db0ab9fbfcb09e38b 100644
--- a/tests/swap-columns.lisp
+++ b/tests/swap-columns.lisp
@@ -116,6 +116,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5)))
                         (MULTIPLE-VALUE-LIST
@@ -125,6 +126,7 @@
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
                            (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((67 189 44) (116 140 163) (161 98 215)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/swap-elements.lisp b/tests/swap-elements.lisp
index 89f3396f396976a1d37acaf4e708a94ce4a507d8..70d2be0d17c04034f729dfd234f0455a505daa3d 100644
--- a/tests/swap-elements.lisp
+++ b/tests/swap-elements.lisp
@@ -110,6 +110,7 @@
                                              '(67 44 189 116 163 140 161 215))))
                            (SWAP-ELEMENTS V1 2 5)
                            (CL-ARRAY V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(-64 -68 -10 -91 52 71 73 -5))
                         (MULTIPLE-VALUE-LIST
@@ -119,6 +120,7 @@
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (SWAP-ELEMENTS V1 2 5)
                            (CL-ARRAY V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(67 44 140 116 163 189 161 215))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/swap-row-column.lisp b/tests/swap-row-column.lisp
index 4a3efe7b31b730180508fdb64d828703a02fe41f..a80e7211f99669ee7f717ccb51822dfe52d30c15 100644
--- a/tests/swap-row-column.lisp
+++ b/tests/swap-row-column.lisp
@@ -115,6 +115,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((71 -10 123) (-91 52 -68) (73 -5 -64)))
                         (MULTIPLE-VALUE-LIST
@@ -124,6 +125,7 @@
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
                            (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((189 140 98) (116 163 44) (161 215 67)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/swap-rows.lisp b/tests/swap-rows.lisp
index 9ae40c2d64048d214712fd9f80495d28221650f8..153b61fd7c3dcf1918983d8db7de8554749e5852 100644
--- a/tests/swap-rows.lisp
+++ b/tests/swap-rows.lisp
@@ -116,6 +116,7 @@
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
                            (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123)))
                         (MULTIPLE-VALUE-LIST
@@ -125,6 +126,7 @@
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
                            (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((116 163 140) (67 44 189) (161 215 98)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-copy.lisp b/tests/vector-copy.lisp
index 1503c4c260835c4a27f7c074b5de1bfff5d2d6fd..de9548ae9b3002fb402eae5156bd85f0f9c88d5d 100644
--- a/tests/vector-copy.lisp
+++ b/tests/vector-copy.lisp
@@ -151,6 +151,7 @@
                                                                    '3)))
                                                              (COPY V2 V1)
                                                              (CL-ARRAY V2))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-64 -68 71))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -168,6 +169,7 @@
                                                                    '3)))
                                                              (COPY V2 V1)
                                                              (CL-ARRAY V2))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(67 44 189))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-div.lisp b/tests/vector-div.lisp
index cd9154c9c588a908e502cb84e65a4da2b6afee95..ca38df969ad2202a4cab6a788cdd1f65af3b5eca 100644
--- a/tests/vector-div.lisp
+++ b/tests/vector-div.lisp
@@ -133,6 +133,7 @@
                                                                      140))))
                                                              (CL-ARRAY
                                                               (M/ V1 V2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 -1 -7))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -151,6 +152,7 @@
                                                                      -10))))
                                                              (CL-ARRAY
                                                               (M/ V1 V2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 1))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-m+.lisp b/tests/vector-m+.lisp
index 8f4367a2fe0f0db1ef7aace1f8777af96b4e3ec6..838fa979c067c499c4e7294512191e0b219f00eb 100644
--- a/tests/vector-m+.lisp
+++ b/tests/vector-m+.lisp
@@ -131,6 +131,7 @@
                                                                      140))))
                                                              (CL-ARRAY
                                                               (M+ V1 V2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-155 -16 61))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -149,6 +150,7 @@
                                                                      -10))))
                                                              (CL-ARRAY
                                                               (M+ V1 V2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(183 207 329))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-m-.lisp b/tests/vector-m-.lisp
index daa57748a73adc1d9fed4ef73ab6344bf914aea2..f83ad685e56488ef86338f9d2907fbf2d21b97a8 100644
--- a/tests/vector-m-.lisp
+++ b/tests/vector-m-.lisp
@@ -116,6 +116,7 @@
                                 (MAKE-MARRAY '(UNSIGNED-BYTE 32)
                                              :INITIAL-CONTENTS '(116 163 140))))
                            (CL-ARRAY (M- V1 V2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -134,6 +135,7 @@
                                                                      -10))))
                                                              (CL-ARRAY
                                                               (M- V1 V2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(18446744073709551567 18446744073709551497 49))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-max-index.lisp b/tests/vector-max-index.lisp
index 05b980fd11a2074c908ebe1311395da64a004b98..b4f395787f8d2b22ad97652ab23877110857e50e 100644
--- a/tests/vector-max-index.lisp
+++ b/tests/vector-max-index.lisp
@@ -100,6 +100,7 @@
                                                                      140 161
                                                                      215))))
                                                              (MAX-INDEX V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -111,6 +112,7 @@
                                                                      -91 52 -10
                                                                      73 -5))))
                                                              (MAX-INDEX V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-max.lisp b/tests/vector-max.lisp
index 497d00f35a8279aba42e832c4cf2b7f25f56ba57..d63ea382fd67c731c77051ab8eaa9feca76f0b66 100644
--- a/tests/vector-max.lisp
+++ b/tests/vector-max.lisp
@@ -82,6 +82,7 @@
                                                                    '(67 44
                                                                      189))))
                                                              (MMAX V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -92,6 +93,7 @@
                                                                    '(-64 -68
                                                                      71))))
                                                              (MMAX V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-mean.lisp b/tests/vector-mean.lisp
index c2fc337c1e54e239cb0ebd27d01cb1e29d7eaf3f..a56f3d327e074e4aef13d1ac4efd2067678dcc1e 100644
--- a/tests/vector-mean.lisp
+++ b/tests/vector-mean.lisp
@@ -95,6 +95,7 @@
                                                                      140 161
                                                                      215))))
                                                              (MEAN V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -106,6 +107,7 @@
                                                                      -91 52 -10
                                                                      73 -5))))
                                                              (MEAN V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-min-index.lisp b/tests/vector-min-index.lisp
index 505faf4d1c0768aa7f5bbaa348a6c6d600e37c03..4124b7977f0c55a47b2a18a4e323ff01c9f82a63 100644
--- a/tests/vector-min-index.lisp
+++ b/tests/vector-min-index.lisp
@@ -100,6 +100,7 @@
                                                                      140 161
                                                                      215))))
                                                              (MIN-INDEX V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -111,6 +112,7 @@
                                                                      -91 52 -10
                                                                      73 -5))))
                                                              (MIN-INDEX V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-min.lisp b/tests/vector-min.lisp
new file mode 100644
index 0000000000000000000000000000000000000000..62eba3b1cc1d69aa41dbeacd1bf5e56a15a6bbc3
--- /dev/null
+++ b/tests/vector-min.lisp
@@ -0,0 +1,107 @@
+;; Regression test VECTOR-MIN for GSLL, automatically generated
+
+(in-package :gsl)
+
+(LISP-UNIT:DEFINE-TEST VECTOR-MIN
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((V1
+                                                                  (MAKE-MARRAY
+                                                                   'SINGLE-FLOAT
+                                                                   :INITIAL-CONTENTS
+                                                                   '(-34.5 8.24
+                                                                     3.29))))
+                                                             (MMIN V1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((V1
+                                                                  (MAKE-MARRAY
+                                                                   'DOUBLE-FLOAT
+                                                                   :INITIAL-CONTENTS
+                                                                   '(-34.5d0
+                                                                     8.24d0
+                                                                     3.29d0))))
+                                                             (MMIN V1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((V1
+                                                                  (MAKE-MARRAY
+                                                                   '(SIGNED-BYTE
+                                                                     8)
+                                                                   :INITIAL-CONTENTS
+                                                                   '(-64 -68
+                                                                     71))))
+                                                             (MMIN V1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((V1
+                                                                  (MAKE-MARRAY
+                                                                   '(UNSIGNED-BYTE
+                                                                     8)
+                                                                   :INITIAL-CONTENTS
+                                                                   '(67 44
+                                                                     189))))
+                                                             (MMIN V1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((V1
+                                                                  (MAKE-MARRAY
+                                                                   '(SIGNED-BYTE
+                                                                     16)
+                                                                   :INITIAL-CONTENTS
+                                                                   '(-64 -68
+                                                                     71))))
+                                                             (MMIN V1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((V1
+                                                                  (MAKE-MARRAY
+                                                                   '(UNSIGNED-BYTE
+                                                                     16)
+                                                                   :INITIAL-CONTENTS
+                                                                   '(67 44
+                                                                     189))))
+                                                             (MMIN V1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((V1
+                                                                  (MAKE-MARRAY
+                                                                   '(SIGNED-BYTE
+                                                                     32)
+                                                                   :INITIAL-CONTENTS
+                                                                   '(-64 -68
+                                                                     71))))
+                                                             (MMIN V1))))
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((V1
+                                                                  (MAKE-MARRAY
+                                                                   '(UNSIGNED-BYTE
+                                                                     32)
+                                                                   :INITIAL-CONTENTS
+                                                                   '(67 44
+                                                                     189))))
+                                                             (MMIN V1))))
+		       #+int64
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((V1
+                                                                  (MAKE-MARRAY
+                                                                   '(SIGNED-BYTE
+                                                                     64)
+                                                                   :INITIAL-CONTENTS
+                                                                   '(-64 -68
+                                                                     71))))
+                                                             (MMIN V1))))
+		       #+int64
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
+                                                          (MULTIPLE-VALUE-LIST
+                                                           (LET ((V1
+                                                                  (MAKE-MARRAY
+                                                                   '(UNSIGNED-BYTE
+                                                                     64)
+                                                                   :INITIAL-CONTENTS
+                                                                   '(67 44
+                                                                     189))))
+                                                             (MMIN V1)))))
+
diff --git a/tests/vector-minmax-index.lisp b/tests/vector-minmax-index.lisp
index 953d4ddb8881b3745b01619b80741edfd2c1ed49..46e6249624eda4a28de675295f18a0476ced57bb 100644
--- a/tests/vector-minmax-index.lisp
+++ b/tests/vector-minmax-index.lisp
@@ -108,6 +108,7 @@
                                                                      215))))
                                                              (MINMAX-INDEX
                                                               V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3 6)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -120,6 +121,7 @@
                                                                      73 -5))))
                                                              (MINMAX-INDEX
                                                               V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 7)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-minmax.lisp b/tests/vector-minmax.lisp
index e8d2bcb6efcf3f46ba2f05c87f184ff50dac87e2..6a995b08746ba357651cf9629a8f0dfcfc985e64 100644
--- a/tests/vector-minmax.lisp
+++ b/tests/vector-minmax.lisp
@@ -82,6 +82,7 @@
                                                                    '(67 44
                                                                      189))))
                                                              (MINMAX V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68 71)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -92,6 +93,7 @@
                                                                    '(-64 -68
                                                                      71))))
                                                              (MINMAX V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 189)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-mult.lisp b/tests/vector-mult.lisp
index c3439e9424e8ace723e1fe5b033750aa2f8a87bb..5606878546ebd9b53d227fa99f1a53cb38ba8e34 100644
--- a/tests/vector-mult.lisp
+++ b/tests/vector-mult.lisp
@@ -99,6 +99,7 @@
                                 (MAKE-MARRAY '(UNSIGNED-BYTE 32)
                                              :INITIAL-CONTENTS '(116 163 140))))
                            (CL-ARRAY (M* V1 V2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(5824 -3536 -710))
                         (MULTIPLE-VALUE-LIST
@@ -109,6 +110,7 @@
                                 (MAKE-MARRAY '(SIGNED-BYTE 64)
                                              :INITIAL-CONTENTS '(-91 52 -10))))
                            (CL-ARRAY (M* V1 V2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(7772 7172 26460))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-reverse.lisp b/tests/vector-reverse.lisp
index 6645d8bc04ba7ba78622fef86b93ff33e2987c86..21e7cd12ea748198919e5605a1e2e2b7cfac605e 100644
--- a/tests/vector-reverse.lisp
+++ b/tests/vector-reverse.lisp
@@ -100,6 +100,7 @@
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
                            (CL-ARRAY (VECTOR-REVERSE V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(-5 73 -10 52 -91 71 -68 -64))
                         (MULTIPLE-VALUE-LIST
@@ -108,6 +109,7 @@
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (CL-ARRAY (VECTOR-REVERSE V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(215 161 140 163 116 189 44 67))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-set-all-m+.lisp b/tests/vector-set-all-m+.lisp
index 9a33752869cd770d853a57c165766b3fd1854013..3a72a45315fc6f5c5a131c9a50bccdd807362e52 100644
--- a/tests/vector-set-all-m+.lisp
+++ b/tests/vector-set-all-m+.lisp
@@ -113,6 +113,7 @@
                                                              (SET-ALL V1 116)
                                                              (CL-ARRAY
                                                               (M+ V1 V2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(-155 -159 -20))
                         (MULTIPLE-VALUE-LIST
@@ -123,6 +124,7 @@
                                              :INITIAL-CONTENTS '(-64 -68 71))))
                            (SET-ALL V1 -91)
                            (CL-ARRAY (M+ V1 V2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(183 160 305))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-set-zero.lisp b/tests/vector-set-zero.lisp
index b52b2e7f2f64bb01417f39793a8dac2703c6eb87..4b1b33840a7c4b8be6dfb5d44fb60061f14d37d7 100644
--- a/tests/vector-set-zero.lisp
+++ b/tests/vector-set-zero.lisp
@@ -108,6 +108,7 @@
                                                                      189))))
                                                              (SET-ZERO V1)
                                                              (CL-ARRAY V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -119,6 +120,7 @@
                                                                      71))))
                                                              (SET-ZERO V1)
                                                              (CL-ARRAY V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-standard-deviation-with-fixed-mean.lisp b/tests/vector-standard-deviation-with-fixed-mean.lisp
index c19139083450d5c44a0f72cea7d942708b98f728..24469c57bda2088f31e2172f7d4f2b24902f8103 100644
--- a/tests/vector-standard-deviation-with-fixed-mean.lisp
+++ b/tests/vector-standard-deviation-with-fixed-mean.lisp
@@ -67,6 +67,7 @@
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
                            (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 61.216317269172606d0)
                         (MULTIPLE-VALUE-LIST
@@ -75,6 +76,7 @@
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 54.81659762334762d0)
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-standard-deviation-with-mean.lisp b/tests/vector-standard-deviation-with-mean.lisp
index 1f7daff059de433b65ddd1afee14722fe925dd36..fe8abc818bd13d0141b6ae18e60fe274022ca8bb 100644
--- a/tests/vector-standard-deviation-with-mean.lisp
+++ b/tests/vector-standard-deviation-with-mean.lisp
@@ -67,6 +67,7 @@
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
                            (STANDARD-DEVIATION V1 (MEAN V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 65.44299591465624d0)
                         (MULTIPLE-VALUE-LIST
@@ -75,6 +76,7 @@
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (STANDARD-DEVIATION V1 (MEAN V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 58.60140783291814d0)
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-standard-deviation.lisp b/tests/vector-standard-deviation.lisp
index b4fad93e980e4624b8cce0ce6c6f343083820ba3..689b1f987458683312f5895de2b2e2293f2a686c 100644
--- a/tests/vector-standard-deviation.lisp
+++ b/tests/vector-standard-deviation.lisp
@@ -67,6 +67,7 @@
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
                            (STANDARD-DEVIATION V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 65.44299591465624d0)
                         (MULTIPLE-VALUE-LIST
@@ -75,6 +76,7 @@
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (STANDARD-DEVIATION V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 58.60140783291814d0)
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-swap.lisp b/tests/vector-swap.lisp
index 5a1949e27bfa12cfc420937b2fd0ecb87b77a031..9106fe03c3a029801e1565206a24f899cffbffaf 100644
--- a/tests/vector-swap.lisp
+++ b/tests/vector-swap.lisp
@@ -131,6 +131,7 @@
                                              :INITIAL-CONTENTS '(116 163 140))))
                            (SWAP V2 V1)
                            (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST (LIST #(-91 52 -10) #(-64 -68 71)))
                         (MULTIPLE-VALUE-LIST
@@ -142,6 +143,7 @@
                                              :INITIAL-CONTENTS '(-91 52 -10))))
                            (SWAP V2 V1)
                            (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST (LIST #(116 163 140) #(67 44 189)))
                         (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-variance-with-fixed-mean.lisp b/tests/vector-variance-with-fixed-mean.lisp
index 19768179de50b7f7f8c9aef309baa0e3f3d53f64..00074011ba8fb9fdbbb2f08328d0cf87c17b5bb5 100644
--- a/tests/vector-variance-with-fixed-mean.lisp
+++ b/tests/vector-variance-with-fixed-mean.lisp
@@ -95,6 +95,7 @@
                                                                      215))))
                                                              (VARIANCE-WITH-FIXED-MEAN
                                                               V1 (MEAN V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -107,6 +108,7 @@
                                                                      73 -5))))
                                                              (VARIANCE-WITH-FIXED-MEAN
                                                               V1 (MEAN V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-variance-with-mean.lisp b/tests/vector-variance-with-mean.lisp
index 1cd64af0d7495bc211a953547460a968bdb53362..8da952792e34e0f891e7a9d0e9028d1756e1653c 100644
--- a/tests/vector-variance-with-mean.lisp
+++ b/tests/vector-variance-with-mean.lisp
@@ -85,6 +85,7 @@
                                                              (VARIANCE V1
                                                                        (MEAN
                                                                         V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 4282.785714285714d0)
                         (MULTIPLE-VALUE-LIST
@@ -93,6 +94,7 @@
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (VARIANCE V1 (MEAN V1)))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
diff --git a/tests/vector-variance.lisp b/tests/vector-variance.lisp
index 668bf73b3c165892df89875b365c5800b3ce3d78..0594c4c46a5dc5ca46361d81f32594215b51e2cb 100644
--- a/tests/vector-variance.lisp
+++ b/tests/vector-variance.lisp
@@ -79,6 +79,7 @@
                                                                      140 161
                                                                      215))))
                                                              (VARIANCE V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 4282.785714285714d0)
                         (MULTIPLE-VALUE-LIST
@@ -87,6 +88,7 @@
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (VARIANCE V1))))
+		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1