diff --git a/documentation/index.html b/documentation/index.html
index 495b3c75434761ff473536c562adf8ecfd3d081e..05ad1d9e1152e9aa640b674153ab36a55ad72f14 100644
--- a/documentation/index.html
+++ b/documentation/index.html
@@ -88,12 +88,6 @@ complex conjugate scalar product</a> of two complex vectors of length 3:
       #2m(#c(49.27d0 -13.49d0) #c(32.5d0 42.73d0) #c(-17.24d0 43.31d0)))
 #C(-2940.2118d0 1861.9380999999998d0)
 </pre>
-<p>or equivalently the vector arguments may be specified with reals,
-<pre>
-(cdot #2m(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0)
-      #2m(49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 43.31d0))
-#C(-2940.2118d0 1861.9380999999998d0)
-</pre>
 <p>There are over 1500 examples available from within GSLL with the
 function <code>examples</code>.  There is also a suite of over
 4000 tests; many of the examples also serve as tests, and most others
@@ -472,7 +466,7 @@ and arrays used internally or for function return.
 <!-- Created: Feb 25 2005 -->
 <!-- hhmts start -->
 <small>
-Time-stamp: <2010-06-30 19:57:28EDT index.html>
+Time-stamp: <2010-06-30 21:18:34EDT index.html>
 </small>
 <!-- hhmts end -->
  </div>
diff --git a/tests/absolute-sum.lisp b/tests/absolute-sum.lisp
index 4d7ab271ae65169fc174e6c3ba9d5b2e1c585c7e..fa1d6b7079279b1217d5ed4bef21e8eb1d60abca 100644
--- a/tests/absolute-sum.lisp
+++ b/tests/absolute-sum.lisp
@@ -1,6 +1,6 @@
 ;; Regression test ABSOLUTE-SUM for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,68 +19,40 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST ABSOLUTE-SUM
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 157.99)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49))))
-                                                             (ABSOLUTE-SUM
-                                                              V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 157.99d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'DOUBLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5d0
-                                                                     8.24d0
-                                                                     3.29d0
-                                                                     -8.93d0
-                                                                     34.12d0
-                                                                     -6.15d0
-                                                                     49.27d0
-                                                                     -13.49d0))))
-                                                             (ABSOLUTE-SUM
-                                                              V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 388.65997)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(COMPLEX
-                                                                     SINGLE-FLOAT)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49
-                                                                     32.5 42.73
-                                                                     -17.24
-                                                                     43.31
-                                                                     -16.12
-                                                                     -8.25
-                                                                     21.44
-                                                                     -49.08))))
-                                                             (ABSOLUTE-SUM
-                                                              V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 388.65999999999997d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0 -13.49d0
-                                               32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0))))
-                           (ABSOLUTE-SUM V1)))))
-
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 157.99)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
+      (ABSOLUTE-SUM V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 157.99d0)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+      (ABSOLUTE-SUM V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 388.65997)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX
+	      SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) #C(49.27 -13.49)
+	      #C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
+      (ABSOLUTE-SUM V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 388.65999999999997d0)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   #2m(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0)
+		 #C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+		 #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0))))
+      (ABSOLUTE-SUM V1)))))
diff --git a/tests/axpy.lisp b/tests/axpy.lisp
index 8d28e853d49deb1f2401caeeee3f3a9b47a99296..63bf5dff328cadfcf11c479e024bc4e3e5d8519f 100644
--- a/tests/axpy.lisp
+++ b/tests/axpy.lisp
@@ -19,91 +19,95 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST AXPY
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(1400.77 -284.0684 -147.7214 397.47382 -1369.3191
-                           235.659 -1932.6083 485.93335))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(32.5 42.73 -17.24 43.31 -16.12
-                                               -8.25 21.44 -49.08)))
-                               (SCALAR -39.66))
-                           (CL-ARRAY (AXPY SCALAR V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(1400.77d0 -284.06839999999994d0 -147.7214d0
-                           397.4738d0 -1369.3191999999997d0 235.659d0
-                           -1932.6082d0 485.93339999999995d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0)))
-                               (SCALAR -39.66d0))
-                           (CL-ARRAY (AXPY SCALAR V1 V2)))))
-			#+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(1808.3204 1422.3015) #C(-589.3992 234.75043)
-                           #C(-1673.498 -1451.916) #C(-2599.8237 -1950.9608)
-                           #C(784.81586 -3351.5815) #C(2845.531 -870.5343)
-                           #C(222.45422 1149.8602) #C(-3308.3872 917.76044)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49 32.5 42.73
-                                               -17.24 43.31 -16.12 -8.25 21.44
-                                               -49.08)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(32.5 42.73 -17.24 43.31 -16.12
-                                               -8.25 21.44 -49.08 -39.66 -49.46
-                                               19.68 -5.55 -8.82 25.37 -30.58
-                                               31.67)))
-                               (SCALAR #C(-39.66 -49.46)))
-                           (CL-ARRAY (AXPY SCALAR V1 V2)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(1808.3204d0 1422.3016000000002d0)
-                           #C(-589.3992d0 234.75039999999998d0)
-                           #C(-1673.4981999999998d0 -1451.9162000000001d0)
-                           #C(-2599.8236d0 -1950.9608000000003d0)
-                           #C(784.8158000000002d0 -3351.5818d0)
-                           #C(2845.5309999999995d0 -870.5342d0)
-                           #C(222.45420000000001d0 1149.8601999999998d0)
-                           #C(-3308.3871999999997d0 917.7603999999995d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0 -13.49d0
-                                               32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0 -39.66d0 -49.46d0
-                                               19.68d0 -5.55d0 -8.82d0 25.37d0
-                                               -30.58d0 31.67d0)))
-                               (SCALAR #C(-39.66d0 -49.46d0)))
-                           (CL-ARRAY (AXPY SCALAR V1 V2))))))
-
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(1400.77 -284.0684 -147.7214 397.47382 -1369.3191
+      235.659 -1932.6083 485.93335))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '(32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 -49.08)))
+	  (SCALAR -39.66))
+      (CL-ARRAY (AXPY SCALAR V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(1400.77d0 -284.06839999999994d0 -147.7214d0
+      397.4738d0 -1369.3191999999997d0 235.659d0
+      -1932.6082d0 485.93339999999995d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(-34.5d0 8.24d0 3.29d0 -8.93d0
+	      34.12d0 -6.15d0 49.27d0
+	      -13.49d0)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(32.5d0 42.73d0 -17.24d0 43.31d0
+	      -16.12d0 -8.25d0 21.44d0
+	      -49.08d0)))
+	  (SCALAR -39.66d0))
+      (CL-ARRAY (AXPY SCALAR V1 V2)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(1808.3204 1422.3015) #C(-589.3992 234.75043)
+      #C(-1673.498 -1451.916) #C(-2599.8237 -1950.9608)
+      #C(784.81586 -3351.5815) #C(2845.531 -870.5343)
+      #C(222.45422 1149.8602) #C(-3308.3872 917.76044)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93)
+	      #C(34.12 -6.15) #C(49.27 -13.49) #C(32.5 42.73)
+	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25)
+	      #C(21.44 -49.08) #C(-39.66 -49.46)
+	      #C(19.68 -5.55) #C(-8.82 25.37)
+	      #C(-30.58 31.67))))
+	  (SCALAR #C(-39.66 -49.46)))
+      (CL-ARRAY (AXPY SCALAR V1 V2)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(1808.3204d0 1422.3016000000002d0)
+      #C(-589.3992d0 234.75039999999998d0)
+      #C(-1673.4981999999998d0 -1451.9162000000001d0)
+      #C(-2599.8236d0 -1950.9608000000003d0)
+      #C(784.8158000000002d0 -3351.5818d0)
+      #C(2845.5309999999995d0 -870.5342d0)
+      #C(222.45420000000001d0 1149.8601999999998d0)
+      #C(-3308.3871999999997d0 917.7603999999995d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+	      #C(34.12d0 -6.15d0) #C(49.27d0 -13.49d0)
+	      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)
+	      #C(-39.66d0 -49.46d0) #C(19.68d0 -5.55d0)
+	      #C(-8.82d0 25.37d0) #C(-30.58d0 31.67d0))))
+	  (SCALAR #C(-39.66d0 -49.46d0)))
+      (CL-ARRAY (AXPY SCALAR V1 V2))))))
diff --git a/tests/blas-copy.lisp b/tests/blas-copy.lisp
index 2dda8d0ef9f78ad765c42177dea2c0482eeba1d5..51f8eba05ce04bbffa0cb15d1bd5fefc61c14c76 100644
--- a/tests/blas-copy.lisp
+++ b/tests/blas-copy.lisp
@@ -1,6 +1,6 @@
 ;; Regression test BLAS-COPY for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,50 +19,50 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST BLAS-COPY
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-34.5 8.24 3.29))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29)))
-                               (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
-                           (BLAS-COPY V1 V2)
-                           (CL-ARRAY V2))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-34.5d0 8.24d0 3.29d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0)))
-                               (V2 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
-                           (BLAS-COPY V1 V2)
-                           (CL-ARRAY V2))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :DIMENSIONS '3)))
-                           (BLAS-COPY V1 V2)
-                           (CL-ARRAY V2))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
-                           #C(34.12d0 -6.15d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :DIMENSIONS '3)))
-                           (BLAS-COPY V1 V2)
-                           (CL-ARRAY V2)))))
-
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-34.5 8.24 3.29))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5 8.24 3.29)))
+	  (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
+      (BLAS-COPY V1 V2)
+      (CL-ARRAY V2))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-34.5d0 8.24d0 3.29d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS '(-34.5d0 8.24d0 3.29d0)))
+	  (V2 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
+      (BLAS-COPY V1 V2)
+      (CL-ARRAY V2))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3)))
+      (BLAS-COPY V1 V2)
+      (CL-ARRAY V2))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+      #C(34.12d0 -6.15d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+	      #C(34.12d0 -6.15d0))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT) :DIMENSIONS '3)))
+      (BLAS-COPY V1 V2)
+      (CL-ARRAY V2)))))
diff --git a/tests/blas-swap.lisp b/tests/blas-swap.lisp
index deb41a29b93a1d74a457c7769e72ea9c706165db..28a36abd1ed1b18a8a47ee06943ffb5dd9bdecfa 100644
--- a/tests/blas-swap.lisp
+++ b/tests/blas-swap.lisp
@@ -1,6 +1,6 @@
 ;; Regression test BLAS-SWAP for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,66 +19,69 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST BLAS-SWAP
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST (LIST #(-8.93 34.12 -6.15) #(-34.5 8.24 3.29)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93 34.12 -6.15))))
-                           (BLAS-SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST #(-8.93d0 34.12d0 -6.15d0)
-                               #(-34.5d0 8.24d0 3.29d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93d0 34.12d0 -6.15d0))))
-                           (BLAS-SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST
-                          #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-                          #(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-8.93 34.12 -6.15 49.27 -13.49
-                                               32.5))))
-                           (BLAS-SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST
-                          #(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0)
-                            #C(-13.49d0 32.5d0))
-                          #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
-                            #C(34.12d0 -6.15d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-8.93d0 34.12d0 -6.15d0 49.27d0
-                                               -13.49d0 32.5d0))))
-                           (BLAS-SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2))))))
-
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST (LIST #(-8.93 34.12 -6.15) #(-34.5 8.24 3.29)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '(-34.5 8.24 3.29)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '(-8.93 34.12 -6.15))))
+      (BLAS-SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST #(-8.93d0 34.12d0 -6.15d0)
+	  #(-34.5d0 8.24d0 3.29d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '(-34.5d0 8.24d0 3.29d0)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '(-8.93d0 34.12d0 -6.15d0))))
+      (BLAS-SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST
+     #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+     #(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)))))
+      (BLAS-SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST
+     #(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0)
+       #C(-13.49d0 32.5d0))
+     #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+       #C(34.12d0 -6.15d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0)))))
+      (BLAS-SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2))))))
diff --git a/tests/cdot.lisp b/tests/cdot.lisp
index 0cd8b041e170664ce297497a618b1dba9a1a7bda..7834112e243ba82a2670dc33f60704b293a48acd 100644
--- a/tests/cdot.lisp
+++ b/tests/cdot.lisp
@@ -1,6 +1,6 @@
 ;; Regression test CDOT for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,42 +19,43 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST CDOT
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #C(-1.1684039224427728d28 0.0d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49 32.5 42.73
-                                               -17.24 43.31 -16.12 -8.25 21.44
-                                               -49.08)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(32.5 42.73 -17.24 43.31 -16.12
-                                               -8.25 21.44 -49.08 -39.66 -49.46
-                                               19.68 -5.55 -8.82 25.37 -30.58
-                                               31.67))))
-                           (CDOT V1 V2))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #C(-6252.624d0 -6236.050300000001d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0 -13.49d0
-                                               32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0 -39.66d0 -49.46d0
-                                               19.68d0 -5.55d0 -8.82d0 25.37d0
-                                               -30.58d0 31.67d0))))
-                           (CDOT V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #C(-1.1684039224427728d28 0.0d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)
+	      #C(49.27 -13.49) #C(32.5 42.73)
+	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25)
+	      #C(21.44 -49.08) #C(-39.66 -49.46)
+	      #C(19.68 -5.55) #C(-8.82 25.37) #C(-30.58 31.67)))))
+      (CDOT V1 V2))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #C(-6252.624d0 -6236.050300000001d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+	      #C(34.12d0 -6.15d0) #C(49.27d0 -13.49d0)
+	      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)
+	      #C(-39.66d0 -49.46d0)
+	      #C(19.68d0 -5.55d0) #C(-8.82d0 25.37d0)
+	      #C(-30.58d0 31.67d0)))))
+      (CDOT V1 V2)))))
 
diff --git a/tests/column.lisp b/tests/column.lisp
index 10d6eb8fc29fffa972749313d31c5bf690a01ed0..9ecaebc59b7ab197c9804a41d8b5d6bddfe633e6 100644
--- a/tests/column.lisp
+++ b/tests/column.lisp
@@ -1,6 +1,6 @@
 ;; Regression test COLUMN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,236 +19,175 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST COLUMN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(8.24 34.12 -13.49))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (COL (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
-                           (CL-ARRAY (COLUMN M1 1 COL)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(8.24d0 34.12d0 -13.49d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (COL (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
-                           (CL-ARRAY (COLUMN M1 1 COL)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :DIMENSIONS '3)))
-                           (CL-ARRAY (COLUMN M1 1 COL)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(3.29d0 -8.93d0) #C(-6.15d0 49.27d0)
-                           #C(32.5d0 42.73d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :DIMENSIONS '3)))
-                           (CL-ARRAY (COLUMN M1 1 COL)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123))))
-                                                                 (COL
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (COLUMN M1
-                                                                      1 COL)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98))))
-                                                                 (COL
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (COLUMN M1
-                                                                      1 COL)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123))))
-                                                                 (COL
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (COLUMN M1
-                                                                      1 COL)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98))))
-                                                                 (COL
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (COLUMN M1
-                                                                      1 COL)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123))))
-                                                                 (COL
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (COLUMN M1
-                                                                      1 COL)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98))))
-                                                                 (COL
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (COLUMN M1
-                                                                      1 COL)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123))))
-                                                                 (COL
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (COLUMN M1
-                                                                      1 COL)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98))))
-                                                                 (COL
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (COLUMN M1
-                                                                      1 COL))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(8.24 34.12 -13.49))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5))))
+	  (COL (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
+      (CL-ARRAY (COLUMN M1 1 COL)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(8.24d0 34.12d0 -13.49d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0))))
+	  (COL (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
+      (CL-ARRAY (COLUMN M1 1 COL)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3)))
+      (CL-ARRAY (COLUMN M1 1 COL)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(3.29d0 -8.93d0) #C(-6.15d0 49.27d0)
+      #C(32.5d0 42.73d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT) :DIMENSIONS '3)))
+      (CL-ARRAY (COLUMN M1 1 COL)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-68 52 -5))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71)
+	      (-91 52 -10)
+	      (73 -5 123))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :DIMENSIONS '3)))
+      (CL-ARRAY (COLUMN M1 1 COL)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(44 163 215))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((67 44 189)
+	      (116 163 140)
+	      (161 215 98))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :DIMENSIONS '3)))
+      (CL-ARRAY (COLUMN M1 1 COL)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-68 52 -5))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71)
+	      (-91 52 -10)
+	      (73 -5 123))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16) :DIMENSIONS '3)))
+      (CL-ARRAY (COLUMN M1 1 COL)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(44 163 215))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((67 44 189)
+	      (116 163 140)
+	      (161 215 98))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :DIMENSIONS '3)))
+      (CL-ARRAY (COLUMN M1 1 COL)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-68 52 -5))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71)
+	      (-91 52 -10)
+	      (73 -5 123))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32) :DIMENSIONS '3)))
+      (CL-ARRAY (COLUMN M1 1 COL)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(44 163 215))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((67 44 189)
+	      (116 163 140)
+	      (161 215 98))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32) :DIMENSIONS '3)))
+      (CL-ARRAY (COLUMN M1 1 COL)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-68 52 -5))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71)
+	      (-91 52 -10)
+	      (73 -5 123))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :DIMENSIONS '3)))
+      (CL-ARRAY (COLUMN M1 1 COL)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(44 163 215))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((67 44 189)
+	      (116 163 140)
+	      (161 215 98))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :DIMENSIONS '3)))
+      (CL-ARRAY (COLUMN M1 1 COL))))))
 
diff --git a/tests/covariance.lisp b/tests/covariance.lisp
index b9f33c4d52446dd4168d65f29fed827393aae876..16b5f83d2123eddb2157ca0c28bdd011471d2c8a 100644
--- a/tests/covariance.lisp
+++ b/tests/covariance.lisp
@@ -1,6 +1,6 @@
 ;; Regression test COVARIANCE for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -24,10 +24,10 @@
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-			'(-34.5 8.24 3.29)))
+				    '(-34.5 8.24 3.29)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-			'(-8.93 34.12 -6.15))))
+				    '(-8.93 34.12 -6.15))))
       (LET ((MEAN1 (MEAN V1)) (MEAN2 (MEAN V2)))
 	(COVARIANCE V1 V2 MEAN1 MEAN2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -35,10 +35,10 @@
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-			'(-34.5d0 8.24d0 3.29d0)))
+				    '(-34.5d0 8.24d0 3.29d0)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-			'(-8.93d0 34.12d0 -6.15d0))))
+				    '(-8.93d0 34.12d0 -6.15d0))))
       (LET ((MEAN1 (MEAN V1)) (MEAN2 (MEAN V2)))
 	(COVARIANCE V1 V2 MEAN1 MEAN2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -46,10 +46,10 @@
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-			'(-64 -68 71)))
+				    '(-64 -68 71)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-			'(-91 52 -10))))
+				    '(-91 52 -10))))
       (LET ((MEAN1 (MEAN V1)) (MEAN2 (MEAN V2)))
 	(COVARIANCE V1 V2 MEAN1 MEAN2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -66,9 +66,9 @@
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-			:INITIAL-CONTENTS '(-64 -68 71)))
+				    :INITIAL-CONTENTS '(-64 -68 71)))
 	  (V2 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-			   :INITIAL-CONTENTS '(-91 52 -10))))
+				       :INITIAL-CONTENTS '(-91 52 -10))))
       (LET ((MEAN1 (MEAN V1)) (MEAN2 (MEAN V2)))
 	(COVARIANCE V1 V2 MEAN1 MEAN2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -96,10 +96,10 @@
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-			:INITIAL-CONTENTS '(-64 -68 71)))
+				    :INITIAL-CONTENTS '(-64 -68 71)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-			:INITIAL-CONTENTS '(-91 52 -10))))
+				    :INITIAL-CONTENTS '(-91 52 -10))))
       (LET ((MEAN1 (MEAN V1)) (MEAN2 (MEAN V2)))
 	(COVARIANCE V1 V2 MEAN1 MEAN2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -116,10 +116,10 @@
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-			:INITIAL-CONTENTS '(-64 -68 71)))
+				    :INITIAL-CONTENTS '(-64 -68 71)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-			:INITIAL-CONTENTS '(-91 52 -10))))
+				    :INITIAL-CONTENTS '(-91 52 -10))))
       (LET ((MEAN1 (MEAN V1)) (MEAN2 (MEAN V2)))
 	(COVARIANCE V1 V2 MEAN1 MEAN2)))))
   #+int64
diff --git a/tests/dot.lisp b/tests/dot.lisp
index dce03a31d66b0b076b439b0616f2add2e75288d0..52ea38f2b8aad3de2f25edb906175c55a8df08c7 100644
--- a/tests/dot.lisp
+++ b/tests/dot.lisp
@@ -19,80 +19,72 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST DOT
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6.5285645)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(32.5 42.73
-                                                                     -17.24
-                                                                     43.31
-                                                                     -16.12
-                                                                     -8.25
-                                                                     21.44
-                                                                     -49.08))))
-                                                             (DOT V1 V2))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 6.528400000000033d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0))))
-                           (DOT V1 V2))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #C(-8.778225633844878d26 0.0d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49 32.5 42.73
-                                               -17.24 43.31 -16.12 -8.25 21.44
-                                               -49.08)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(32.5 42.73 -17.24 43.31 -16.12
-                                               -8.25 21.44 -49.08 -39.66 -49.46
-                                               19.68 -5.55 -8.82 25.37 -30.58
-                                               31.67))))
-                           (DOT V1 V2))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #C(625.9736000000007d0 -4310.1183d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0 -13.49d0
-                                               32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0 -39.66d0 -49.46d0
-                                               19.68d0 -5.55d0 -8.82d0 25.37d0
-                                               -30.58d0 31.67d0))))
-                           (DOT V1 V2)))))
-
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6.5285645)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 -49.08))))
+      (DOT V1 V2))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6.528400000000033d0)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '(-34.5d0 8.24d0 3.29d0 -8.93d0
+	      34.12d0 -6.15d0 49.27d0
+	      -13.49d0)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '(32.5d0 42.73d0 -17.24d0 43.31d0
+	      -16.12d0 -8.25d0 21.44d0
+	      -49.08d0))))
+      (DOT V1 V2))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #C(-8.778225633844878d26 0.0d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)
+	      #C(49.27 -13.49) #C(32.5 42.73)
+	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25)
+	      #C(21.44 -49.08) #C(-39.66 -49.46)
+	      #C(19.68 -5.55) #C(-8.82 25.37) #C(-30.58 31.67)))))
+      (DOT V1 V2))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #C(625.9736000000007d0 -4310.1183d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+	      #C(34.12d0 -6.15d0) #C(49.27d0 -13.49d0)
+	      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)
+	      #C(-39.66d0 -49.46d0)
+	      #C(19.68d0 -5.55d0) #C(-8.82d0 25.37d0)
+	      #C(-30.58d0 31.67d0)))))
+      (DOT V1 V2)))))
diff --git a/tests/euclidean-norm.lisp b/tests/euclidean-norm.lisp
index 5d91e528639fa5f411448d4a208ff09142adc699..fcee147a020c60a5684d1d8c1d526e88b866152d 100644
--- a/tests/euclidean-norm.lisp
+++ b/tests/euclidean-norm.lisp
@@ -1,6 +1,6 @@
 ;; Regression test EUCLIDEAN-NORM for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,61 +19,45 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST EUCLIDEAN-NORM
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71.83472)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49))))
-                                                             (EUCLIDEAN-NORM
-                                                              V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 71.83471653734007d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0))))
-                           (EUCLIDEAN-NORM V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 115.80907)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(COMPLEX
-                                                                     SINGLE-FLOAT)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49
-                                                                     32.5 42.73
-                                                                     -17.24
-                                                                     43.31
-                                                                     -16.12
-                                                                     -8.25
-                                                                     21.44
-                                                                     -49.08))))
-                                                             (EUCLIDEAN-NORM
-                                                              V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 115.8090670025452d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0 -13.49d0
-                                               32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0))))
-                           (EUCLIDEAN-NORM V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 71.83472)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
+      (EUCLIDEAN-NORM V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 71.83471653734007d0)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+      (EUCLIDEAN-NORM V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 115.80907)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93)
+	      #C(34.12 -6.15) #C(49.27 -13.49)
+	      #C(32.5 42.73) #C(-17.24 43.31)
+	      #C(-16.12 -8.25) #C(21.44 -49.08)))))
+      (EUCLIDEAN-NORM V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 115.8090670025452d0)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+	      #C(34.12d0 -6.15d0) #C(49.27d0 -13.49d0)
+	      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)))))
+      (EUCLIDEAN-NORM V1)))))
 
diff --git a/tests/givens.lisp b/tests/givens.lisp
index 4903be72a30809af5d9f85c5a3d313def15eb5da..ef781a3bb5aed20a1f742595734cbf22836a08e5 100644
--- a/tests/givens.lisp
+++ b/tests/givens.lisp
@@ -43,9 +43,9 @@
                                (COSINES
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8)))
                            (LOOP FOR I BELOW 8 DO
-                                 (SETF (MAREF SINES I) (SIN (MAREF ANGLES I)))
-                                 (SETF (MAREF COSINES I)
-                                         (COS (MAREF ANGLES I))))
+                                 (SETF (GRID:GREF SINES I) (SIN (GRID:GREF ANGLES I)))
+                                 (SETF (GRID:GREF COSINES I)
+                                         (COS (GRID:GREF ANGLES I))))
                            (GIVENS-ROTATION V1 V2 COSINES SINES)
                            (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -76,9 +76,9 @@
                                (COSINES
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8)))
                            (LOOP FOR I BELOW 8 DO
-                                 (SETF (MAREF SINES I) (SIN (MAREF ANGLES I)))
-                                 (SETF (MAREF COSINES I)
-                                         (COS (MAREF ANGLES I))))
+                                 (SETF (GRID:GREF SINES I) (SIN (GRID:GREF ANGLES I)))
+                                 (SETF (GRID:GREF COSINES I)
+                                         (COS (GRID:GREF ANGLES I))))
                            (GIVENS-ROTATION V1 V2 COSINES SINES)
                            (LIST (CL-ARRAY V1) (CL-ARRAY V2))))))
 
diff --git a/tests/hankel.lisp b/tests/hankel.lisp
index 66fc52a6fab48de91513bbed131233ee178bb80f..95ef9c186b4cce041ea7f750d937f249fe7afd37 100644
--- a/tests/hankel.lisp
+++ b/tests/hankel.lisp
@@ -116,7 +116,7 @@
                          (LET ((HANK (MAKE-HANKEL 128 0.0d0 100.0d0))
                                (IN (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 128)))
                            (LOOP FOR N FROM 0 BELOW 128 DO
-                                 (SETF (MAREF IN N)
+                                 (SETF (GRID:GREF IN N)
                                          (/
                                           (1+
                                            (EXPT (SAMPLE-X-HANKEL HANK N)
@@ -192,7 +192,7 @@
                          (LET ((HANK (MAKE-HANKEL 128 1.0d0 20.0d0))
                                (IN (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 128)))
                            (LOOP FOR N FROM 0 BELOW 128 DO
-                                 (SETF (MAREF IN N)
+                                 (SETF (GRID:GREF IN N)
                                          (EXP (- (SAMPLE-X-HANKEL HANK N)))))
                            (COPY (APPLY-HANKEL HANK IN) 'ARRAY))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -265,7 +265,7 @@
                          (LET ((HANK (MAKE-HANKEL 128 1.0d0 1.0d0))
                                (IN (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 128)))
                            (LOOP FOR N FROM 0 BELOW 128 DO
-                                 (SETF (MAREF IN N)
+                                 (SETF (GRID:GREF IN N)
                                          (LET ((X (SAMPLE-X-HANKEL HANK N)))
                                            (* X (- 1 (EXPT X 2))))))
                            (COPY (APPLY-HANKEL HANK IN) 'ARRAY)))))
diff --git a/tests/histogram.lisp b/tests/histogram.lisp
index 677b6b56e86bf58b2b2b78fa3f0559dddbdf5367..d832eb4e9ecfe1771116095dc94a365c3bc55114 100644
--- a/tests/histogram.lisp
+++ b/tests/histogram.lisp
@@ -39,7 +39,7 @@
                                                              (INCREMENT HISTO
                                                                         6.9d0
                                                                         2.0d0)
-                                                             (MAREF HISTO 1))))
+                                                             (GRID:GREF HISTO 1))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.0d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((HISTO
@@ -53,7 +53,7 @@
                                                              (INCREMENT HISTO
                                                                         6.9d0
                                                                         2.0d0)
-                                                             (MAREF HISTO 2))))
+                                                             (GRID:GREF HISTO 2))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2.0d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((HISTO
@@ -67,7 +67,7 @@
                                                              (INCREMENT HISTO
                                                                         6.9d0
                                                                         2.0d0)
-                                                             (MAREF HISTO 6))))
+                                                             (GRID:GREF HISTO 6))))
                        (LISP-UNIT:ASSERT-ERROR 'INPUT-DOMAIN
                                                (LET ((HISTO
                                                       (MAKE-HISTOGRAM 10)))
@@ -76,7 +76,7 @@
                                                                      10.0d0)
                                                  (INCREMENT HISTO 2.7d0)
                                                  (INCREMENT HISTO 6.9d0 2.0d0)
-                                                 (MAREF HISTO 16)))
+                                                 (GRID:GREF HISTO 16)))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.0d0 10.0d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((HISTO
diff --git a/tests/index-max.lisp b/tests/index-max.lisp
index ac18040feee9d2050636a0b1fc71558063835200..0752044424bfa9c51ca1c44dd9cec75660620056 100644
--- a/tests/index-max.lisp
+++ b/tests/index-max.lisp
@@ -1,6 +1,6 @@
 ;; Regression test INDEX-MAX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,77 +19,49 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST INDEX-MAX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49))))
-                                                             (INDEX-MAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'DOUBLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5d0
-                                                                     8.24d0
-                                                                     3.29d0
-                                                                     -8.93d0
-                                                                     34.12d0
-                                                                     -6.15d0
-                                                                     49.27d0
-                                                                     -13.49d0))))
-                                                             (INDEX-MAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 4)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(COMPLEX
-                                                                     SINGLE-FLOAT)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49
-                                                                     32.5 42.73
-                                                                     -17.24
-                                                                     43.31
-                                                                     -16.12
-                                                                     -8.25
-                                                                     21.44
-                                                                     -49.08))))
-                                                             (INDEX-MAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 4)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(COMPLEX
-                                                                     DOUBLE-FLOAT)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5d0
-                                                                     8.24d0
-                                                                     3.29d0
-                                                                     -8.93d0
-                                                                     34.12d0
-                                                                     -6.15d0
-                                                                     49.27d0
-                                                                     -13.49d0
-                                                                     32.5d0
-                                                                     42.73d0
-                                                                     -17.24d0
-                                                                     43.31d0
-                                                                     -16.12d0
-                                                                     -8.25d0
-                                                                     21.44d0
-                                                                     -49.08d0))))
-                                                             (INDEX-MAX V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
+      (INDEX-MAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+      (INDEX-MAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)
+	      #C(49.27 -13.49) #C(32.5 42.73)
+	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
+      (INDEX-MAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4)
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0)
+	      #C(3.29d0 -8.93d0)
+	      #C(34.12d0 -6.15d0)
+	      #C(49.27d0 -13.49d0)
+	      #C(32.5d0 42.73d0)
+	      #C(-17.24d0 43.31d0)
+	      #C(-16.12d0 -8.25d0)
+	      #C(21.44d0 -49.08d0)))))
+      (INDEX-MAX V1)))))
 
diff --git a/tests/inverse-matrix-product.lisp b/tests/inverse-matrix-product.lisp
index 6a7d1b56b7b1c8ca7cb0f75acb3177295ca6601f..3949bdb769e081b0e4beedde83a6098622a22373 100644
--- a/tests/inverse-matrix-product.lisp
+++ b/tests/inverse-matrix-product.lisp
@@ -1,6 +1,6 @@
 ;; Regression test INVERSE-MATRIX-PRODUCT for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,177 +19,172 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST INVERSE-MATRIX-PRODUCT
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-30.708971 5.3737082 -25.897392)
-                             (-14.654706 -9.08723 6.96797)
-                             (-29.71983 -24.015656 -29.949932)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((42.73 -17.24 43.31)
-                                               (-16.12 -8.25 21.44)
-                                               (-49.08 -39.66 -49.46))))
-                               (S1 19.68))
-                           (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-30.708968222785604d0 5.373707833953741d0
-                              -25.89739157520614d0)
-                             (-14.654705167282895d0 -9.087229795292632d0
-                              6.967969411128146d0)
-                             (-29.71982769230769d0 -24.015655384615382d0
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-30.708971 5.3737082 -25.897392)
+	(-14.654706 -9.08723 6.96797)
+	(-29.71983 -24.015656 -29.949932)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((42.73 -17.24 43.31)
+	      (-16.12 -8.25 21.44)
+	      (-49.08 -39.66 -49.46))))
+	  (S1 19.68))
+      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-30.708968222785604d0 5.373707833953741d0
+			       -25.89739157520614d0)
+	(-14.654705167282895d0 -9.087229795292632d0
+			       6.967969411128146d0)
+	(-29.71982769230769d0 -24.015655384615382d0
                               -29.949932307692308d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((42.73d0 -17.24d0 43.31d0)
-                                               (-16.12d0 -8.25d0 21.44d0)
-                                               (-49.08d0 -39.66d0 -49.46d0))))
-                               (S1 19.68d0))
-                           (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-28.191956 35.052914) #C(-13.378113 28.736774)
-                              #C(5.4411864 -3.0717967))
-                             (#C(5.1555862 -11.330741) #C(-33.49236 -12.241006)
-                              #C(-10.527424 20.3357))
-                             (#C(-0.71776515 27.669863) #C(20.046593 11.972884)
-                              #C(-1.5907472 4.2853727))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((42.73 -17.24 43.31 -16.12 -8.25
-                                                21.44)
-                                               (-16.12 -8.25 21.44 -49.08
-                                                -39.66 -49.46)
-                                               (-49.08 -39.66 -49.46 19.68
-                                                -5.55 -8.82))))
-                               (S1 #C(19.68 -5.55)))
-                           (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-28.191956546692666d0 35.052909000810466d0)
-                              #C(-13.378112744466048d0 28.736769449657892d0)
-                              #C(5.441186078394205d0 -3.071795512940909d0))
-                             (#C(5.155586147762611d0 -11.330740389402608d0)
-                              #C(-33.49236130612107d0 -12.241006594989193d0)
-                              #C(-10.527425621635187d0 20.33570209413866d0))
-                             (#C(-0.7177649743298794d0 27.669860728641122d0)
-                              #C(20.046591997869093d0 11.972882797431007d0)
-                              #C(-1.590747546093172d0 4.285372608973592d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((42.73d0 -17.24d0 43.31d0
-                                                -16.12d0 -8.25d0 21.44d0)
-                                               (-16.12d0 -8.25d0 21.44d0
-                                                -49.08d0 -39.66d0 -49.46d0)
-                                               (-49.08d0 -39.66d0 -49.46d0
-                                                19.68d0 -5.55d0 -8.82d0))))
-                               (S1 #C(19.68d0 -5.55d0)))
-                           (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-1.1747805 -0.26507667 1.3326154))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(42.73 -17.24 43.31)))
-                               (S1 -16.12))
-                           (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-1.1747804927980594d0 -0.26507665253855167d0
-                           1.3326153846153848d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(42.73d0 -17.24d0 43.31d0)))
-                               (S1 -16.12d0))
-                           (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-1.1218005 0.24990065) #C(-0.7679142 -0.9143634)
-                           #C(0.4927793 -0.0056687724)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(42.73 -17.24 43.31 -16.12 -8.25
-                                               21.44)))
-                               (S1 #C(-16.12 -8.25)))
-                           (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-1.1218005239477833d0 0.2499006037347623d0)
-                           #C(-0.7679142088967384d0 -0.9143634017568469d0)
-                           #C(0.49277927293827817d0 -0.005668775466541512d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0)))
-                               (S1 #C(-16.12d0 -8.25d0)))
-                           (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1))))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((42.73d0 -17.24d0 43.31d0)
+	      (-16.12d0 -8.25d0 21.44d0)
+	      (-49.08d0 -39.66d0 -49.46d0))))
+	  (S1 19.68d0))
+      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-28.191956 35.052914) #C(-13.378113 28.736774)
+	   #C(5.4411864 -3.0717967))
+	(#C(5.1555862 -11.330741) #C(-33.49236 -12.241006)
+	   #C(-10.527424 20.3357))
+	(#C(-0.71776515 27.669863) #C(20.046593 11.972884)
+	   #C(-1.5907472 4.2853727))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))
+	      (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
+	      (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82)))))
+	  (S1 #C(19.68 -5.55)))
+      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-28.191956546692666d0 35.052909000810466d0)
+	   #C(-13.378112744466048d0 28.736769449657892d0)
+	   #C(5.441186078394205d0 -3.071795512940909d0))
+	(#C(5.155586147762611d0 -11.330740389402608d0)
+	   #C(-33.49236130612107d0 -12.241006594989193d0)
+	   #C(-10.527425621635187d0 20.33570209413866d0))
+	(#C(-0.7177649743298794d0 27.669860728641122d0)
+	   #C(20.046591997869093d0 11.972882797431007d0)
+	   #C(-1.590747546093172d0 4.285372608973592d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))
+	      (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
+	      (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0)))))
+	  (S1 #C(19.68d0 -5.55d0)))
+      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-1.1747805 -0.26507667 1.3326154))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '(42.73 -17.24 43.31)))
+	  (S1 -16.12))
+      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(-1.1747804927980594d0 -0.26507665253855167d0
+      1.3326153846153848d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				    '(42.73d0 -17.24d0 43.31d0)))
+	  (S1 -16.12d0))
+      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-1.1218005 0.24990065) #C(-0.7679142 -0.9143634)
+      #C(0.4927793 -0.0056687724)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))))
+	  (S1 #C(-16.12 -8.25)))
+      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-1.1218005239477833d0 0.2499006037347623d0)
+      #C(-0.7679142088967384d0 -0.9143634017568469d0)
+      #C(0.49277927293827817d0 -0.005668775466541512d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))))
+	  (S1 #C(-16.12d0 -8.25d0)))
+      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1))))))
 
diff --git a/tests/matrix-product-hermitian.lisp b/tests/matrix-product-hermitian.lisp
index d58d6cec0c6f87585ec2af529ca7611af618c639..3971273463248c425021ab06014e66c37de41f69 100644
--- a/tests/matrix-product-hermitian.lisp
+++ b/tests/matrix-product-hermitian.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-PRODUCT-HERMITIAN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,144 +20,128 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT-HERMITIAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(161635.16 -134299.77) #C(93510.016 -191870.72)
-                              #C(55739.336 13621.439))
-                             (#C(-68526.41 125188.29) #C(46318.242 59787.605)
-                              #C(-28142.984 5816.9385))
-                             (#C(-139503.38 55690.902) #C(2898.8164 49116.78)
-                              #C(-57882.3 -176350.63))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((42.73 -17.24 43.31 -16.12 -8.25
-                                                21.44)
-                                               (-16.12 -8.25 21.44 -49.08
-                                                -39.66 -49.46)
-                                               (-49.08 -39.66 -49.46 19.68
-                                                -5.55 -8.82))))
-                               (M3
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((19.68 -5.55 -8.82 25.37 -30.58
-                                                31.67)
-                                               (25.37 -30.58 31.67 29.36 -33.24
-                                                -27.03)
-                                               (29.36 -33.24 -27.03 -41.67 42.0
-                                                -20.81))))
-                               (S1 #C(-41.67 42.0))
-                               (S2 #C(42.0 -20.81)))
-                           (CL-ARRAY
-                            (MATRIX-PRODUCT-HERMITIAN M1 M2 M3 S1 S2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(161635.17690299999d0 -134299.761873d0)
-                              #C(93510.01525000001d0 -191870.723694d0)
-                              #C(55739.340844000006d0 13621.441385000013d0))
-                             (#C(-68526.41140699999d0 125188.28846599998d0)
-                              #C(46318.25349699999d0 59787.61715899999d0)
-                              #C(-28142.984856000003d0 5816.936996999999d0))
-                             (#C(-139503.391422d0 55690.900627999996d0)
-                              #C(2898.816300000017d0 49116.78897299998d0)
-                              #C(-57882.29909799999d0 -176350.62442500002d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((42.73d0 -17.24d0 43.31d0
-                                                -16.12d0 -8.25d0 21.44d0)
-                                               (-16.12d0 -8.25d0 21.44d0
-                                                -49.08d0 -39.66d0 -49.46d0)
-                                               (-49.08d0 -39.66d0 -49.46d0
-                                                19.68d0 -5.55d0 -8.82d0))))
-                               (M3
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((19.68d0 -5.55d0 -8.82d0 25.37d0
-                                                -30.58d0 31.67d0)
-                                               (25.37d0 -30.58d0 31.67d0
-                                                29.36d0 -33.24d0 -27.03d0)
-                                               (29.36d0 -33.24d0 -27.03d0
-                                                -41.67d0 42.0d0 -20.81d0))))
-                               (S1 #C(-41.67d0 42.0d0))
-                               (S2 #C(42.0d0 -20.81d0)))
-                           (CL-ARRAY
-                            (MATRIX-PRODUCT-HERMITIAN M1 M2 M3 S1 S2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(117171.67 19582.54) #C(18787.117 29534.742)
-                           #C(-104992.03 72729.13)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(42.73 -17.24 43.31 -16.12 -8.25
-                                               21.44)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-16.12 -8.25 21.44 -49.08 -39.66
-                                               -49.46)))
-                               (S1 #C(-49.08 -39.66))
-                               (S2 #C(-39.66 -49.46)))
-                           (CL-ARRAY
-                            (MATRIX-PRODUCT-HERMITIAN M1 V1 V2 S1 S2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(117171.67150799997d0 19582.539385999997d0)
-                           #C(18787.113150000005d0 29534.74247000001d0)
-                           #C(-104992.03586199998d0 72729.12516600001d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-16.12d0 -8.25d0 21.44d0
-                                               -49.08d0 -39.66d0 -49.46d0)))
-                               (S1 #C(-49.08d0 -39.66d0))
-                               (S2 #C(-39.66d0 -49.46d0)))
-                           (CL-ARRAY
-                            (MATRIX-PRODUCT-HERMITIAN M1 V1 V2 S1 S2))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(161635.16 -134299.77) #C(93510.016 -191870.72)
+	   #C(55739.336 13621.439))
+	(#C(-68526.41 125188.29) #C(46318.242 59787.605)
+	   #C(-28142.984 5816.9385))
+	(#C(-139503.38 55690.902) #C(2898.8164 49116.78)
+	   #C(-57882.3 -176350.63))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))
+	      (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
+	      (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82)))))
+	  (M3
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(19.68 -5.55) #C(-8.82 25.37) #C(-30.58 31.67))
+	      (#C(25.37 -30.58) #C(31.67 29.36) #C(-33.24 -27.03))
+	      (#C(29.36 -33.24) #C(-27.03 -41.67) #C(42.0 -20.81)))))
+	  (S1 #C(-41.67 42.0))
+	  (S2 #C(42.0 -20.81)))
+      (CL-ARRAY
+       (MATRIX-PRODUCT-HERMITIAN M1 M2 M3 S1 S2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(161635.17690299999d0 -134299.761873d0)
+	   #C(93510.01525000001d0 -191870.723694d0)
+	   #C(55739.340844000006d0 13621.441385000013d0))
+	(#C(-68526.41140699999d0 125188.28846599998d0)
+	   #C(46318.25349699999d0 59787.61715899999d0)
+	   #C(-28142.984856000003d0 5816.936996999999d0))
+	(#C(-139503.391422d0 55690.900627999996d0)
+	   #C(2898.816300000017d0 49116.78897299998d0)
+	   #C(-57882.29909799999d0 -176350.62442500002d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))
+	      (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
+	      (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0)))))
+	  (M3
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(19.68d0 -5.55d0) #C(-8.82d0 25.37d0) #C(-30.58d0 31.67d0))
+	      (#C(25.37d0 -30.58d0) #C(31.67d0 29.36d0) #C(-33.24d0 -27.03d0))
+	      (#C(29.36d0 -33.24d0) #C(-27.03d0 -41.67d0) #C(42.0d0 -20.81d0)))))
+	  (S1 #C(-41.67d0 42.0d0))
+	  (S2 #C(42.0d0 -20.81d0)))
+      (CL-ARRAY
+       (MATRIX-PRODUCT-HERMITIAN M1 M2 M3 S1 S2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(117171.67 19582.54) #C(18787.117 29534.742)
+      #C(-104992.03 72729.13)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))))
+	  (S1 #C(-49.08 -39.66))
+	  (S2 #C(-39.66 -49.46)))
+      (CL-ARRAY
+       (MATRIX-PRODUCT-HERMITIAN M1 V1 V2 S1 S2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(117171.67150799997d0 19582.539385999997d0)
+      #C(18787.113150000005d0 29534.74247000001d0)
+      #C(-104992.03586199998d0 72729.12516600001d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))))
+	  (S1 #C(-49.08d0 -39.66d0))
+	  (S2 #C(-39.66d0 -49.46d0)))
+      (CL-ARRAY
+       (MATRIX-PRODUCT-HERMITIAN M1 V1 V2 S1 S2))))))
 
diff --git a/tests/matrix-product-nonsquare.lisp b/tests/matrix-product-nonsquare.lisp
index 82f833885c684645c6e57a6bcc1c9318cd4628a8..aa30b3c0f6c3eaf941b51bde4ad84d4eb741de08 100644
--- a/tests/matrix-product-nonsquare.lisp
+++ b/tests/matrix-product-nonsquare.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-PRODUCT-NONSQUARE for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,78 +19,79 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT-NONSQUARE
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-1488.7347 959.9901) (774.94495 1312.0566)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((49.27 -13.49) (32.5 42.73)
-                                               (-17.24 43.31)))))
-                           (CL-ARRAY (MATRIX-PRODUCT M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-1488.7346d0 959.9901d0)
-                             (774.9448999999998d0 1312.0567999999996d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((49.27d0 -13.49d0)
-                                               (32.5d0 42.73d0)
-                                               (-17.24d0 43.31d0)))))
-                           (CL-ARRAY (MATRIX-PRODUCT M1 M2)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-1422.0259 2305.5098)
-                              #C(-1744.0583 -1092.294))
-                             (#C(-3459.892 1995.4918)
-                              #C(-3290.4465 -801.0577))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((49.27 -13.49 32.5 42.73)
-                                               (32.5 42.73 -17.24 43.31)
-                                               (-17.24 43.31 -16.12 -8.25)))))
-                           (CL-ARRAY (MATRIX-PRODUCT M1 M2)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-1422.0258d0 2305.5097000000005d0)
-                              #C(-1744.0584d0 -1092.2939d0))
-                             (#C(-3459.8918d0 1995.4917d0)
-                              #C(-3290.4465d0 -801.0577000000002d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((49.27d0 -13.49d0 32.5d0
-                                                42.73d0)
-                                               (32.5d0 42.73d0 -17.24d0
-                                                43.31d0)
-                                               (-17.24d0 43.31d0 -16.12d0
-                                                -8.25d0)))))
-                           (CL-ARRAY (MATRIX-PRODUCT M1 M2))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-1488.7347 959.9901) (774.94495 1312.0566)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((49.27 -13.49) (32.5 42.73)
+	      (-17.24 43.31)))))
+      (CL-ARRAY (MATRIX-PRODUCT M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-1488.7346d0 959.9901d0)
+	(774.9448999999998d0 1312.0567999999996d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((49.27d0 -13.49d0)
+	      (32.5d0 42.73d0)
+	      (-17.24d0 43.31d0)))))
+      (CL-ARRAY (MATRIX-PRODUCT M1 M2)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-1422.0259 2305.5098)
+	   #C(-1744.0583 -1092.294))
+	(#C(-3459.892 1995.4918)
+	   #C(-3290.4465 -801.0577))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(49.27 -13.49) #C(32.5 42.73))
+	      (#C(32.5 42.73) #C(-17.24 43.31))
+	      (#C(-17.24 43.31) #C(-16.12 -8.25))))))
+      (CL-ARRAY (MATRIX-PRODUCT M1 M2)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-1422.0258d0 2305.5097000000005d0)
+	   #C(-1744.0584d0 -1092.2939d0))
+	(#C(-3459.8918d0 1995.4917d0)
+	   #C(-3290.4465d0 -801.0577000000002d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0))
+	      (#C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))
+	      (#C(-17.24d0 43.31d0) #C(-16.12d0 -8.25d0))))))
+      (CL-ARRAY (MATRIX-PRODUCT M1 M2))))))
 
diff --git a/tests/matrix-product-triangular.lisp b/tests/matrix-product-triangular.lisp
index a6a4320019b7e4c0e00b7ee351110e5a8442ad7f..20015c8a308c09ff7e2c924202f1d7851a6c7c0d 100644
--- a/tests/matrix-product-triangular.lisp
+++ b/tests/matrix-product-triangular.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-PRODUCT-TRIANGULAR for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,178 +19,167 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT-TRIANGULAR
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34803.82 7799.5503 -29131.375)
-                             (-4884.0327 -739.594 20382.809)
-                             (-31391.57 -25366.535 -31634.615)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((42.73 -17.24 43.31)
-                                               (-16.12 -8.25 21.44)
-                                               (-49.08 -39.66 -49.46))))
-                               (S1 19.68))
-                           (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34803.82416d0 7799.550047999999d0
-                              -29131.375104000002d0)
-                             (-4884.032832000001d0 -739.5940799999992d0
-                              20382.808224d0)
-                             (-31391.568d0 -25366.535999999996d0
-                              -31634.616d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((42.73d0 -17.24d0 43.31d0)
-                                               (-16.12d0 -8.25d0 21.44d0)
-                                               (-49.08d0 -39.66d0 -49.46d0))))
-                               (S1 19.68d0))
-                           (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-66397.9 18986.908) #C(-56335.145 48514.305)
-                              #C(-18830.469 -13449.601))
-                             (#C(38337.09 -49128.918) #C(42681.344 -22972.445)
-                              #C(50375.406 -50562.54))
-                             (#C(42453.223 -42606.086)
-                              #C(-13764.868 -48835.813)
-                              #C(8910.526 -4389.117))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((42.73 -17.24 43.31 -16.12 -8.25
-                                                21.44)
-                                               (-16.12 -8.25 21.44 -49.08
-                                                -39.66 -49.46)
-                                               (-49.08 -39.66 -49.46 19.68
-                                                -5.55 -8.82))))
-                               (S1 #C(19.68 -5.55)))
-                           (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-66397.89753899998d0 18986.908142999997d0)
-                              #C(-56335.14258600001d0 48514.306278000004d0)
-                              #C(-18830.468709d0 -13449.603000000003d0))
-                             (#C(38337.08717099999d0 -49128.917505000005d0)
-                              #C(42681.34176d0 -22972.447481999992d0)
-                              #C(50375.404416000005d0 -50562.535017d0))
-                             (#C(42453.21956399999d0 -42606.08134200001d0)
-                              #C(-13764.866562000001d0 -48835.809623999994d0)
-                              #C(8910.526581d0 -4389.116526d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((42.73d0 -17.24d0 43.31d0
-                                                -16.12d0 -8.25d0 21.44d0)
-                                               (-16.12d0 -8.25d0 21.44d0
-                                                -49.08d0 -39.66d0 -49.46d0)
-                                               (-49.08d0 -39.66d0 -49.46d0
-                                                19.68d0 -5.55d0 -8.82d0))))
-                               (S1 #C(19.68d0 -5.55d0)))
-                           (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-1473.7527 -854.58527 1407.5751))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(42.73 -17.24 43.31)))
-                               (S1 -16.12))
-                           (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-1473.7527d0 -854.5853d0 1407.575d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(42.73d0 -17.24d0 43.31d0)))
-                               (S1 -16.12d0))
-                           (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-1483.223 1289.3523) #C(-57.63159 1675.6711)
-                           #C(-786.3365 -726.9331)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(42.73 -17.24 43.31 -16.12 -8.25
-                                               21.44)))
-                               (S1 #C(-16.12 -8.25)))
-                           (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-1483.2230999999997d0 1289.3523999999998d0)
-                           #C(-57.63160000000005d0 1675.6711000000003d0)
-                           #C(-786.3364000000001d0 -726.9331d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0)))
-                               (S1 #C(-16.12d0 -8.25d0)))
-                           (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34803.82 7799.5503 -29131.375)
+	(-4884.0327 -739.594 20382.809)
+	(-31391.57 -25366.535 -31634.615)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((42.73 -17.24 43.31)
+	      (-16.12 -8.25 21.44)
+	      (-49.08 -39.66 -49.46))))
+	  (S1 19.68))
+      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34803.82416d0 7799.550047999999d0 -29131.375104000002d0)
+	(-4884.032832000001d0 -739.5940799999992d0 20382.808224d0)
+	(-31391.568d0 -25366.535999999996d0 -31634.616d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((42.73d0 -17.24d0 43.31d0)
+	      (-16.12d0 -8.25d0 21.44d0)
+	      (-49.08d0 -39.66d0 -49.46d0))))
+	  (S1 19.68d0))
+      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-66397.9 18986.908) #C(-56335.145 48514.305) #C(-18830.469 -13449.601))
+	(#C(38337.09 -49128.918) #C(42681.344 -22972.445) #C(50375.406 -50562.54))
+	(#C(42453.223 -42606.086) #C(-13764.868 -48835.813) #C(8910.526 -4389.117))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))
+	      (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
+	      (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82)))))
+	  (S1 #C(19.68 -5.55)))
+      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-66397.89753899998d0 18986.908142999997d0)
+	   #C(-56335.14258600001d0 48514.306278000004d0)
+	   #C(-18830.468709d0 -13449.603000000003d0))
+	(#C(38337.08717099999d0 -49128.917505000005d0)
+	   #C(42681.34176d0 -22972.447481999992d0)
+	   #C(50375.404416000005d0 -50562.535017d0))
+	(#C(42453.21956399999d0 -42606.08134200001d0)
+	   #C(-13764.866562000001d0 -48835.809623999994d0)
+	   #C(8910.526581d0 -4389.116526d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))
+	      (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
+	      (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0)))))
+	  (S1 #C(19.68d0 -5.55d0)))
+      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-1473.7527 -854.58527 1407.5751))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '(42.73 -17.24 43.31)))
+	  (S1 -16.12))
+      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-1473.7527d0 -854.5853d0 1407.575d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '(42.73d0 -17.24d0 43.31d0)))
+	  (S1 -16.12d0))
+      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-1483.223 1289.3523) #C(-57.63159 1675.6711)
+      #C(-786.3365 -726.9331)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))))
+	  (S1 #C(-16.12 -8.25)))
+      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-1483.2230999999997d0 1289.3523999999998d0)
+      #C(-57.63160000000005d0 1675.6711000000003d0)
+      #C(-786.3364000000001d0 -726.9331d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))))
+	  (S1 #C(-16.12d0 -8.25d0)))
+      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1))))))
 
diff --git a/tests/matrix-product.lisp b/tests/matrix-product.lisp
index 9a214c34795c0272e2b38dd99159b93a4c40bf98..70ae43afe4b61dfbbc4a30f8f766a0f5d7880f3f 100644
--- a/tests/matrix-product.lisp
+++ b/tests/matrix-product.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-PRODUCT for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,231 +19,223 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((74519.41 -16747.695 61311.69)
-                             (27307.273 -6133.5903 -25711.75)
-                             (-29088.719 83072.016 -11019.719)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((42.73 -17.24 43.31)
-                                               (-16.12 -8.25 21.44)
-                                               (-49.08 -39.66 -49.46))))
-                               (M3
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((19.68 -5.55 -8.82)
-                                               (25.37 -30.58 31.67)
-                                               (29.36 -33.24 -27.03))))
-                               (S1 -41.67)
-                               (S2 42.0))
-                           (CL-ARRAY (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((74519.41329d0 -16747.696061999995d0
-                              61311.694176d0)
-                             (27307.276670999996d0 -6133.589574d0
-                              -25711.752344999997d0)
-                             (-29088.718053000033d0 83072.022741d0
-                              -11019.721527000016d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((42.73d0 -17.24d0 43.31d0)
-                                               (-16.12d0 -8.25d0 21.44d0)
-                                               (-49.08d0 -39.66d0 -49.46d0))))
-                               (M3
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((19.68d0 -5.55d0 -8.82d0)
-                                               (25.37d0 -30.58d0 31.67d0)
-                                               (29.36d0 -33.24d0 -27.03d0))))
-                               (S1 -41.67d0)
-                               (S2 42.0d0))
-                           (CL-ARRAY (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(140927.64 -143005.16) #C(72986.305 -201162.86)
-                              #C(65956.16 9034.215))
-                             (#C(-102500.125 118033.82) #C(-147775.0 58489.473)
-                              #C(-9582.236 190719.98))
-                             (#C(-16551.412 336505.22) #C(-7668.242 385798.25)
-                              #C(45313.527 140641.6))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((42.73 -17.24 43.31 -16.12 -8.25
-                                                21.44)
-                                               (-16.12 -8.25 21.44 -49.08
-                                                -39.66 -49.46)
-                                               (-49.08 -39.66 -49.46 19.68
-                                                -5.55 -8.82))))
-                               (M3
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((19.68 -5.55 -8.82 25.37 -30.58
-                                                31.67)
-                                               (25.37 -30.58 31.67 29.36 -33.24
-                                                -27.03)
-                                               (29.36 -33.24 -27.03 -41.67 42.0
-                                                -20.81))))
-                               (S1 #C(-41.67 42.0))
-                               (S2 #C(42.0 -20.81)))
-                           (CL-ARRAY (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(140927.638311d0 -143005.14965699997d0)
-                              #C(72986.314354d0 -201162.870342d0)
-                              #C(65956.156396d0 9034.212785d0))
-                             (#C(-102500.143082d0 118033.81826900001d0)
-                              #C(-147775.01365700003d0 58489.469011999994d0)
-                              #C(-9582.23530800004d0 190719.98257199998d0))
-                             (#C(-16551.43698600002d0 336505.21680500003d0)
-                              #C(-7668.248943000013d0 385798.22976300004d0)
-                              #C(45313.51313299998d0 140641.59851399998d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((42.73d0 -17.24d0 43.31d0
-                                                -16.12d0 -8.25d0 21.44d0)
-                                               (-16.12d0 -8.25d0 21.44d0
-                                                -49.08d0 -39.66d0 -49.46d0)
-                                               (-49.08d0 -39.66d0 -49.46d0
-                                                19.68d0 -5.55d0 -8.82d0))))
-                               (M3
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((19.68d0 -5.55d0 -8.82d0 25.37d0
-                                                -30.58d0 31.67d0)
-                                               (25.37d0 -30.58d0 31.67d0
-                                                29.36d0 -33.24d0 -27.03d0)
-                                               (29.36d0 -33.24d0 -27.03d0
-                                                -41.67d0 42.0d0 -20.81d0))))
-                               (S1 #C(-41.67d0 42.0d0))
-                               (S2 #C(42.0d0 -20.81d0)))
-                           (CL-ARRAY (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(72971.1 60998.137 -184676.98))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(42.73 -17.24 43.31)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-16.12 -8.25 21.44)))
-                               (S1 -49.08)
-                               (S2 -39.66))
-                           (CL-ARRAY (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(72971.10171599999d0 60998.13393599999d0
-                           -184676.981676d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(42.73d0 -17.24d0 43.31d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-16.12d0 -8.25d0 21.44d0)))
-                               (S1 -49.08d0)
-                               (S2 -39.66d0))
-                           (CL-ARRAY (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(124163.57 -3332.2988) #C(119793.48 -166378.0)
-                           #C(-189845.23 -81764.12)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(42.73 -17.24 43.31 -16.12 -8.25
-                                               21.44)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-16.12 -8.25 21.44 -49.08 -39.66
-                                               -49.46)))
-                               (S1 #C(-49.08 -39.66))
-                               (S2 #C(-39.66 -49.46)))
-                           (CL-ARRAY (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(124163.58013199999d0 -3332.2974459999896d0)
-                           #C(119793.47618999999d0 -166378.00423d0)
-                           #C(-189845.21679399998d0 -81764.10481799999d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-16.12d0 -8.25d0 21.44d0
-                                               -49.08d0 -39.66d0 -49.46d0)))
-                               (S1 #C(-49.08d0 -39.66d0))
-                               (S2 #C(-39.66d0 -49.46d0)))
-                           (CL-ARRAY (MATRIX-PRODUCT M1 V1 V2 S1 S2))))))
-
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((74519.41 -16747.695 61311.69)
+	(27307.273 -6133.5903 -25711.75)
+	(-29088.719 83072.016 -11019.719)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((42.73 -17.24 43.31)
+	      (-16.12 -8.25 21.44)
+	      (-49.08 -39.66 -49.46))))
+	  (M3
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((19.68 -5.55 -8.82)
+	      (25.37 -30.58 31.67)
+	      (29.36 -33.24 -27.03))))
+	  (S1 -41.67)
+	  (S2 42.0))
+      (CL-ARRAY (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((74519.41329d0 -16747.696061999995d0 61311.694176d0)
+	(27307.276670999996d0 -6133.589574d0 -25711.752344999997d0)
+	(-29088.718053000033d0 83072.022741d0 -11019.721527000016d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((42.73d0 -17.24d0 43.31d0)
+	      (-16.12d0 -8.25d0 21.44d0)
+	      (-49.08d0 -39.66d0 -49.46d0))))
+	  (M3
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((19.68d0 -5.55d0 -8.82d0)
+	      (25.37d0 -30.58d0 31.67d0)
+	      (29.36d0 -33.24d0 -27.03d0))))
+	  (S1 -41.67d0)
+	  (S2 42.0d0))
+      (CL-ARRAY (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(140927.64 -143005.16) #C(72986.305 -201162.86)
+	   #C(65956.16 9034.215))
+	(#C(-102500.125 118033.82) #C(-147775.0 58489.473)
+	   #C(-9582.236 190719.98))
+	(#C(-16551.412 336505.22) #C(-7668.242 385798.25)
+	   #C(45313.527 140641.6))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))
+	      (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
+	      (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82)))))
+	  (M3
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(19.68 -5.55) #C(-8.82 25.37) #C(-30.58 31.67))
+	      (#C(25.37 -30.58) #C(31.67 29.36) #C(-33.24 -27.03))
+	      (#C(29.36 -33.24) #C(-27.03 -41.67) #C(42.0 -20.81)))))
+	  (S1 #C(-41.67 42.0))
+	  (S2 #C(42.0 -20.81)))
+      (CL-ARRAY (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(140927.638311d0 -143005.14965699997d0)
+	   #C(72986.314354d0 -201162.870342d0)
+	   #C(65956.156396d0 9034.212785d0))
+	(#C(-102500.143082d0 118033.81826900001d0)
+	   #C(-147775.01365700003d0 58489.469011999994d0)
+	   #C(-9582.23530800004d0 190719.98257199998d0))
+	(#C(-16551.43698600002d0 336505.21680500003d0)
+	   #C(-7668.248943000013d0 385798.22976300004d0)
+	   #C(45313.51313299998d0 140641.59851399998d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))
+	      (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
+	      (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0)))))
+	  (M3
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(19.68d0 -5.55d0) #C(-8.82d0 25.37d0) #C(-30.58d0 31.67d0))
+	      (#C(25.37d0 -30.58d0) #C(31.67d0 29.36d0) #C(-33.24d0 -27.03d0))
+	      (#C(29.36d0 -33.24d0) #C(-27.03d0 -41.67d0) #C(42.0d0 -20.81d0)))))
+	  (S1 #C(-41.67d0 42.0d0))
+	  (S2 #C(42.0d0 -20.81d0)))
+      (CL-ARRAY (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(72971.1 60998.137 -184676.98))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '(42.73 -17.24 43.31)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '(-16.12 -8.25 21.44)))
+	  (S1 -49.08)
+	  (S2 -39.66))
+      (CL-ARRAY (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(72971.10171599999d0 60998.13393599999d0
+      -184676.981676d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '(42.73d0 -17.24d0 43.31d0)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '(-16.12d0 -8.25d0 21.44d0)))
+	  (S1 -49.08d0)
+	  (S2 -39.66d0))
+      (CL-ARRAY (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(124163.57 -3332.2988) #C(119793.48 -166378.0)
+      #C(-189845.23 -81764.12)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))))
+	  (S1 #C(-49.08 -39.66))
+	  (S2 #C(-39.66 -49.46)))
+      (CL-ARRAY (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(124163.58013199999d0 -3332.2974459999896d0)
+      #C(119793.47618999999d0 -166378.00423d0)
+      #C(-189845.21679399998d0 -81764.10481799999d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))))
+	  (S1 #C(-49.08d0 -39.66d0))
+	  (S2 #C(-39.66d0 -49.46d0)))
+      (CL-ARRAY (MATRIX-PRODUCT M1 V1 V2 S1 S2))))))
diff --git a/tests/matrix-set-zero.lisp b/tests/matrix-set-zero.lisp
index 68d4ae5f367de416b62818d25627988b525e8835..be65d0f30b5e67e5be964e30743fdf0f21457948 100644
--- a/tests/matrix-set-zero.lisp
+++ b/tests/matrix-set-zero.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-SET-ZERO for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,143 +19,143 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-SET-ZERO
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((0.0 0.0 0.0) (0.0 0.0 0.0) (0.0 0.0 0.0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5)))))
-                           (SET-ZERO M1)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((0.0d0 0.0d0 0.0d0)
-                             (0.0d0 0.0d0 0.0d0)
-                             (0.0d0 0.0d0 0.0d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0)))))
-                           (SET-ZERO M1)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0))
-                             (#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0))
-                             (#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31)))))
-                           (SET-ZERO M1)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0))
-                             (#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0))
-                             (#C(0.0d0 0.0d0) #C(0.0d0 0.0d0)
-                              #C(0.0d0 0.0d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0)))))
-                           (SET-ZERO M1)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (SET-ZERO M1)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (SET-ZERO M1)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (SET-ZERO M1)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (SET-ZERO M1)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (SET-ZERO M1)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (SET-ZERO M1)
-                           (CL-ARRAY M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((0.0 0.0 0.0) (0.0 0.0 0.0) (0.0 0.0 0.0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5)))))
+      (SET-ZERO M1)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((0.0d0 0.0d0 0.0d0)
+	(0.0d0 0.0d0 0.0d0)
+	(0.0d0 0.0d0 0.0d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0)))))
+      (SET-ZERO M1)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0))
+	(#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0))
+	(#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
+      (SET-ZERO M1)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0))
+	(#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0))
+	(#C(0.0d0 0.0d0) #C(0.0d0 0.0d0)
+	   #C(0.0d0 0.0d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))))
+      (SET-ZERO M1)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (SET-ZERO M1)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140)
+	      (161 215 98)))))
+      (SET-ZERO M1)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10)
+	      (73 -5 123)))))
+      (SET-ZERO M1)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (SET-ZERO M1)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (SET-ZERO M1)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (SET-ZERO M1)
+      (CL-ARRAY M1)))))
 
diff --git a/tests/matrix-swap.lisp b/tests/matrix-swap.lisp
index 861f586767a12b880a8b62a66c838903f4e4670a..266c16b3b93ab887115542046deb93dcaae69e45 100644
--- a/tests/matrix-swap.lisp
+++ b/tests/matrix-swap.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-SWAP for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,254 +19,241 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-SWAP
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST
-                          #2A((42.73 -17.24 43.31)
-                              (-16.12 -8.25 21.44)
-                              (-49.08 -39.66 -49.46))
-                          #2A((-34.5 8.24 3.29)
-                              (-8.93 34.12 -6.15)
-                              (49.27 -13.49 32.5))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((42.73 -17.24 43.31)
-                                               (-16.12 -8.25 21.44)
-                                               (-49.08 -39.66 -49.46)))))
-                           (SWAP M2 M1)
-                           (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST
-                          #2A((42.73d0 -17.24d0 43.31d0)
-                              (-16.12d0 -8.25d0 21.44d0)
-                              (-49.08d0 -39.66d0 -49.46d0))
-                          #2A((-34.5d0 8.24d0 3.29d0)
-                              (-8.93d0 34.12d0 -6.15d0)
-                              (49.27d0 -13.49d0 32.5d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((42.73d0 -17.24d0 43.31d0)
-                                               (-16.12d0 -8.25d0 21.44d0)
-                                               (-49.08d0 -39.66d0 -49.46d0)))))
-                           (SWAP M2 M1)
-                           (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST
-                          #2A((#C(42.73 -17.24) #C(43.31 -16.12)
-                               #C(-8.25 21.44))
-                              (#C(-16.12 -8.25) #C(21.44 -49.08)
-                               #C(-39.66 -49.46))
-                              (#C(-49.08 -39.66) #C(-49.46 19.68)
-                               #C(-5.55 -8.82)))
-                          #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-                              (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-                              (#C(49.27 -13.49) #C(32.5 42.73)
-                               #C(-17.24 43.31)))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((42.73 -17.24 43.31 -16.12 -8.25
-                                                21.44)
-                                               (-16.12 -8.25 21.44 -49.08
-                                                -39.66 -49.46)
-                                               (-49.08 -39.66 -49.46 19.68
-                                                -5.55 -8.82)))))
-                           (SWAP M2 M1)
-                           (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST
-                          #2A((#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0)
-                               #C(-8.25d0 21.44d0))
-                              (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)
-                               #C(-39.66d0 -49.46d0))
-                              (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0)
-                               #C(-5.55d0 -8.82d0)))
-                          #2A((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
-                               #C(34.12d0 -6.15d0))
-                              (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0)
-                               #C(-13.49d0 32.5d0))
-                              (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0)
-                               #C(-17.24d0 43.31d0)))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((42.73d0 -17.24d0 43.31d0
-                                                -16.12d0 -8.25d0 21.44d0)
-                                               (-16.12d0 -8.25d0 21.44d0
-                                                -49.08d0 -39.66d0 -49.46d0)
-                                               (-49.08d0 -39.66d0 -49.46d0
-                                                19.68d0 -5.55d0 -8.82d0)))))
-                           (SWAP M2 M1)
-                           (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68))
-                               #2A((-64 -68 71) (-91 52 -10) (73 -5 123))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((32 28 30) (37 -73 -8)
-                                               (-15 -22 68)))))
-                           (SWAP M2 M1)
-                           (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST #2A((28 10 19) (28 178 217) (36 109 222))
-                               #2A((67 44 189) (116 163 140) (161 215 98))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((28 10 19) (28 178 217)
-                                               (36 109 222)))))
-                           (SWAP M2 M1)
-                           (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68))
-                               #2A((-64 -68 71) (-91 52 -10) (73 -5 123))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((32 28 30) (37 -73 -8)
-                                               (-15 -22 68)))))
-                           (SWAP M2 M1)
-                           (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST #2A((28 10 19) (28 178 217) (36 109 222))
-                               #2A((67 44 189) (116 163 140) (161 215 98))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((28 10 19) (28 178 217)
-                                               (36 109 222)))))
-                           (SWAP M2 M1)
-                           (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68))
-                               #2A((-64 -68 71) (-91 52 -10) (73 -5 123))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((32 28 30) (37 -73 -8)
-                                               (-15 -22 68)))))
-                           (SWAP M2 M1)
-                           (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST #2A((28 10 19) (28 178 217) (36 109 222))
-                               #2A((67 44 189) (116 163 140) (161 215 98))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((28 10 19) (28 178 217)
-                                               (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))
-                               #2A((-64 -68 71) (-91 52 -10) (73 -5 123))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((32 28 30) (37 -73 -8)
-                                               (-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))
-                               #2A((67 44 189) (116 163 140) (161 215 98))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((28 10 19) (28 178 217)
-                                               (36 109 222)))))
-                           (SWAP M2 M1)
-                           (LIST (CL-ARRAY M1) (CL-ARRAY M2))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST
+     #2A((42.73 -17.24 43.31)
+	 (-16.12 -8.25 21.44)
+	 (-49.08 -39.66 -49.46))
+     #2A((-34.5 8.24 3.29)
+	 (-8.93 34.12 -6.15)
+	 (49.27 -13.49 32.5))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((42.73 -17.24 43.31)
+	      (-16.12 -8.25 21.44)
+	      (-49.08 -39.66 -49.46)))))
+      (SWAP M2 M1)
+      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST
+     #2A((42.73d0 -17.24d0 43.31d0)
+	 (-16.12d0 -8.25d0 21.44d0)
+	 (-49.08d0 -39.66d0 -49.46d0))
+     #2A((-34.5d0 8.24d0 3.29d0)
+	 (-8.93d0 34.12d0 -6.15d0)
+	 (49.27d0 -13.49d0 32.5d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((42.73d0 -17.24d0 43.31d0)
+	      (-16.12d0 -8.25d0 21.44d0)
+	      (-49.08d0 -39.66d0 -49.46d0)))))
+      (SWAP M2 M1)
+      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST
+     #2A((#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))
+	 (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
+	 (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82)))
+     #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	 (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	 (#C(49.27 -13.49) #C(32.5 42.73)
+	    #C(-17.24 43.31)))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))
+	      (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
+	      (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82))))))
+      (SWAP M2 M1)
+      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST
+     #2A((#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))
+	 (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
+	 (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0)))
+     #2A((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	 (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	 (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))
+	      (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
+	      (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0))))))
+      (SWAP M2 M1)
+      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68))
+	  #2A((-64 -68 71) (-91 52 -10) (73 -5 123))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				    '((-64 -68 71) (-91 52 -10)
+				      (73 -5 123))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				    '((32 28 30) (37 -73 -8)
+				      (-15 -22 68)))))
+      (SWAP M2 M1)
+      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST #2A((28 10 19) (28 178 217) (36 109 222))
+	  #2A((67 44 189) (116 163 140) (161 215 98))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				    :INITIAL-CONTENTS
+				    '((67 44 189) (116 163 140)
+				      (161 215 98))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				    :INITIAL-CONTENTS
+				    '((28 10 19) (28 178 217)
+				      (36 109 222)))))
+      (SWAP M2 M1)
+      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68))
+	  #2A((-64 -68 71) (-91 52 -10) (73 -5 123))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				    :INITIAL-CONTENTS
+				    '((-64 -68 71) (-91 52 -10)
+				      (73 -5 123))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				    :INITIAL-CONTENTS
+				    '((32 28 30) (37 -73 -8)
+				      (-15 -22 68)))))
+      (SWAP M2 M1)
+      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST #2A((28 10 19) (28 178 217) (36 109 222))
+	  #2A((67 44 189) (116 163 140) (161 215 98))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				    :INITIAL-CONTENTS
+				    '((67 44 189) (116 163 140)
+				      (161 215 98))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				    :INITIAL-CONTENTS
+				    '((28 10 19) (28 178 217)
+				      (36 109 222)))))
+      (SWAP M2 M1)
+      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68))
+	  #2A((-64 -68 71) (-91 52 -10) (73 -5 123))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				    :INITIAL-CONTENTS
+				    '((-64 -68 71) (-91 52 -10)
+				      (73 -5 123))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				    :INITIAL-CONTENTS
+				    '((32 28 30) (37 -73 -8)
+				      (-15 -22 68)))))
+      (SWAP M2 M1)
+      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST #2A((28 10 19) (28 178 217) (36 109 222))
+	  #2A((67 44 189) (116 163 140) (161 215 98))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				    :INITIAL-CONTENTS
+				    '((67 44 189) (116 163 140)
+				      (161 215 98))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				    :INITIAL-CONTENTS
+				    '((28 10 19) (28 178 217)
+				      (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))
+	  #2A((-64 -68 71) (-91 52 -10) (73 -5 123))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				    :INITIAL-CONTENTS
+				    '((-64 -68 71) (-91 52 -10)
+				      (73 -5 123))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				    :INITIAL-CONTENTS
+				    '((32 28 30) (37 -73 -8)
+				      (-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))
+	  #2A((67 44 189) (116 163 140) (161 215 98))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				    :INITIAL-CONTENTS
+				    '((67 44 189) (116 163 140)
+				      (161 215 98))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				    :INITIAL-CONTENTS
+				    '((28 10 19) (28 178 217)
+				      (36 109 222)))))
+      (SWAP M2 M1)
+      (LIST (CL-ARRAY M1) (CL-ARRAY M2))))))
 
diff --git a/tests/matrix-transpose-copy.lisp b/tests/matrix-transpose-copy.lisp
index b85169be412e655d03b2607b060c121529d877da..681db8c31e505969f89c3a9d1d166f24956459f9 100644
--- a/tests/matrix-transpose-copy.lisp
+++ b/tests/matrix-transpose-copy.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-TRANSPOSE for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,171 +19,157 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-TRANSPOSE
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5 -8.93 49.27)
-                             (8.24 34.12 -13.49)
-                             (3.29 -6.15 32.5)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(3 3))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5d0 -8.93d0 49.27d0)
-                             (8.24d0 34.12d0 -13.49d0)
-                             (3.29d0 -6.15d0 32.5d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(3 3))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-34.5 8.24) #C(-8.93 34.12) #C(49.27 -13.49))
-                             (#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73))
-                             (#C(34.12 -6.15) #C(-13.49 32.5)
-                              #C(-17.24 43.31))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :DIMENSIONS '(3 3))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-34.5d0 8.24d0) #C(-8.93d0 34.12d0)
-                              #C(49.27d0 -13.49d0))
-                             (#C(3.29d0 -8.93d0) #C(-6.15d0 49.27d0)
-                              #C(32.5d0 42.73d0))
-                             (#C(34.12d0 -6.15d0) #C(-13.49d0 32.5d0)
-                              #C(-17.24d0 43.31d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :DIMENSIONS '(3 3))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS
-                                             '(3 3))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS
-                                             '(3 3))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS
-                                             '(3 3))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS
-                                             '(3 3))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS
-                                             '(3 3))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
-                                             '(3 3))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS
-                                             '(3 3))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS
-                                             '(3 3))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE M1 M2))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5 -8.93 49.27)
+	(8.24 34.12 -13.49)
+	(3.29 -6.15 32.5)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(3 3))))
+      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5d0 -8.93d0 49.27d0)
+	(8.24d0 34.12d0 -13.49d0)
+	(3.29d0 -6.15d0 32.5d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(3 3))))
+      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-34.5 8.24) #C(-8.93 34.12) #C(49.27 -13.49))
+	(#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73))
+	(#C(34.12 -6.15) #C(-13.49 32.5) #C(-17.24 43.31))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '(3 3))))
+      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-34.5d0 8.24d0) #C(-8.93d0 34.12d0) #C(49.27d0 -13.49d0))
+	(#C(3.29d0 -8.93d0) #C(-6.15d0 49.27d0) #C(32.5d0 42.73d0))
+	(#C(34.12d0 -6.15d0) #C(-13.49d0 32.5d0) #C(-17.24d0 43.31d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT) :DIMENSIONS '(3 3))))
+      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS '(3 3))))
+      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8) :DIMENSIONS '(3 3))))
+      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS '(3 3))))
+      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS '(3 3))))
+      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS
+				    '(3 3))))
+      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140)
+	      (161 215 98))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS '(3 3))))
+      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-1 52 -10) (73 -5 123))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS '(3 3))))
+      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				    :INITIAL-CONTENTS
+				    '((67 44 189) (116 163 140) (161 215 98))))
+	  (M2
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS '(3 3))))
+      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2))))))
 
diff --git a/tests/matrix-transpose.lisp b/tests/matrix-transpose.lisp
index b5b8f4658bf0288e6ee6f9f54ff89406bd0caf20..906f07d840d88cdd47035c698184877a15971f58 100644
--- a/tests/matrix-transpose.lisp
+++ b/tests/matrix-transpose.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-TRANSPOSE for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,137 +19,135 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-TRANSPOSE*
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5 -8.93 49.27)
-                             (8.24 34.12 -13.49)
-                             (3.29 -6.15 32.5)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5)))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5d0 -8.93d0 49.27d0)
-                             (8.24d0 34.12d0 -13.49d0)
-                             (3.29d0 -6.15d0 32.5d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0)))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-34.5 8.24) #C(-8.93 34.12) #C(49.27 -13.49))
-                             (#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73))
-                             (#C(34.12 -6.15) #C(-13.49 32.5)
-                              #C(-17.24 43.31))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31)))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-34.5d0 8.24d0) #C(-8.93d0 34.12d0)
-                              #C(49.27d0 -13.49d0))
-                             (#C(3.29d0 -8.93d0) #C(-6.15d0 49.27d0)
-                              #C(32.5d0 42.73d0))
-                             (#C(34.12d0 -6.15d0) #C(-13.49d0 32.5d0)
-                              #C(-17.24d0 43.31d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0)))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (MATRIX-TRANSPOSE* M1))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5 -8.93 49.27)
+	(8.24 34.12 -13.49)
+	(3.29 -6.15 32.5)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5)))))
+      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5d0 -8.93d0 49.27d0)
+	(8.24d0 34.12d0 -13.49d0)
+	(3.29d0 -6.15d0 32.5d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0)))))
+      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-34.5 8.24) #C(-8.93 34.12) #C(49.27 -13.49))
+	(#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73))
+	(#C(34.12 -6.15) #C(-13.49 32.5)
+	   #C(-17.24 43.31))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
+      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-34.5d0 8.24d0) #C(-8.93d0 34.12d0)
+	   #C(49.27d0 -13.49d0))
+	(#C(3.29d0 -8.93d0) #C(-6.15d0 49.27d0)
+	   #C(32.5d0 42.73d0))
+	(#C(34.12d0 -6.15d0) #C(-13.49d0 32.5d0)
+	   #C(-17.24d0 43.31d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))))
+      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((-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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (MATRIX-TRANSPOSE* M1))))))
 
diff --git a/tests/row.lisp b/tests/row.lisp
index 3f3cf1f44cfd6f3f4f293455626ffa688624737b..c04c514a8d1e6db3807442b6b2e38f044d02c0e8 100644
--- a/tests/row.lisp
+++ b/tests/row.lisp
@@ -1,6 +1,6 @@
 ;; Regression test ROW for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,237 +19,160 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST ROW
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-8.93 34.12 -6.15))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (ROW (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
-                           (CL-ARRAY (ROW M1 1 ROW)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-8.93d0 34.12d0 -6.15d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (ROW (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
-                           (CL-ARRAY (ROW M1 1 ROW)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :DIMENSIONS '3)))
-                           (CL-ARRAY (ROW M1 1 ROW)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0)
-                           #C(-13.49d0 32.5d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :DIMENSIONS '3)))
-                           (CL-ARRAY (ROW M1 1 ROW)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 52 -10))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123))))
-                                                                 (ROW
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (ROW M1
-                                                                   1 ROW)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(116 163 140))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98))))
-                                                                 (ROW
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (ROW M1
-                                                                   1 ROW)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 52 -10))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123))))
-                                                                 (ROW
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (ROW M1
-                                                                   1 ROW)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(116 163 140))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98))))
-                                                                 (ROW
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (ROW M1
-                                                                   1 ROW)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 52 -10))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123))))
-                                                                 (ROW
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (ROW M1
-                                                                   1 ROW)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(116 163 140))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98))))
-                                                                 (ROW
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (ROW M1
-                                                                   1 ROW)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 52 -10))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123))))
-                                                                 (ROW
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (ROW M1
-                                                                   1 ROW)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(116 163 140))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98))))
-                                                                 (ROW
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :DIMENSIONS
-                                                                   '3)))
-                                                             (CL-ARRAY
-                                                              (ROW M1
-                                                                   1 ROW))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-8.93 34.12 -6.15))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5))))
+	  (ROW (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
+      (CL-ARRAY (ROW M1 1 ROW)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-8.93d0 34.12d0 -6.15d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0))))
+	  (ROW (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
+      (CL-ARRAY (ROW M1 1 ROW)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3)))
+      (CL-ARRAY (ROW M1 1 ROW)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0)
+      #C(-13.49d0 32.5d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT) :DIMENSIONS '3)))
+      (CL-ARRAY (ROW M1 1 ROW)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-91 52 -10))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTETS
+	    '((-64 -68 71)
+	      (-91 52 -10)
+	      (73 -5 123))))
+	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS '3)))
+      (CL-ARRAY
+       (ROW M1
+	    1 ROW)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(116 163 140))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((67 44 189)
+	      (116 163 140)
+	      (161 215 98))))
+	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS '3)))
+      (CL-ARRAY (ROW M1 1 ROW)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-91 52 -10))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71)
+	      (-91 52 -10)
+	      (73 -5 123))))
+	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS '3)))
+      (CL-ARRAY
+       (ROW M1
+	    1 ROW)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(116 163 140))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((67 44 189)
+	      (116 163 140)
+	      (161 215 98))))
+	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS '3)))
+      (CL-ARRAY (ROW M1 1 ROW)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-91 52 -10))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTETS
+	    '((-64 -68 71)
+	      (-91 52 -10)
+	      (73 -5 123))))
+	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS '3)))
+      (CL-ARRAY (ROW M1 1 ROW)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(116 163 140))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((67 44 189)
+	      (116 163 140)
+	      (161 215 98))))
+	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS '3)))
+      (CL-ARRAY (ROW M1 1 ROW)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-91 52 -10))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71)
+	      (-91 52 -10)
+	      (73 -5 123))))
+	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS '3)))
+      (CL-ARRAY (ROW M1 1 ROW)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(116 163 140))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((67 44 189)
+	      (116 163 140)
+	      (161 215 98))))
+	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS '3)))
+      (CL-ARRAY (ROW M1 1 ROW))))))
 
diff --git a/tests/scale.lisp b/tests/scale.lisp
index 44aac3345c088dd131b45952d41fdbd1ef8d226e..5b071308ebc395d4e4e92480a34d5aa59090ae77 100644
--- a/tests/scale.lisp
+++ b/tests/scale.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SCALE for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,102 +19,100 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SCALE
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-1121.25 267.8) #C(106.924995 -290.225)
-                           #C(1108.9 -199.875) #C(1601.275 -438.425)
-                           #C(1056.25 1388.725) #C(-560.3 1407.5751)
-                           #C(-523.9 -268.125) #C(696.8 -1595.1001)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49 32.5 42.73
-                                               -17.24 43.31 -16.12 -8.25 21.44
-                                               -49.08)))
-                               (SCALAR 32.5))
-                           (CL-ARRAY (SCALE SCALAR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-1121.25d0 267.8d0)
-                           #C(106.925d0 -290.22499999999997d0)
-                           #C(1108.8999999999999d0 -199.875d0)
-                           #C(1601.275d0 -438.425d0) #C(1056.25d0 1388.725d0)
-                           #C(-560.3d0 1407.575d0) #C(-523.9d0 -268.125d0)
-                           #C(696.8000000000001d0 -1595.1d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0 -13.49d0
-                                               32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0)))
-                               (SCALAR 32.5d0))
-                           (CL-ARRAY (SCALE SCALAR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-1121.25 267.8 106.924995 -290.225 1108.9 -199.875
-                           1601.275 -438.425))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49)))
-                               (SCALAR 32.5))
-                           (CL-ARRAY (SCALE SCALAR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-1121.25d0 267.8d0 106.925d0 -290.22499999999997d0
-                           1108.8999999999999d0 -199.875d0 1601.275d0
-                           -438.425d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0)))
-                               (SCALAR 32.5d0))
-                           (CL-ARRAY (SCALE SCALAR V1)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-1473.3452 -1206.385) #C(488.5039 -149.64331)
-                           #C(1371.6895 1258.0725) #C(2177.7026 1666.8821)
-                           #C(-769.6029 2777.45) #C(-2410.9363 670.9099)
-                           #C(-171.37753 -956.9326) #C(2793.9885 -678.9689)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49 32.5 42.73
-                                               -17.24 43.31 -16.12 -8.25 21.44
-                                               -49.08)))
-                               (SCALAR #C(32.5 42.73)))
-                           (CL-ARRAY (SCALE SCALAR V1)))))
-		       #+fsbv
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-1473.3452d0 -1206.385d0)
-                           #C(488.5039d0 -149.64329999999998d0)
-                           #C(1371.6895d0 1258.0725999999997d0)
-                           #C(2177.7027d0 1666.8821d0)
-                           #C(-769.6028999999996d0 2777.45d0)
-                           #C(-2410.9363d0 670.9098000000001d0)
-                           #C(-171.3775d0 -956.9326d0)
-                           #C(2793.9883999999997d0 -678.9687999999999d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0 -13.49d0
-                                               32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0)))
-                               (SCALAR #C(32.5d0 42.73d0)))
-                           (CL-ARRAY (SCALE SCALAR V1))))))
-
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-1121.25 267.8) #C(106.924995 -290.225)
+      #C(1108.9 -199.875) #C(1601.275 -438.425)
+      #C(1056.25 1388.725) #C(-560.3 1407.5751)
+      #C(-523.9 -268.125) #C(696.8 -1595.1001)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(-34.5 8.24 3.29 -8.93 34.12
+	      -6.15 49.27 -13.49 32.5 42.73
+	      -17.24 43.31 -16.12 -8.25 21.44
+	      -49.08)))
+	  (SCALAR 32.5))
+      (CL-ARRAY (SCALE SCALAR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-1121.25d0 267.8d0)
+      #C(106.925d0 -290.22499999999997d0)
+      #C(1108.8999999999999d0 -199.875d0)
+      #C(1601.275d0 -438.425d0) #C(1056.25d0 1388.725d0)
+      #C(-560.3d0 1407.575d0) #C(-523.9d0 -268.125d0)
+      #C(696.8000000000001d0 -1595.1d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0)
+	      #C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0))))
+	  (SCALAR 32.5d0))
+      (CL-ARRAY (SCALE SCALAR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-1121.25 267.8 106.924995 -290.225 1108.9 -199.875 1601.275 -438.425))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) #C(49.27 -13.49))))
+	  (SCALAR 32.5))
+      (CL-ARRAY (SCALE SCALAR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(-1121.25d0 267.8d0 106.925d0 -290.22499999999997d0
+      1108.8999999999999d0 -199.875d0 1601.275d0
+      -438.425d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+	      #C(34.12d0 -6.15d0) #C(49.27d0 -13.49d0))))
+	  (SCALAR 32.5d0))
+      (CL-ARRAY (SCALE SCALAR V1)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-1473.3452 -1206.385) #C(488.5039 -149.64331)
+      #C(1371.6895 1258.0725) #C(2177.7026 1666.8821)
+      #C(-769.6029 2777.45) #C(-2410.9363 670.9099)
+      #C(-171.37753 -956.9326) #C(2793.9885 -678.9689)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)
+	      #C(49.27 -13.49) #C(32.5 42.73)
+	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))
+	  (SCALAR #C(32.5 42.73)))
+      (CL-ARRAY (SCALE SCALAR V1)))))
+  #+fsbv
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-1473.3452d0 -1206.385d0)
+      #C(488.5039d0 -149.64329999999998d0)
+      #C(1371.6895d0 1258.0725999999997d0)
+      #C(2177.7027d0 1666.8821d0)
+      #C(-769.6028999999996d0 2777.45d0)
+      #C(-2410.9363d0 670.9098000000001d0)
+      #C(-171.3775d0 -956.9326d0)
+      #C(2793.9883999999997d0 -678.9687999999999d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+	      #C(34.12d0 -6.15d0) #C(49.27d0 -13.49d0)
+	      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0))))
+	  (SCALAR #C(32.5d0 42.73d0)))
+      (CL-ARRAY (SCALE SCALAR V1))))))
diff --git a/tests/set-basis.lisp b/tests/set-basis.lisp
index c79be7f7270b76a403107ca8609476c8124bc92e..7e09aa7fb311d38c73bbd1548ad652d6322e4058 100644
--- a/tests/set-basis.lisp
+++ b/tests/set-basis.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SET-BASIS for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,127 +19,136 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SET-BASIS
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49))))
-                           (SET-BASIS V1 2)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(0.0d0 0.0d0 1.0d0 0.0d0 0.0d0 0.0d0 0.0d0 0.0d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0))))
-                           (SET-BASIS V1 2)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(0.0 0.0) #C(0.0 0.0) #C(1.0 0.0) #C(0.0 0.0)
-                           #C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49 32.5 42.73
-                                               -17.24 43.31 -16.12 -8.25 21.44
-                                               -49.08))))
-                           (SET-BASIS V1 2)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(1.0d0 0.0d0)
-                           #C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0)
-                           #C(0.0d0 0.0d0) #C(0.0d0 0.0d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0 -13.49d0
-                                               32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0))))
-                           (SET-BASIS V1 2)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(0 0 1 0 0 0 0 0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SET-BASIS V1 2)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(0 0 1 0 0 0 0 0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SET-BASIS V1 2)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(0 0 1 0 0 0 0 0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SET-BASIS V1 2)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(0 0 1 0 0 0 0 0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SET-BASIS V1 2)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(0 0 1 0 0 0 0 0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SET-BASIS V1 2)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(0 0 1 0 0 0 0 0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(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
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-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
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SET-BASIS V1 2)
-                           (CL-ARRAY V1)))))
-
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
+      (SET-BASIS V1 2)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(0.0d0 0.0d0 1.0d0 0.0d0 0.0d0 0.0d0 0.0d0 0.0d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+      (SET-BASIS V1 2)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(0.0 0.0) #C(0.0 0.0) #C(1.0 0.0) #C(0.0 0.0)
+      #C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93)
+	      #C(34.12 -6.15) #C(49.27 -13.49) #C(32.5 42.73)
+	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
+      (SET-BASIS V1 2)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(1.0d0 0.0d0)
+      #C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0)
+      #C(0.0d0 0.0d0) #C(0.0d0 0.0d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+	      #C(34.12d0 -6.15d0) #C(49.27d0 -13.49d0)
+	      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)))))
+      (SET-BASIS V1 2)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 1 0 0 0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '(-64 -68 71 -91 52 -10 73 -5))))
+      (SET-BASIS V1 2)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 1 0 0 0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '(67 44 189 116 163 140 161 215))))
+      (SET-BASIS V1 2)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 1 0 0 0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '(-64 -68 71 -91 52 -10 73 -5))))
+      (SET-BASIS V1 2)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 1 0 0 0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '(67 44 189 116 163 140 161 215))))
+      (SET-BASIS V1 2)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 1 0 0 0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '(-64 -68 71 -91 52 -10 73 -5))))
+      (SET-BASIS V1 2)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 1 0 0 0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '(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
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '(-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
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '(67 44 189 116 163 140 161 215))))
+      (SET-BASIS V1 2)
+      (CL-ARRAY V1)))))
diff --git a/tests/set-identity.lisp b/tests/set-identity.lisp
index 0b2819436d475b8b2e70bb282c6b002d7447bb21..496b3c5c7af20a8acae2f48dfbb882bc419e9dba 100644
--- a/tests/set-identity.lisp
+++ b/tests/set-identity.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SET-IDENTITY for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,131 +19,132 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SET-IDENTITY
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((1.0 0.0 0.0) (0.0 1.0 0.0) (0.0 0.0 1.0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5)))))
-                           (CL-ARRAY (SET-IDENTITY M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((1.0d0 0.0d0 0.0d0)
-                             (0.0d0 1.0d0 0.0d0)
-                             (0.0d0 0.0d0 1.0d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0)))))
-                           (CL-ARRAY (SET-IDENTITY M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(1.0 0.0) #C(0.0 0.0) #C(0.0 0.0))
-                             (#C(0.0 0.0) #C(1.0 0.0) #C(0.0 0.0))
-                             (#C(0.0 0.0) #C(0.0 0.0) #C(1.0 0.0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31)))))
-                           (CL-ARRAY (SET-IDENTITY M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(1.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0))
-                             (#C(0.0d0 0.0d0) #C(1.0d0 0.0d0) #C(0.0d0 0.0d0))
-                             (#C(0.0d0 0.0d0) #C(0.0d0 0.0d0)
-                              #C(1.0d0 0.0d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0)))))
-                           (CL-ARRAY (SET-IDENTITY M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (SET-IDENTITY M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (SET-IDENTITY M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (SET-IDENTITY M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (SET-IDENTITY M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (SET-IDENTITY M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (SET-IDENTITY M1))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((1.0 0.0 0.0) (0.0 1.0 0.0) (0.0 0.0 1.0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5)))))
+      (CL-ARRAY (SET-IDENTITY M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((1.0d0 0.0d0 0.0d0)
+	(0.0d0 1.0d0 0.0d0)
+	(0.0d0 0.0d0 1.0d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0)))))
+      (CL-ARRAY (SET-IDENTITY M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(1.0 0.0) #C(0.0 0.0) #C(0.0 0.0))
+	(#C(0.0 0.0) #C(1.0 0.0) #C(0.0 0.0))
+	(#C(0.0 0.0) #C(0.0 0.0) #C(1.0 0.0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
+      (CL-ARRAY (SET-IDENTITY M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(1.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0))
+	(#C(0.0d0 0.0d0) #C(1.0d0 0.0d0) #C(0.0d0 0.0d0))
+	(#C(0.0d0 0.0d0) #C(0.0d0 0.0d0)
+	   #C(1.0d0 0.0d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))))
+      (CL-ARRAY (SET-IDENTITY M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (SET-IDENTITY M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (SET-IDENTITY M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (SET-IDENTITY M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (SET-IDENTITY M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (SET-IDENTITY M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((-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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (SET-IDENTITY M1))))))
 
diff --git a/tests/setf-column.lisp b/tests/setf-column.lisp
index 68b7dd4ebab5d14238f881eb9c309ca14c0f1309..d1f13c2c91c3b47b6b89995f961b0bb00c175f03 100644
--- a/tests/setf-column.lisp
+++ b/tests/setf-column.lisp
@@ -19,189 +19,186 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SETF-COLUMN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5 8.24 42.73)
-                             (-8.93 34.12 -17.24)
-                             (49.27 -13.49 43.31)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(42.73 -17.24 43.31))))
-                           (SETF (COLUMN M1 2) COL)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5d0 8.24d0 42.73d0)
-                             (-8.93d0 34.12d0 -17.24d0)
-                             (49.27d0 -13.49d0 43.31d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(42.73d0 -17.24d0 43.31d0))))
-                           (SETF (COLUMN M1 2) COL)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(42.73 -17.24))
-                             (#C(-8.93 34.12) #C(-6.15 49.27) #C(43.31 -16.12))
-                             (#C(49.27 -13.49) #C(32.5 42.73)
-                              #C(-8.25 21.44))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(42.73 -17.24 43.31 -16.12 -8.25
-                                               21.44))))
-                           (SETF (COLUMN M1 2) COL)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
-                              #C(42.73d0 -17.24d0))
-                             (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0)
-                              #C(43.31d0 -16.12d0))
-                             (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0)
-                              #C(-8.25d0 21.44d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0))))
-                           (SETF (COLUMN M1 2) COL)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(32 28 30))))
-                           (SETF (COLUMN M1 2) COL)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 44 28) (116 163 10) (161 215 19)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS '(28 10 19))))
-                           (SETF (COLUMN M1 2) COL)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(32 28 30))))
-                           (SETF (COLUMN M1 2) COL)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 44 28) (116 163 10) (161 215 19)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(28 10 19))))
-                           (SETF (COLUMN M1 2) COL)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS '(32 28 30))))
-                           (SETF (COLUMN M1 2) COL)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 44 28) (116 163 10) (161 215 19)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (COL
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS '(28 10 19))))
-                           (SETF (COLUMN M1 2) COL)
-                           (CL-ARRAY M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5 8.24 42.73)
+	(-8.93 34.12 -17.24)
+	(49.27 -13.49 43.31)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT :INITIAL-CONTENTS
+	    '(42.73 -17.24 43.31))))
+      (SETF (COLUMN M1 2) COL)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5d0 8.24d0 42.73d0)
+	(-8.93d0 34.12d0 -17.24d0)
+	(49.27d0 -13.49d0 43.31d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '(42.73d0 -17.24d0 43.31d0))))
+      (SETF (COLUMN M1 2) COL)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(42.73 -17.24))
+	(#C(-8.93 34.12) #C(-6.15 49.27) #C(43.31 -16.12))
+	(#C(49.27 -13.49) #C(32.5 42.73) #C(-8.25 21.44))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44)))))
+      (SETF (COLUMN M1 2) COL)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(42.73d0 -17.24d0))
+	(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(43.31d0 -16.12d0))
+	(#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-8.25d0 21.44d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0)))))
+      (SETF (COLUMN M1 2) COL)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '((-64 -68 71) (-91 52 -10) (73 -5 123))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(32 28 30))))
+      (SETF (COLUMN M1 2) COL)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 44 28) (116 163 10) (161 215 19)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '((67 44 189) (116 163 140) (161 215 98))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(28 10 19))))
+      (SETF (COLUMN M1 2) COL)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '(32 28 30))))
+      (SETF (COLUMN M1 2) COL)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 44 28) (116 163 10) (161 215 19)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '((67 44 189) (116 163 140) (161 215 98))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16) :INITIAL-CONTENTS '(28 10 19))))
+      (SETF (COLUMN M1 2) COL)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS '((-64 -68 71) (-91 52 -10) (73 -5 123))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS '(32 28 30))))
+      (SETF (COLUMN M1 2) COL)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 44 28) (116 163 10) (161 215 19)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64) :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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS '((67 44 189) (116 163 140) (161 215 98))))
+	  (COL
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64) :INITIAL-CONTENTS '(28 10 19))))
+      (SETF (COLUMN M1 2) COL)
+      (CL-ARRAY M1)))))
 
diff --git a/tests/setf-row.lisp b/tests/setf-row.lisp
index 541cc876d510052a2f6a547e40ed9fb36ff731ab..fb487d45e5883f3e448b2209221a53d6a79d4851 100644
--- a/tests/setf-row.lisp
+++ b/tests/setf-row.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SETF-ROW for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,189 +19,191 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SETF-ROW
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5 8.24 3.29)
-                             (-8.93 34.12 -6.15)
-                             (42.73 -17.24 43.31)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(42.73 -17.24 43.31))))
-                           (SETF (ROW M1 2) ROW)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5d0 8.24d0 3.29d0)
-                             (-8.93d0 34.12d0 -6.15d0)
-                             (42.73d0 -17.24d0 43.31d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(42.73d0 -17.24d0 43.31d0))))
-                           (SETF (ROW M1 2) ROW)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-                             (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-                             (#C(42.73 -17.24) #C(43.31 -16.12)
-                              #C(-8.25 21.44))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(42.73 -17.24 43.31 -16.12 -8.25
-                                               21.44))))
-                           (SETF (ROW M1 2) ROW)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
-                              #C(34.12d0 -6.15d0))
-                             (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0)
-                              #C(-13.49d0 32.5d0))
-                             (#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0)
-                              #C(-8.25d0 21.44d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0))))
-                           (SETF (ROW M1 2) ROW)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(32 28 30))))
-                           (SETF (ROW M1 2) ROW)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 44 189) (116 163 140) (28 10 19)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS '(28 10 19))))
-                           (SETF (ROW M1 2) ROW)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(32 28 30))))
-                           (SETF (ROW M1 2) ROW)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 44 189) (116 163 140) (28 10 19)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(28 10 19))))
-                           (SETF (ROW M1 2) ROW)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS '(32 28 30))))
-                           (SETF (ROW M1 2) ROW)
-                           (CL-ARRAY M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 44 189) (116 163 140) (28 10 19)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (ROW
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS '(28 10 19))))
-                           (SETF (ROW M1 2) ROW)
-                           (CL-ARRAY M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5 8.24 3.29)
+	(-8.93 34.12 -6.15)
+	(42.73 -17.24 43.31)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS '(42.73 -17.24 43.31))))
+      (SETF (ROW M1 2) ROW)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5d0 8.24d0 3.29d0)
+	(-8.93d0 34.12d0 -6.15d0)
+	(42.73d0 -17.24d0 43.31d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS '(42.73d0 -17.24d0 43.31d0))))
+      (SETF (ROW M1 2) ROW)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	(#C(42.73 -17.24) #C(43.31 -16.12)
+	   #C(-8.25 21.44))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44)))))
+      (SETF (ROW M1 2) ROW)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS '(42.73d0 -17.24d0 43.31d0 -16.12d0 -8.25d0 21.44d0))))
+      (SETF (ROW M1 2) ROW)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(32 28 30))))
+      (SETF (ROW M1 2) ROW)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 44 189) (116 163 140) (28 10 19)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(28 10 19))))
+      (SETF (ROW M1 2) ROW)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '(32 28 30))))
+      (SETF (ROW M1 2) ROW)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 44 189) (116 163 140) (28 10 19)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '((67 44 189) (116 163 140) (161 215 98))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '(28 10 19))))
+      (SETF (ROW M1 2) ROW)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :INITIAL-CONTENTS '(32 28 30))))
+      (SETF (ROW M1 2) ROW)
+      (CL-ARRAY M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 44 189) (116 163 140) (28 10 19)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98))))
+	  (ROW
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				    :INITIAL-CONTENTS '(28 10 19))))
+      (SETF (ROW M1 2) ROW)
+      (CL-ARRAY M1)))))
 
diff --git a/tests/swap-columns.lisp b/tests/swap-columns.lisp
index 80b1dfb62e6282069178f96feb59bed01b55d87a..6691ce29016c9ed8195c3f4310d77a10eaca5893 100644
--- a/tests/swap-columns.lisp
+++ b/tests/swap-columns.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SWAP-COLUMNS for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,137 +19,135 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SWAP-COLUMNS
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5 3.29 8.24)
-                             (-8.93 -6.15 34.12)
-                             (49.27 32.5 -13.49)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5)))))
-                           (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5d0 3.29d0 8.24d0)
-                             (-8.93d0 -6.15d0 34.12d0)
-                             (49.27d0 32.5d0 -13.49d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0)))))
-                           (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-34.5 8.24) #C(34.12 -6.15) #C(3.29 -8.93))
-                             (#C(-8.93 34.12) #C(-13.49 32.5) #C(-6.15 49.27))
-                             (#C(49.27 -13.49) #C(-17.24 43.31)
-                              #C(32.5 42.73))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31)))))
-                           (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-34.5d0 8.24d0) #C(34.12d0 -6.15d0)
-                              #C(3.29d0 -8.93d0))
-                             (#C(-8.93d0 34.12d0) #C(-13.49d0 32.5d0)
-                              #C(-6.15d0 49.27d0))
-                             (#C(49.27d0 -13.49d0) #C(-17.24d0 43.31d0)
-                              #C(32.5d0 42.73d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0)))))
-                           (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 189 44) (116 140 163) (161 98 215)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 189 44) (116 140 163) (161 98 215)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 189 44) (116 140 163) (161 98 215)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (SWAP-COLUMNS M1 1 2))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5 3.29 8.24)
+	(-8.93 -6.15 34.12)
+	(49.27 32.5 -13.49)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5)))))
+      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5d0 3.29d0 8.24d0)
+	(-8.93d0 -6.15d0 34.12d0)
+	(49.27d0 32.5d0 -13.49d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0)))))
+      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-34.5 8.24) #C(34.12 -6.15) #C(3.29 -8.93))
+	(#C(-8.93 34.12) #C(-13.49 32.5) #C(-6.15 49.27))
+	(#C(49.27 -13.49) #C(-17.24 43.31)
+	   #C(32.5 42.73))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
+      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-34.5d0 8.24d0) #C(34.12d0 -6.15d0) #C(3.29d0 -8.93d0))
+	(#C(-8.93d0 34.12d0) #C(-13.49d0 32.5d0) #C(-6.15d0 49.27d0))
+	(#C(49.27d0 -13.49d0) #C(-17.24d0 43.31d0) #C(32.5d0 42.73d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))))
+      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 189 44) (116 140 163) (161 98 215)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 189 44) (116 140 163) (161 98 215)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 189 44) (116 140 163) (161 98 215)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((-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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (SWAP-COLUMNS M1 1 2))))))
 
diff --git a/tests/swap-elements.lisp b/tests/swap-elements.lisp
index 6700b13e6265f0ab65ddfea52975474f669fd98e..7602d5e16d7fd9f1ca6b5934b21989f9c5099597 100644
--- a/tests/swap-elements.lisp
+++ b/tests/swap-elements.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SWAP-ELEMENTS for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,131 +19,131 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SWAP-ELEMENTS
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-34.5 8.24 -6.15 -8.93 34.12 3.29 49.27 -13.49))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49))))
-                           (SWAP-ELEMENTS V1 2 5)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-34.5d0 8.24d0 -6.15d0 -8.93d0 34.12d0 3.29d0
-                           49.27d0 -13.49d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0))))
-                           (SWAP-ELEMENTS V1 2 5)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-34.5 8.24) #C(3.29 -8.93) #C(-17.24 43.31)
-                           #C(49.27 -13.49) #C(32.5 42.73) #C(34.12 -6.15)
-                           #C(-16.12 -8.25) #C(21.44 -49.08)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49 32.5 42.73
-                                               -17.24 43.31 -16.12 -8.25 21.44
-                                               -49.08))))
-                           (SWAP-ELEMENTS V1 2 5)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
-                           #C(-17.24d0 43.31d0) #C(49.27d0 -13.49d0)
-                           #C(32.5d0 42.73d0) #C(34.12d0 -6.15d0)
-                           #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0 -13.49d0
-                                               32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0))))
-                           (SWAP-ELEMENTS V1 2 5)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-64 -68 -10 -91 52 71 73 -5))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SWAP-ELEMENTS V1 2 5)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(67 44 140 116 163 189 161 215))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SWAP-ELEMENTS V1 2 5)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-64 -68 -10 -91 52 71 73 -5))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SWAP-ELEMENTS V1 2 5)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(67 44 140 116 163 189 161 215))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SWAP-ELEMENTS V1 2 5)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-64 -68 -10 -91 52 71 73 -5))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SWAP-ELEMENTS V1 2 5)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(67 44 140 116 163 189 161 215))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(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
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-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
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SWAP-ELEMENTS V1 2 5)
-                           (CL-ARRAY V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(-34.5 8.24 -6.15 -8.93 34.12 3.29 49.27 -13.49))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
+      (SWAP-ELEMENTS V1 2 5)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(-34.5d0 8.24d0 -6.15d0 -8.93d0 34.12d0 3.29d0
+      49.27d0 -13.49d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT :INITIAL-CONTENTS
+	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+      (SWAP-ELEMENTS V1 2 5)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-34.5 8.24) #C(3.29 -8.93) #C(-17.24 43.31)
+      #C(49.27 -13.49) #C(32.5 42.73) #C(34.12 -6.15)
+      #C(-16.12 -8.25) #C(21.44 -49.08)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) #C(49.27 -13.49)
+	      #C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
+      (SWAP-ELEMENTS V1 2 5)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+      #C(-17.24d0 43.31d0) #C(49.27d0 -13.49d0)
+      #C(32.5d0 42.73d0) #C(34.12d0 -6.15d0)
+      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+	      #C(34.12d0 -6.15d0) #C(49.27d0 -13.49d0)
+	      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)))))
+      (SWAP-ELEMENTS V1 2 5)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-64 -68 -10 -91 52 71 73 -5))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+      (SWAP-ELEMENTS V1 2 5)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(67 44 140 116 163 189 161 215))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+      (SWAP-ELEMENTS V1 2 5)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-64 -68 -10 -91 52 71 73 -5))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+      (SWAP-ELEMENTS V1 2 5)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(67 44 140 116 163 189 161 215))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+      (SWAP-ELEMENTS V1 2 5)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-64 -68 -10 -91 52 71 73 -5))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+      (SWAP-ELEMENTS V1 2 5)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(67 44 140 116 163 189 161 215))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS '(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
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS '(-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
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+      (SWAP-ELEMENTS V1 2 5)
+      (CL-ARRAY V1)))))
 
diff --git a/tests/swap-row-column.lisp b/tests/swap-row-column.lisp
index 4e2c0a3c7385f5d6908bcaa696d1714c8175e5b0..393d13d4c3fcbeea4095618a98963c9d0405a9ac 100644
--- a/tests/swap-row-column.lisp
+++ b/tests/swap-row-column.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SWAP-ROW-COLUMN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,136 +19,128 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SWAP-ROW-COLUMN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((3.29 -6.15 32.5)
-                             (-8.93 34.12 8.24)
-                             (49.27 -13.49 -34.5)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5)))))
-                           (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((3.29d0 -6.15d0 32.5d0)
-                             (-8.93d0 34.12d0 8.24d0)
-                             (49.27d0 -13.49d0 -34.5d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0)))))
-                           (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(34.12 -6.15) #C(-13.49 32.5) #C(-17.24 43.31))
-                             (#C(-8.93 34.12) #C(-6.15 49.27) #C(3.29 -8.93))
-                             (#C(49.27 -13.49) #C(32.5 42.73) #C(-34.5 8.24))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31)))))
-                           (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(34.12d0 -6.15d0) #C(-13.49d0 32.5d0)
-                              #C(-17.24d0 43.31d0))
-                             (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0)
-                              #C(3.29d0 -8.93d0))
-                             (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0)
-                              #C(-34.5d0 8.24d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0)))))
-                           (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((71 -10 123) (-91 52 -68) (73 -5 -64)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((189 140 98) (116 163 44) (161 215 67)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((71 -10 123) (-91 52 -68) (73 -5 -64)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((189 140 98) (116 163 44) (161 215 67)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((71 -10 123) (-91 52 -68) (73 -5 -64)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((189 140 98) (116 163 44) (161 215 67)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2))))))
-
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((3.29 -6.15 32.5)
+	(-8.93 34.12 8.24)
+	(49.27 -13.49 -34.5)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5)))))
+      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((3.29d0 -6.15d0 32.5d0)
+	(-8.93d0 34.12d0 8.24d0)
+	(49.27d0 -13.49d0 -34.5d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0)))))
+      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(34.12 -6.15) #C(-13.49 32.5) #C(-17.24 43.31))
+	(#C(-8.93 34.12) #C(-6.15 49.27) #C(3.29 -8.93))
+	(#C(49.27 -13.49) #C(32.5 42.73) #C(-34.5 8.24))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
+      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(34.12d0 -6.15d0) #C(-13.49d0 32.5d0) #C(-17.24d0 43.31d0))
+	(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(3.29d0 -8.93d0))
+	(#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-34.5d0 8.24d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))))
+      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((71 -10 123) (-91 52 -68) (73 -5 -64)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((189 140 98) (116 163 44) (161 215 67)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((71 -10 123) (-91 52 -68) (73 -5 -64)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((189 140 98) (116 163 44) (161 215 67)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((71 -10 123) (-91 52 -68) (73 -5 -64)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((189 140 98) (116 163 44) (161 215 67)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				    :INITIAL-CONTENTS
+				    '((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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS '((-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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2))))))
diff --git a/tests/swap-rows.lisp b/tests/swap-rows.lisp
index cfc0270018e3c565b9b213ff8a6868f368ce6dff..cb08861137fed2b97077b495d079d1515b6480b2 100644
--- a/tests/swap-rows.lisp
+++ b/tests/swap-rows.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SWAP-ROWS for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,137 +19,135 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SWAP-ROWS
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-8.93 34.12 -6.15)
-                             (-34.5 8.24 3.29)
-                             (49.27 -13.49 32.5)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5)))))
-                           (CL-ARRAY (SWAP-ROWS M1 0 1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-8.93d0 34.12d0 -6.15d0)
-                             (-34.5d0 8.24d0 3.29d0)
-                             (49.27d0 -13.49d0 32.5d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0)))))
-                           (CL-ARRAY (SWAP-ROWS M1 0 1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-                             (#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-                             (#C(49.27 -13.49) #C(32.5 42.73)
-                              #C(-17.24 43.31))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29 -8.93 34.12
-                                                -6.15)
-                                               (-8.93 34.12 -6.15 49.27 -13.49
-                                                32.5)
-                                               (49.27 -13.49 32.5 42.73 -17.24
-                                                43.31)))))
-                           (CL-ARRAY (SWAP-ROWS M1 0 1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0)
-                              #C(-13.49d0 32.5d0))
-                             (#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
-                              #C(34.12d0 -6.15d0))
-                             (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0)
-                              #C(-17.24d0 43.31d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0 -8.93d0
-                                                34.12d0 -6.15d0)
-                                               (-8.93d0 34.12d0 -6.15d0 49.27d0
-                                                -13.49d0 32.5d0)
-                                               (49.27d0 -13.49d0 32.5d0 42.73d0
-                                                -17.24d0 43.31d0)))))
-                           (CL-ARRAY (SWAP-ROWS M1 0 1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (SWAP-ROWS M1 0 1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((116 163 140) (67 44 189) (161 215 98)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (SWAP-ROWS M1 0 1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (SWAP-ROWS M1 0 1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((116 163 140) (67 44 189) (161 215 98)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (SWAP-ROWS M1 0 1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (CL-ARRAY (SWAP-ROWS M1 0 1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((116 163 140) (67 44 189) (161 215 98)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-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
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (CL-ARRAY (SWAP-ROWS M1 0 1))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-8.93 34.12 -6.15)
+	(-34.5 8.24 3.29)
+	(49.27 -13.49 32.5)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5 8.24 3.29)
+	      (-8.93 34.12 -6.15)
+	      (49.27 -13.49 32.5)))))
+      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-8.93d0 34.12d0 -6.15d0)
+	(-34.5d0 8.24d0 3.29d0)
+	(49.27d0 -13.49d0 32.5d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '((-34.5d0 8.24d0 3.29d0)
+	      (-8.93d0 34.12d0 -6.15d0)
+	      (49.27d0 -13.49d0 32.5d0)))))
+      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	(#C(49.27 -13.49) #C(32.5 42.73)
+	   #C(-17.24 43.31))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
+	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
+      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	(#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))))
+      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((116 163 140) (67 44 189) (161 215 98)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((116 163 140) (67 44 189) (161 215 98)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
+      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((116 163 140) (67 44 189) (161 215 98)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS
+	    '((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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((-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
+    (LET ((M1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS
+	    '((67 44 189) (116 163 140) (161 215 98)))))
+      (CL-ARRAY (SWAP-ROWS M1 0 1))))))
 
diff --git a/tests/vector-reverse.lisp b/tests/vector-reverse.lisp
index 39f0385c5aeac63d56d019ec5935fac07bb04329..4576422e529a60ef358f2d9b2a22372b85b7e14d 100644
--- a/tests/vector-reverse.lisp
+++ b/tests/vector-reverse.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-REVERSE for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,119 +19,120 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-REVERSE
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-13.49 49.27 -6.15 34.12 -8.93 3.29 8.24 -34.5))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49))))
-                           (CL-ARRAY (VECTOR-REVERSE V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-13.49d0 49.27d0 -6.15d0 34.12d0 -8.93d0 3.29d0
-                           8.24d0 -34.5d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0))))
-                           (CL-ARRAY (VECTOR-REVERSE V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(21.44 -49.08) #C(-16.12 -8.25) #C(-17.24 43.31)
-                           #C(32.5 42.73) #C(49.27 -13.49) #C(34.12 -6.15)
-                           #C(3.29 -8.93) #C(-34.5 8.24)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49 32.5 42.73
-                                               -17.24 43.31 -16.12 -8.25 21.44
-                                               -49.08))))
-                           (CL-ARRAY (VECTOR-REVERSE V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(21.44d0 -49.08d0) #C(-16.12d0 -8.25d0)
-                           #C(-17.24d0 43.31d0) #C(32.5d0 42.73d0)
-                           #C(49.27d0 -13.49d0) #C(34.12d0 -6.15d0)
-                           #C(3.29d0 -8.93d0) #C(-34.5d0 8.24d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0 -13.49d0
-                                               32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0))))
-                           (CL-ARRAY (VECTOR-REVERSE V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-5 73 -10 52 -91 71 -68 -64))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (CL-ARRAY (VECTOR-REVERSE V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(215 161 140 163 116 189 44 67))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (CL-ARRAY (VECTOR-REVERSE V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-5 73 -10 52 -91 71 -68 -64))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (CL-ARRAY (VECTOR-REVERSE V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(215 161 140 163 116 189 44 67))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (CL-ARRAY (VECTOR-REVERSE V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-5 73 -10 52 -91 71 -68 -64))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (CL-ARRAY (VECTOR-REVERSE V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(215 161 140 163 116 189 44 67))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :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
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :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
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (CL-ARRAY (VECTOR-REVERSE V1))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(-13.49 49.27 -6.15 34.12 -8.93 3.29 8.24 -34.5))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
+      (CL-ARRAY (VECTOR-REVERSE V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(-13.49d0 49.27d0 -6.15d0 34.12d0 -8.93d0 3.29d0
+      8.24d0 -34.5d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS
+	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+      (CL-ARRAY (VECTOR-REVERSE V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(21.44 -49.08) #C(-16.12 -8.25) #C(-17.24 43.31)
+      #C(32.5 42.73) #C(49.27 -13.49) #C(34.12 -6.15)
+      #C(3.29 -8.93) #C(-34.5 8.24)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)
+	      #C(49.27 -13.49) #C(32.5 42.73)
+	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
+      (CL-ARRAY (VECTOR-REVERSE V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(21.44d0 -49.08d0) #C(-16.12d0 -8.25d0)
+      #C(-17.24d0 43.31d0) #C(32.5d0 42.73d0)
+      #C(49.27d0 -13.49d0) #C(34.12d0 -6.15d0)
+      #C(3.29d0 -8.93d0) #C(-34.5d0 8.24d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+				    :INITIAL-CONTENTS
+				    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+				      #C(34.12d0 -6.15d0) #C(49.27d0 -13.49d0)
+				      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+				      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)))))
+      (CL-ARRAY (VECTOR-REVERSE V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-5 73 -10 52 -91 71 -68 -64))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+      (CL-ARRAY (VECTOR-REVERSE V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(215 161 140 163 116 189 44 67))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+      (CL-ARRAY (VECTOR-REVERSE V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-5 73 -10 52 -91 71 -68 -64))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+      (CL-ARRAY (VECTOR-REVERSE V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(215 161 140 163 116 189 44 67))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+      (CL-ARRAY (VECTOR-REVERSE V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-5 73 -10 52 -91 71 -68 -64))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+      (CL-ARRAY (VECTOR-REVERSE V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(215 161 140 163 116 189 44 67))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :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
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :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
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+      (CL-ARRAY (VECTOR-REVERSE V1))))))
 
diff --git a/tests/vector-set-zero.lisp b/tests/vector-set-zero.lisp
index cb5e579aa6bd186687c5e1b77bfb7115dc979eb0..7dd668288b9b2f502d610c885538bf0980defc2a 100644
--- a/tests/vector-set-zero.lisp
+++ b/tests/vector-set-zero.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-SET-ZERO for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,133 +19,94 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-SET-ZERO
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0.0 0.0 0.0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29))))
-                                                             (SET-ZERO V1)
-                                                             (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(0.0d0 0.0d0 0.0d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0))))
-                           (SET-ZERO V1)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15))))
-                           (SET-ZERO V1)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0))))
-                           (SET-ZERO V1)
-                           (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71))))
-                                                             (SET-ZERO V1)
-                                                             (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189))))
-                                                             (SET-ZERO V1)
-                                                             (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71))))
-                                                             (SET-ZERO V1)
-                                                             (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189))))
-                                                             (SET-ZERO V1)
-                                                             (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71))))
-                                                             (SET-ZERO V1)
-                                                             (CL-ARRAY V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189))))
-                                                             (SET-ZERO V1)
-                                                             (CL-ARRAY V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71))))
-                                                             (SET-ZERO V1)
-                                                             (CL-ARRAY V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189))))
-                                                             (SET-ZERO V1)
-                                                             (CL-ARRAY V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0.0 0.0 0.0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5 8.24 3.29))))
+      (SET-ZERO V1)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0.0d0 0.0d0 0.0d0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS '(-34.5d0 8.24d0 3.29d0))))
+      (SET-ZERO V1)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)))))
+      (SET-ZERO V1)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0)))))
+      (SET-ZERO V1)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS '(-64 -68 71))))
+      (SET-ZERO V1)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(67 44 189))))
+      (SET-ZERO V1)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 16) :INITIAL-CONTENTS '(-64 -68 71))))
+      (SET-ZERO V1)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :INITIAL-CONTENTS '(67 44 189))))
+      (SET-ZERO V1)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :INITIAL-CONTENTS '(-64 -68 71))))
+      (SET-ZERO V1)
+      (CL-ARRAY V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :INITIAL-CONTENTS '(67 44 189))))
+      (SET-ZERO V1)
+      (CL-ARRAY V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :INITIAL-CONTENTS '(-64 -68 71))))
+      (SET-ZERO V1)
+      (CL-ARRAY V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 0 0))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :INITIAL-CONTENTS '(67 44 189))))
+      (SET-ZERO V1)
+      (CL-ARRAY V1)))))
 
diff --git a/tests/vector-swap.lisp b/tests/vector-swap.lisp
index 73e41e67480f19d6cc9cde0ca8fb023701363b2e..5d466947f6b72be8daa1fbc7313c7a4402fdf3e1 100644
--- a/tests/vector-swap.lisp
+++ b/tests/vector-swap.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-SWAP for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,156 +19,174 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-SWAP
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST (LIST #(-8.93 34.12 -6.15) #(-34.5 8.24 3.29)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93 34.12 -6.15))))
-                           (SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST #(-8.93d0 34.12d0 -6.15d0)
-                               #(-34.5d0 8.24d0 3.29d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93d0 34.12d0 -6.15d0))))
-                           (SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST
-                          #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-                          #(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-8.93 34.12 -6.15 49.27 -13.49
-                                               32.5))))
-                           (SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST
-                          #(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0)
-                            #C(-13.49d0 32.5d0))
-                          #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
-                            #C(34.12d0 -6.15d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :INITIAL-CONTENTS
-                                             '(-8.93d0 34.12d0 -6.15d0 49.27d0
-                                               -13.49d0 32.5d0))))
-                           (SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST (LIST #(-91 52 -10) #(-64 -68 71)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-91 52 -10))))
-                           (SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST (LIST #(116 163 140) #(67 44 189)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS '(67 44 189)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS '(116 163 140))))
-                           (SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST (LIST #(-91 52 -10) #(-64 -68 71)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(-64 -68 71)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(-91 52 -10))))
-                           (SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST (LIST #(116 163 140) #(67 44 189)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(67 44 189)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(116 163 140))))
-                           (SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST (LIST #(-91 52 -10) #(-64 -68 71)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS '(-64 -68 71)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS '(-91 52 -10))))
-                           (SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST (LIST #(116 163 140) #(67 44 189)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS '(67 44 189)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :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
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS '(-64 -68 71)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :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
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS '(67 44 189)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS '(116 163 140))))
-                           (SWAP V2 V1)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST (LIST #(-8.93 34.12 -6.15) #(-34.5 8.24 3.29)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS '(-34.5 8.24 3.29)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'SINGLE-FLOAT
+	    :INITIAL-CONTENTS '(-8.93 34.12 -6.15))))
+      (SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST #(-8.93d0 34.12d0 -6.15d0)
+	  #(-34.5d0 8.24d0 3.29d0)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS '(-34.5d0 8.24d0 3.29d0)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    'DOUBLE-FLOAT
+	    :INITIAL-CONTENTS '(-8.93d0 34.12d0 -6.15d0))))
+      (SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST
+     #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
+     #(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX SINGLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)))))
+      (SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST
+     #(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+     #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(COMPLEX DOUBLE-FLOAT)
+	    :INITIAL-CONTENTS
+	    '(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0)))))
+      (SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST (LIST #(-91 52 -10) #(-64 -68 71)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(-64 -68 71)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(-91 52 -10))))
+      (SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST (LIST #(116 163 140) #(67 44 189)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(67 44 189)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 8)
+	    :INITIAL-CONTENTS '(116 163 140))))
+      (SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST (LIST #(-91 52 -10) #(-64 -68 71)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '(-64 -68 71)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '(-91 52 -10))))
+      (SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST (LIST #(116 163 140) #(67 44 189)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '(67 44 189)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 16)
+	    :INITIAL-CONTENTS '(116 163 140))))
+      (SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST (LIST #(-91 52 -10) #(-64 -68 71)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS '(-64 -68 71)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 32)
+	    :INITIAL-CONTENTS '(-91 52 -10))))
+      (SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST (LIST #(116 163 140) #(67 44 189)))
+   (MULTIPLE-VALUE-LIST
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :INITIAL-CONTENTS '(67 44 189)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 32)
+	    :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
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :INITIAL-CONTENTS '(-64 -68 71)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(SIGNED-BYTE 64)
+	    :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
+    (LET ((V1
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS '(67 44 189)))
+	  (V2
+	   (GRID:MAKE-FOREIGN-ARRAY
+	    '(UNSIGNED-BYTE 64)
+	    :INITIAL-CONTENTS '(116 163 140))))
+      (SWAP V2 V1)
+      (LIST (CL-ARRAY V1) (CL-ARRAY V2))))))