From c057c7f3e0ee010da92091f006f4b431b4ae6f2f Mon Sep 17 00:00:00 2001
From: Liam Healy <liam@thinkpad.local>
Date: Wed, 31 Dec 2008 22:32:34 -0500
Subject: [PATCH] No 64 bit integers on 32 bit platforms

Both CLISP and SBCL fail when making arrays of 64 bit integers,
despite cffi-features:no-long-long being absent for either.
Therefore, conditionalize away these types in *array-element-types* on
32 bit platforms in general, and conditionalize away all the 64 bit
tests as well.  Separated out integer size check into types.lisp.
Restored tests vector-min and vector-max which fail in SBCL for
(signed-integer 8) and (signed-integer 16) for unknown reasons.
Test results:
64 bit SBCL:   TOTAL: 1223 assertions passed, 5 failed, 0 execution errors.
64 bit CCL:    TOTAL: 1228 assertions passed, 0 failed, 0 execution errors.
32 bit SBCL:   TOTAL: 1069 assertions passed, 31 failed, 0 execution errors.
32 bit CLISP:  TOTAL: 1051 assertions passed, 27 failed, 5 execution errors.
---
 data/array-tests.lisp                         |   4 +-
 data/combination.lisp                         |   6 +-
 data/permutation.lisp                         |   6 +-
 floating-point/ieee-modes.lisp                |   5 +-
 gsll-tests.asd                                |   4 +-
 gsll.asd                                      |   5 +-
 init/conditions.lisp                          |   8 +-
 init/element-types.lisp                       |  24 +--
 init/types.lisp                               |  27 ++++
 mathematical.lisp                             |   4 +-
 tests/column.lisp                             |   2 +
 tests/matrix-add-scalar.lisp                  |   2 +
 tests/matrix-copy.lisp                        |   2 +
 tests/matrix-div.lisp                         |   2 +
 tests/matrix-m+.lisp                          |   2 +
 tests/matrix-m-.lisp                          |   2 +
 tests/matrix-max-index.lisp                   |   2 +
 tests/matrix-max.lisp                         |   2 +
 tests/matrix-mean.lisp                        |   2 +
 tests/matrix-min-index.lisp                   |   2 +
 tests/matrix-min.lisp                         | 152 ++++++++++++++++++
 tests/matrix-minmax-index.lisp                |   2 +
 tests/matrix-minmax.lisp                      |   2 +
 tests/matrix-mult-scalar.lisp                 |   2 +
 tests/matrix-mult.lisp                        |   2 +
 tests/matrix-set-all-m+.lisp                  |   2 +
 tests/matrix-set-zero.lisp                    |   2 +
 ...ix-standard-deviation-with-fixed-mean.lisp |   2 +
 .../matrix-standard-deviation-with-mean.lisp  |   2 +
 tests/matrix-standard-deviation.lisp          |   2 +
 tests/matrix-swap.lisp                        |   2 +
 tests/matrix-transpose-copy.lisp              |   2 +
 tests/matrix-transpose.lisp                   |   2 +
 tests/matrix-variance-with-fixed-mean.lisp    |   2 +
 tests/matrix-variance-with-mean.lisp          |   2 +
 tests/matrix-variance.lisp                    |   2 +
 tests/row.lisp                                |   2 +
 tests/set-basis.lisp                          |   2 +
 tests/set-identity.lisp                       |   2 +
 tests/setf-column.lisp                        |   2 +
 tests/setf-row.lisp                           |   2 +
 tests/sort-matrix-largest.lisp                |   2 +
 tests/sort-matrix-smallest.lisp               |   2 +
 tests/sort-matrix.lisp                        |   2 +
 tests/sort-vector-index.lisp                  |   2 +
 tests/sort-vector-largest-index.lisp          |   2 +
 tests/sort-vector-largest.lisp                |   2 +
 tests/sort-vector-smallest-index.lisp         |   2 +
 tests/sort-vector-smallest.lisp               |   2 +
 tests/sort-vector.lisp                        |   2 +
 tests/swap-columns.lisp                       |   2 +
 tests/swap-elements.lisp                      |   2 +
 tests/swap-row-column.lisp                    |   2 +
 tests/swap-rows.lisp                          |   2 +
 tests/vector-copy.lisp                        |   2 +
 tests/vector-div.lisp                         |   2 +
 tests/vector-m+.lisp                          |   2 +
 tests/vector-m-.lisp                          |   2 +
 tests/vector-max-index.lisp                   |   2 +
 tests/vector-max.lisp                         |   2 +
 tests/vector-mean.lisp                        |   2 +
 tests/vector-min-index.lisp                   |   2 +
 tests/vector-min.lisp                         | 107 ++++++++++++
 tests/vector-minmax-index.lisp                |   2 +
 tests/vector-minmax.lisp                      |   2 +
 tests/vector-mult.lisp                        |   2 +
 tests/vector-reverse.lisp                     |   2 +
 tests/vector-set-all-m+.lisp                  |   2 +
 tests/vector-set-zero.lisp                    |   2 +
 ...or-standard-deviation-with-fixed-mean.lisp |   2 +
 .../vector-standard-deviation-with-mean.lisp  |   2 +
 tests/vector-standard-deviation.lisp          |   2 +
 tests/vector-swap.lisp                        |   2 +
 tests/vector-variance-with-fixed-mean.lisp    |   2 +
 tests/vector-variance-with-mean.lisp          |   2 +
 tests/vector-variance.lisp                    |   2 +
 76 files changed, 439 insertions(+), 41 deletions(-)
 create mode 100644 init/types.lisp
 create mode 100644 tests/matrix-min.lisp
 create mode 100644 tests/vector-min.lisp

diff --git a/data/array-tests.lisp b/data/array-tests.lisp
index 63e25139..94846a50 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 cdc915f7..17e5ee41 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 7099d58d..8cfed933 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 a7f80a0f..65424776 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 d4fbc590..8a6f75b6 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 4dfd81f7..64163579 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 0cf14fbd..54ecd51a 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 4650b9b7..5122ae9d 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 00000000..e1d41fe3
--- /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 264331e8..bbfb2a70 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 cea707af..5ad05e2d 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 2faa1843..64a5fc01 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 d9ac3bd6..5dbee57c 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 7bde9bb1..e3b7fe9b 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 b582e2e4..7095f759 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 ddd4e08e..93d94f48 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 8b6e1ce7..143af373 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 3d0377a6..93504dc4 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 c460c00b..d6a320fc 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 87923e4c..c66bb4d0 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 00000000..05281e91
--- /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 18b16973..db9ea914 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 9981dc42..577ee660 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 ae897a9f..a1ac2167 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 2ba53be3..36dfccc7 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 a15b4907..a9d9335d 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 d26658f4..6f8a9436 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 7e58a279..f62634e0 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 ccc0649b..6c75d750 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 b487bc58..5b9953cd 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 58f8c590..90a79cc5 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 9112f395..250bb744 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 67d16a5a..5c5ffae7 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 bdcb0d8f..739f1207 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 53fc2b7f..ac9ba80e 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 895922ec..261d4340 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 2d59c6ac..8d84aa09 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 8c96e54f..ba26a56a 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 1bc87084..9dd692c8 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 927ae38e..3afbee69 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 d303d8df..d325a4e6 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 4c4d9321..d00151d9 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 91c39327..e174e301 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 046fc2cb..5b2efdcf 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 6be36626..24014290 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 6da02c82..ef15e98e 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 8cb149f6..ad22a9f9 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 137805d4..bf0f377c 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 497e4e0d..dae3dd36 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 a3728025..0f83e35a 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 7e5421c0..1b058eed 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 89f3396f..70d2be0d 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 4a3efe7b..a80e7211 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 9ae40c2d..153b61fd 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 1503c4c2..de9548ae 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 cd9154c9..ca38df96 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 8f4367a2..838fa979 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 daa57748..f83ad685 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 05b980fd..b4f39578 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 497d00f3..d63ea382 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 c2fc337c..a56f3d32 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 505faf4d..4124b797 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 00000000..62eba3b1
--- /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 953d4ddb..46e62496 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 e8d2bcb6..6a995b08 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 c3439e94..56068785 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 6645d8bc..21e7cd12 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 9a337528..3a72a453 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 b52b2e7f..4b1b3384 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 c1913908..24469c57 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 1f7daff0..fe8abc81 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 b4fad93e..689b1f98 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 5a1949e2..9106fe03 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 19768179..00074011 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 1cd64af0..8da95279 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 668bf73b..0594c4c4 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
-- 
GitLab