From 52cc09fec6de5dbf783ff9e2fdee1c0c031f0418 Mon Sep 17 00:00:00 2001
From: "Liam M. Healy" <lhealy@common-lisp.net>
Date: Wed, 12 Jan 2011 09:15:28 -0500
Subject: [PATCH] Single-float tests have explicit single-float numbers
 (finish)

---
 tests/matrix-product-nonsquare.lisp           |  30 +-
 tests/matrix-product-symmetric.lisp           | 182 +++++-----
 tests/matrix-product-triangular.lisp          |  66 ++--
 tests/matrix-set-all.lisp                     | 204 +++++------
 tests/matrix-set-zero.lisp                    |  16 +-
 ...ix-standard-deviation-with-fixed-mean.lisp | 186 +++++-----
 .../matrix-standard-deviation-with-mean.lisp  | 186 +++++-----
 tests/matrix-standard-deviation.lisp          | 186 +++++-----
 tests/matrix-sub.lisp                         | 316 +++++++++--------
 tests/matrix-swap.lisp                        | 335 +++++++++---------
 tests/matrix-transpose-copy.lisp              |  26 +-
 tests/matrix-transpose.lisp                   |  27 +-
 tests/matrix-variance-with-fixed-mean.lisp    | 186 +++++-----
 tests/matrix-variance-with-mean.lisp          | 244 ++++++-------
 tests/matrix-variance.lisp                    | 228 ++++++------
 15 files changed, 1217 insertions(+), 1201 deletions(-)

diff --git a/tests/matrix-product-nonsquare.lisp b/tests/matrix-product-nonsquare.lisp
index 451928f1..d8a28910 100644
--- a/tests/matrix-product-nonsquare.lisp
+++ b/tests/matrix-product-nonsquare.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-PRODUCT-NONSQUARE for GSLL, automatically generated
 ;;
-;; Copyright 2009, 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,18 +20,18 @@
 
 (LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT-NONSQUARE
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #2A((-1488.7347 959.9901) (774.94495 1312.0566)))
+   (LIST #2A((-1488.7347f0 959.9901f0) (774.94495f0 1312.0566f0)))
    (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))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '((49.27 -13.49) (32.5 42.73)
-	      (-17.24 43.31)))))
+	    '((49.27f0 -13.49f0) (32.5f0 42.73f0)
+	      (-17.24f0 43.31f0)))))
       (GRID:COPY-TO (MATRIX-PRODUCT M1 M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -53,24 +53,24 @@
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(-1422.0259 2305.5098)
-	   #C(-1744.0583 -1092.294))
-	(#C(-3459.892 1995.4918)
-	   #C(-3290.4465 -801.0577))))
+    #2A((#C(-1422.0259f0 2305.5098f0)
+	   #C(-1744.0583f0 -1092.294f0))
+	(#C(-3459.892f0 1995.4918f0)
+	   #C(-3290.4465f0 -801.0577f0))))
    (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(-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)))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '((#C(49.27 -13.49) #C(32.5 42.73))
-	      (#C(32.5 42.73) #C(-17.24 43.31))
-	      (#C(-17.24 43.31) #C(-16.12 -8.25))))))
+	    '((#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0))
+	      (#C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))
+	      (#C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0))))))
       (GRID:COPY-TO (MATRIX-PRODUCT M1 M2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/matrix-product-symmetric.lisp b/tests/matrix-product-symmetric.lisp
index bab60036..92c9560f 100644
--- a/tests/matrix-product-symmetric.lisp
+++ b/tests/matrix-product-symmetric.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-PRODUCT-SYMMETRIC 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,95 +19,95 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT-SYMMETRIC
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((74519.41 -16747.695 61311.69)
-                             (-3264.9219 6201.1797 -56698.92)
-                             (57711.813 52563.74 65404.063)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((42.73 -17.24 43.31)
-                                               (-16.12 -8.25 21.44)
-                                               (-49.08 -39.66 -49.46))))
-                               (M3
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((19.68 -5.55 -8.82)
-                                               (25.37 -30.58 31.67)
-                                               (29.36 -33.24 -27.03))))
-                               (S1 -41.67)
-                               (S2 42.0))
-                           (GRID:COPY-TO
-                            (MATRIX-PRODUCT-SYMMETRIC M1 M2 M3 S1 S2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((74519.41329d0 -16747.696062d0
-                              61311.694176000005d0)
-                             (-3264.923076000001d0 6201.180462000002d0
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((74519.41f0 -16747.695f0 61311.69f0)
+	(-3264.9219f0 6201.1797f0 -56698.92f0)
+	(57711.813f0 52563.74f0 65404.063f0)))
+   (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 :INITIAL-CONTENTS
+				       '((42.73f0 -17.24f0 43.31f0)
+					 (-16.12f0 -8.25f0 21.44f0)
+					 (-49.08f0 -39.66f0 -49.46f0))))
+	     (M3
+	      (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
+				       '((19.68f0 -5.55f0 -8.82f0)
+					 (25.37f0 -30.58f0 31.67f0)
+					 (29.36f0 -33.24f0 -27.03f0))))
+	     (S1 -41.67f0)
+	     (S2 42.0f0))
+	 (GRID:COPY-TO
+	  (MATRIX-PRODUCT-SYMMETRIC M1 M2 M3 S1 S2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((74519.41329d0 -16747.696062d0
+		       61311.694176000005d0)
+	(-3264.923076000001d0 6201.180462000002d0
                               -56698.92695400001d0)
-                             (57711.81710100001d0 52563.740607d0
-                              65404.066887d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((42.73d0 -17.24d0 43.31d0)
-                                               (-16.12d0 -8.25d0 21.44d0)
-                                               (-49.08d0 -39.66d0 -49.46d0))))
-                               (M3
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((19.68d0 -5.55d0 -8.82d0)
-                                               (25.37d0 -30.58d0 31.67d0)
-                                               (29.36d0 -33.24d0 -27.03d0))))
-                               (S1 -41.67d0)
-                               (S2 42.0d0))
-                           (GRID:COPY-TO
-                            (MATRIX-PRODUCT-SYMMETRIC M1 M2 M3 S1 S2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(72971.1 24989.41 -82037.61))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(42.73 -17.24 43.31)))
-                               (V3
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-16.12 -8.25 21.44)))
-                               (S1 -49.08)
-                               (S2 -39.66))
-                           (GRID:COPY-TO
-                            (MATRIX-PRODUCT-SYMMETRIC M1 V1 V3 S1 S2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(72971.10171599999d0 24989.409107999996d0
-                           -82037.597316d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(42.73d0 -17.24d0 43.31d0)))
-                               (V3
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-16.12d0 -8.25d0 21.44d0)))
-                               (S1 -49.08d0)
-                               (S2 -39.66d0))
-                           (GRID:COPY-TO
-                            (MATRIX-PRODUCT-SYMMETRIC M1 V1 V3 S1 S2))))))
+	(57711.81710100001d0 52563.740607d0
+			     65404.066887d0)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '((-34.5d0 8.24d0 3.29d0)
+					 (-8.93d0 34.12d0 -6.15d0)
+					 (49.27d0 -13.49d0 32.5d0))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '((42.73d0 -17.24d0 43.31d0)
+					 (-16.12d0 -8.25d0 21.44d0)
+					 (-49.08d0 -39.66d0 -49.46d0))))
+	     (M3
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '((19.68d0 -5.55d0 -8.82d0)
+					 (25.37d0 -30.58d0 31.67d0)
+					 (29.36d0 -33.24d0 -27.03d0))))
+	     (S1 -41.67d0)
+	     (S2 42.0d0))
+	 (GRID:COPY-TO
+	  (MATRIX-PRODUCT-SYMMETRIC M1 M2 M3 S1 S2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(72971.1f0 24989.41f0 -82037.61f0))
+   (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))))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
+				       '(42.73f0 -17.24f0 43.31f0)))
+	     (V3
+	      (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
+				       '(-16.12f0 -8.25f0 21.44f0)))
+	     (S1 -49.08f0)
+	     (S2 -39.66f0))
+	 (GRID:COPY-TO
+	  (MATRIX-PRODUCT-SYMMETRIC M1 V1 V3 S1 S2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(72971.10171599999d0 24989.409107999996d0
+      -82037.597316d0))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '((-34.5d0 8.24d0 3.29d0)
+					 (-8.93d0 34.12d0 -6.15d0)
+					 (49.27d0 -13.49d0 32.5d0))))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(42.73d0 -17.24d0 43.31d0)))
+	     (V3
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(-16.12d0 -8.25d0 21.44d0)))
+	     (S1 -49.08d0)
+	     (S2 -39.66d0))
+	 (GRID:COPY-TO
+	  (MATRIX-PRODUCT-SYMMETRIC M1 V1 V3 S1 S2))))))
 
diff --git a/tests/matrix-product-triangular.lisp b/tests/matrix-product-triangular.lisp
index 8b6131ea..db483738 100644
--- a/tests/matrix-product-triangular.lisp
+++ b/tests/matrix-product-triangular.lisp
@@ -21,23 +21,23 @@
 (LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT-TRIANGULAR
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((-34803.82 7799.5503 -29131.375)
-	(-4884.0327 -739.594 20382.809)
-	(-31391.57 -25366.535 -31634.615)))
+    #2A((-34803.82f0 7799.5503f0 -29131.375f0)
+	(-4884.0327f0 -739.594f0 20382.809f0)
+	(-31391.57f0 -25366.535f0 -31634.615f0)))
    (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 (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -62,25 +62,25 @@
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(-66397.9 18986.908) #C(-56335.145 48514.305) #C(-18830.469 -13449.601))
-	(#C(38337.09 -49128.918) #C(42681.344 -22972.445) #C(50375.406 -50562.54))
-	(#C(42453.223 -42606.086) #C(-13764.868 -48835.813) #C(8910.526 -4389.117))))
+    #2A((#C(-66397.9f0 18986.908f0) #C(-56335.145f0 48514.305f0) #C(-18830.469f0 -13449.601f0))
+	(#C(38337.09f0 -49128.918f0) #C(42681.344f0 -22972.445f0) #C(50375.406f0 -50562.54f0))
+	(#C(42453.223f0 -42606.086f0) #C(-13764.868f0 -48835.813f0) #C(8910.526f0 -4389.117f0))))
    (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 (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -112,19 +112,19 @@
 	  (S1 #C(19.68d0 -5.55d0)))
       (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(-1473.7527 -854.58527 1407.5751))
+   (LIST #(-1473.7527f0 -854.58527f0 1407.5751f0))
    (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 (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-1473.7527d0 -854.5853d0 1407.575d0))
@@ -144,22 +144,22 @@
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #(#C(-1483.223 1289.3523) #C(-57.63159 1675.6711)
-      #C(-786.3365 -726.9331)))
+    #(#C(-1483.223f0 1289.3523f0) #C(-57.63159f0 1675.6711f0)
+      #C(-786.3365f0 -726.9331f0)))
    (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 (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/matrix-set-all.lisp b/tests/matrix-set-all.lisp
index 0cf3ffdf..e87e73c1 100644
--- a/tests/matrix-set-all.lisp
+++ b/tests/matrix-set-all.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-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
@@ -19,105 +19,105 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-SET-ALL
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5 -34.5 -34.5)
-                             (-34.5 -34.5 -34.5)
-                             (-34.5 -34.5 -34.5)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(3 3))))
-                           (GRID:COPY-TO (SET-ALL M1 -34.5)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5d0 -34.5d0 -34.5d0)
-                             (-34.5d0 -34.5d0 -34.5d0)
-                             (-34.5d0 -34.5d0 -34.5d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(3 3))))
-                           (GRID:COPY-TO (SET-ALL M1 -34.5d0)))))
-		       #+fsbv
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-34.5 8.24) #C(-34.5 8.24) #C(-34.5 8.24))
-                             (#C(-34.5 8.24) #C(-34.5 8.24) #C(-34.5 8.24))
-                             (#C(-34.5 8.24) #C(-34.5 8.24) #C(-34.5 8.24))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
-                                             :DIMENSIONS '(3 3))))
-                           (GRID:COPY-TO (SET-ALL M1 #C(-34.5 8.24))))))
-		       #+fsbv
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0)
-                              #C(-34.5d0 8.24d0))
-                             (#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0)
-                              #C(-34.5d0 8.24d0))
-                             (#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0)
-                              #C(-34.5d0 8.24d0))))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
-                                             :DIMENSIONS '(3 3))))
-                           (GRID:COPY-TO (SET-ALL M1 #C(-34.5d0 8.24d0))))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS
-                                             '(3 3))))
-                           (GRID:COPY-TO (SET-ALL M1 -64)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 67 67) (67 67 67) (67 67 67)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS
-                                             '(3 3))))
-                           (GRID:COPY-TO (SET-ALL M1 67)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS
-                                             '(3 3))))
-                           (GRID:COPY-TO (SET-ALL M1 -64)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 67 67) (67 67 67) (67 67 67)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS
-                                             '(3 3))))
-                           (GRID:COPY-TO (SET-ALL M1 67)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS
-                                             '(3 3))))
-                           (GRID:COPY-TO (SET-ALL M1 -64)))))
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 67 67) (67 67 67) (67 67 67)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
-                                             '(3 3))))
-                           (GRID:COPY-TO (SET-ALL M1 67)))))
-		       #+int64
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS
-                                             '(3 3))))
-                           (GRID:COPY-TO (SET-ALL M1 -64)))))
-		       #+int64
-                       (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((67 67 67) (67 67 67) (67 67 67)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS
-                                             '(3 3))))
-                           (GRID:COPY-TO (SET-ALL M1 67))))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5f0 -34.5f0 -34.5f0)
+	(-34.5f0 -34.5f0 -34.5f0)
+	(-34.5f0 -34.5f0 -34.5f0)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(3 3))))
+	 (GRID:COPY-TO (SET-ALL M1 -34.5f0)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5d0 -34.5d0 -34.5d0)
+	(-34.5d0 -34.5d0 -34.5d0)
+	(-34.5d0 -34.5d0 -34.5d0)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(3 3))))
+	 (GRID:COPY-TO (SET-ALL M1 -34.5d0)))))
+  #+fsbv
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0))
+	(#C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0))
+	(#C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0))))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
+				       :DIMENSIONS '(3 3))))
+	 (GRID:COPY-TO (SET-ALL M1 #C(-34.5f0 8.24f0))))))
+  #+fsbv
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0)
+	   #C(-34.5d0 8.24d0))
+	(#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0)
+	   #C(-34.5d0 8.24d0))
+	(#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0)
+	   #C(-34.5d0 8.24d0))))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
+				       :DIMENSIONS '(3 3))))
+	 (GRID:COPY-TO (SET-ALL M1 #C(-34.5d0 8.24d0))))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS
+				       '(3 3))))
+	 (GRID:COPY-TO (SET-ALL M1 -64)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 67 67) (67 67 67) (67 67 67)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS
+				       '(3 3))))
+	 (GRID:COPY-TO (SET-ALL M1 67)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS
+				       '(3 3))))
+	 (GRID:COPY-TO (SET-ALL M1 -64)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 67 67) (67 67 67) (67 67 67)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS
+				       '(3 3))))
+	 (GRID:COPY-TO (SET-ALL M1 67)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS
+				       '(3 3))))
+	 (GRID:COPY-TO (SET-ALL M1 -64)))))
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 67 67) (67 67 67) (67 67 67)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
+				       '(3 3))))
+	 (GRID:COPY-TO (SET-ALL M1 67)))))
+  #+int64
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS
+				       '(3 3))))
+	 (GRID:COPY-TO (SET-ALL M1 -64)))))
+  #+int64
+  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((67 67 67) (67 67 67) (67 67 67)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS
+				       '(3 3))))
+	 (GRID:COPY-TO (SET-ALL M1 67))))))
 
diff --git a/tests/matrix-set-zero.lisp b/tests/matrix-set-zero.lisp
index 404839e6..a4ac57c4 100644
--- a/tests/matrix-set-zero.lisp
+++ b/tests/matrix-set-zero.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-SET-ZERO for GSLL, automatically generated
 ;;
-;; Copyright 2009, 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,14 +20,14 @@
 
 (LISP-UNIT:DEFINE-TEST MATRIX-SET-ZERO
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #2A((0.0 0.0 0.0) (0.0 0.0 0.0) (0.0 0.0 0.0)))
+   (LIST #2A((0.0f0 0.0f0 0.0f0) (0.0f0 0.0f0 0.0f0) (0.0f0 0.0f0 0.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)))))
       (SET-ZERO M1)
       (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -54,9 +54,9 @@
 	   (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))))))
       (SET-ZERO M1)
       (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/matrix-standard-deviation-with-fixed-mean.lisp b/tests/matrix-standard-deviation-with-fixed-mean.lisp
index 5d828d61..990c48a0 100644
--- a/tests/matrix-standard-deviation-with-fixed-mean.lisp
+++ b/tests/matrix-standard-deviation-with-fixed-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-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,95 +19,97 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-STANDARD-DEVIATION-WITH-FIXED-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 25.290257201025927d0)
-                        (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)))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 25.290257236950186d0)
-                        (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)))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 70.39570693980959d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 53.10599696437538d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 70.39570693980959d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 53.10599696437538d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 70.39570693980959d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 53.10599696437538d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 70.39570693980959d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 53.10599696437538d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 25.290257201025927d0)
+   (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)))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 25.290257236950186d0)
+   (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)))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 70.39570693980959d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 53.10599696437538d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 70.39570693980959d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 53.10599696437538d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 70.39570693980959d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 53.10599696437538d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 70.39570693980959d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 53.10599696437538d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))))
 
diff --git a/tests/matrix-standard-deviation-with-mean.lisp b/tests/matrix-standard-deviation-with-mean.lisp
index a89173a2..3112a402 100644
--- a/tests/matrix-standard-deviation-with-mean.lisp
+++ b/tests/matrix-standard-deviation-with-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-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,95 +19,97 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-STANDARD-DEVIATION-WITH-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 26.824368547196023d0)
-                        (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)))))
-                           (STANDARD-DEVIATION M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 26.82436858529945d0)
-                        (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)))))
-                           (STANDARD-DEVIATION M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 74.66592261534039d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (STANDARD-DEVIATION M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 56.32741586277306d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (STANDARD-DEVIATION M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 74.66592261534039d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (STANDARD-DEVIATION M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 56.32741586277306d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (STANDARD-DEVIATION M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 74.66592261534039d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (STANDARD-DEVIATION M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 56.32741586277306d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (STANDARD-DEVIATION M1 (MEAN M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 74.66592261534039d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (STANDARD-DEVIATION M1 (MEAN M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 56.32741586277306d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (STANDARD-DEVIATION M1 (MEAN M1))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 26.824368547196023d0)
+   (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)))))
+	 (STANDARD-DEVIATION M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 26.82436858529945d0)
+   (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)))))
+	 (STANDARD-DEVIATION M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 74.66592261534039d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (STANDARD-DEVIATION M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 56.32741586277306d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (STANDARD-DEVIATION M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 74.66592261534039d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (STANDARD-DEVIATION M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 56.32741586277306d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (STANDARD-DEVIATION M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 74.66592261534039d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (STANDARD-DEVIATION M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 56.32741586277306d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (STANDARD-DEVIATION M1 (MEAN M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 74.66592261534039d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (STANDARD-DEVIATION M1 (MEAN M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 56.32741586277306d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (STANDARD-DEVIATION M1 (MEAN M1))))))
 
diff --git a/tests/matrix-standard-deviation.lisp b/tests/matrix-standard-deviation.lisp
index f03008bc..e0409c36 100644
--- a/tests/matrix-standard-deviation.lisp
+++ b/tests/matrix-standard-deviation.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-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,95 +19,97 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-STANDARD-DEVIATION
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 26.824368547196023d0)
-                        (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)))))
-                           (STANDARD-DEVIATION M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 26.82436858529945d0)
-                        (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)))))
-                           (STANDARD-DEVIATION M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 74.66592261534039d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (STANDARD-DEVIATION M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 56.32741586277306d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (STANDARD-DEVIATION M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 74.66592261534039d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (STANDARD-DEVIATION M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 56.32741586277306d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (STANDARD-DEVIATION M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 74.66592261534039d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (STANDARD-DEVIATION M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 56.32741586277306d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (STANDARD-DEVIATION M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 74.66592261534039d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (STANDARD-DEVIATION M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 56.32741586277306d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (STANDARD-DEVIATION M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 26.824368547196023d0)
+   (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)))))
+	 (STANDARD-DEVIATION M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 26.82436858529945d0)
+   (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)))))
+	 (STANDARD-DEVIATION M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 74.66592261534039d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (STANDARD-DEVIATION M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 56.32741586277306d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (STANDARD-DEVIATION M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 74.66592261534039d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (STANDARD-DEVIATION M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 56.32741586277306d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (STANDARD-DEVIATION M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 74.66592261534039d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (STANDARD-DEVIATION M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 56.32741586277306d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (STANDARD-DEVIATION M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 74.66592261534039d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (STANDARD-DEVIATION M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 56.32741586277306d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (STANDARD-DEVIATION M1)))))
 
diff --git a/tests/matrix-sub.lisp b/tests/matrix-sub.lisp
index f34a2da4..8b1421d7 100644
--- a/tests/matrix-sub.lisp
+++ b/tests/matrix-sub.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-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,160 +19,164 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-SUB
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-77.229996 25.48 -40.02)
-                             (7.1900005 42.37 -27.59)
-                             (98.350006 26.17 81.96)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((42.73 -17.24 43.31)
-                                               (-16.12 -8.25 21.44)
-                                               (-49.08 -39.66 -49.46)))))
-                           (GRID:COPY-TO (ELT- M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-77.22999999999999d0 25.479999999999997d0
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-77.229996f0 25.48f0 -40.02f0)
+	(7.1900005f0 42.37f0 -27.59f0)
+	(98.350006f0 26.17f0 81.96f0)))
+   (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
+	       :INITIAL-CONTENTS
+	       '((42.73f0 -17.24f0 43.31f0)
+		 (-16.12f0 -8.25f0 21.44f0)
+		 (-49.08f0 -39.66f0 -49.46f0)))))
+	 (GRID:COPY-TO (ELT- M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-77.22999999999999d0 25.479999999999997d0
                               -40.02d0)
-                             (7.190000000000001d0 42.37d0
-                              -27.590000000000003d0)
-                             (98.35d0 26.169999999999995d0
-                              81.96000000000001d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((42.73d0 -17.24d0 43.31d0)
-                                               (-16.12d0 -8.25d0 21.44d0)
-                                               (-49.08d0 -39.66d0 -49.46d0)))))
-                           (GRID:COPY-TO (ELT- M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((32 28 30) (37 -73 -8)
-                                               (-15 -22 68)))))
-                           (GRID:COPY-TO (ELT- M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((39 34 170) (88 241 179) (125 106 132)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((28 10 19) (28 178 217)
-                                               (36 109 222)))))
-                           (GRID:COPY-TO (ELT- M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((32 28 30) (37 -73 -8)
-                                               (-15 -22 68)))))
-                           (GRID:COPY-TO (ELT- M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((39 34 170) (88 65521 65459) (125 106 65412)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((28 10 19) (28 178 217)
-                                               (36 109 222)))))
-                           (GRID:COPY-TO (ELT- M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((32 28 30) (37 -73 -8)
-                                               (-15 -22 68)))))
-                           (GRID:COPY-TO (ELT- M1 M2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((39 34 170)
-                             (88 4294967281 4294967219)
-                             (125 106 4294967172)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((28 10 19) (28 178 217)
-                                               (36 109 222)))))
-                           (GRID:COPY-TO (ELT- M1 M2)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((32 28 30) (37 -73 -8)
-                                               (-15 -22 68)))))
-                           (GRID:COPY-TO (ELT- M1 M2)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((39 34 170)
-                             (88 18446744073709551601 18446744073709551539)
-                             (125 106 18446744073709551492)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((28 10 19) (28 178 217)
-                                               (36 109 222)))))
-                           (GRID:COPY-TO (ELT- M1 M2))))))
+	(7.190000000000001d0 42.37d0
+			     -27.590000000000003d0)
+	(98.35d0 26.169999999999995d0
+		 81.96000000000001d0)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '((-34.5d0 8.24d0 3.29d0)
+					 (-8.93d0 34.12d0 -6.15d0)
+					 (49.27d0 -13.49d0 32.5d0))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '((42.73d0 -17.24d0 43.31d0)
+					 (-16.12d0 -8.25d0 21.44d0)
+					 (-49.08d0 -39.66d0 -49.46d0)))))
+	 (GRID:COPY-TO (ELT- M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((32 28 30) (37 -73 -8)
+					 (-15 -22 68)))))
+	 (GRID:COPY-TO (ELT- M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((39 34 170) (88 241 179) (125 106 132)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((28 10 19) (28 178 217)
+					 (36 109 222)))))
+	 (GRID:COPY-TO (ELT- M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((32 28 30) (37 -73 -8)
+					 (-15 -22 68)))))
+	 (GRID:COPY-TO (ELT- M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((39 34 170) (88 65521 65459) (125 106 65412)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((28 10 19) (28 178 217)
+					 (36 109 222)))))
+	 (GRID:COPY-TO (ELT- M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((32 28 30) (37 -73 -8)
+					 (-15 -22 68)))))
+	 (GRID:COPY-TO (ELT- M1 M2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((39 34 170)
+	(88 4294967281 4294967219)
+	(125 106 4294967172)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((28 10 19) (28 178 217)
+					 (36 109 222)))))
+	 (GRID:COPY-TO (ELT- M1 M2)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((32 28 30) (37 -73 -8)
+					 (-15 -22 68)))))
+	 (GRID:COPY-TO (ELT- M1 M2)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((39 34 170)
+	(88 18446744073709551601 18446744073709551539)
+	(125 106 18446744073709551492)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((28 10 19) (28 178 217)
+					 (36 109 222)))))
+	 (GRID:COPY-TO (ELT- M1 M2))))))
 
diff --git a/tests/matrix-swap.lisp b/tests/matrix-swap.lisp
index 71024321..d204d7f2 100644
--- a/tests/matrix-swap.lisp
+++ b/tests/matrix-swap.lisp
@@ -22,27 +22,29 @@
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
-     #2A((42.73 -17.24 43.31)
-	 (-16.12 -8.25 21.44)
-	 (-49.08 -39.66 -49.46))
-     #2A((-34.5 8.24 3.29)
-	 (-8.93 34.12 -6.15)
-	 (49.27 -13.49 32.5))))
+     #2A((42.73f0 -17.24f0 43.31f0)
+	 (-16.12f0 -8.25f0 21.44f0)
+	 (-49.08f0 -39.66f0 -49.46f0))
+     #2A((-34.5f0 8.24f0 3.29f0)
+	 (-8.93f0 34.12f0 -6.15f0)
+	 (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))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '((42.73 -17.24 43.31)
-	      (-16.12 -8.25 21.44)
-	      (-49.08 -39.66 -49.46)))))
-      (SWAP M2 M1)
-      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
+       (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
+	       :INITIAL-CONTENTS
+	       '((42.73f0 -17.24f0 43.31f0)
+		 (-16.12f0 -8.25f0 21.44f0)
+		 (-49.08f0 -39.66f0 -49.46f0)))))
+	 (SWAP M2 M1)
+	 (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
@@ -53,47 +55,46 @@
 	 (-8.93d0 34.12d0 -6.15d0)
 	 (49.27d0 -13.49d0 32.5d0))))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'DOUBLE-FLOAT :INITIAL-CONTENTS
-	    '((-34.5d0 8.24d0 3.29d0)
-	      (-8.93d0 34.12d0 -6.15d0)
-	      (49.27d0 -13.49d0 32.5d0))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'DOUBLE-FLOAT :INITIAL-CONTENTS
-	    '((42.73d0 -17.24d0 43.31d0)
-	      (-16.12d0 -8.25d0 21.44d0)
-	      (-49.08d0 -39.66d0 -49.46d0)))))
-      (SWAP M2 M1)
-      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT :INITIAL-CONTENTS
+	       '((-34.5d0 8.24d0 3.29d0)
+		 (-8.93d0 34.12d0 -6.15d0)
+		 (49.27d0 -13.49d0 32.5d0))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT :INITIAL-CONTENTS
+	       '((42.73d0 -17.24d0 43.31d0)
+		 (-16.12d0 -8.25d0 21.44d0)
+		 (-49.08d0 -39.66d0 -49.46d0)))))
+	 (SWAP M2 M1)
+	 (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
-     #2A((#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))
-	 (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
-	 (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82)))
-     #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	 (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	 (#C(49.27 -13.49) #C(32.5 42.73)
-	    #C(-17.24 43.31)))))
+     #2A((#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)))
+     #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(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)))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX SINGLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))
-	      (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
-	      (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82))))))
-      (SWAP M2 M1)
-      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
+       (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)))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX SINGLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '((#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))))))
+	 (SWAP M2 M1)
+	 (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
@@ -104,156 +105,156 @@
 	 (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
 	 (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX DOUBLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
-	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
-	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX DOUBLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))
-	      (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
-	      (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0))))))
-      (SWAP M2 M1)
-      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX DOUBLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+		 (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+		 (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX DOUBLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '((#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))
+		 (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
+		 (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0))))))
+	 (SWAP M2 M1)
+	 (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68))
 	  #2A((-64 -68 71) (-91 52 -10) (73 -5 123))))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-				    '((-64 -68 71) (-91 52 -10)
-				      (73 -5 123))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-				    '((32 28 30) (37 -73 -8)
-				      (-15 -22 68)))))
-      (SWAP M2 M1)
-      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((32 28 30) (37 -73 -8)
+					 (-15 -22 68)))))
+	 (SWAP M2 M1)
+	 (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST #2A((28 10 19) (28 178 217) (36 109 222))
 	  #2A((67 44 189) (116 163 140) (161 215 98))))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-				    :INITIAL-CONTENTS
-				    '((67 44 189) (116 163 140)
-				      (161 215 98))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-				    :INITIAL-CONTENTS
-				    '((28 10 19) (28 178 217)
-				      (36 109 222)))))
-      (SWAP M2 M1)
-      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((28 10 19) (28 178 217)
+					 (36 109 222)))))
+	 (SWAP M2 M1)
+	 (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68))
 	  #2A((-64 -68 71) (-91 52 -10) (73 -5 123))))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-				    :INITIAL-CONTENTS
-				    '((-64 -68 71) (-91 52 -10)
-				      (73 -5 123))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-				    :INITIAL-CONTENTS
-				    '((32 28 30) (37 -73 -8)
-				      (-15 -22 68)))))
-      (SWAP M2 M1)
-      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((32 28 30) (37 -73 -8)
+					 (-15 -22 68)))))
+	 (SWAP M2 M1)
+	 (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST #2A((28 10 19) (28 178 217) (36 109 222))
 	  #2A((67 44 189) (116 163 140) (161 215 98))))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-				    :INITIAL-CONTENTS
-				    '((67 44 189) (116 163 140)
-				      (161 215 98))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-				    :INITIAL-CONTENTS
-				    '((28 10 19) (28 178 217)
-				      (36 109 222)))))
-      (SWAP M2 M1)
-      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((28 10 19) (28 178 217)
+					 (36 109 222)))))
+	 (SWAP M2 M1)
+	 (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68))
 	  #2A((-64 -68 71) (-91 52 -10) (73 -5 123))))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-				    :INITIAL-CONTENTS
-				    '((-64 -68 71) (-91 52 -10)
-				      (73 -5 123))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-				    :INITIAL-CONTENTS
-				    '((32 28 30) (37 -73 -8)
-				      (-15 -22 68)))))
-      (SWAP M2 M1)
-      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((32 28 30) (37 -73 -8)
+					 (-15 -22 68)))))
+	 (SWAP M2 M1)
+	 (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST #2A((28 10 19) (28 178 217) (36 109 222))
 	  #2A((67 44 189) (116 163 140) (161 215 98))))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-				    :INITIAL-CONTENTS
-				    '((67 44 189) (116 163 140)
-				      (161 215 98))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-				    :INITIAL-CONTENTS
-				    '((28 10 19) (28 178 217)
-				      (36 109 222)))))
-      (SWAP M2 M1)
-      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((28 10 19) (28 178 217)
+					 (36 109 222)))))
+	 (SWAP M2 M1)
+	 (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68))
 	  #2A((-64 -68 71) (-91 52 -10) (73 -5 123))))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-				    :INITIAL-CONTENTS
-				    '((-64 -68 71) (-91 52 -10)
-				      (73 -5 123))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-				    :INITIAL-CONTENTS
-				    '((32 28 30) (37 -73 -8)
-				      (-15 -22 68)))))
-      (SWAP M2 M1)
-      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((32 28 30) (37 -73 -8)
+					 (-15 -22 68)))))
+	 (SWAP M2 M1)
+	 (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST #2A((28 10 19) (28 178 217) (36 109 222))
 	  #2A((67 44 189) (116 163 140) (161 215 98))))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-				    :INITIAL-CONTENTS
-				    '((67 44 189) (116 163 140)
-				      (161 215 98))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-				    :INITIAL-CONTENTS
-				    '((28 10 19) (28 178 217)
-				      (36 109 222)))))
-      (SWAP M2 M1)
-      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((28 10 19) (28 178 217)
+					 (36 109 222)))))
+	 (SWAP M2 M1)
+	 (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))))
 
diff --git a/tests/matrix-transpose-copy.lisp b/tests/matrix-transpose-copy.lisp
index 181803c4..1c5c0943 100644
--- a/tests/matrix-transpose-copy.lisp
+++ b/tests/matrix-transpose-copy.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-TRANSPOSE for GSLL, automatically generated
 ;;
-;; Copyright 2009, 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,16 +21,16 @@
 (LISP-UNIT:DEFINE-TEST MATRIX-TRANSPOSE
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((-34.5 -8.93 49.27)
-	(8.24 34.12 -13.49)
-	(3.29 -6.15 32.5)))
+    #2A((-34.5f0 -8.93f0 49.27f0)
+	(8.24f0 34.12f0 -13.49f0)
+	(3.29f0 -6.15f0 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))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(3 3))))
       (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
@@ -51,17 +51,17 @@
       (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(-34.5 8.24) #C(-8.93 34.12) #C(49.27 -13.49))
-	(#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73))
-	(#C(34.12 -6.15) #C(-13.49 32.5) #C(-17.24 43.31))))
+    #2A((#C(-34.5f0 8.24f0) #C(-8.93f0 34.12f0) #C(49.27f0 -13.49f0))
+	(#C(3.29f0 -8.93f0) #C(-6.15f0 49.27f0) #C(32.5f0 42.73f0))
+	(#C(34.12f0 -6.15f0) #C(-13.49f0 32.5f0) #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)))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '(3 3))))
       (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
diff --git a/tests/matrix-transpose.lisp b/tests/matrix-transpose.lisp
index 78013e6f..b2407770 100644
--- a/tests/matrix-transpose.lisp
+++ b/tests/matrix-transpose.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-TRANSPOSE for GSLL, automatically generated
 ;;
-;; Copyright 2009, 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,16 +21,16 @@
 (LISP-UNIT:DEFINE-TEST MATRIX-TRANSPOSE*
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((-34.5 -8.93 49.27)
-	(8.24 34.12 -13.49)
-	(3.29 -6.15 32.5)))
+    #2A((-34.5f0 -8.93f0 49.27f0)
+	(8.24f0 34.12f0 -13.49f0)
+	(3.29f0 -6.15f0 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 (MATRIX-TRANSPOSE* M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -47,18 +47,17 @@
       (GRID:COPY-TO (MATRIX-TRANSPOSE* M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(-34.5 8.24) #C(-8.93 34.12) #C(49.27 -13.49))
-	(#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73))
-	(#C(34.12 -6.15) #C(-13.49 32.5)
-	   #C(-17.24 43.31))))
+    #2A((#C(-34.5f0 8.24f0) #C(-8.93f0 34.12f0) #C(49.27f0 -13.49f0))
+	(#C(3.29f0 -8.93f0) #C(-6.15f0 49.27f0) #C(32.5f0 42.73f0))
+	(#C(34.12f0 -6.15f0) #C(-13.49f0 32.5f0) #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 (MATRIX-TRANSPOSE* M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/matrix-variance-with-fixed-mean.lisp b/tests/matrix-variance-with-fixed-mean.lisp
index 6c66e156..018852e0 100644
--- a/tests/matrix-variance-with-fixed-mean.lisp
+++ b/tests/matrix-variance-with-fixed-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-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
@@ -20,95 +20,97 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-VARIANCE-WITH-FIXED-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 639.5971092940438d0)
-                        (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)))))
-                           (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 639.5971111111112d0)
-                        (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)))))
-                           (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 4955.555555555556d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 2820.246913580247d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 4955.555555555556d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 2820.246913580247d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 4955.555555555556d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 2820.246913580247d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 4955.555555555556d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 2820.246913580247d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 639.5971092940438d0)
+   (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)))))
+	 (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 639.5971111111112d0)
+   (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)))))
+	 (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4955.555555555556d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 2820.246913580247d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4955.555555555556d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 2820.246913580247d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4955.555555555556d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 2820.246913580247d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4955.555555555556d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 2820.246913580247d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))))
 
diff --git a/tests/matrix-variance-with-mean.lisp b/tests/matrix-variance-with-mean.lisp
index 4c376ae3..ec72c618 100644
--- a/tests/matrix-variance-with-mean.lisp
+++ b/tests/matrix-variance-with-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-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
@@ -19,124 +19,126 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-VARIANCE-WITH-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 719.5467479557992d0)
-                        (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)))))
-                           (VARIANCE M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 719.5467500000001d0)
-                        (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)))))
-                           (VARIANCE M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (VARIANCE M1
-                                                                       (MEAN
-                                                                        M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 3172.777777777778d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (VARIANCE M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (VARIANCE M1
-                                                                       (MEAN
-                                                                        M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 3172.777777777778d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (VARIANCE M1 (MEAN M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (VARIANCE M1
-                                                                       (MEAN
-                                                                        M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 3172.777777777778d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (VARIANCE M1 (MEAN M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (VARIANCE M1
-                                                                       (MEAN
-                                                                        M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 3172.777777777778d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (VARIANCE M1 (MEAN M1))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 719.5467479557992d0)
+   (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)))))
+	 (VARIANCE M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 719.5467500000001d0)
+   (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)))))
+	 (VARIANCE M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (VARIANCE M1
+						     (MEAN
+						      M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 3172.777777777778d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (VARIANCE M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (VARIANCE M1
+						     (MEAN
+						      M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 3172.777777777778d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (VARIANCE M1 (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (VARIANCE M1
+						     (MEAN
+						      M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 3172.777777777778d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (VARIANCE M1 (MEAN M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (VARIANCE M1
+						     (MEAN
+						      M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 3172.777777777778d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (VARIANCE M1 (MEAN M1))))))
 
diff --git a/tests/matrix-variance.lisp b/tests/matrix-variance.lisp
index db95eafb..c5744bd7 100644
--- a/tests/matrix-variance.lisp
+++ b/tests/matrix-variance.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-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,116 +19,118 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-VARIANCE
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 719.5467479557992d0)
-                        (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)))))
-                           (VARIANCE M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 719.5467500000001d0)
-                        (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)))))
-                           (VARIANCE M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (VARIANCE M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 3172.777777777778d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (VARIANCE M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (VARIANCE M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 3172.777777777778d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (VARIANCE M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (VARIANCE M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 3172.777777777778d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (VARIANCE M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (VARIANCE M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 3172.777777777778d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (VARIANCE M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 719.5467479557992d0)
+   (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)))))
+	 (VARIANCE M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 719.5467500000001d0)
+   (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)))))
+	 (VARIANCE M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (VARIANCE M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 3172.777777777778d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (VARIANCE M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (VARIANCE M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 3172.777777777778d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (VARIANCE M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (VARIANCE M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 3172.777777777778d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (VARIANCE M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (VARIANCE M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 3172.777777777778d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (VARIANCE M1)))))
 
-- 
GitLab