diff --git a/tests/absolute-sum.lisp b/tests/absolute-sum.lisp
index fa1d6b7079279b1217d5ed4bef21e8eb1d60abca..e77374b57edf20984dd6f035592002436b027ae2 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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,13 +20,13 @@
 
 (LISP-UNIT:DEFINE-TEST ABSOLUTE-SUM
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST 157.99)
+   (LIST 157.99f0)
    (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))))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
       (ABSOLUTE-SUM V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 157.99d0)
@@ -38,15 +38,14 @@
 	    '(-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)
+   (LIST 388.65997f0)
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX
-	      SINGLE-FLOAT)
+	    '(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)))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0)
+	      #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))))
       (ABSOLUTE-SUM V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 388.65999999999997d0)
diff --git a/tests/axpy.lisp b/tests/axpy.lisp
index 8b014436c218e2ce8d6bb6e75fef2455e9452366..5b6677b947af6f24a9d78944a49a1dd3cbf94873 100644
--- a/tests/axpy.lisp
+++ b/tests/axpy.lisp
@@ -1,6 +1,6 @@
 ;; Regression test AXPY for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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
@@ -21,18 +21,18 @@
 (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))
+    #(1400.77f0 -284.0684f0 -147.7214f0 397.47382f0 -1369.3191f0
+      235.659f0 -1932.6083f0 485.93335f0))
    (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)))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))
 	  (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))
+	    '(32.5f0 42.73f0 -17.24f0 43.31f0 -16.12f0 -8.25f0 21.44f0 -49.08f0)))
+	  (SCALAR -39.66f0))
       (grid:copy-to (AXPY SCALAR V1 V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -59,27 +59,27 @@
   #+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)))
+    #(#C(1808.3204f0 1422.3015f0) #C(-589.3992f0 234.75043f0)
+      #C(-1673.498f0 -1451.916f0) #C(-2599.8237f0 -1950.9608f0)
+      #C(784.81586f0 -3351.5815f0) #C(2845.531f0 -870.5343f0)
+      #C(222.45422f0 1149.8602f0) #C(-3308.3872f0 917.76044f0)))
    (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))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0)
+	      #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	      #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))
 	  (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)))
+	    '(#C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0)
+	      #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)
+	      #C(19.68f0 -5.55f0) #C(-8.82f0 25.37f0)
+	      #C(-30.58f0 31.67f0))))
+	  (SCALAR #C(-39.66f0 -49.46f0)))
       (GRID:COPY-TO (AXPY SCALAR V1 V2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/cdot.lisp b/tests/cdot.lisp
index 59db2a942de63cd4c263afd22307d665240ed647..42af8212efcc600d58c4fc4376a3eaee1594021a 100644
--- a/tests/cdot.lisp
+++ b/tests/cdot.lisp
@@ -1,6 +1,6 @@
 ;; Regression test CDOT for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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,22 +20,22 @@
 
 (LISP-UNIT:DEFINE-TEST CDOT
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #C(-6252.624 -6236.0503))
+   (LIST #C(-6252.624f0 -6236.0503f0))
    (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))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)
+	      #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	      #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))
 	  (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)))))
+	    '(#C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0)
+	      #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)
+	      #C(19.68f0 -5.55f0) #C(-8.82f0 25.37f0) #C(-30.58f0 31.67f0)))))
       (CDOT V1 V2))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #C(-6252.624d0 -6236.050300000001d0))
diff --git a/tests/column.lisp b/tests/column.lisp
index fac955d630173ec70a0bea04ef5d31296f5eec05..d25e69c842aba1d493e860bcd526a776eb47a087 100644
--- a/tests/column.lisp
+++ b/tests/column.lisp
@@ -1,6 +1,6 @@
 ;; Regression test COLUMN for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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,175 +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)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(8.24f0 34.12f0 -13.49f0))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((M1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '((-34.5f0 8.24f0 3.29f0)
+		   (-8.93f0 34.12f0 -6.15f0)
+		   (49.27f0 -13.49f0 32.5f0))))
+	       (COL (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
+	   (GRID:COPY-TO (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)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (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)))
+	 (GRID:COPY-TO (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)))
+   (LIST #(#C(3.29f0 -8.93f0) #C(-6.15f0 49.27f0) #C(32.5f0 42.73f0)))
    (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)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX SINGLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+		 (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+		 (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
+	     (COL
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3)))
+	 (GRID:COPY-TO (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)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (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)))
+	 (GRID:COPY-TO (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)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (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)))
+	 (GRID:COPY-TO (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)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (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)))
+	 (GRID:COPY-TO (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)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (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)))
+	 (GRID:COPY-TO (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)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (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)))
+	 (GRID:COPY-TO (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)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (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)))
+	 (GRID:COPY-TO (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)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (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)))
+	 (GRID:COPY-TO (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)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (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)))
+	 (GRID:COPY-TO (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)))
-      (GRID:COPY-TO (COLUMN M1 1 COL))))))
+       (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)))
+	 (GRID:COPY-TO (COLUMN M1 1 COL))))))
 
diff --git a/tests/correlation.lisp b/tests/correlation.lisp
index b05deb8870c95029d84a30b50812e783a43c12c1..1d66fd399c90c85e88d1d9edb47c1bc4a188591c 100644
--- a/tests/correlation.lisp
+++ b/tests/correlation.lisp
@@ -1,6 +1,6 @@
 ;; Regression test CORRELATION for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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.5f0 8.24f0 3.29f0)))
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93 34.12 -6.15))))
+                                             '(-8.93f0 34.12f0 -6.15f0))))
                            (CORRELATION V1 V2))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 0.6345226817840662d0)
diff --git a/tests/covariance.lisp b/tests/covariance.lisp
index 16b5f83d2123eddb2157ca0c28bdd011471d2c8a..b64c07f18c5f6d8c414ebc0c437dce205e5c5f95 100644
--- a/tests/covariance.lisp
+++ b/tests/covariance.lisp
@@ -1,6 +1,6 @@
 ;; Regression test COVARIANCE for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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.5f0 8.24f0 3.29f0)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-				    '(-8.93 34.12 -6.15))))
+				    '(-8.93f0 34.12f0 -6.15f0))))
       (LET ((MEAN1 (MEAN V1)) (MEAN2 (MEAN V2)))
 	(COVARIANCE V1 V2 MEAN1 MEAN2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/dot.lisp b/tests/dot.lisp
index 6375c5541e4af028a7005e296ab3378e2b7e4a37..dae47afb249b7f3cf1d2e788faaf82f1f3e4c759 100644
--- a/tests/dot.lisp
+++ b/tests/dot.lisp
@@ -1,6 +1,6 @@
 ;; Regression test DOT for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,18 +20,18 @@
 
 (LISP-UNIT:DEFINE-TEST DOT
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST 6.5285645)
+   (LIST 6.5285645f0)
    (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)))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))
 	  (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))))
+	    '(32.5f0 42.73f0 -17.24f0 43.31f0 -16.12f0 -8.25f0 21.44f0 -49.08f0))))
       (DOT V1 V2))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 6.528400000000033d0)
@@ -50,22 +50,22 @@
 	      -49.08d0))))
       (DOT V1 V2))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #C(625.9737 -4310.1177))
+   (LIST #C(625.9737f0 -4310.1177f0))
    (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))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)
+	      #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	      #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))
 	  (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)))))
+	    '(#C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0)
+	      #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)
+	      #C(19.68f0 -5.55f0) #C(-8.82f0 25.37f0) #C(-30.58f0 31.67f0)))))
       (DOT V1 V2))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #C(625.9736000000007d0 -4310.1183d0))
diff --git a/tests/euclidean-norm.lisp b/tests/euclidean-norm.lisp
index fcee147a020c60a5684d1d8c1d526e88b866152d..818d862dab50ba692d47425ab16604b747c23c67 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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,13 +20,13 @@
 
 (LISP-UNIT:DEFINE-TEST EUCLIDEAN-NORM
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST 71.83472)
+   (LIST 71.83472f0)
    (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))))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
       (EUCLIDEAN-NORM V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 71.83471653734007d0)
@@ -37,16 +37,16 @@
 	    '(-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)
+   (LIST 115.80907f0)
    (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)))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0)
+	      #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0)
+	      #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)
+	      #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))))
       (EUCLIDEAN-NORM V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 115.8090670025452d0)
@@ -60,4 +60,3 @@
 	      #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 5c90408d0fd76f048ca0b8f2a00a7e31b78ce28c..a9231fe77ca2a9ce87b0cea4babf6a52d3061502 100644
--- a/tests/givens.lisp
+++ b/tests/givens.lisp
@@ -1,6 +1,6 @@
 ;; Regression test GIVENS for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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 GIVENS
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST
-                          #(-47.39726 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)
-                          #(-0.6856937 42.73 -17.24 43.31 -16.12 -8.25 21.44
-                            -49.08)))
-                        (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)))
-                               (ANGLES
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-39.66 -49.46 19.68 -5.55 -8.82
-                                               25.37 -30.58 31.67)))
-                               (SINES
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8))
-                               (COSINES
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8)))
-                           (LOOP FOR I BELOW 8 DO
-                                 (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 (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST
-                          #(-47.39725730461627d0 8.24d0 3.29d0 -8.93d0 34.12d0
-                            -6.15d0 49.27d0 -13.49d0)
-                          #(-0.6856936845760199d0 42.73d0 -17.24d0 43.31d0
-                            -16.12d0 -8.25d0 21.44d0 -49.08d0)))
-                        (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)))
-                               (ANGLES
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-39.66d0 -49.46d0 19.68d0
-                                               -5.55d0 -8.82d0 25.37d0 -30.58d0
-                                               31.67d0)))
-                               (SINES
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8))
-                               (COSINES
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8)))
-                           (LOOP FOR I BELOW 8 DO
-                                 (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 (GRID:COPY-TO V1) (GRID:COPY-TO V2))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST
+      (LIST
+       #(-47.39726f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)
+       #(-0.6856937f0 42.73f0 -17.24f0 43.31f0 -16.12f0 -8.25f0 21.44f0
+	 -49.08f0)))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))
+	       (V2
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(32.5f0 42.73f0 -17.24f0 43.31f0 -16.12f0 -8.25f0 21.44f0 -49.08f0)))
+	       (ANGLES
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-39.66f0 -49.46f0 19.68f0 -5.55f0 -8.82f0 25.37f0 -30.58f0 31.67f0)))
+	       (SINES
+		(GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8))
+	       (COSINES
+		(GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8)))
+	   (LOOP FOR I BELOW 8 DO
+	     (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 (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST
+     #(-47.39725730461627d0 8.24d0 3.29d0 -8.93d0 34.12d0
+       -6.15d0 49.27d0 -13.49d0)
+     #(-0.6856936845760199d0 42.73d0 -17.24d0 43.31d0
+       -16.12d0 -8.25d0 21.44d0 -49.08d0)))
+   (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)))
+	     (ANGLES
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(-39.66d0 -49.46d0 19.68d0
+					 -5.55d0 -8.82d0 25.37d0 -30.58d0
+					 31.67d0)))
+	     (SINES
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8))
+	     (COSINES
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8)))
+	 (LOOP FOR I BELOW 8 DO
+	   (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 (GRID:COPY-TO V1) (GRID:COPY-TO V2))))))
 
diff --git a/tests/index-max.lisp b/tests/index-max.lisp
index 0752044424bfa9c51ca1c44dd9cec75660620056..0dff9495d5a1680649f9d9c5f29d36b655d14c2e 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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,49 +19,48 @@
 (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.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (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))))
+       (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))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX SINGLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)
+		 #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+		 #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))))
+	 (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)))))
-
+       (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 0730e9713a8ad77ecd4f0b32b9b6bd27210e4b1a..a5c7fb102b2451a267bb001778f7a467486ae680 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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
@@ -21,23 +21,23 @@
 (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)))
+    #2A((-30.708971f0 5.3737082f0 -25.897392f0)
+	(-14.654706f0 -9.08723f0 6.96797f0)
+	(-29.71983f0 -24.015656f0 -29.949932f0)))
    (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))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0))))
 	  (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))
+	    '((42.73f0 -17.24f0 43.31f0)
+	      (-16.12f0 -8.25f0 21.44f0)
+	      (-49.08f0 -39.66f0 -49.46f0))))
+	  (S1 19.68f0))
       (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -65,28 +65,28 @@
   #+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))))
+    #2A((#C(-28.191956f0 35.052914f0) #C(-13.378113f0 28.736774f0)
+	   #C(5.4411864f0 -3.0717967f0))
+	(#C(5.1555862f0 -11.330741f0) #C(-33.49236f0 -12.241006f0)
+	   #C(-10.527424f0 20.3357f0))
+	(#C(-0.71776515f0 27.669863f0) #C(20.046593f0 11.972884f0)
+	   #C(-1.5907472f0 4.2853727f0))))
    (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)))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
 	  (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)))
+	    '((#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0))
+	      (#C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0))
+	      (#C(-49.08f0 -39.66f0) #C(-49.46f0 19.68f0) #C(-5.55f0 -8.82f0)))))
+	  (S1 #C(19.68f0 -5.55f0)))
       (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -118,19 +118,19 @@
 	  (S1 #C(19.68d0 -5.55d0)))
       (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(-1.1747805 -0.26507667 1.3326154))
+   (LIST #(-1.1747805f0 -0.26507667f0 1.3326154f0))
    (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))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0))))
 	  (V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '(42.73 -17.24 43.31)))
-	  (S1 -16.12))
+	    '(42.73f0 -17.24f0 43.31f0)))
+	  (S1 -16.12f0))
       (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -150,22 +150,22 @@
       (GRID:COPY-TO (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)))
+    #(#C(-1.1218005f0 0.24990065f0) #C(-0.7679142f0 -0.9143634f0)
+      #C(0.4927793f0 -0.0056687724f0)))
    (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)))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
 	  (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)))
+	    '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0))))
+	  (S1 #C(-16.12f0 -8.25f0)))
       (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/rank-1-update.lisp b/tests/rank-1-update.lisp
index 0214352f4611da05f26312aa362b7cdf0e523346..b522c047dd2d71ebe035ffa1259f39187c462b4b 100644
--- a/tests/rank-1-update.lisp
+++ b/tests/rank-1-update.lisp
@@ -1,26 +1,42 @@
 ;; Regression test RANK-1-UPDATE for GSLL, automatically generated
+;;
+;; Copyright 2009, 2011 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
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+;;
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST RANK-1-UPDATE
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((33772.18 17310.045 -44960.434)
-	(-13648.694 -6946.5283 18135.074)
-	(34314.832 17523.164 -45541.547)))
+    #2A((33772.18f0 17310.045f0 -44960.434f0)
+	(-13648.694f0 -6946.5283f0 18135.074f0)
+	(34314.832f0 17523.164f0 -45541.547f0)))
    (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))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0))))
 	  (V1
-	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(42.73 -17.24 43.31)))
+	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(42.73f0 -17.24f0 43.31f0)))
 	  (V2
-	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-16.12 -8.25 21.44)))
-	  (S1 -49.08))
+	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-16.12f0 -8.25f0 21.44f0)))
+	  (S1 -49.08f0))
       (GRID:COPY-TO (RANK-1-UPDATE S1 V1 V2 M1)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -43,31 +59,31 @@
       (GRID:COPY-TO (RANK-1-UPDATE S1 V1 V2 M1)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(37793.65 36629.23) #C(-101265.76 118286.42)
-	   #C(68357.26 171191.28))
-	(#C(36918.79 37780.418) #C(-104760.06 115889.945)
-	   #C(63820.45 173533.31))
-	(#C(-26166.797 1319.2356) #C(-8642.514 -77109.22)
-	   #C(-85661.76 -33283.21))))
+    #2A((#C(37793.65f0 36629.23f0) #C(-101265.76f0 118286.42f0)
+	   #C(68357.26f0 171191.28f0))
+	(#C(36918.79f0 37780.418f0) #C(-104760.06f0 115889.945f0)
+	   #C(63820.45f0 173533.31f0))
+	(#C(-26166.797f0 1319.2356f0) #C(-8642.514f0 -77109.22f0)
+	   #C(-85661.76f0 -33283.21f0))))
    (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)))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
 	  (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))))
+	    '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0))))
 	  (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)))
+	    '(#C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0))))
+	  (S1 #C(-49.08f0 -39.66f0)))
       (GRID:COPY-TO (RANK-1-UPDATE S1 V1 V2 M1)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/row.lisp b/tests/row.lisp
index abda2bbb8deafbe8ddf34699e71e14d32cc86a46..9440c8dc446c434df00844fb6938453d87f72b18 100644
--- a/tests/row.lisp
+++ b/tests/row.lisp
@@ -1,6 +1,6 @@
 ;; Regression test ROW for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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,15 +20,15 @@
 
 (LISP-UNIT:DEFINE-TEST ROW
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(-8.93 34.12 -6.15))
+   (LIST #(-8.93f0 34.12f0 -6.15f0))
    (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))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0))))
 	  (ROW (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
       (GRID:COPY-TO (ROW M1 1 ROW)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -45,15 +45,15 @@
       (GRID:COPY-TO (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)))
+    #(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)))
    (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)))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
 	  (ROW
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3)))
diff --git a/tests/scale.lisp b/tests/scale.lisp
index 5055a6c9c217bb68766ff0c1bd0777774603945e..4826c303e24e7374c71cba40f99a11bfbaa5e7a7 100644
--- a/tests/scale.lisp
+++ b/tests/scale.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SCALE for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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
@@ -21,19 +21,19 @@
 (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)))
+    #(#C(-1121.25f0 267.8f0) #C(106.924995f0 -290.225f0)
+      #C(1108.9f0 -199.875f0) #C(1601.275f0 -438.425f0)
+      #C(1056.25f0 1388.725f0) #C(-560.3f0 1407.5751f0)
+      #C(-523.9f0 -268.125f0) #C(696.8f0 -1595.1001f0)))
    (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 32.5))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)
+	      #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	      #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))
+	  (SCALAR 32.5f0))
       (GRID:COPY-TO (SCALE SCALAR V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -54,14 +54,14 @@
 	  (SCALAR 32.5d0))
       (GRID:COPY-TO (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))
+   (LIST #(-1121.25f0 267.8f0 106.924995f0 -290.225f0 1108.9f0 -199.875f0 1601.275f0 -438.425f0))
    (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))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))
+	  (SCALAR 32.5f0))
       (GRID:COPY-TO (SCALE SCALAR V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -79,19 +79,19 @@
   #+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)))
+    #(#C(-1473.3452f0 -1206.385f0) #C(488.5039f0 -149.64331f0)
+      #C(1371.6895f0 1258.0725f0) #C(2177.7026f0 1666.8821f0)
+      #C(-769.6029f0 2777.45f0) #C(-2410.9363f0 670.9099f0)
+      #C(-171.37753f0 -956.9326f0) #C(2793.9885f0 -678.9689f0)))
    (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)))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)
+	      #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	      #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))
+	  (SCALAR #C(32.5f0 42.73f0)))
       (GRID:COPY-TO (SCALE SCALAR V1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/set-basis.lisp b/tests/set-basis.lisp
index ab80bdf3d26a56eaf65408a646e6c4645a3a0bcb..3571e72b05fed0db43413cf5c2c7eb8a7f9d2c5f 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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,13 +20,13 @@
 
 (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))
+   (LIST #(0.0f0 0.0f0 1.0f0 0.0f0 0.0f0 0.0f0 0.0f0 0.0f0))
    (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))))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
       (SET-BASIS V1 2)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -42,16 +42,16 @@
       (GRID:COPY-TO 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)))
+    #(#C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(1.0f0 0.0f0) #C(0.0f0 0.0f0)
+      #C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(0.0f0 0.0f0)))
    (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)))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0)
+	      #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	      #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))))
       (SET-BASIS V1 2)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/set-identity.lisp b/tests/set-identity.lisp
index 97e06458ea1636decc64fbf511b64cc9f12a385e..d2b401db65688c36e4197cfa2697767d4f746416 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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,15 +20,15 @@
 
 (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)))
+   (LIST #2A((1.0f0 0.0f0 0.0f0) (0.0f0 1.0f0 0.0f0) (0.0f0 0.0f0 1.0f0)))
    (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)))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0)))))
       (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -46,17 +46,17 @@
       (GRID:COPY-TO (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))))
+    #2A((#C(1.0f0 0.0f0) #C(0.0f0 0.0f0) #C(0.0f0 0.0f0))
+	(#C(0.0f0 0.0f0) #C(1.0f0 0.0f0) #C(0.0f0 0.0f0))
+	(#C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(1.0f0 0.0f0))))
    (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))))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))))
       (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/setf-column.lisp b/tests/setf-column.lisp
index 91b5ede0883a2b413dfb29090b35446c62787352..55a5691b3f0cb6baef7db0435205e4a41984eb8a 100644
--- a/tests/setf-column.lisp
+++ b/tests/setf-column.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SETF-COLUMN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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
@@ -21,20 +21,20 @@
 (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)))
+    #2A((-34.5f0 8.24f0 42.73f0)
+	(-8.93f0 34.12f0 -17.24f0)
+	(49.27f0 -13.49f0 43.31f0)))
    (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))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0))))
 	  (COL
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '(42.73 -17.24 43.31))))
+	    '(42.73f0 -17.24f0 43.31f0))))
       (SETF (COLUMN M1 2) COL)
       (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -57,22 +57,22 @@
       (GRID:COPY-TO 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))))
+    #2A((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(42.73f0 -17.24f0))
+	(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(43.31f0 -16.12f0))
+	(#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-8.25f0 21.44f0))))
    (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)))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
 	  (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)))))
+	    '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)))))
       (SETF (COLUMN M1 2) COL)
       (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/setf-row.lisp b/tests/setf-row.lisp
index 688a0c9b45bf5cd8f2d44eaf553270a2124d01bd..a469859323742c5838dd42e6a4e7f362ee02bbcd 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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
@@ -21,21 +21,21 @@
 (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)))
+    #2A((-34.5f0 8.24f0 3.29f0)
+	(-8.93f0 34.12f0 -6.15f0)
+	(42.73f0 -17.24f0 43.31f0)))
    (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))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0))))
 	  (ROW
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
-	    :INITIAL-CONTENTS '(42.73 -17.24 43.31))))
+	    :INITIAL-CONTENTS '(42.73f0 -17.24f0 43.31f0))))
       (SETF (ROW M1 2) ROW)
       (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -59,22 +59,21 @@
       (GRID:COPY-TO 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))))
+    #2A((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0))))
    (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)))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
 	  (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)))))
+	    :INITIAL-CONTENTS '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)))))
       (SETF (ROW M1 2) ROW)
       (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/sort-matrix-largest.lisp b/tests/sort-matrix-largest.lisp
index e2c737000cf3e20eed1ba4e77f7b42cf353582be..0703f60320eed8f61c66481b80317279cf6ddf48 100644
--- a/tests/sort-matrix-largest.lisp
+++ b/tests/sort-matrix-largest.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-MATRIX-LARGEST for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,124 +19,126 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-MATRIX-LARGEST
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((49.27 34.12 32.5) (8.24 3.29 -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))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((49.27d0 34.12d0 32.5d0) (8.24d0 3.29d0 -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))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((123 73 71) (52 -5 -10)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((215 189 163) (161 140 116)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((123 73 71) (52 -5 -10)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((215 189 163) (161 140 116)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((123 73 71) (52 -5 -10)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((215 189 163) (161 140 116)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((123 73 71) (52 -5 -10)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((215 189 163) (161 140 116)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #2A((49.27f0 34.12f0 32.5f0) (8.24f0 3.29f0 -6.15f0)))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((M1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '((-34.5f0 8.24f0 3.29f0)
+		   (-8.93f0 34.12f0 -6.15f0)
+		   (49.27f0 -13.49f0 32.5f0))))
+	       (M2
+		(GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3))))
+	   (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((49.27d0 34.12d0 32.5d0) (8.24d0 3.29d0 -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))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((123 73 71) (52 -5 -10)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((215 189 163) (161 140 116)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((123 73 71) (52 -5 -10)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((215 189 163) (161 140 116)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((123 73 71) (52 -5 -10)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((215 189 163) (161 140 116)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((123 73 71) (52 -5 -10)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((215 189 163) (161 140 116)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1))))))
 
diff --git a/tests/sort-matrix-smallest.lisp b/tests/sort-matrix-smallest.lisp
index 36e10a61e0cc82be7da37800d290e15bf437eefa..8e7ef7ad21daffb66bfbf9762ccdeccc2728aeaf 100644
--- a/tests/sort-matrix-smallest.lisp
+++ b/tests/sort-matrix-smallest.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-MATRIX-SMALLEST for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,125 +19,126 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-MATRIX-SMALLEST
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-34.5 -13.49 -8.93) (-6.15 3.29 8.24)))
-                        (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 '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5d0 -13.49d0 -8.93d0)
-                             (-6.15d0 3.29d0 8.24d0)))
-                        (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 '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161)))
-                        (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
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #2A((-34.5f0 -13.49f0 -8.93f0) (-6.15f0 3.29f0 8.24f0)))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((M1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT :INITIAL-CONTENTS
+		 '((-34.5f0 8.24f0 3.29f0)
+		   (-8.93f0 34.12f0 -6.15f0)
+		   (49.27f0 -13.49f0 32.5f0))))
+	       (M2
+		(GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3))))
+	   (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5d0 -13.49d0 -8.93d0)
+	(-6.15d0 3.29d0 8.24d0)))
+   (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 '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161)))
+   (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
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1))))))
 
diff --git a/tests/sort-matrix.lisp b/tests/sort-matrix.lisp
index 90cb6129e372f995369d01e6e542819b3764e9e2..a79066b040721dab794259e1289ae8967feb790a 100644
--- a/tests/sort-matrix.lisp
+++ b/tests/sort-matrix.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-MATRIX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,101 +19,103 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-MATRIX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5 -13.49 -8.93)
-                             (-6.15 3.29 8.24)
-                             (32.5 34.12 49.27)))
-                        (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)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5d0 -13.49d0 -8.93d0)
-                             (-6.15d0 3.29d0 8.24d0)
-                             (32.5d0 34.12d0 49.27d0)))
-                        (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)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (GRID:COPY-TO (MSORT M1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST
+      #2A((-34.5f0 -13.49f0 -8.93f0)
+	  (-6.15f0 3.29f0 8.24f0)
+	  (32.5f0 34.12f0 49.27f0)))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((M1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '((-34.5f0 8.24f0 3.29f0)
+		   (-8.93f0 34.12f0 -6.15f0)
+		   (49.27f0 -13.49f0 32.5f0)))))
+	   (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5d0 -13.49d0 -8.93d0)
+	(-6.15d0 3.29d0 8.24d0)
+	(32.5d0 34.12d0 49.27d0)))
+   (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)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (GRID:COPY-TO (MSORT M1))))))
 
diff --git a/tests/sort-vector-index.lisp b/tests/sort-vector-index.lisp
index dd0dc70d438d623cfbf414356752a17ed0d593f0..16819a9aa29789cd5899627db93dcf61aa497f5f 100644
--- a/tests/sort-vector-index.lisp
+++ b/tests/sort-vector-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-VECTOR-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,106 +19,106 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-VECTOR-INDEX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(0 7 3 5 2 1 4 6))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (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))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(0 7 3 5 2 1 4 6))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (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))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(3 1 0 5 7 4 2 6))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(1 0 3 5 6 4 2 7))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(3 1 0 5 7 4 2 6))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(1 0 3 5 6 4 2 7))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(3 1 0 5 7 4 2 6))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(1 0 3 5 6 4 2 7))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(3 1 0 5 7 4 2 6))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(1 0 3 5 6 4 2 7))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(0 7 3 5 2 1 4 6))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((PERM (MAKE-PERMUTATION 8))
+	       (V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (SORT-VECTOR-INDEX PERM V1)
+	   (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 7 3 5 2 1 4 6))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (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))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(3 1 0 5 7 4 2 6))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(1 0 3 5 6 4 2 7))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(3 1 0 5 7 4 2 6))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(1 0 3 5 6 4 2 7))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(3 1 0 5 7 4 2 6))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(1 0 3 5 6 4 2 7))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(3 1 0 5 7 4 2 6))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(1 0 3 5 6 4 2 7))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM)))))
 
diff --git a/tests/sort-vector-largest-index.lisp b/tests/sort-vector-largest-index.lisp
index 3e2c0e76c411e852421f7520b540967d1999b1d2..01d7bbaa163c3cfd524254943dea2081f8cf7af6 100644
--- a/tests/sort-vector-largest-index.lisp
+++ b/tests/sort-vector-largest-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-VECTOR-LARGEST-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,176 +19,170 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-VECTOR-LARGEST-INDEX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 4 1))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (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))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 4 1))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (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))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(6 4 1))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((COMB (MAKE-COMBINATION 8 3 NIL))
+	       (V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (GRID:COPY-TO
+	    (SORT-VECTOR-LARGEST-INDEX
+	     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 4 1))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (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))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1))))))
 
diff --git a/tests/sort-vector-largest.lisp b/tests/sort-vector-largest.lisp
index 0b6fc92dcf549853201dc0a2d9da90e0dfc373f4..30b528f1d39c3a93490e1d691f744cd09a08a2e9 100644
--- a/tests/sort-vector-largest.lisp
+++ b/tests/sort-vector-largest.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-VECTOR-LARGEST for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,193 +19,194 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-VECTOR-LARGEST
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(49.27 34.12 8.24))
-                        (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))))
-                           (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(49.27d0 34.12d0 8.24d0))
-                        (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))))
-                           (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(49.27f0 34.12f0 8.24f0))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))
+	       (V2
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(32.5f0 42.73f0 -17.24f0))))
+	   (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(49.27d0 34.12d0 8.24d0))
+   (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))))
+	 (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1))))))
 
diff --git a/tests/sort-vector-smallest-index.lisp b/tests/sort-vector-smallest-index.lisp
index 1aede641df89f116dc9fd61a5327354e0e3352d9..078279d0f41d0e2915053b212f388f1695df65aa 100644
--- a/tests/sort-vector-smallest-index.lisp
+++ b/tests/sort-vector-smallest-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-VECTOR-SMALLEST-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,176 +19,168 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-VECTOR-SMALLEST-INDEX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 7 3))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (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))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 7 3))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (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))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(0 7 3))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((COMB (MAKE-COMBINATION 8 3 NIL))
+	       (V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (GRID:COPY-TO (SORT-VECTOR-SMALLEST-INDEX COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 7 3))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (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))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1))))))
 
diff --git a/tests/sort-vector-smallest.lisp b/tests/sort-vector-smallest.lisp
index 485b04c68fd7b231328fec5d3a44a289fd2f4f3d..99594965ac4ad8637861abbb3d009ffaa9ff3334 100644
--- a/tests/sort-vector-smallest.lisp
+++ b/tests/sort-vector-smallest.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-VECTOR-SMALLEST for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,193 +19,195 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-VECTOR-SMALLEST
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-34.5 -13.49 -8.93))
-                        (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))))
-                           (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-34.5d0 -13.49d0 -8.93d0))
-                        (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))))
-                           (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(-34.5f0 -13.49f0 -8.93f0))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))
+	       (V2
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(32.5f0 42.73f0 -17.24f0))))
+	   (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-34.5d0 -13.49d0 -8.93d0))
+   (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))))
+	 (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1))))))
 
diff --git a/tests/sort-vector.lisp b/tests/sort-vector.lisp
index b101ffff7aad09d2799d5543c308ae90393b330c..deb0ad0f74e967f6da8ded50900a6a1eaaca6bc5 100644
--- a/tests/sort-vector.lisp
+++ b/tests/sort-vector.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-VECTOR for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,89 +19,89 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-VECTOR
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-34.5 -13.49 -8.93 -6.15 3.29 8.24 34.12 49.27))
-                        (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))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-34.5d0 -13.49d0 -8.93d0 -6.15d0 3.29d0 8.24d0
-                           34.12d0 49.27d0))
-                        (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))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-91 -68 -64 -10 -5 52 71 73))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(44 67 116 140 161 163 189 215))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-91 -68 -64 -10 -5 52 71 73))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(44 67 116 140 161 163 189 215))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-91 -68 -64 -10 -5 52 71 73))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(44 67 116 140 161 163 189 215))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-91 -68 -64 -10 -5 52 71 73))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(44 67 116 140 161 163 189 215))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (GRID:COPY-TO (SORT-VECTOR V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST
+      #(-34.5f0 -13.49f0 -8.93f0 -6.15f0 3.29f0 8.24f0 34.12f0 49.27f0))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(-34.5d0 -13.49d0 -8.93d0 -6.15d0 3.29d0 8.24d0
+      34.12d0 49.27d0))
+   (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))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-91 -68 -64 -10 -5 52 71 73))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(44 67 116 140 161 163 189 215))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-91 -68 -64 -10 -5 52 71 73))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(44 67 116 140 161 163 189 215))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-91 -68 -64 -10 -5 52 71 73))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(44 67 116 140 161 163 189 215))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-91 -68 -64 -10 -5 52 71 73))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(44 67 116 140 161 163 189 215))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (SORT-VECTOR V1))))))
 
diff --git a/tests/swap-columns.lisp b/tests/swap-columns.lisp
index 58253aec9050987f1e7d01a045066108e24c0e08..93bf963d5209bce2ab3dd4f7d2c43e696472dba9 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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
@@ -21,17 +21,17 @@
 (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)))
+    #2A((-34.5f0 3.29f0 8.24f0)
+	(-8.93f0 -6.15f0 34.12f0)
+	(49.27f0 32.5f0 -13.49f0)))
    (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)))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0)))))
       (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -49,18 +49,18 @@
       (GRID:COPY-TO (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))))
+    #2A((#C(-34.5f0 8.24f0) #C(34.12f0 -6.15f0) #C(3.29f0 -8.93f0))
+	(#C(-8.93f0 34.12f0) #C(-13.49f0 32.5f0) #C(-6.15f0 49.27f0))
+	(#C(49.27f0 -13.49f0) #C(-17.24f0 43.31f0)
+	   #C(32.5f0 42.73f0))))
    (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))))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))))
       (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/swap-elements.lisp b/tests/swap-elements.lisp
index 1a1fa95d034d7fd06c100ddef1bd2f22628c6026..ef41c52d7d95b81becc125e83644624dae9603d6 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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
@@ -21,13 +21,13 @@
 (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))
+    #(-34.5f0 8.24f0 -6.15f0 -8.93f0 34.12f0 3.29f0 49.27f0 -13.49f0))
    (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))))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
       (SWAP-ELEMENTS V1 2 5)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -43,16 +43,16 @@
       (GRID:COPY-TO 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)))
+    #(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(-17.24f0 43.31f0)
+      #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(34.12f0 -6.15f0)
+      #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))
    (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)))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0)
+	      #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))))
       (SWAP-ELEMENTS V1 2 5)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/swap-row-column.lisp b/tests/swap-row-column.lisp
index 21863d94bff16e718299b83c01c671abdd553304..892973a63416f280bc32e6ff754fe25bc2af3ee9 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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
@@ -21,17 +21,17 @@
 (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)))
+    #2A((3.29f0 -6.15f0 32.5f0)
+	(-8.93f0 34.12f0 8.24f0)
+	(49.27f0 -13.49f0 -34.5f0)))
    (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)))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0)))))
       (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -49,17 +49,17 @@
       (GRID:COPY-TO (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))))
+    #2A((#C(34.12f0 -6.15f0) #C(-13.49f0 32.5f0) #C(-17.24f0 43.31f0))
+	(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(3.29f0 -8.93f0))
+	(#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-34.5f0 8.24f0))))
    (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))))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))))
       (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/swap-rows.lisp b/tests/swap-rows.lisp
index b2c80c339de811b92d22b4b8cfd5584e1433652a..ce11e4463d7b8c44d019e937be6fb6f0ccc7d20e 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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
@@ -21,17 +21,17 @@
 (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)))
+    #2A((-8.93f0 34.12f0 -6.15f0)
+	(-34.5f0 8.24f0 3.29f0)
+	(49.27f0 -13.49f0 32.5f0)))
    (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)))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0)))))
       (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -49,18 +49,18 @@
       (GRID:COPY-TO (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))))
+    #2A((#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	(#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	   #C(-17.24f0 43.31f0))))
    (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))))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))))
       (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/vector-add.lisp b/tests/vector-add.lisp
index 1bd99ee9e67b12a8362ced38d6d927cc47524a8e..ea7a01643851e73e8a572cab1c89d7a17c9d22d2 100644
--- a/tests/vector-add.lisp
+++ b/tests/vector-add.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-ADD for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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
@@ -22,14 +22,14 @@
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
     (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-		 '(-43.43 42.36 -2.8600001)))
+		 '(-43.43f0 42.36f0 -2.8600001f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-			'(-34.5 8.24 3.29)))
+			'(-34.5f0 8.24f0 3.29f0)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-			'(-8.93 34.12 -6.15))))
+			'(-8.93f0 34.12f0 -6.15f0))))
       (ELT+ V1 V2))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/vector-div.lisp b/tests/vector-div.lisp
index 0d628edd334cbb61f483262126f56152f9c2dabf..e05282e7d2027ad04bda4a49635e6b920f0be90a 100644
--- a/tests/vector-div.lisp
+++ b/tests/vector-div.lisp
@@ -20,14 +20,14 @@
 
 (LISP-UNIT:DEFINE-TEST VECTOR-DIV
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(3.8633816 0.24150059 -0.5349593))
+                        (LIST #(3.8633816f0 0.24150059f0 -0.5349593f0))
                         (MULTIPLE-VALUE-LIST
                          (LET ((V1
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29)))
+                                             '(-34.5f0 8.24f0 3.29f0)))
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93 34.12 -6.15))))
+                                             '(-8.93f0 34.12f0 -6.15f0))))
                            (GRID:COPY-TO (ELT/ V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
diff --git a/tests/vector-max-index.lisp b/tests/vector-max-index.lisp
index bf98bb0abc126af57f10bfcb4747445011acebea..fbf6199152421da6264f0e992b8a5f60040088c6 100644
--- a/tests/vector-max-index.lisp
+++ b/tests/vector-max-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MAX-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,126 +19,96 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-MAX-INDEX
-                       (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))))
-                                                             (MAX-INDEX 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))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MAX-INDEX V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MAX-INDEX V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MAX-INDEX V1)))))
-
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 6)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (MAX-INDEX 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))))
+	 (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 8)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 7)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 8)
+	       :INITIAL-CONTENTS
+	       '(67 44 189 116 163 140 161 215))))
+	 (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 16)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 7)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 16)
+	       :INITIAL-CONTENTS
+	       '(67 44 189 116 163 140 161 215))))
+	 (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 32)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 7)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE
+		 32)
+	       :INITIAL-CONTENTS
+	       '(67 44 189 116 163 140 161 215))))
+	 (MAX-INDEX V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 64)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MAX-INDEX V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 7)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 64)
+	       :INITIAL-CONTENTS
+	       '(67 44 189 116 163 140 161 215))))
+	 (MAX-INDEX V1)))))
diff --git a/tests/vector-max.lisp b/tests/vector-max.lisp
index 130d92fb82db7a543a0de916b36f49520799ad47..d28fc53251da7621af033a91d25d514d77031ad3 100644
--- a/tests/vector-max.lisp
+++ b/tests/vector-max.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MAX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,105 +19,94 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-MAX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 8.24)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 8.24d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'DOUBLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5d0
-                                                                     8.24d0
-                                                                     3.29d0))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189))))
-                                                             (MMAX V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71))))
-                                                             (MMAX V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189))))
-                                                             (MMAX V1)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 8.24f0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0))))
+	   (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 8.24d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '(-34.5d0 8.24d0 3.29d0))))
+	 (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 71)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 8)
+	       :INITIAL-CONTENTS '(-64 -68 71))))
+	 (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 189)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 8)
+	       :INITIAL-CONTENTS '(67 44 189))))
+	 (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 71)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 16)
+	       :INITIAL-CONTENTS '(-64 -68 71))))
+	 (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 189)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 16)
+	       :INITIAL-CONTENTS
+	       '(67 44 189))))
+	 (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 71)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 32)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71))))
+	 (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 189)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE
+		 32)
+	       :INITIAL-CONTENTS
+	       '(67 44
+		 189))))
+	 (MMAX V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 71)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 64)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71))))
+	 (MMAX V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 189)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 64)
+	       :INITIAL-CONTENTS
+	       '(67 44 189))))
+	 (MMAX V1)))))
 
diff --git a/tests/vector-mean.lisp b/tests/vector-mean.lisp
index 257240f90bede5b32ce9705370ccdf3e2809fe74..62ed0c2911c60c20b574726478494919c9a95585 100644
--- a/tests/vector-mean.lisp
+++ b/tests/vector-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MEAN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,121 +19,92 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 3.9812498688697815d0)
-                        (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))))
-                           (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3.98125d0)
-                                                          (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))))
-                                                             (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MEAN V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MEAN V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MEAN V1)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 3.9812498688697815d0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 3.98125d0)
+   (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))))
+	 (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST -5.25d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 8)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 136.875d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 8)
+	       :INITIAL-CONTENTS
+	       '(67 44 189 116 163 140 161 215))))
+	 (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST -5.25d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 16)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 136.875d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 16)
+	       :INITIAL-CONTENTS
+	       '(67 44 189 116 163 140 161 215))))
+	 (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST -5.25d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 32)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE 32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189 116 163 140 161 215))))
+					   (MEAN V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE 64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71 -91 52 -10 73 -5))))
+					   (MEAN V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE 64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189 116 163 140 161 215))))
+					   (MEAN V1)))))
 
diff --git a/tests/vector-min-index.lisp b/tests/vector-min-index.lisp
index 61b5bdc0655da436e7ebfc0bc5ca21626b09fc86..2f6f6bb088ee6066e7fc9778b1291de7c5ab85e2 100644
--- a/tests/vector-min-index.lisp
+++ b/tests/vector-min-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MIN-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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
@@ -25,12 +25,12 @@
                                                                   (GRID:MAKE-FOREIGN-ARRAY
                                                                    'SINGLE-FLOAT
                                                                    :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49))))
+                                                                   '(-34.5f0 8.24f0
+                                                                     3.29f0 -8.93f0
+                                                                     34.12f0
+                                                                     -6.15f0
+                                                                     49.27f0
+                                                                     -13.49f0))))
                                                              (MIN-INDEX V1))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0)
                                                           (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-min.lisp b/tests/vector-min.lisp
index 543313949c8c83c8c10abd80a62c1c7f4965023b..dffc7c74b7ce1e14c5f02426bb8fc47717b9651e 100644
--- a/tests/vector-min.lisp
+++ b/tests/vector-min.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MIN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,14 +19,13 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-MIN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5)
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5f0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
                                                                   (GRID:MAKE-FOREIGN-ARRAY
                                                                    'SINGLE-FLOAT
                                                                    :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29))))
+                                                                   '(-34.5f0 8.24f0 3.29f0))))
                                                              (MMIN V1))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0)
                                                           (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-minmax-index.lisp b/tests/vector-minmax-index.lisp
index 16c0da8efca4d79703ba2cfd87df1324644dfa1b..9c8aef726dddaf39585998ec93908239f4f744ea 100644
--- a/tests/vector-minmax-index.lisp
+++ b/tests/vector-minmax-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MINMAX-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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
@@ -25,12 +25,12 @@
                                                                   (GRID:MAKE-FOREIGN-ARRAY
                                                                    'SINGLE-FLOAT
                                                                    :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49))))
+                                                                   '(-34.5f0 8.24f0
+                                                                     3.29f0 -8.93f0
+                                                                     34.12f0
+                                                                     -6.15f0
+                                                                     49.27f0
+                                                                     -13.49f0))))
                                                              (MINMAX-INDEX
                                                               V1))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 6)
diff --git a/tests/vector-minmax.lisp b/tests/vector-minmax.lisp
index 8589a4fef2c268061e167b4e8615d83dc2fd0d38..e827d6b3f4c45ca6fdfaf46a7183c779f841f12b 100644
--- a/tests/vector-minmax.lisp
+++ b/tests/vector-minmax.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MINMAX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,14 +19,13 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-MINMAX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5 8.24)
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5f0 8.24f0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
                                                                   (GRID:MAKE-FOREIGN-ARRAY
                                                                    'SINGLE-FLOAT
                                                                    :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29))))
+                                                                   '(-34.5f0 8.24f0 3.29f0))))
                                                              (MINMAX V1))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0 8.24d0)
                                                           (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-mult.lisp b/tests/vector-mult.lisp
index 604d4d7083b1b81df91078e2ee5bfda0532d5383..03d8786106257beaa6673158708a3e8bd32db76d 100644
--- a/tests/vector-mult.lisp
+++ b/tests/vector-mult.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MULT for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,14 +20,14 @@
 
 (LISP-UNIT:DEFINE-TEST VECTOR-MULT
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(308.08502 281.14877 -20.2335))
+                        (LIST #(308.08502f0 281.14877f0 -20.2335f0))
                         (MULTIPLE-VALUE-LIST
                          (LET ((V1
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29)))
+                                             '(-34.5f0 8.24f0 3.29f0)))
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93 34.12 -6.15))))
+                                             '(-8.93f0 34.12f0 -6.15f0))))
                            (GRID:COPY-TO (ELT* V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(308.085d0 281.1488d0 -20.233500000000003d0))
diff --git a/tests/vector-reverse.lisp b/tests/vector-reverse.lisp
index 7b753f8a9e36b62e3d776d2773e8b4d685ecc18e..e0bd759e7dfcaae5438e2bf5654ae1fd719353ba 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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,40 +19,40 @@
 (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))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST
+      #(-13.49f0 49.27f0 -6.15f0 34.12f0 -8.93f0 3.29f0 8.24f0 -34.5f0))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (GRID:COPY-TO (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))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (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))))
+	 (GRID:COPY-TO (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)))
+    #(#C(21.44f0 -49.08f0) #C(-16.12f0 -8.25f0) #C(-17.24f0 43.31f0)
+      #C(32.5f0 42.73f0) #C(49.27f0 -13.49f0) #C(34.12f0 -6.15f0)
+      #C(3.29f0 -8.93f0) #C(-34.5f0 8.24f0)))
    (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)))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX SINGLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)
+		 #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+		 #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(21.44d0 -49.08d0) #C(-16.12d0 -8.25d0)
@@ -60,79 +60,79 @@
       #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)))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (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)))))
+	 (GRID:COPY-TO (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))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 8)
+	       :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (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))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 8)
+	       :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (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))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 16)
+	       :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (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))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 16)
+	       :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (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))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 32)
+	       :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (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))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 32)
+	       :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (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))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 64)
+	       :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (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))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1))))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 64)
+	       :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1))))))
 
diff --git a/tests/vector-set-all.lisp b/tests/vector-set-all.lisp
index 9d2b34692b66eb1e4a428390275b7ad0dba717ba..41f4c9403e4f50c45223dee2e7c9a3bd4b5b5fc1 100644
--- a/tests/vector-set-all.lisp
+++ b/tests/vector-set-all.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-SET-ALL for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,10 +20,10 @@
 
 (LISP-UNIT:DEFINE-TEST VECTOR-SET-ALL
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-   (LIST #(-34.5 -34.5 -34.5))
+   (LIST #(-34.5f0 -34.5f0 -34.5f0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
-      (GRID:COPY-TO (SET-ALL V1 -34.5)))))
+      (GRID:COPY-TO (SET-ALL V1 -34.5f0)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST #(-34.5d0 -34.5d0 -34.5d0))
    (MULTIPLE-VALUE-LIST
@@ -31,12 +31,12 @@
       (GRID:COPY-TO (SET-ALL V1 -34.5d0)))))
   #+fsbv
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-   (LIST #(#C(-34.5 8.24) #C(-34.5 8.24) #C(-34.5 8.24)))
+   (LIST #(#C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
 			:DIMENSIONS '3)))
-      (GRID:COPY-TO (SET-ALL V1 #C(-34.5 8.24))))))
+      (GRID:COPY-TO (SET-ALL V1 #C(-34.5f0 8.24f0))))))
   #+fsbv
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/vector-set-zero.lisp b/tests/vector-set-zero.lisp
index a996afdf736a856f83692c18d6661247df1c9c1d..26cf9efe25d1c03a1fef6efc0150d811b99991b5 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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,10 +20,10 @@
 
 (LISP-UNIT:DEFINE-TEST VECTOR-SET-ZERO
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(0.0 0.0 0.0))
+   (LIST #(0.0f0 0.0f0 0.0f0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5 8.24 3.29))))
+	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0))))
       (SET-ZERO V1)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -34,12 +34,12 @@
       (SET-ZERO V1)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0)))
+   (LIST #(#C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(0.0f0 0.0f0)))
    (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)))))
+	    :INITIAL-CONTENTS '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)))))
       (SET-ZERO V1)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/vector-standard-deviation-with-fixed-mean.lisp b/tests/vector-standard-deviation-with-fixed-mean.lisp
index 461606835516fe0a43401cdd9bb1142ed0d23685..2da23145f83bbcd23169a89ae8c5e39ce478b226 100644
--- a/tests/vector-standard-deviation-with-fixed-mean.lisp
+++ b/tests/vector-standard-deviation-with-fixed-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-STANDARD-DEVIATION-WITH-FIXED-MEAN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,86 +19,87 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-STANDARD-DEVIATION-WITH-FIXED-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 25.08341998337271d0)
-                        (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))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 25.08342004068624d0)
-                        (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))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 61.216317269172606d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 54.81659762334762d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 61.216317269172606d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 54.81659762334762d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 61.216317269172606d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 54.81659762334762d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 61.216317269172606d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 54.81659762334762d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 25.08341998337271d0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 25.08342004068624d0)
+   (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))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 61.216317269172606d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 54.81659762334762d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 61.216317269172606d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 54.81659762334762d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 61.216317269172606d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 54.81659762334762d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 61.216317269172606d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 54.81659762334762d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))))
 
diff --git a/tests/vector-standard-deviation-with-mean.lisp b/tests/vector-standard-deviation-with-mean.lisp
index 70861eef49453862a0d292b14f23630d1b74fa7c..4742663cc80367b381b41130cea0e551c56fba9c 100644
--- a/tests/vector-standard-deviation-with-mean.lisp
+++ b/tests/vector-standard-deviation-with-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-STANDARD-DEVIATION-WITH-MEAN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,86 +19,85 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-STANDARD-DEVIATION-WITH-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 26.815303904668458d0)
-                        (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))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 26.815303965939197d0)
-                        (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))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1 (MEAN V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 26.815303904668458d0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 26.815303965939197d0)
+   (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))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1 (MEAN V1))))))
 
diff --git a/tests/vector-standard-deviation.lisp b/tests/vector-standard-deviation.lisp
index 1fde788bae6930fd73bd77614c2860a6615a4a6d..083ee98dcfd217c56e1afca24bb8addd20791794 100644
--- a/tests/vector-standard-deviation.lisp
+++ b/tests/vector-standard-deviation.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-STANDARD-DEVIATION for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,86 +19,87 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-STANDARD-DEVIATION
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 26.815303904668458d0)
-                        (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))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 26.815303965939197d0)
-                        (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))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 26.815303904668458d0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 26.815303965939197d0)
+   (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))))
+	 (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1)))))
 
diff --git a/tests/vector-sub.lisp b/tests/vector-sub.lisp
index ec1875e09a2f6f3c0a483c9f5748f3012361c5d0..a6c77915116abfa0615ddad9a397319aa549ba10 100644
--- a/tests/vector-sub.lisp
+++ b/tests/vector-sub.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-SUB for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,147 +19,147 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-SUB
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-25.57 -25.88 9.440001))
-                        (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))))
-                           (GRID:COPY-TO (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-25.57d0 -25.879999999999995d0 9.440000000000001d0))
-                        (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))))
-                           (GRID:COPY-TO (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
-                                                          (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))))
-                                                             (GRID:COPY-TO
-                                                              (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(207 137 49))
-                                                          (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))))
-                                                             (GRID:COPY-TO
-                                                              (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
-                                                          (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))))
-                                                             (GRID:COPY-TO
-                                                              (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(65487 65417 49))
-                        (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))))
-                           (GRID:COPY-TO (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
-                                                          (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))))
-                                                             (GRID:COPY-TO
-                                                              (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(4294967247 4294967177 49))
-                        (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))))
-                           (GRID:COPY-TO (ELT- V1 V2)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
-                                                          (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))))
-                                                             (GRID:COPY-TO
-                                                              (ELT- V1 V2)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(18446744073709551567 18446744073709551497 49))
-                        (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))))
-                           (GRID:COPY-TO (ELT- V1 V2))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(-25.57f0 -25.88f0 9.440001f0))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
+					 '(-34.5f0 8.24f0 3.29f0)))
+	       (V2
+		(GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
+					 '(-8.93f0 34.12f0 -6.15f0))))
+	   (GRID:COPY-TO (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(-25.57d0 -25.879999999999995d0 9.440000000000001d0))
+   (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))))
+	 (GRID:COPY-TO (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
+				     (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))))
+					   (GRID:COPY-TO
+					    (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(207 137 49))
+				     (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))))
+					   (GRID:COPY-TO
+					    (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
+				     (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))))
+					   (GRID:COPY-TO
+					    (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(65487 65417 49))
+   (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))))
+	 (GRID:COPY-TO (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
+				     (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))))
+					   (GRID:COPY-TO
+					    (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(4294967247 4294967177 49))
+   (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))))
+	 (GRID:COPY-TO (ELT- V1 V2)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
+				     (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))))
+					   (GRID:COPY-TO
+					    (ELT- V1 V2)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(18446744073709551567 18446744073709551497 49))
+   (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))))
+	 (GRID:COPY-TO (ELT- V1 V2))))))
 
diff --git a/tests/vector-swap.lisp b/tests/vector-swap.lisp
index 0284afebb65f359f9b902b8099dcd034d605bec7..c9ed03b64c95addab524c204940028cfa5049851 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, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 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,16 +20,16 @@
 
 (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)))
+   (LIST (LIST #(-8.93f0 34.12f0 -6.15f0) #(-34.5f0 8.24f0 3.29f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
-	    :INITIAL-CONTENTS '(-34.5 8.24 3.29)))
+	    :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
-	    :INITIAL-CONTENTS '(-8.93 34.12 -6.15))))
+	    :INITIAL-CONTENTS '(-8.93f0 34.12f0 -6.15f0))))
       (SWAP V2 V1)
       (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -50,19 +50,19 @@
   (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))))
+     #(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+     #(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))))
    (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(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))))
 	  (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)))))
+	    '(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)))))
       (SWAP V2 V1)
       (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/vector-variance-with-fixed-mean.lisp b/tests/vector-variance-with-fixed-mean.lisp
index 17101679afe1f835334ee262d7e5d2a362856375..abc6a545a9a010f2469600d4fcb052a6d40a7d1a 100644
--- a/tests/vector-variance-with-fixed-mean.lisp
+++ b/tests/vector-variance-with-fixed-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-VARIANCE-WITH-FIXED-MEAN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,123 +19,123 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-VARIANCE-WITH-FIXED-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 629.1779580622615d0)
-                        (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))))
-                           (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 629.1779609375001d0)
-                        (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))))
-                           (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 629.1779580622615d0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 629.1779609375001d0)
+   (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))))
+	 (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1))))))
 
diff --git a/tests/vector-variance-with-mean.lisp b/tests/vector-variance-with-mean.lisp
index fd2ba2dd1137af8ad41d1e886ef8828d549b6f20..775a540a620a09fc12c6f37ca99313708a9e267c 100644
--- a/tests/vector-variance-with-mean.lisp
+++ b/tests/vector-variance-with-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-VARIANCE-WITH-MEAN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,8 +24,8 @@
                         (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))))
+                                             '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0
+                                               -6.15f0 49.27f0 -13.49f0))))
                            (VARIANCE V1 (MEAN V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 719.0605267857144d0)
diff --git a/tests/vector-variance.lisp b/tests/vector-variance.lisp
index 0d64116a247dea4bcdb00dc18e14085193b68464..45aa4f51f0dc0c6a751e2e461eebe75ad141499b 100644
--- a/tests/vector-variance.lisp
+++ b/tests/vector-variance.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-VARIANCE for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 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,105 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-VARIANCE
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 719.0605234997274d0)
-                        (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))))
-                           (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 719.0605267857144d0)
-                        (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))))
-                           (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 4282.785714285714d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 4282.785714285714d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 4282.785714285714d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 4282.785714285714d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (VARIANCE V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE V1)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 719.0605234997274d0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 719.0605267857144d0)
+   (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))))
+	 (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4282.785714285714d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 8)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4282.785714285714d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4282.785714285714d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4282.785714285714d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (VARIANCE V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE V1)))))