diff --git a/basis-splines.lisp b/basis-splines.lisp
index eddb72a329a1a28ccfc671f301ebd09f9c0f60ea..b5f3b8bad596464742c0762a58d34ca610a96121 100644
--- a/basis-splines.lisp
+++ b/basis-splines.lisp
@@ -1,8 +1,8 @@
 ;; Basis splines.
 ;; Liam Healy 2008-02-18 14:43:20EST basis-splines.lisp
-;; Time-stamp: <2010-06-30 19:57:28EDT basis-splines.lisp>
+;; Time-stamp: <2011-05-26 12:37:29EDT basis-splines.lisp>
 ;;
-;; Copyright 2008, 2009 Liam M. Healy
+;; Copyright 2008, 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
@@ -125,18 +125,18 @@
       (let* ((xi (coerce (* i (/ 15 (1- ndata))) 'double-float))
 	     (yi (+ (* (cos xi) (exp (* -0.1d0 xi)))
 		    (sample rng :gaussian :sigma sigma))))
-	(setf (grid:gref x i) xi
-	      (grid:gref y i) yi
-	      (grid:gref w i) (/ (expt sigma 2)))))
+	(setf (grid:aref x i) xi
+	      (grid:aref y i) yi
+	      (grid:aref w i) (/ (expt sigma 2)))))
     ;; Uniform breakpoints [0, 15]
     (uniform-knots 0.0d0 15.0d0 bw)
     ;; Fit matrix
     (dotimes (i ndata)
       ;; Compute B_j
-      (evaluate bw (grid:gref x i) :b B)
+      (evaluate bw (grid:aref x i) :b B)
       ;; Fill in row i of X
       (dotimes (j ncoeffs)
-	(setf (grid:gref Xmatrix i j) (grid:gref B j))))
+	(setf (grid:aref Xmatrix i j) (grid:aref B j))))
     ;; Do the fit
     (linear-mfit Xmatrix y c w nil cov mw)
     ;; Return the smoothed curve
diff --git a/calculus/monte-carlo.lisp b/calculus/monte-carlo.lisp
index 6bffa80318a67013dafd1109c920994a7d2502b2..fdd628e6ea7d3d345e1066da5d50b67af5d8af82 100644
--- a/calculus/monte-carlo.lisp
+++ b/calculus/monte-carlo.lisp
@@ -1,8 +1,8 @@
 ;; Monte Carlo Integration
 ;; Liam Healy Sat Feb  3 2007 - 17:42
-;; Time-stamp: <2010-08-07 21:41:14EDT monte-carlo.lisp>
+;; Time-stamp: <2011-01-10 17:59:20EST monte-carlo.lisp>
 ;;
-;; Copyright 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2007, 2008, 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
@@ -51,7 +51,7 @@
 	      (scalars t))
   "gsl_monte_plain_integrate"
   ((callback :pointer)
-   ((foreign-pointer lower-limits) :pointer) ((foreign-pointer upper-limits) :pointer)
+   ((grid:foreign-pointer lower-limits) :pointer) ((grid:foreign-pointer upper-limits) :pointer)
    ((dim0 lower-limits) sizet) (number-of-samples sizet)
    ((mpointer generator) :pointer)
    ((mpointer state) :pointer)
@@ -112,7 +112,7 @@
 	      (scalars t))
   "gsl_monte_miser_integrate"
   ((callback :pointer)
-   ((foreign-pointer lower-limits) :pointer) ((foreign-pointer upper-limits) :pointer)
+   ((grid:foreign-pointer lower-limits) :pointer) ((grid:foreign-pointer upper-limits) :pointer)
    ((dim0 lower-limits) sizet) (number-of-samples sizet)
    ((mpointer generator) :pointer)
    ((mpointer state) :pointer)
@@ -173,7 +173,7 @@
 	      (scalars t))
   "gsl_monte_vegas_integrate"
   ((callback :pointer)
-   ((foreign-pointer lower-limits) :pointer) ((foreign-pointer upper-limits) :pointer)
+   ((grid:foreign-pointer lower-limits) :pointer) ((grid:foreign-pointer upper-limits) :pointer)
    ((dim0 lower-limits) sizet) (number-of-samples sizet)
    ((mpointer generator) :pointer)
    ((mpointer state) :pointer)
diff --git a/calculus/numerical-integration.lisp b/calculus/numerical-integration.lisp
index f11be59c1700f1c8bf299a540b731952224931c7..e398b2b1a2e05889d52fe42b3aaddb8b4bf3ecaf 100644
--- a/calculus/numerical-integration.lisp
+++ b/calculus/numerical-integration.lisp
@@ -1,8 +1,8 @@
 ;; Numerical integration
 ;; Liam Healy, Wed Jul  5 2006 - 23:14
-;; Time-stamp: <2010-08-07 21:46:21EDT numerical-integration.lisp>
+;; Time-stamp: <2011-01-10 17:59:21EST numerical-integration.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009, 2010 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -157,7 +157,7 @@
 	      (limit 1000) (workspace (make-integration-workspace limit)))
   "gsl_integration_qagp"
   ((callback :pointer)
-   ((foreign-pointer points) :pointer) ((dim0 points) sizet)
+   ((grid:foreign-pointer points) :pointer) ((dim0 points) sizet)
    (absolute-error :double) (relative-error :double) (limit sizet)
    ((mpointer workspace) :pointer)
    (result (:pointer :double)) (abserr (:pointer :double)))
diff --git a/data/both.lisp b/data/both.lisp
index 31c23f450a53af34d39d3dc06758cc26433147ef..10ad027e3c433e3125c5b5351d4947e56b14a882 100644
--- a/data/both.lisp
+++ b/data/both.lisp
@@ -1,8 +1,8 @@
 ;; Functions for both vectors and matrices.
 ;; Liam Healy 2008-04-26 20:48:44EDT both.lisp
-;; Time-stamp: <2010-11-25 09:31:17EST both.lisp>
+;; Time-stamp: <2011-05-26 12:37:36EDT both.lisp>
 ;;
-;; Copyright 2008, 2009, 2010 Liam M. Healy
+;; Copyright 2008, 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
@@ -35,13 +35,13 @@
   :export nil
   :documentation "Allocate memory for the GSL struct given a block pointer.")
 
-(defmfun alloc-from-block ((object matrix) blockptr)
+(defmfun alloc-from-block ((object grid:matrix) blockptr)
   ("gsl_" :category :type "_alloc_from_block")
   ((blockptr :pointer)
    (0 sizet)				; offset
-   ((first (dimensions object)) sizet)	; number of rows
-   ((second (dimensions object)) sizet)	; number of columns
-   ((second (dimensions object)) sizet))	; "tda" = number of columns for now
+   ((first (grid:dimensions object)) sizet)	; number of rows
+   ((second (grid:dimensions object)) sizet)	; number of columns
+   ((second (grid:dimensions object)) sizet))	; "tda" = number of columns for now
   :definition :methods
   :c-return :pointer
   :export nil)
@@ -81,7 +81,7 @@
 ;;;;****************************************************************************
 ;;;; Array elements; used in callbacks scalarsp=T only
 ;;;;****************************************************************************
-;;; Normal foreign array access is with grid:gref, but in order to
+;;; Normal foreign array access is with grid:aref, but in order to
 ;;; avoid the overhead of instantiating a foreign-array object to
 ;;; access components, we use these macros which expand to gsl_*_get
 ;;; and gsl_*_set.
@@ -113,7 +113,7 @@
     `(cffi:foreign-funcall
       ,(actual-gsl-function-name
 	`("gsl_" :category :type ,(if value "_set" "_get"))
-	(if matrixp 'matrix 'vector)
+	(if matrixp 'grid:matrix 'vector)
 	element-type)
       :pointer ,mpointer
       sizet ,(first indices)
@@ -192,7 +192,7 @@
   :documentation			; FDL
   "Add the scalar complex x to all the elements of array a.")
 
-(defmethod elt+ ((x float) (a foreign-array))
+(defmethod elt+ ((x float) (a grid:foreign-array))
   (elt+ a x))
   
 (defmfun elt- ((a both) (b both))
@@ -207,7 +207,7 @@
   "Subtract the elements of b from the elements of a.
    The two must have the same dimensions.")
 
-(defmethod elt- ((a foreign-array) (x float))
+(defmethod elt- ((a grid:foreign-array) (x float))
   (elt+ a (- x)))
 
 (defmfun elt* ((a vector) (b vector))
@@ -222,7 +222,7 @@
   "Multiply the elements of a by the elements of b.
    The two must have the same dimensions.")
 
-(defmfun elt* ((a matrix) (b matrix))
+(defmfun elt* ((a grid:matrix) (b grid:matrix))
   ("gsl_" :category :type "_mul_elements")
   (((mpointer a) :pointer) ((mpointer b) :pointer))
   :definition :methods
@@ -243,7 +243,7 @@
   "Divide the elements of a by the elements of b.
    The two must have the same dimensions.")
 
-(defmfun elt/ ((a matrix) (b matrix))
+(defmfun elt/ ((a grid:matrix) (b grid:matrix))
   ("gsl_" :category :type "_div_elements")
   (((mpointer a) :pointer) ((mpointer b) :pointer))
   :definition :methods
@@ -252,7 +252,7 @@
   :outputs (a)
   :return (a))
 
-(defmethod elt/ ((a foreign-array) (x number))
+(defmethod elt/ ((a grid:foreign-array) (x number))
   (elt* a (/ x)))
 
 (defmfun elt* ((a both) (x float))
@@ -279,7 +279,7 @@
   :documentation			; FDL
   "Multiply the elements of a by the scalar complex factor x.")
 
-(defmethod elt* ((x float) (a foreign-array))
+(defmethod elt* ((x float) (a grid:foreign-array))
   (elt* a x))
 
 ;;;;****************************************************************************
@@ -329,7 +329,7 @@
   "The index of the minimum value in a.  When there are several
   equal minimum elements, then the lowest index is returned.")
 
-(defmfun min-index ((a matrix))
+(defmfun min-index ((a grid:matrix))
   ("gsl_" :category :type "_min_index")
   (((mpointer a) :pointer) (imin (:pointer sizet)) (jmin (:pointer sizet)))
   :definition :methods
@@ -348,7 +348,7 @@
   "The index of the maximum value in a.  When there are several
   equal maximum elements, then the lowest index is returned.")
 
-(defmfun max-index ((a matrix))
+(defmfun max-index ((a grid:matrix))
   ("gsl_" :category :type "_max_index")
   (((mpointer a) :pointer) (imin (:pointer sizet)) (jmin (:pointer sizet)))
   :definition :methods
@@ -369,7 +369,7 @@
   returned.  Returned indices are minimum, maximum; for matrices
   imin, jmin, imax, jmax.")
 
-(defmfun minmax-index ((a matrix))
+(defmfun minmax-index ((a grid:matrix))
   ("gsl_" :category :type "_minmax_index")
   (((mpointer a) :pointer)
    (imin (:pointer sizet)) (jmin (:pointer sizet))
diff --git a/data/combination.lisp b/data/combination.lisp
index ae57ad5b50536346dfff795f605619d4f84054c2..06d2538c66e16a883a34cfb7021484b5afeefb49 100644
--- a/data/combination.lisp
+++ b/data/combination.lisp
@@ -1,8 +1,8 @@
 ;; Combinations
 ;; Liam Healy, Sun Mar 26 2006 - 11:51
-;; Time-stamp: <2010-07-16 17:14:03EDT combination.lisp>
+;; Time-stamp: <2011-01-10 18:16:28EST combination.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009, 2010 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -37,7 +37,7 @@
     (setf (grid:metadata-slot object 'mpointer)
 	  mptr
 	  (cffi:foreign-slot-value mptr 'gsl-combination-c 'data)
-	  (foreign-pointer object)
+	  (grid:foreign-pointer object)
 	  (cffi:foreign-slot-value mptr 'gsl-combination-c 'range)
 	  range
 	  (cffi:foreign-slot-value mptr 'gsl-combination-c 'size)
@@ -56,7 +56,7 @@
 	     (make-instance
 	      'combination
 	      :element-type '(unsigned-byte #+int64 64 #+int32 32)
-	      :range (combination-range n) :dimensions (dimensions k))
+	      :range (combination-range n) :dimensions (grid:dimensions k))
 	     (make-instance
 	      'combination
 	      :element-type '(unsigned-byte #+int64 64 #+int32 32)
diff --git a/data/foreign-array.lisp b/data/foreign-array.lisp
index f5b3a543df049eff58df569e764bf622ad4f497d..8ebf9e681c340889213c6d815c982e0ef82ebe97 100644
--- a/data/foreign-array.lisp
+++ b/data/foreign-array.lisp
@@ -1,8 +1,8 @@
 ;; A grid:foreign-array with added metadata for GSL.
 ;; Liam Healy 2008-04-06 21:23:41EDT
-;; Time-stamp: <2010-07-13 22:53:02EDT foreign-array.lisp>
+;; Time-stamp: <2011-01-12 00:34:42EST foreign-array.lisp>
 ;;
-;; Copyright 2008, 2009, 2010 Liam M. Healy
+;; Copyright 2008, 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
@@ -44,7 +44,7 @@
       (setf (cffi:foreign-slot-value blockptr 'gsl-block-c 'size)
 	    (size object)
 	    (cffi:foreign-slot-value blockptr 'gsl-block-c 'data)
-	    (foreign-pointer object)
+	    (grid:foreign-pointer object)
 	    (grid:metadata-slot object 'block-pointer) blockptr)
       (let ((array-struct (alloc-from-block object blockptr)))
 	(setf
@@ -53,8 +53,8 @@
 	 ;; from the block to the vector/matrix; we must do that manually here
 	 (cffi:foreign-slot-value
 	  array-struct
-	  (if (typep object 'matrix) 'gsl-matrix-c 'gsl-vector-c) 'data)
-	 (foreign-pointer object))
+	  (if (typep object 'grid:matrix) 'gsl-matrix-c 'gsl-vector-c) 'data)
+	 (grid:foreign-pointer object))
 	(tg:finalize object
 		     (lambda ()
 		       (cffi:foreign-free blockptr)
@@ -82,23 +82,23 @@
   (let* ((category
 	  (case category-or-rank
 	    ((vector :vector 1) 'vector)
-	    ((matrix :matrix 2) 'matrix)
+	    ((matrix grid:matrix :matrix 2) 'grid:matrix)
 	    (t (error "Unrecognized category ~a" category-or-rank))))
 	 (cstruct
 	  (case category
 	    (vector 'gsl-vector-c)
-	    (matrix 'gsl-matrix-c)))
+	    (grid:matrix 'gsl-matrix-c)))
 	 (fa
 	  (grid:make-grid
 	   (case category
 	     (vector
-	      `((foreign-array ,(cffi:foreign-slot-value mpointer cstruct 'size))
-		,element-type))
-	     (matrix
-	      `((foreign-array
-		 ,(cffi:foreign-slot-value mpointer cstruct 'size0)
-		 ,(cffi:foreign-slot-value mpointer cstruct 'size1))
-		,element-type)))
+		`((grid:foreign-array ,(cffi:foreign-slot-value mpointer cstruct 'size))
+		  ,element-type))
+	     (grid:matrix
+		`((grid:foreign-array
+		   ,(cffi:foreign-slot-value mpointer cstruct 'size0)
+		   ,(cffi:foreign-slot-value mpointer cstruct 'size1))
+		  ,element-type)))
 	   :foreign-pointer
 	   (cffi:foreign-slot-value mpointer cstruct 'data)
 	   :finalizer finalize)))
diff --git a/data/matrix.lisp b/data/matrix.lisp
index 4ebdbcbf1c945a7fad7b79e60e2cc326ad979ffd..22df33a2171efefae0a62f92421c7a6dda3fa4d3 100644
--- a/data/matrix.lisp
+++ b/data/matrix.lisp
@@ -1,8 +1,8 @@
 ;; Matrices
 ;; Liam Healy 2008-04-15 21:57:52EDT matrix.lisp
-;; Time-stamp: <2010-06-29 22:10:48EDT matrix.lisp>
+;; Time-stamp: <2011-01-12 00:34:45EST matrix.lisp>
 ;;
-;; Copyright 2008, 2009 Liam M. Healy
+;; Copyright 2008, 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
@@ -26,7 +26,7 @@
 ;;;; Mathematical
 ;;;;****************************************************************************
 
-(defmfun set-identity ((matrix matrix))
+(defmfun set-identity ((matrix grid:matrix))
   ("gsl_matrix" :type "_set_identity")
   (((mpointer matrix) :pointer))
   :definition :generic
@@ -43,8 +43,7 @@
 ;;;; Copying rows and columns
 ;;;;****************************************************************************
 
-(defmfun row
-    ((matrix matrix) i
+(defmfun row ((matrix grid:matrix) i
      &optional (vector (grid:make-foreign-array element-type :dimensions (dim1 matrix))))
   ("gsl_matrix" :type "_get_row")
   (((mpointer vector) :pointer) ((mpointer matrix) :pointer) (i sizet))
@@ -57,7 +56,7 @@
    into the vector.  The length of the vector must be the
    same as the length of the row.")
 
-(defmfun (setf row) ((vector vector) (matrix matrix) i)
+(defmfun (setf row) ((vector vector) (matrix grid:matrix) i)
   ("gsl_matrix" :type "_set_row")
   (((mpointer matrix) :pointer) (i sizet) ((mpointer vector) :pointer))
   :definition :generic
@@ -68,8 +67,7 @@
   "Copy the elements of the vector into the jth row of the matrix.
   The length of the vector must be the same as the length of the row.")
 
-(defmfun column
-    ((matrix matrix) i
+(defmfun column ((matrix grid:matrix) i
      &optional (vector (grid:make-foreign-array element-type :dimensions (dim0 matrix))))
   ("gsl_matrix" :type "_get_col")
   (((mpointer vector) :pointer) ((mpointer matrix) :pointer) (i sizet))
@@ -82,7 +80,7 @@
    into the vector.  The length of the vector must be the
    same as the length of the column.")
 
-(defmfun (setf column) ((vector vector) (matrix matrix) i)
+(defmfun (setf column) ((vector vector) (matrix grid:matrix) i)
   ("gsl_matrix" :type "_set_col")
   (((mpointer matrix) :pointer) (i sizet) ((mpointer vector) :pointer))
   :definition :generic
@@ -97,7 +95,7 @@
 ;;;; Exchanging rows and columns
 ;;;;****************************************************************************
 
-(defmfun swap-rows ((matrix matrix) i j)
+(defmfun swap-rows ((matrix grid:matrix) i j)
   ("gsl_matrix" :type "_swap_rows")
   (((mpointer matrix) :pointer) (i sizet) (j sizet))
   :definition :generic
@@ -107,7 +105,7 @@
   :documentation 			; FDL
   "Exchange the ith and jth rows of the matrix in-place.")
 
-(defmfun swap-columns ((matrix matrix) i j)
+(defmfun swap-columns ((matrix grid:matrix) i j)
   ("gsl_matrix" :type "_swap_columns")
   (((mpointer matrix) :pointer) (i sizet) (j sizet))
   :definition :generic
@@ -117,7 +115,7 @@
   :documentation 			; FDL
   "Exchange the ith and jth columns of the matrix in-place.")
 
-(defmfun swap-row-column ((matrix matrix) i j)
+(defmfun swap-row-column ((matrix grid:matrix) i j)
   ("gsl_matrix" :type "_swap_rowcol")
   (((mpointer matrix) :pointer) (i sizet) (j sizet))
   :definition :generic
@@ -129,7 +127,7 @@
    matrix in-place.  The matrix must be square for this operation to
    be possible.")
 
-(defmfun matrix-transpose* ((matrix matrix))
+(defmfun matrix-transpose* ((matrix grid:matrix))
   ("gsl_matrix" :type "_transpose")
   (((mpointer matrix) :pointer))
   :definition :generic
@@ -142,10 +140,10 @@
    operation to be possible.")
 
 (defmfun matrix-transpose
-    ((source matrix)
+    ((source grid:matrix)
      &optional
      (destination
-      (grid:make-foreign-array element-type :dimensions (reverse (dimensions source)))))
+      (grid:make-foreign-array element-type :dimensions (reverse (grid:dimensions source)))))
   ("gsl_matrix" :type "_transpose_memcpy")
   (((mpointer destination) :pointer) ((mpointer source) :pointer))
   :definition :generic
diff --git a/data/permutation.lisp b/data/permutation.lisp
index b894b0cd4447ddef8142a16fd827e7cb7a438e12..89185942f8f95c71eaab88c13af977849fbe81ab 100644
--- a/data/permutation.lisp
+++ b/data/permutation.lisp
@@ -1,8 +1,8 @@
 ;; Permutations
 ;; Liam Healy, Sun Mar 26 2006 - 11:51
-;; Time-stamp: <2010-11-13 18:44:09EST permutation.lisp>
+;; Time-stamp: <2011-05-26 12:37:36EDT permutation.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009, 2010 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -38,7 +38,7 @@
     (setf (grid:metadata-slot object 'mpointer)
 	  mptr
 	  (cffi:foreign-slot-value mptr 'gsl-permutation-c 'data)
-	  (foreign-pointer object)
+	  (grid:foreign-pointer object)
 	  (cffi:foreign-slot-value mptr 'gsl-permutation-c 'size)
 	  (first dimensions))
     (tg:finalize object (lambda () (cffi:foreign-free mptr)))))
@@ -53,7 +53,7 @@
 	 (make-instance
 	  'permutation
 	  :element-type '(unsigned-byte #+int64 64 #+int32 32)
-	  :dimensions (if (typep n 'permutation) (dimensions n) (list n)))))
+	  :dimensions (if (typep n 'permutation) (grid:dimensions n) (list n)))))
     (when initialize
       (if (typep n 'permutation)
 	  (error "not available yet")	; (copy perm n)
@@ -339,7 +339,7 @@
 
 (save-test permutation
  (let ((perm-1 (make-permutation 4 t)))
-   (grid:gref perm-1 2))
+   (grid:aref perm-1 2))
  (let ((perm-1 (make-permutation 4 t)))	;grid:contents
    (grid:contents perm-1))
  (let ((perm-1 (make-permutation 4 t)))	;permutation-reverse
diff --git a/documentation/index.html b/documentation/index.html
index 8eb8da7272852f61f841b92a9bccd878d75230e1..499796d32dc297e435340092f3951958becb4fa2 100644
--- a/documentation/index.html
+++ b/documentation/index.html
@@ -9,6 +9,21 @@
           content="text/html; charset=iso-8859-1">
     <link rev="made" href="mailto:lhealy@common-lisp.net">
     <link rel="stylesheet" type="text/css" href="site.css">
+<script type="text/javascript">
+
+  var _gaq = _gaq || [];
+  _gaq.push(['_setAccount', 'UA-25052371-1']);
+  _gaq.push(['_setDomainName', 'none']);
+  _gaq.push(['_setAllowLinker', true]);
+  _gaq.push(['_trackPageview']);
+
+  (function() {
+    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+  })();
+
+</script>
   </head>
   <body>
     <div id="banner">
@@ -336,18 +351,9 @@ four-digit number; please attach them all to your email.
 <!-- Created: Feb 25 2005 -->
 <!-- hhmts start -->
 <small>
-Time-stamp: <2010-10-12 17:46:29EDT index.html>
+Time-stamp: <2011-08-09 22:37:23EDT index.html>
 </small>
 <!-- hhmts end -->
  </div>
-<script type="text/javascript">
-var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
-document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
-</script>
-<script type="text/javascript">
-var pageTracker = _gat._getTracker("UA-3669275-1");
-pageTracker._initData();
-pageTracker._trackPageview();
-</script>
   </body>
 </html>
diff --git a/eigensystems/generalized.lisp b/eigensystems/generalized.lisp
index c0a0cbbfcbbbd49123463e78df43d5a3feda8f06..466d48fc334291772a96fcaad63b5c128c117533 100644
--- a/eigensystems/generalized.lisp
+++ b/eigensystems/generalized.lisp
@@ -1,8 +1,8 @@
 ;; Real generalized eigensystems
 ;; Liam Healy 2009-02-16 12:55:04EST real-generalized.lisp
-;; Time-stamp: <2010-06-29 22:15:24EDT generalized.lisp>
+;; Time-stamp: <2011-01-12 00:08:22EST generalized.lisp>
 ;;
-;; 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
@@ -56,8 +56,7 @@
     n-by-n complex generalized hermitian-definite eigensystems. The
     size of the workspace is O(5n).")
 
-(defmfun eigenvalues-gensymm
-    ((A matrix) (B matrix)
+(defmfun eigenvalues-gensymm ((A grid:matrix) (B grid:matrix)
      &optional
      (eigenvalues (grid:make-foreign-array element-type :dimensions (dim0 A)))
      (ws (eltcase complex (make-eigen-genherm (dim0 A))
@@ -78,11 +77,10 @@
   outlined above. On output, B contains its Cholesky decomposition and
   A is destroyed.")
 
-(defmfun eigenvalues-eigenvectors-gensymm
-    ((A matrix) (B matrix)
+(defmfun eigenvalues-eigenvectors-gensymm ((A grid:matrix) (B grid:matrix)
      &optional
      (eigenvalues (grid:make-foreign-array element-type :dimensions (dim0 A)))
-     (eigenvectors (grid:make-foreign-array element-type :dimensions (dimensions A)))
+     (eigenvectors (grid:make-foreign-array element-type :dimensions (grid:dimensions A)))
      (ws (eltcase complex (make-eigen-hermv (dim0 A))
 		  t (make-eigen-symmv (dim0 A)))))
   (double-float "gsl_eigen_gensymmv"
diff --git a/eigensystems/nonsymmetric-generalized.lisp b/eigensystems/nonsymmetric-generalized.lisp
index 9ec85cfed0dc049ea7e308e52066b5b2e934700c..3ee35f8242323c13e85a23c1d84838f354d02ae9 100644
--- a/eigensystems/nonsymmetric-generalized.lisp
+++ b/eigensystems/nonsymmetric-generalized.lisp
@@ -1,8 +1,8 @@
 ;; Generalized eigensystems for nonsymmetric real matrices
 ;; Liam Healy 2009-02-16 14:27:20EST nonsymmetric-generalized.lisp
-;; Time-stamp: <2010-06-29 22:15:24EDT nonsymmetric-generalized.lisp>
+;; Time-stamp: <2011-01-10 18:19:14EST nonsymmetric-generalized.lisp>
 ;;
-;; 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
@@ -63,11 +63,11 @@
        (balance nil)			; unused by GSL
        (Q
 	(if (eql shur-vectors t)
-	    (grid:make-foreign-array 'double-float :dimensions (dimensions A))
+	    (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A))
 	    shur-vectors))
        (Z
 	(if (eql shur-vectors t)
-	    (grid:make-foreign-array 'double-float :dimensions (dimensions A))
+	    (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A))
 	    shur-vectors)))
   ("gsl_eigen_gen" "gsl_eigen_gen_QZ")
   ((((mpointer A) :pointer) ((mpointer B) :pointer)
@@ -118,18 +118,18 @@
        (beta
 	(grid:make-foreign-array 'double-float :dimensions (dim0 A)))
        (eigenvectors
-	(grid:make-foreign-array 'double-float :dimensions (dimensions A)))
+	(grid:make-foreign-array 'double-float :dimensions (grid:dimensions A)))
        (ws (make-eigen-genv (dim0 A)))
        compute-shur-form-s compute-shur-form-t shur-vectors
        &aux
        (balance nil)			; unused by GSL
        (Q
 	(if (eql shur-vectors t)
-	    (grid:make-foreign-array 'double-float :dimensions (dimensions A))
+	    (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A))
 	    shur-vectors))
        (Z
 	(if (eql shur-vectors t)
-	    (grid:make-foreign-array 'double-float :dimensions (dimensions A))
+	    (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A))
 	    shur-vectors)))
   ("gsl_eigen_genv" "gsl_eigen_genv_QZ")
   ((((mpointer A) :pointer) ((mpointer B) :pointer)
diff --git a/eigensystems/nonsymmetric.lisp b/eigensystems/nonsymmetric.lisp
index fc68668ae1e4c4075a19bf4759d4d089b7e39cca..9514709a1abc290dda6565d2989761f3b080095e 100644
--- a/eigensystems/nonsymmetric.lisp
+++ b/eigensystems/nonsymmetric.lisp
@@ -1,8 +1,8 @@
 ;; Eigensystems for nonsymmetric real matrices
 ;; Liam Healy 2009-02-16 12:51:18EST nonsymmetric.lisp
-;; Time-stamp: <2010-06-29 22:15:24EDT nonsymmetric.lisp>
+;; Time-stamp: <2011-01-10 18:19:13EST nonsymmetric.lisp>
 ;;
-;; 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
@@ -58,7 +58,7 @@
      &aux
      (sv
       (if (eql shur-vectors t)
-	  (grid:make-foreign-array 'double-float :dimensions (dimensions A))
+	  (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A))
 	  shur-vectors)))
   ("gsl_eigen_nonsymm" "gsl_eigen_nonsymm_Z")
   ((((mpointer A) :pointer)
@@ -119,13 +119,13 @@
      (eigenvalues
       (grid:make-foreign-array '(complex double-float) :dimensions (dim0 A)))
      (eigenvectors
-      (grid:make-foreign-array  '(complex double-float) :dimensions (dimensions A)))
+      (grid:make-foreign-array  '(complex double-float) :dimensions (grid:dimensions A)))
      (ws (make-eigen-nonsymmv (dim0 A)))
      shur-vectors
      &aux
      (sv
       (if (eql shur-vectors t)
-	  (grid:make-foreign-array 'double-float :dimensions (dimensions A))
+	  (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A))
 	  shur-vectors)))
   ("gsl_eigen_nonsymmv" "gsl_eigen_nonsymmv_Z")
   ((((mpointer A) :pointer)
diff --git a/eigensystems/symmetric-hermitian.lisp b/eigensystems/symmetric-hermitian.lisp
index 38404d2c2272a57ec5d7778469e9033d36058c9a..01534f333262e235ce18e9cfe4fe811de1aa8f8e 100644
--- a/eigensystems/symmetric-hermitian.lisp
+++ b/eigensystems/symmetric-hermitian.lisp
@@ -1,8 +1,8 @@
 ;; Eigenvectors and eigenvalues
 ;; Liam Healy, Sun May 21 2006 - 19:52
-;; Time-stamp: <2010-07-07 14:25:01EDT symmetric-hermitian.lisp>
+;; Time-stamp: <2011-01-12 00:09:43EST symmetric-hermitian.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -66,8 +66,7 @@
 ;;;; Eigenvalues and eigenvectors
 ;;;;****************************************************************************
 
-(defmfun eigenvalues
-    ((A matrix)
+(defmfun eigenvalues ((A grid:matrix)
      &optional
      (eigenvalues (grid:make-foreign-array element-type :dimensions (dim0 A)))
      (ws (eltcase complex (make-eigen-herm (dim0 A))
@@ -91,11 +90,10 @@
   referenced.  The eigenvalues are stored in the vector eigenvalues and
   are unordered.")
 
-(defmfun eigenvalues-eigenvectors
-    ((A matrix)
+(defmfun eigenvalues-eigenvectors ((A grid:matrix)
      &optional
      (eigenvalues (grid:make-foreign-array element-type :dimensions (dim0 A)))
-     (eigenvectors (grid:make-foreign-array element-type :dimensions (dimensions A)))
+     (eigenvectors (grid:make-foreign-array element-type :dimensions (grid:dimensions A)))
      (ws (eltcase complex (make-eigen-hermv (dim0 A))
 		  t (make-eigen-symmv (dim0 A)))))
   (double-float "gsl_eigen_symmv"
@@ -126,7 +124,7 @@
 ;;;;****************************************************************************
 
 (defmfun sort-eigenvalues-eigenvectors
-    ((eigenvalues vector) (eigenvectors matrix) sort-type)
+    ((eigenvalues vector) (eigenvectors grid:matrix) sort-type)
   (double-float "gsl_eigen_symmv_sort"
    complex-double-float "gsl_eigen_hermv_sort")
   (((mpointer eigenvalues) :pointer) ((mpointer eigenvectors) :pointer)
diff --git a/fast-fourier-transforms/backward.lisp b/fast-fourier-transforms/backward.lisp
index 8b62af1d75d85d97a9707c518a8c994f67fa8166..a5bf3c7b4ff37353fe783d20a76e915c920535a8 100644
--- a/fast-fourier-transforms/backward.lisp
+++ b/fast-fourier-transforms/backward.lisp
@@ -1,8 +1,8 @@
 ;; Backward FFT
 ;; Sumant Oemrawsingh, Sat Oct 24 2009 - 12:55
-;; Time-stamp: <2010-06-27 18:13:59EDT backward.lisp>
+;; Time-stamp: <2011-01-11 23:34:19EST backward.lisp>
 ;;
-;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
+;; Copyright 2009, 2011 Sumant Oemrawsingh, 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
@@ -33,7 +33,7 @@
 (defmfun backward-fourier-transform-radix2
   ((vector vector) &key (stride 1))
   ("gsl_fft" :type "_radix2_backward")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :complex
   :inputs (vector)
@@ -49,7 +49,7 @@
      (wavetable (make-fft-wavetable element-type (floor (size vector) stride)))
      (workspace (make-fft-workspace element-type (floor (size vector) stride))))
   ("gsl_fft" :type "_backward")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
    ((mpointer wavetable) :pointer) ((mpointer workspace) :pointer))
   :definition :generic
   :element-types :complex
@@ -69,7 +69,7 @@
 (defmfun backward-fourier-transform-halfcomplex-radix2
     ((vector vector) &key (stride 1))
   ("gsl_fft_halfcomplex" :type "_radix2_backward")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :float
   :inputs (vector)
@@ -86,7 +86,7 @@
      (wavetable (make-fft-wavetable element-type (floor (size vector) stride) t))
      (workspace (make-fft-workspace element-type (floor (size vector) stride))))
   ("gsl_fft_halfcomplex" :type "_backward")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
    ((mpointer wavetable) :pointer) ((mpointer workspace) :pointer))
   :definition :generic
   :element-types :float
@@ -106,7 +106,7 @@
 (defmfun backward-fourier-transform-dif-radix2
   ((vector vector) &key (stride 1))
   ("gsl_fft" :type "_radix2_dif_backward")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :complex
   :inputs (vector)
@@ -138,13 +138,13 @@
     (remf pass-on-args :decimation-in-frequency)
     (remf pass-on-args :non-radix-2)
     (if (and (not non-radix-2) (power-of-2-p (floor (size vector) stride)))
-	(if (subtypep (element-type vector) 'real)
+	(if (subtypep (grid:element-type vector) 'real)
 	    (apply 'backward-fourier-transform-halfcomplex-radix2
 		   vector pass-on-args)
 	    (if decimation-in-frequency
 		(apply 'backward-fourier-transform-dif-radix2 vector pass-on-args)
 		(apply 'backward-fourier-transform-radix2 vector pass-on-args)))
-	(if (subtypep (element-type vector) 'real)
+	(if (subtypep (grid:element-type vector) 'real)
 	    (apply 'backward-fourier-transform-halfcomplex-nonradix2
 		   vector pass-on-args)
 	    (apply 'backward-fourier-transform-nonradix2 vector pass-on-args)))))
diff --git a/fast-fourier-transforms/discrete.lisp b/fast-fourier-transforms/discrete.lisp
index 6d85e2912d3d24730412d65a41ee5159ec24eddb..ac7b7ae4e8ea5e07acdd6b5c6ffcea209bbd323e 100644
--- a/fast-fourier-transforms/discrete.lisp
+++ b/fast-fourier-transforms/discrete.lisp
@@ -1,8 +1,8 @@
 ;; Discrete Fourier Transforms
 ;; Liam Healy 2009-11-07 14:24:07EST
-;; Time-stamp: <2010-06-29 22:15:25EDT discrete.lisp>
+;; Time-stamp: <2011-01-10 18:16:24EST discrete.lisp>
 ;;
-;; 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
@@ -29,10 +29,10 @@
 (defmfun forward-discrete-fourier-transform
     ((vector vector)
      &key (stride 1)
-     (result (grid:make-foreign-array element-type :dimensions (dimensions vector))))
+     (result (grid:make-foreign-array element-type :dimensions (grid:dimensions vector))))
   ("gsl_dft" :type "_forward")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
-   ((foreign-pointer result) :pointer))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+   ((grid:foreign-pointer result) :pointer))
   :definition :generic
   :element-types :complex
   :inputs (vector)
@@ -45,10 +45,10 @@
 (defmfun backward-discrete-fourier-transform
     ((vector vector)
      &key (stride 1)
-     (result (grid:make-foreign-array element-type :dimensions (dimensions vector))))
+     (result (grid:make-foreign-array element-type :dimensions (grid:dimensions vector))))
   ("gsl_dft" :type "_backward")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
-   ((foreign-pointer result) :pointer))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+   ((grid:foreign-pointer result) :pointer))
   :definition :generic
   :element-types :complex
   :inputs (vector)
@@ -61,10 +61,10 @@
 (defmfun inverse-discrete-fourier-transform
     ((vector vector)
      &key (stride 1)
-     (result (grid:make-foreign-array element-type :dimensions (dimensions vector))))
+     (result (grid:make-foreign-array element-type :dimensions (grid:dimensions vector))))
   ("gsl_dft" :type "_inverse")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
-   ((foreign-pointer result) :pointer))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+   ((grid:foreign-pointer result) :pointer))
   :definition :generic
   :element-types :complex
   :inputs (vector)
@@ -77,10 +77,10 @@
 (defmfun discrete-fourier-transform
     ((vector vector)
      &key (stride 1)
-     (result (grid:make-foreign-array element-type :dimensions (dimensions vector))))
+     (result (grid:make-foreign-array element-type :dimensions (grid:dimensions vector))))
   ("gsl_dft" :type "_transform")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
-   ((foreign-pointer result) :pointer))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+   ((grid:foreign-pointer result) :pointer))
   :definition :generic
   :element-types :complex
   :inputs (vector)
diff --git a/fast-fourier-transforms/example.lisp b/fast-fourier-transforms/example.lisp
index a05d5d3bfccc723724e07c69572e8ea4adbd1342..8c3fd578beaecc5f1376e1d41735abfe476e9a92 100644
--- a/fast-fourier-transforms/example.lisp
+++ b/fast-fourier-transforms/example.lisp
@@ -1,8 +1,8 @@
 ;; Example FFT: transform a pulse (using the "clean" fft interface)
 ;; Sumant Oemrawsingh, Sat Oct 31 2009 - 00:24
-;; Time-stamp: <2010-09-04 08:44:35EDT example.lisp>
+;; Time-stamp: <2011-05-26 12:37:35EDT example.lisp>
 ;;
-;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
+;; Copyright 2009, 2010, 2011 Sumant Oemrawsingh, 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
@@ -42,10 +42,10 @@
   (assert (and (integerp dimension) (> dimension 20)))
   (let ((pulse (grid:make-foreign-array element-type :dimensions dimension))
         (init-value (coerce 1 element-type)))
-    (setf (grid:gref pulse 0) init-value)
+    (setf (grid:aref pulse 0) init-value)
     (loop for i from 1 to 10
-          do (setf (grid:gref pulse i) init-value
-                   (grid:gref pulse (- dimension i)) init-value))
+          do (setf (grid:aref pulse i) init-value
+                   (grid:aref pulse (- dimension i)) init-value))
     (forward-fourier-transform pulse)))
 
 (save-test
@@ -82,7 +82,7 @@
     (when init-offset
       (loop for i from 0 below size
             do
-            (setf (grid:gref vec i)
+            (setf (grid:aref vec i)
                   (if (subtypep element-type 'complex)
                     (coerce (complex (+ (* 2 i) init-offset)
                                      (+ (* 2 i) init-offset 1))
@@ -97,7 +97,7 @@
                                    (* stride dimension) :init-offset init-offset)))
     (loop for i from 0 below (* stride dimension) by stride
        do
-       (setf (grid:gref vec i)
+       (setf (grid:aref vec i)
 	     (if (subtypep element-type 'complex)
 		 (coerce (complex (urand) (urand)) element-type)
 		 (complex (coerce (urand) element-type)))))
@@ -107,31 +107,32 @@
   "The real vector consisting of the real part of the complex vector."
   (let ((real-vector
           (make-and-init-vector
-            (grid:component-float-type (element-type complex-vector))
+            (grid:component-float-type (grid:element-type complex-vector))
             (size complex-vector)
             :init-offset init-offset)))
     (loop for i below (size complex-vector) by stride
           do
-          (setf (grid:gref real-vector i)
-                (realpart (grid:gref complex-vector i))))
+          (setf (grid:aref real-vector i)
+                (realpart (grid:aref complex-vector i))))
     real-vector))
 
 (defun copy-with-stride (vector &key (stride 1) init-offset)
   "Copy a vector and initialize it."
   (let ((vec
-          (make-and-init-vector (element-type vector)
-                                (size vector)
-                                :init-offset init-offset)))
+	 (make-and-init-vector
+	  (grid:element-type vector)
+	  (size vector)
+	  :init-offset init-offset)))
     (loop for i below (size vector) by stride
           do
-          (setf (grid:gref vec i) (grid:gref vector i)))
+       (setf (grid:aref vec i) (grid:aref vector i)))
     vec))
 
 (defun size-vector-scalar (vector &key (stride 1))
   "Return the size of a vector while taking the stride into account."
   (coerce (floor (size vector) stride)
-	  (if (subtypep (element-type vector) 'complex)
-	      (element-type vector)
+	  (if (subtypep (grid:element-type vector) 'complex)
+	      (grid:element-type vector)
 	      'double-float)))
 
 #+nil
@@ -139,11 +140,11 @@
   (elt/ vector (size-vector-scalar vector :stride stride)))
 
 (defun vector/length (vector &key (stride 1))
-  (let ((element-type (element-type vector)))
+  (let ((element-type (grid:element-type vector)))
     (loop with length = (size-vector-scalar vector :stride stride)
           for i from 0 below (size vector) by stride
           do
-          (setf (grid:gref vector i) (coerce (/ (grid:gref vector i) length) element-type)))
+          (setf (grid:aref vector i) (coerce (/ (grid:aref vector i) length) element-type)))
   vector))
 
 (defun test-real-fft-noise (vector &key (stride 1) non-radix-2)
diff --git a/fast-fourier-transforms/extras.lisp b/fast-fourier-transforms/extras.lisp
index 21d9a370fc2d3ea1c2e3cc237343fb2343c31e57..6ce7999ff39b3807790793c3fac698ececfdcc15 100644
--- a/fast-fourier-transforms/extras.lisp
+++ b/fast-fourier-transforms/extras.lisp
@@ -76,12 +76,12 @@
          (zero-pos (if (evenp n) (- split 1) split)))
     ;; Positive frequencies
     (loop for i from zero-pos to (- n 1)
-          do (setf (grid:gref shifted (* i stride))
-                   (grid:gref vector (* (- i zero-pos) stride))))
+          do (setf (grid:aref shifted (* i stride))
+                   (grid:aref vector (* (- i zero-pos) stride))))
     ;; Negative frequencies
     (loop for i from (+ split 1) to (- n 1)
-          do (setf (grid:gref shifted (* (- i split 1) stride))
-                   (grid:gref vector (* i stride))))
+          do (setf (grid:aref shifted (* (- i split 1) stride))
+                   (grid:aref vector (* i stride))))
     shifted))
 
 (export 'fft-inverse-shift)
@@ -96,10 +96,10 @@
          (zero-pos (if (evenp n) (- split 1) split)))
     ;; Positive frequencies
     (loop for i from zero-pos to (- n 1)
-          do (setf (grid:gref inv-shifted (* (- i zero-pos) stride))
-                   (grid:gref vector (* i stride))))
+          do (setf (grid:aref inv-shifted (* (- i zero-pos) stride))
+                   (grid:aref vector (* i stride))))
     ;; Negative frequencies
     (loop for i from (+ split 1) to (- n 1)
-          do (setf (grid:gref inv-shifted (* i stride))
-                   (grid:gref vector (* (- i split 1) stride))))
+          do (setf (grid:aref inv-shifted (* i stride))
+                   (grid:aref vector (* (- i split 1) stride))))
     inv-shifted))
diff --git a/fast-fourier-transforms/forward.lisp b/fast-fourier-transforms/forward.lisp
index b90182609112abf4a17807293a2994c26918e738..e20508ae45624598358f92865b21515f485b9ea3 100644
--- a/fast-fourier-transforms/forward.lisp
+++ b/fast-fourier-transforms/forward.lisp
@@ -1,8 +1,8 @@
 ;; Forward FFT.
 ;; Sumant Oemrawsingh, Sat Oct 31 2009 - 23:48
-;; Time-stamp: <2010-06-27 18:13:58EDT forward.lisp>
+;; Time-stamp: <2011-01-10 17:59:23EST forward.lisp>
 ;;
-;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
+;; Copyright 2009, 2011 Sumant Oemrawsingh, 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
@@ -37,7 +37,7 @@
    single-float "gsl_fft_real_float_radix2_transform"
    complex-double-float "gsl_fft_complex_radix2_forward"
    complex-single-float "gsl_fft_complex_float_radix2_forward")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :float-complex
   :inputs (vector)
@@ -56,7 +56,7 @@
 		single-float "gsl_fft_real_float_transform"
 		complex-double-float "gsl_fft_complex_forward"
 		complex-single-float "gsl_fft_complex_float_forward")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
    ((mpointer wavetable) :pointer) ((mpointer workspace) :pointer))
   :definition :generic
   :element-types :float-complex
@@ -75,7 +75,7 @@
 (defmfun forward-fourier-transform-halfcomplex-radix2
     ((vector vector) &key (stride 1))
   ("gsl_fft_halfcomplex" :type "_radix2_transform")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :float
   :inputs (vector)
@@ -92,7 +92,7 @@
      (wavetable (make-fft-wavetable element-type (floor (size vector) stride) t))
      (workspace (make-fft-workspace element-type (floor (size vector) stride))))
   ("gsl_fft_halfcomplex" :type "_transform")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
    ((mpointer wavetable) :pointer) ((mpointer workspace) :pointer))
   :definition :generic
   :element-types :float
@@ -111,7 +111,7 @@
 
 (defmfun forward-fourier-transform-dif-radix2 ((vector vector) &key (stride 1))
   ("gsl_fft" :type "_radix2_dif_forward")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :complex
   :inputs (vector)
diff --git a/fast-fourier-transforms/inverse.lisp b/fast-fourier-transforms/inverse.lisp
index 77545e27e3449e921c1369d917eadeba57e28456..27c89e07d441758a2ab144def96ed7408c6a8464 100644
--- a/fast-fourier-transforms/inverse.lisp
+++ b/fast-fourier-transforms/inverse.lisp
@@ -1,8 +1,8 @@
 ;; Inverse FFT
 ;; Sumant Oemrawsingh, Sat Oct 24 2009 - 12:55
-;; Time-stamp: <2010-06-27 18:14:00EDT inverse.lisp>
+;; Time-stamp: <2011-01-11 23:34:17EST inverse.lisp>
 ;;
-;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
+;; Copyright 2009, 2011 Sumant Oemrawsingh, 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
@@ -33,7 +33,7 @@
 (defmfun inverse-fourier-transform-radix2
   ((vector vector) &key (stride 1))
   ("gsl_fft" :type "_radix2_inverse")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :complex
   :inputs (vector)
@@ -49,7 +49,7 @@
      (wavetable (make-fft-wavetable element-type (floor (size vector) stride)))
      (workspace (make-fft-workspace element-type (floor (size vector) stride))))
   ("gsl_fft" :type "_inverse")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
    ((mpointer wavetable) :pointer) ((mpointer workspace) :pointer))
   :definition :generic
   :element-types :complex
@@ -69,7 +69,7 @@
 (defmfun inverse-fourier-transform-halfcomplex-radix2
     ((vector vector) &key (stride 1))
   ("gsl_fft_halfcomplex" :type "_radix2_inverse")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :float
   :inputs (vector)
@@ -86,7 +86,7 @@
      (wavetable (make-fft-wavetable element-type (floor (size vector) stride) t))
      (workspace (make-fft-workspace element-type (floor (size vector) stride))))
   ("gsl_fft_halfcomplex" :type "_inverse")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
    ((mpointer wavetable) :pointer) ((mpointer workspace) :pointer))
   :definition :generic
   :element-types :float
@@ -106,7 +106,7 @@
 (defmfun inverse-fourier-transform-dif-radix2
   ((vector vector) &key (stride 1))
   ("gsl_fft" :type "_radix2_dif_inverse")
-  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :complex
   :inputs (vector)
@@ -138,13 +138,13 @@
     (remf pass-on-args :decimation-in-frequency)
     (remf pass-on-args :non-radix-2)
     (if (and (not non-radix-2) (power-of-2-p (floor (size vector) stride)))
-	(if (subtypep (element-type vector) 'real)
+	(if (subtypep (grid:element-type vector) 'real)
 	    (apply 'inverse-fourier-transform-halfcomplex-radix2
 		   vector pass-on-args)
 	    (if decimation-in-frequency
 		(apply 'inverse-fourier-transform-dif-radix2 vector pass-on-args)
 		(apply 'inverse-fourier-transform-radix2 vector pass-on-args)))
-	(if (subtypep (element-type vector) 'real)
+	(if (subtypep (grid:element-type vector) 'real)
 	    (apply 'inverse-fourier-transform-halfcomplex-nonradix2
 		   vector pass-on-args)
 	    (apply 'inverse-fourier-transform-nonradix2 vector pass-on-args)))))
diff --git a/fast-fourier-transforms/select-direction.lisp b/fast-fourier-transforms/select-direction.lisp
index 115fe4e639ba962944c291d972142d3c7bd1c7c5..c505e424d8798cd64495fe4addaa13984c2ef67f 100644
--- a/fast-fourier-transforms/select-direction.lisp
+++ b/fast-fourier-transforms/select-direction.lisp
@@ -1,8 +1,8 @@
 ;; FFT where direction is selected.
 ;; Sumant Oemrawsingh, Sat Oct 24 2009 - 12:55
-;; Time-stamp: <2010-06-27 18:13:58EDT select-direction.lisp>
+;; Time-stamp: <2011-01-10 17:59:24EST select-direction.lisp>
 ;;
-;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
+;; Copyright 2009, 2011 Sumant Oemrawsingh, 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
@@ -26,7 +26,7 @@
 (defmfun fourier-transform-radix2
     ((vector vector) direction &key (stride 1) (n (expt 2 (floor (log (size vector) 2)))))
   ("gsl_fft" :type "_radix2_transform")
-  (((foreign-pointer vector) :pointer) (stride sizet) (n sizet) (direction fft-direction))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) (n sizet) (direction fft-direction))
   :definition :generic
   :element-types :complex
   :inputs (vector)
@@ -40,7 +40,7 @@
 (defmfun fourier-transform-dif-radix2
     ((vector vector) direction &key (stride 1) (n (expt 2 (floor (log (size vector) 2)))))
   ("gsl_fft" :type "_radix2_dif_transform")
-  (((foreign-pointer vector) :pointer) (stride sizet) (n sizet) (direction fft-direction))
+  (((grid:foreign-pointer vector) :pointer) (stride sizet) (n sizet) (direction fft-direction))
   :definition :generic
   :element-types :complex
   :inputs (vector)
diff --git a/fast-fourier-transforms/unpack.lisp b/fast-fourier-transforms/unpack.lisp
index 228b4679d5d2ea4b1cc2e8a95568f25fca1fd39d..da474a8a8d7b5e35bb2aa594920a03188b3be640 100644
--- a/fast-fourier-transforms/unpack.lisp
+++ b/fast-fourier-transforms/unpack.lisp
@@ -1,8 +1,8 @@
 ;; Unpack functions for FFT vectors.
 ;; Sumant Oemrawsingh, Sun Oct 25 2009 - 16:35
-;; Time-stamp: <2010-06-29 22:12:06EDT unpack.lisp>
+;; Time-stamp: <2011-01-10 17:59:24EST unpack.lisp>
 ;;
-;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
+;; Copyright 2009, 2011 Sumant Oemrawsingh, 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
@@ -34,8 +34,8 @@
 		  t
 		  (grid:make-foreign-array '(complex double-float) :dimensions (size vector)))))
   ("gsl_fft_real" :type "_unpack")
-  (((foreign-pointer vector) :pointer)
-   ((foreign-pointer output) :pointer)
+  (((grid:foreign-pointer vector) :pointer)
+   ((grid:foreign-pointer output) :pointer)
    (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :float
@@ -58,8 +58,8 @@
 		  t
 		  (grid:make-foreign-array '(complex double-float) :dimensions (size vector)))))
   ("gsl_fft_halfcomplex" :type "_radix2_unpack")
-  (((foreign-pointer vector) :pointer)
-   ((foreign-pointer output) :pointer)
+  (((grid:foreign-pointer vector) :pointer)
+   ((grid:foreign-pointer output) :pointer)
    (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :float
@@ -81,8 +81,8 @@
 		  t
 		  (grid:make-foreign-array '(complex double-float) :dimensions (size vector)))))
   ("gsl_fft_halfcomplex" :type "_unpack")
-  (((foreign-pointer vector) :pointer)
-   ((foreign-pointer output) :pointer)
+  (((grid:foreign-pointer vector) :pointer)
+   ((grid:foreign-pointer output) :pointer)
    (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :float
diff --git a/gsll-tests.asd b/gsll-tests.asd
deleted file mode 100644
index 78b5f8dddc70db30c53fdea7f507a0acedec329d..0000000000000000000000000000000000000000
--- a/gsll-tests.asd
+++ /dev/null
@@ -1,218 +0,0 @@
-;; Definition of GSLL system 
-;; Liam Healy
-;; Time-stamp: <2010-10-03 18:11:16EDT gsll-tests.asd>
-;;
-;; Copyright 2007, 2008, 2009 Liam M. Healy
-;; Distributed under the terms of the GNU General Public License
-;;
-;; This program is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-;;
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-(eval-when (:compile-toplevel :load-toplevel :execute)
-  (asdf:oos 'asdf:load-op :cffi-grovel))
-
-(asdf:defsystem GSLL-TESTS
-  :name "GSLL-tests"
-  :description "Regression (unit) tests for GNU Scientific Library for Lisp."
-  :version "0"
-  :author "Liam M. Healy"
-  :licence "GPL v3"
-  :depends-on (gsll foreign-array-tests lisp-unit)
-  :components
-  ((:module test-unit
-	    :components
-	    ((cffi-grovel:grovel-file "machine")
-	     (:file "augment" :depends-on ("machine"))))
-   (:module tests
-	    :depends-on (test-unit)
-	    :components
-	    ((:file "absolute-deviation")
-	     (:file "absolute-sum")
-	     (:file "airy")
-	     (:file "autocorrelation")
-	     (:file "axpy")
-	     (:file "basis-spline")
-	     (:file "bernoulli")
-	     (:file "bessel")
-	     (:file "beta")
-	     (:file "binomial")
-	     (:file "blas-copy")
-	     (:file "blas-swap")
-	     (:file "cauchy")
-	     (:file "cdot")
-	     (:file "chebyshev")
-	     (:file "chi-squared")
-	     (:file "cholesky")
-	     (:file "clausen")
-	     (:file "column")
-	     (:file "combination")
-	     (:file "coulomb")
-	     (:file "coupling")
-	     (:file "correlation")
-	     (:file "covariance")
-	     (:file "dawson")
-	     (:file "debye")
-	     (:file "dilogarithm")
-	     (:file "dirichlet")
-	     (:file "discrete")
-	     (:file "dot")
-	     (:file "eigensystems")
-	     (:file "elementary")
-	     (:file "elliptic-functions")
-	     (:file "elliptic-integrals")
-	     (:file "error-functions")
-	     (:file "euclidean-norm")
-	     (:file "exponential-functions")
-	     (:file "exponential-integrals")
-	     (:file "exponential")
-	     (:file "exponential-power")
-	     (:file "fast-fourier-transform")
-	     (:file "fdist")
-	     (:file "fermi-dirac")
-	     (:file "flat")
-	     (:file "gamma")
-	     (:file "gamma-randist")
-	     (:file "gaussian-bivariate")
-	     (:file "gaussian")
-	     (:file "gaussian-tail")
-	     (:file "gegenbauer")
-	     (:file "geometric")
-	     (:file "givens")
-	     (:file "gumbel1")
-	     (:file "gumbel2")
-	     (:file "hankel")
-	     (:file "higher-moments")
-	     (:file "histogram")
-	     (:file "householder")
-	     (:file "hypergeometric")
-	     (:file "hypergeometric-randist")
-	     (:file "index-max")
-	     (:file "interpolation")
-	     (:file "inverse-matrix-product")
-	     (:file "laguerre")
-	     (:file "lambert")
-	     (:file "landau")
-	     (:file "laplace")
-	     (:file "legendre")
-	     (:file "levy")
-	     (:file "linear-least-squares")
-	     (:file "logarithmic")
-	     (:file "logarithm")
-	     (:file "logistic")
-	     (:file "lognormal")
-	     (:file "lu")
-	     (:file "mathematical")
-	     (:file "mathieu")
-	     (:file "matrix-div")
-	     (:file "matrix-max-index")
-	     (:file "matrix-max")
-	     (:file "matrix-mean")
-	     (:file "matrix-min")
-	     (:file "matrix-min-index")
-	     (:file "matrix-minmax-index")
-	     (:file "matrix-minmax")
-	     (:file "matrix-sub")
-	     (:file "matrix-add")
-	     (:file "matrix-mult")
-	     #+fsbv (:file "matrix-product-hermitian")
-	     (:file "matrix-product")
-	     (:file "matrix-product-nonsquare")
-	     (:file "matrix-product-symmetric")
-	     (:file "matrix-product-triangular")
-	     (:file "matrix-set-all")
-	     (:file "matrix-set-zero")
-	     (:file "matrix-standard-deviation")
-	     (:file "matrix-standard-deviation-with-fixed-mean")
-	     (:file "matrix-standard-deviation-with-mean")
-	     (:file "matrix-swap")
-	     (:file "matrix-transpose-copy")
-	     (:file "matrix-transpose")
-	     (:file "matrix-variance")
-	     (:file "matrix-variance-with-fixed-mean")
-	     (:file "matrix-variance-with-mean")
-	     (:file "median-percentile")
-	     (:file "minimization-one")
-	     (:file "minimization-multi")
-	     (:file "monte-carlo")
-	     (:file "multinomial")
-	     (:file "negative-binomial")
-	     (:file "nonlinear-least-squares")
-	     (:file "ntuple")
-	     (:file "numerical-differentiation")
-	     (:file "numerical-integration")
-	     (:file "ode")
-	     (:file "pareto")
-	     (:file "permutation")
-	     (:file "poisson")
-	     (:file "polynomial")
-	     (:file "power")
-	     (:file "psi")
-	     (:file "qr")
-	     (:file "qrpt")
-	     (:file "quasi-random-number-generators")
-	     (:file "random-number-generators")
-	     (:file "rank-1-update")
-	     (:file "rayleigh")
-	     (:file "rayleigh-tail")
-	     (:file "roots-multi")
-	     (:file "roots-one")
-	     (:file "row")
-	     (:file "scale")
-	     (:file "series-acceleration")
-	     (:file "set-basis")
-	     (:file "setf-column")
-	     (:file "setf-row")
-	     (:file "set-identity")
-	     (:file "shuffling-sampling")
-	     (:file "sort-matrix-largest")
-	     (:file "sort-matrix")
-	     (:file "sort-matrix-smallest")
-	     (:file "sort-vector-index")
-	     (:file "sort-vector-largest-index")
-	     (:file "sort-vector-largest")
-	     (:file "sort-vector")
-	     (:file "sort-vector-smallest-index")
-	     (:file "sort-vector-smallest")
-	     (:file "spherical-vector")
-	     (:file "svd")
-	     (:file "swap-columns")
-	     (:file "swap-elements")
-	     (:file "swap-row-column")
-	     (:file "swap-rows")
-	     (:file "synchrotron")
-	     (:file "tdist")
-	     (:file "transport")
-	     (:file "trigonometry")
-	     (:file "vector-div")
-	     (:file "vector-max-index")
-	     (:file "vector-max")
-	     (:file "vector-mean")
-	     (:file "vector-min")
-	     (:file "vector-min-index")
-	     (:file "vector-minmax-index")
-	     (:file "vector-minmax")
-	     (:file "vector-sub")
-	     (:file "vector-add")
-	     (:file "vector-mult")
-	     (:file "vector-reverse")
-	     (:file "vector-set-all")
-	     (:file "vector-set-zero")
-	     (:file "vector-standard-deviation")
-	     (:file "vector-standard-deviation-with-fixed-mean")
-	     (:file "vector-standard-deviation-with-mean")
-	     (:file "vector-swap")
-	     (:file "vector-variance")
-	     (:file "vector-variance-with-fixed-mean")
-	     (:file "vector-variance-with-mean")
-	     (:file "weibull")
-	     (:file "zeta")))))
diff --git a/gsll.asd b/gsll.asd
index 17780b4aa1f90ff6a21e7caf2847bf88a9b0ff38..0b755a7a2da7e9b3344cf358cb0c58438379d125 100644
--- a/gsll.asd
+++ b/gsll.asd
@@ -1,8 +1,8 @@
 ;; Definition of GSLL system 
 ;; Liam Healy
-;; Time-stamp: <2011-02-26 20:44:27EST gsll.asd>
+;; Time-stamp: <2011-01-30 10:41:57EST gsll.asd>
 ;;
-;; Copyright 2006, 2007, 2008, 2009, 2010 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -30,29 +30,7 @@
   :version "0"
   :author "Liam M. Healy"
   :licence "GPL v3"
-  :description "An interface to the GNU Scientific Library (GSL) from Common Lisp."
-  :long-description
-  "The GNU Scientific Library for Lisp (GSLL) allows you to use the
-GNU Scientific Library (GSL) from Common Lisp.  This library provides
-a full range of common mathematical operations useful to scientific
-and engineering applications.  The design of the GSLL interface is
-such that access to most of the GSL library is possible in a
-Lisp-natural way; the intent is that the user not be hampered by the
-restrictions of the C language in which GSL has been written.  GSLL
-thus provides interactive use of GSL for getting quick answers, even
-for someone not intending to program in Lisp.
-      
-Topics include: roots of polynomials, special functions, vectors and
-matrices, permutations, sorting, BLAS (basic linear algebra
-subprograms), linear algebra, eigensystems, fast Fourier transforms,
-quadrature, random numbers, quasi-random sequences, random
-distributions, statistics, histograms, N-tuples, Monte Carlo
-integration, simulated annealing, differential equations,
-interpolation, numerical differentiation, Chebyshev approximation,
-series acceleration, discrete Hankel transforms, root-finding,
-minimization least-squares fitting, IEEE floating-point, discrete
-wavelet transforms."
-  :depends-on (foreign-array grid cffi cffi-grovel trivial-garbage #+fsbv fsbv)
+  :depends-on (antik cffi-grovel trivial-garbage alexandria #+fsbv fsbv)
   :components
   ((:module init
 	    :components
@@ -289,3 +267,199 @@ wavelet transforms."
 	    ((cffi-grovel:grovel-file "mksa")
 	     (cffi-grovel:grovel-file "cgsm")
 	     (:file export)))))
+
+(asdf:defsystem-connection GSLL-tests
+  :name "GSLL-tests"
+  :description "Regression (unit) tests for GNU Scientific Library for Lisp."
+  :version "0"
+  :author "Liam M. Healy"
+  :licence "GPL v3"
+  :requires (gsll lisp-unit)
+  :components
+  ((:module test-unit
+	    :components
+	    ((cffi-grovel:grovel-file "machine")
+	     (:file "augment" :depends-on ("machine"))))
+   (:module tests
+	    :depends-on (test-unit)
+	    :components
+	    ((:file "absolute-deviation")
+	     (:file "absolute-sum")
+	     (:file "airy")
+	     (:file "autocorrelation")
+	     (:file "axpy")
+	     (:file "basis-spline")
+	     (:file "bernoulli")
+	     (:file "bessel")
+	     (:file "beta")
+	     (:file "binomial")
+	     (:file "blas-copy")
+	     (:file "blas-swap")
+	     (:file "cauchy")
+	     (:file "cdot")
+	     (:file "chebyshev")
+	     (:file "chi-squared")
+	     (:file "cholesky")
+	     (:file "clausen")
+	     (:file "column")
+	     (:file "combination")
+	     (:file "coulomb")
+	     (:file "coupling")
+	     (:file "correlation")
+	     (:file "covariance")
+	     (:file "dawson")
+	     (:file "debye")
+	     (:file "dilogarithm")
+	     (:file "dirichlet")
+	     (:file "discrete")
+	     (:file "dot")
+	     (:file "eigensystems")
+	     (:file "elementary")
+	     (:file "elliptic-functions")
+	     (:file "elliptic-integrals")
+	     (:file "error-functions")
+	     (:file "euclidean-norm")
+	     (:file "exponential-functions")
+	     (:file "exponential-integrals")
+	     (:file "exponential")
+	     (:file "exponential-power")
+	     (:file "fast-fourier-transform")
+	     (:file "fdist")
+	     (:file "fermi-dirac")
+	     (:file "flat")
+	     (:file "gamma")
+	     (:file "gamma-randist")
+	     (:file "gaussian-bivariate")
+	     (:file "gaussian")
+	     (:file "gaussian-tail")
+	     (:file "gegenbauer")
+	     (:file "geometric")
+	     (:file "givens")
+	     (:file "gumbel1")
+	     (:file "gumbel2")
+	     (:file "hankel")
+	     (:file "higher-moments")
+	     (:file "histogram")
+	     (:file "householder")
+	     (:file "hypergeometric")
+	     (:file "hypergeometric-randist")
+	     (:file "index-max")
+	     (:file "interpolation")
+	     (:file "inverse-matrix-product")
+	     (:file "laguerre")
+	     (:file "lambert")
+	     (:file "landau")
+	     (:file "laplace")
+	     (:file "legendre")
+	     (:file "levy")
+	     (:file "linear-least-squares")
+	     (:file "logarithmic")
+	     (:file "logarithm")
+	     (:file "logistic")
+	     (:file "lognormal")
+	     (:file "lu")
+	     (:file "mathematical")
+	     (:file "mathieu")
+	     (:file "matrix-div")
+	     (:file "matrix-max-index")
+	     (:file "matrix-max")
+	     (:file "matrix-mean")
+	     (:file "matrix-min")
+	     (:file "matrix-min-index")
+	     (:file "matrix-minmax-index")
+	     (:file "matrix-minmax")
+	     (:file "matrix-sub")
+	     (:file "matrix-add")
+	     (:file "matrix-mult")
+	     #+fsbv (:file "matrix-product-hermitian")
+	     (:file "matrix-product")
+	     (:file "matrix-product-nonsquare")
+	     (:file "matrix-product-symmetric")
+	     (:file "matrix-product-triangular")
+	     (:file "matrix-set-all")
+	     (:file "matrix-set-zero")
+	     (:file "matrix-standard-deviation")
+	     (:file "matrix-standard-deviation-with-fixed-mean")
+	     (:file "matrix-standard-deviation-with-mean")
+	     (:file "matrix-swap")
+	     (:file "matrix-transpose-copy")
+	     (:file "matrix-transpose")
+	     (:file "matrix-variance")
+	     (:file "matrix-variance-with-fixed-mean")
+	     (:file "matrix-variance-with-mean")
+	     (:file "median-percentile")
+	     (:file "minimization-one")
+	     (:file "minimization-multi")
+	     (:file "monte-carlo")
+	     (:file "multinomial")
+	     (:file "negative-binomial")
+	     (:file "nonlinear-least-squares")
+	     (:file "ntuple")
+	     (:file "numerical-differentiation")
+	     (:file "numerical-integration")
+	     (:file "ode")
+	     (:file "pareto")
+	     (:file "permutation")
+	     (:file "poisson")
+	     (:file "polynomial")
+	     (:file "power")
+	     (:file "psi")
+	     (:file "qr")
+	     (:file "qrpt")
+	     (:file "quasi-random-number-generators")
+	     (:file "random-number-generators")
+	     (:file "rank-1-update")
+	     (:file "rayleigh")
+	     (:file "rayleigh-tail")
+	     (:file "roots-multi")
+	     (:file "roots-one")
+	     (:file "row")
+	     (:file "scale")
+	     (:file "series-acceleration")
+	     (:file "set-basis")
+	     (:file "setf-column")
+	     (:file "setf-row")
+	     (:file "set-identity")
+	     (:file "shuffling-sampling")
+	     (:file "sort-matrix-largest")
+	     (:file "sort-matrix")
+	     (:file "sort-matrix-smallest")
+	     (:file "sort-vector-index")
+	     (:file "sort-vector-largest-index")
+	     (:file "sort-vector-largest")
+	     (:file "sort-vector")
+	     (:file "sort-vector-smallest-index")
+	     (:file "sort-vector-smallest")
+	     (:file "spherical-vector")
+	     (:file "svd")
+	     (:file "swap-columns")
+	     (:file "swap-elements")
+	     (:file "swap-row-column")
+	     (:file "swap-rows")
+	     (:file "synchrotron")
+	     (:file "tdist")
+	     (:file "transport")
+	     (:file "trigonometry")
+	     (:file "vector-div")
+	     (:file "vector-max-index")
+	     (:file "vector-max")
+	     (:file "vector-mean")
+	     (:file "vector-min")
+	     (:file "vector-min-index")
+	     (:file "vector-minmax-index")
+	     (:file "vector-minmax")
+	     (:file "vector-sub")
+	     (:file "vector-add")
+	     (:file "vector-mult")
+	     (:file "vector-reverse")
+	     (:file "vector-set-all")
+	     (:file "vector-set-zero")
+	     (:file "vector-standard-deviation")
+	     (:file "vector-standard-deviation-with-fixed-mean")
+	     (:file "vector-standard-deviation-with-mean")
+	     (:file "vector-swap")
+	     (:file "vector-variance")
+	     (:file "vector-variance-with-fixed-mean")
+	     (:file "vector-variance-with-mean")
+	     (:file "weibull")
+	     (:file "zeta")))))
diff --git a/hankel.lisp b/hankel.lisp
index dbf4bb3c51b19a33f35d39ed355ff930e8038024..b89ddeb2b99dd7f879a2c2bf90e9f1ad61a84dba 100644
--- a/hankel.lisp
+++ b/hankel.lisp
@@ -1,8 +1,8 @@
 ;; Discrete Hankel Transforms.
 ;; Liam Healy, Sat Dec  8 2007 - 16:50
-;; Time-stamp: <2010-07-07 14:19:28EDT hankel.lisp>
+;; Time-stamp: <2011-05-26 12:37:29EDT hankel.lisp>
 ;;
-;; Copyright 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2007, 2008, 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
@@ -39,10 +39,10 @@
 (defmfun apply-hankel
     (hankel array-in
      &optional
-     (array-out (grid:make-foreign-array 'double-float :dimensions (dimensions array-in))))
+     (array-out (grid:make-foreign-array 'double-float :dimensions (grid:dimensions array-in))))
   "gsl_dht_apply"
-  (((mpointer hankel) :pointer) ((foreign-pointer array-in) :pointer)
-   ((foreign-pointer array-out) :pointer))
+  (((mpointer hankel) :pointer) ((grid:foreign-pointer array-in) :pointer)
+   ((grid:foreign-pointer array-out) :pointer))
   :inputs (array-in)
   :outputs (array-out)
   :return (array-out)
@@ -81,7 +81,7 @@
  (let ((hank (make-hankel 128 0.0d0 100.0d0))
        (in (grid:make-foreign-array 'double-float :dimensions 128)))
    (loop for n from 0 below 128
-      do (setf (grid:gref in n)
+      do (setf (grid:aref in n)
 	       (/ (1+ (expt (sample-x-hankel hank n) 2)))))
    (grid:copy-to (apply-hankel hank in)))
  ;; Integrate[ x exp(-x) J_1(a x), {x,0,Inf}] = a F(3/2, 2; 2; -a^2)
@@ -89,13 +89,13 @@
  (let ((hank (make-hankel 128 1.0d0 20.0d0))
        (in (grid:make-foreign-array 'double-float :dimensions 128)))
    (loop for n from 0 below 128
-      do (setf (grid:gref in n) (exp (- (sample-x-hankel hank n)))))
+      do (setf (grid:aref in n) (exp (- (sample-x-hankel hank n)))))
    (grid:copy-to (apply-hankel hank in)))
  ;; Integrate[ x^2 (1-x^2) J_1(a x), {x,0,1}] = 2/a^2 J_3(a)
  (let ((hank (make-hankel 128 1.0d0 1.0d0))
        (in (grid:make-foreign-array 'double-float :dimensions 128)))
    (loop for n from 0 below 128
-      do (setf (grid:gref in n)
+      do (setf (grid:aref in n)
 	       (let ((x (sample-x-hankel hank n)))
 		 (* x (- 1 (expt x 2))))))
    (grid:copy-to (apply-hankel hank in))))
diff --git a/histogram/histogram.lisp b/histogram/histogram.lisp
index f657f25a506fea297a6cdee83c60db8857645875..0ef039ef3caca1ac8694a75bbd20eb2e81a3a42a 100644
--- a/histogram/histogram.lisp
+++ b/histogram/histogram.lisp
@@ -1,8 +1,8 @@
 ;; The histogram structure
 ;; Liam Healy, Mon Jan  1 2007 - 11:32
-;; Time-stamp: <2010-11-13 19:24:22EST histogram.lisp>
+;; Time-stamp: <2011-01-10 17:59:25EST histogram.lisp>
 ;;
-;; Copyright 2007, 2008, 2009, 2010 Liam M. Healy
+;; Copyright 2007, 2008, 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
@@ -30,7 +30,7 @@
   ((number-of-bins sizet))
   "one-dimensional histogram, including bin boundaries and bin contents"
   :initialize-suffix "set_ranges"
-  :initialize-args (((foreign-pointer ranges) :pointer) ((dim0 ranges) sizet)))
+  :initialize-args (((grid:foreign-pointer ranges) :pointer) ((dim0 ranges) sizet)))
 
 (defmobject histogram2d
     "gsl_histogram2d"
@@ -38,8 +38,8 @@
   "two-dimensional histogram, including bin boundaries and bin contents."
   :initialize-suffix "set_ranges"
   :initialize-args
-  (((foreign-pointer x-ranges) :pointer) ((dim0 x-ranges) sizet)
-   ((foreign-pointer y-ranges) :pointer) ((dim0 y-ranges) sizet)))
+  (((grid:foreign-pointer x-ranges) :pointer) ((dim0 x-ranges) sizet)
+   ((grid:foreign-pointer y-ranges) :pointer) ((dim0 y-ranges) sizet)))
 
 ;;; GSL documentation does not state what the return value for the
 ;;; C function for reinitialization means; assumed to be error code.
diff --git a/histogram/ntuple-example.dat b/histogram/ntuple-example.dat
deleted file mode 100644
index be4cb5a5d29dc9072987e90d6886995088febcb2..0000000000000000000000000000000000000000
Binary files a/histogram/ntuple-example.dat and /dev/null differ
diff --git a/histogram/ntuple.lisp b/histogram/ntuple.lisp
index 2164ac39a5f6e2bd4069fb70081dee862143a20a..5c8a4a1a83f957805ac63116df2a3d487f478c6c 100644
--- a/histogram/ntuple.lisp
+++ b/histogram/ntuple.lisp
@@ -1,6 +1,6 @@
 ;; N-tuples
 ;; Liam Healy Sat Feb  3 2007 - 12:53
-;; Time-stamp: <2010-06-30 19:57:28EDT ntuple.lisp>
+;; Time-stamp: <2011-05-26 12:37:35EDT ntuple.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -235,7 +235,7 @@
       (close-ntuple ntuple)
       ;; Check the histogram to see if it matches ntuple-example-values
       (dotimes (row 100 t)
-	(unless (= (grid:gref histo row) (aref answer row))
+	(unless (= (grid:aref histo row) (aref answer row))
 	  (return nil))))))
 
 (save-test ntuple
diff --git a/histogram/updating-accessing.lisp b/histogram/updating-accessing.lisp
index 98c8297ea290ea71040d20a2f9e0bea20ae229af..ca3f81b1a942af59cf249d2070284aec74d1561c 100644
--- a/histogram/updating-accessing.lisp
+++ b/histogram/updating-accessing.lisp
@@ -1,6 +1,6 @@
 ;; Updating and accessing histogram elements.
 ;; Liam Healy, Mon Jan  1 2007 - 14:43
-;; Time-stamp: <2010-11-14 17:46:45EST updating-accessing.lisp>
+;; Time-stamp: <2011-05-26 12:37:35EDT updating-accessing.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -42,12 +42,12 @@
    histograms for a small range of a larger dataset, ignoring the values
    outside the range of interest.")
 
-(defmfun grid:gref ((histogram histogram) &rest indices)
+(defmfun grid:aref ((histogram histogram) &rest indices)
   "gsl_histogram_get"
   (((mpointer histogram) :pointer) ((first indices) sizet))
   :definition :method 
   :c-return :double
-  :index grid:gref
+  :index grid:aref
   :documentation			; FDL
   "Return the contents of the i-th bin of the histogram.
    If i lies outside the valid range of index for the
@@ -128,22 +128,22 @@
    (set-ranges-uniform histo 0.0d0 10.0d0)
    (increment histo 2.7d0)
    (increment histo 6.9d0 2.0d0)
-   (grid:gref histo 1))
+   (grid:aref histo 1))
  (let ((histo (make-histogram 10)))
    (set-ranges-uniform histo 0.0d0 10.0d0)
    (increment histo 2.7d0)
    (increment histo 6.9d0 2.0d0)
-   (grid:gref histo 2))
+   (grid:aref histo 2))
  (let ((histo (make-histogram 10)))
    (set-ranges-uniform histo 0.0d0 10.0d0)
    (increment histo 2.7d0)
    (increment histo 6.9d0 2.0d0)
-   (grid:gref histo 6))
+   (grid:aref histo 6))
  (let ((histo (make-histogram 10)))
    (set-ranges-uniform histo 0.0d0 10.0d0)
    (increment histo 2.7d0)
    (increment histo 6.9d0 2.0d0)
-   (grid:gref histo 16))
+   (grid:aref histo 16))
  (let ((histo (make-histogram 10)))
    (set-ranges-uniform histo 0.0d0 10.0d0)
    (increment histo 2.7d0)
diff --git a/init/callback-compile-defs.lisp b/init/callback-compile-defs.lisp
index 4e8b5b18669339ee25c4c180b87067287e8a456e..54ef37bc40fb1735d5acadeb8a1963bdf787b45a 100644
--- a/init/callback-compile-defs.lisp
+++ b/init/callback-compile-defs.lisp
@@ -1,8 +1,8 @@
 ;; Definitions for macro expansion
 ;; Liam Healy 2009-03-15 14:50:28EDT callback-compile-defs.lisp
-;; Time-stamp: <2009-12-27 09:50:34EST callback-compile-defs.lisp>
+;; Time-stamp: <2011-01-10 18:19:12EST callback-compile-defs.lisp>
 ;;
-;; 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
@@ -40,7 +40,7 @@
     `(make-cbstruct
       ',(parse-callback-static cbs 'callback-fnstruct)
       (when (dimension-names object)
-	(mappend 'list (dimension-names object) (dimensions object)))
+	(mappend 'list (dimension-names object) (grid:dimensions object)))
       ,@(mappend
 	 'list
 	 (mapcar
diff --git a/init/callback-included.lisp b/init/callback-included.lisp
index 830f1fee7f8bb325fe12148907814282f3fd0e3b..75a80e9e3c6d628b4eb3f5c0fab417f2e3685ffc 100644
--- a/init/callback-included.lisp
+++ b/init/callback-included.lisp
@@ -1,8 +1,8 @@
 ;; The mobject that defines callbacks
 ;; Liam Healy 2009-03-14 11:20:03EDT callback-included.lisp
-;; Time-stamp: <2009-12-27 09:50:34EST callback-included.lisp>
+;; Time-stamp: <2011-01-10 18:19:12EST callback-included.lisp>
 ;;
-;; 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
@@ -43,7 +43,7 @@
     :initarg :scalarsp :reader scalarsp :initform t
     :documentation "Whether the function expect to be passed and return
     scalars or arrays.")
-   (dimensions :initarg :dimensions :reader dimensions))
+   (grid:dimensions :initarg :dimensions :reader grid:dimensions))
   (:documentation
    "A mobject that includes a callback function or functions to GSL."))
 
@@ -65,7 +65,7 @@
   (declare (ignore ignore))
   `(defclass ,class-name ,superclasses
      ((dimension-names :initform nil :allocation :class)
-      (dimensions :initform '(1) :allocation :class)
+      (grid:dimensions :initform '(1) :allocation :class)
       (scalarsp :initform T :allocation :class))
      (:documentation ,documentation)))
 
@@ -76,7 +76,7 @@
       (princ (first (functions object)) stream)
       (princ ", " stream))
     (princ "dimensions " stream)
-    (princ (dimensions object) stream)))
+    (princ (grid:dimensions object) stream)))
 
 ;;;;****************************************************************************
 ;;;; For making mobjects
diff --git a/init/defmfun-array.lisp b/init/defmfun-array.lisp
index 603319014986aeb2286c49efde178f8b64b1c4a5..f369b2c801c7790aeeca87a78e5d8943d24d317f 100644
--- a/init/defmfun-array.lisp
+++ b/init/defmfun-array.lisp
@@ -1,8 +1,8 @@
 ;; Helpers for defining GSL functions on arrays
 ;; Liam Healy 2009-01-07 22:01:16EST defmfun-array.lisp
-;; Time-stamp: <2010-07-12 12:28:57EDT defmfun-array.lisp>
+;; Time-stamp: <2011-01-29 21:40:31EST defmfun-array.lisp>
 ;;
-;; 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
@@ -28,7 +28,7 @@
     (defn name arglist gsl-name c-arguments categories key-args)
   (setf categories
 	(remove-if-not
-	 (lambda (c) (member c '(both matrix vector)))
+	 (lambda (c) (member c '(both grid:matrix vector)))
 	 categories))
   (if (member 'both categories)
       (progn 
@@ -45,12 +45,12 @@
 	   (optional-args-to-switch-gsl-functions arglist gsl-name))
 	  (copy-list key-args) 'vector)
 	 (generate-methods
-	  defn 'matrix
+	  defn 'grid:matrix
 	  name arglist gsl-name
 	  (actual-array-c-type
-	   'matrix c-arguments
+	   'grid:matrix c-arguments
 	   (optional-args-to-switch-gsl-functions arglist gsl-name))
-	  (copy-list key-args) 'matrix)))
+	  (copy-list key-args) 'grid:matrix)))
       ;; Generate forms for one category
       (generate-methods
        defn (first categories)
@@ -149,18 +149,20 @@
 			base-name))))))))))
 
 (defun actual-array-class (category element-type &optional replace-both)
-  "From the category ('vector, 'matrix, or 'both) and element type,
+  "From the category ('vector, 'grid:matrix, or 'both) and element type,
    find the class name."
   (case category
     (:element-type (grid:number-class element-type))
     (:component-float-type
-     (grid:number-class (grid:component-float-type element-type)))
-    (otherwise
-     (grid:data-class-name
-      (if (and (eq category 'both) replace-both)
-	  replace-both
-	  category)
-      element-type))))
+       (grid:number-class (grid:component-float-type element-type)))
+    ((vector grid:matrix both)
+       (grid:data-class-name
+	(if (and (eq category 'both) replace-both)
+	    replace-both
+	    category)
+	element-type))
+    ;; an actual not-to-be-replaced class name
+    (otherwise category)))
 
 (defun actual-class-arglist
     (arglist element-type c-arguments &optional replace-both)
diff --git a/init/funcallable.lisp b/init/funcallable.lisp
index 3ef4e7b0e401a1a6b4eb2604ae4cb0aa68fd1737..92b99d878d727ed0be3486bf1ea6230c90d4b947 100644
--- a/init/funcallable.lisp
+++ b/init/funcallable.lisp
@@ -1,8 +1,8 @@
 ;; Generate a lambda that calls the user function; will be called by callback.
 ;; Liam Healy 
-;; Time-stamp: <2010-11-25 09:09:40EST funcallable.lisp>
+;; Time-stamp: <2011-01-10 18:19:11EST funcallable.lisp>
 ;;
-;; 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
@@ -214,7 +214,7 @@
     (lambda (fn fnspec)
       (compile
        nil
-       (make-funcallable-form fn fnspec (scalarsp object) (dimensions object))))
+       (make-funcallable-form fn fnspec (scalarsp object) (grid:dimensions object))))
     (functions object)
     (parse-callback-static (cbinfo object) 'functions))))
 
diff --git a/init/init.lisp b/init/init.lisp
index dff9e2c6a9160a268b3cdd5d5723f12d8416468f..7cde22dcf7ef344db06fef194122335ea58f8f98 100644
--- a/init/init.lisp
+++ b/init/init.lisp
@@ -1,8 +1,8 @@
 ;; Load GSL
 ;; Liam Healy Sat Mar  4 2006 - 18:53
-;; Time-stamp: <2010-08-16 23:08:13EDT init.lisp>
+;; Time-stamp: <2011-01-13 09:38:45EST init.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009, 2010 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,17 +19,36 @@
 ;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 (defpackage gsll
-  (:nicknames :gsl)
+    (:nicknames :gsl)
   (:use :common-lisp :cffi)
-  (:import-from
-   :grid
-   #:cl-array #:dimensions #:element-type
-   #:foreign-array #:matrix #:dim0 #:dim1 #:^
-   #:copy)
-  (:shadowing-import-from :grid #:foreign-pointer)
-  (:export
-   #:cl-array #:dimensions #:element-type #:dim0 #:dim1
-   #:copy))
+  (:import-from :grid #:dim0 #:dim1 #:^ #:copy)
+  (:export #:dim0 #:dim1 #:copy)
+  ;; No actual conflict due to different usage of symbols:
+  ;; antik:psi means "pounds per square inch" vs. function #'gsl:psi
+  ;; antik:knots means "nautical miles per hour" vs. function #'gsl:knots
+  ;; antik:acceleration refers to the time derivative of velocity vs. object 'gsl:acceleration.
+  ;; si units symbol-macro vs. GSLL's sine integral.
+  (:shadowing-import-from :antik #:psi #:knots #:acceleration #:si))
+
+(setf
+ antik::*antik-user-shadow-symbols*
+ (append antik::*antik-user-shadow-symbols*
+	 ;; Where there is a symbol conflict between GSLL and other packages,
+	 '(
+	   ;; take from the other package
+	   grid:row			; GSLL alternate is equivalent
+	   grid:column			; GSLL alternate is equivalent
+	   iterate:sum ; GSLL histogram function, both pretty obscure
+	   iterate:multiply		; GSLL function duplicates '*
+	   antik:polar-to-rectangular	; GSLL's doesn't use vectors
+	   antik:rectangular-to-polar	; GSLL's doesn't use vectors
+	   ;; taken from GSLL
+	   gsll::iterate ; conflict with iterate:iterate, but iterate:iter is a synonym
+	   ))
+ antik::*antik-user-use-packages*
+ (cons '#:gsll antik::*antik-user-use-packages*))
+
+(antik:make-user-package :antik-user)	; Add the new use package and shadow symbols to :antik-user
 
 (in-package :gsl)
 
diff --git a/init/mobject.lisp b/init/mobject.lisp
index 0b39a098a42c26b4bff019d29d107a508893be21..8b3836c89c3147f32f2a34fbd6a3bb61aa7eee2c 100644
--- a/init/mobject.lisp
+++ b/init/mobject.lisp
@@ -1,8 +1,8 @@
 ;; Definition of GSL objects and ways to use them.
 ;; Liam Healy, Sun Dec  3 2006 - 10:21
-;; Time-stamp: <2010-11-13 18:22:18EST mobject.lisp>
+;; Time-stamp: <2011-01-11 19:10:48EST mobject.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -288,9 +288,9 @@
   (if (listp symbol)
       (mappend (lambda (s) (symbol-keyword-symbol s singular)) symbol)
       (if (member (singular-symbol symbol) singular)
-	  (list (intern (symbol-name symbol) :keyword)
+	  (list (alexandria:make-keyword symbol)
 		`(list ,(singular-symbol symbol)))
-	  (list (intern (symbol-name symbol) :keyword)
+	  (list (alexandria:make-keyword symbol)
 		symbol))))
 
 ;;;;****************************************************************************
diff --git a/interpolation/evaluation.lisp b/interpolation/evaluation.lisp
index 0c7c6c0c1002f0872e4ce631a388097cea636ba8..1546943b501b5e540bf590f2e0e216d33e984bae 100644
--- a/interpolation/evaluation.lisp
+++ b/interpolation/evaluation.lisp
@@ -1,8 +1,8 @@
 ;; Evaluation of interpolation functions.
 ;; Liam Healy Sun Nov  4 2007 - 18:40
-;; Time-stamp: <2010-06-27 18:13:56EDT evaluation.lisp>
+;; Time-stamp: <2011-01-10 17:59:26EST evaluation.lisp>
 ;;
-;; Copyright 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2007, 2008, 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
@@ -27,8 +27,8 @@
      &key xa ya (acceleration (make-acceleration)))
   "gsl_interp_eval"
   (((mpointer interpolation) :pointer)
-   ((foreign-pointer xa) :pointer)
-   ((foreign-pointer ya) :pointer)
+   ((grid:foreign-pointer xa) :pointer)
+   ((grid:foreign-pointer ya) :pointer)
    (x :double)
    ((mpointer acceleration) :pointer))
   :definition :method
@@ -51,8 +51,8 @@
      &key xa ya (acceleration (make-acceleration)))
   "gsl_interp_eval_deriv"
   (((mpointer interpolation) :pointer)
-   ((foreign-pointer xa) :pointer)
-   ((foreign-pointer ya) :pointer)
+   ((grid:foreign-pointer xa) :pointer)
+   ((grid:foreign-pointer ya) :pointer)
    (x :double)
    ((mpointer acceleration) :pointer))
   :definition :method
@@ -70,8 +70,8 @@
     ((interpolation interpolation) x &key xa ya (acceleration (make-acceleration)))
   "gsl_interp_eval_deriv2"
   (((mpointer interpolation) :pointer)
-   ((foreign-pointer xa) :pointer)
-   ((foreign-pointer ya) :pointer)
+   ((grid:foreign-pointer xa) :pointer)
+   ((grid:foreign-pointer ya) :pointer)
    (x :double)
    ((mpointer acceleration) :pointer))
   :definition :method
@@ -90,8 +90,8 @@
      &key xa ya (acceleration (make-acceleration)))
   "gsl_interp_eval_integ"
   (((mpointer interpolation) :pointer)
-   ((foreign-pointer xa) :pointer)
-   ((foreign-pointer ya) :pointer)
+   ((grid:foreign-pointer xa) :pointer)
+   ((grid:foreign-pointer ya) :pointer)
    (low :double) (high :double) ((mpointer acceleration) :pointer))
   :definition :method
   :inputs (xa ya)
diff --git a/interpolation/interpolation.lisp b/interpolation/interpolation.lisp
index f7845f4f8efdf5a4b2944ceb75d1c6a35d5f45af..dd5a83fe2c08b995a4e9290261dbe6df571c1d5e 100644
--- a/interpolation/interpolation.lisp
+++ b/interpolation/interpolation.lisp
@@ -1,8 +1,8 @@
 ;; Interpolation allocation, initialization, and freeing.
 ;; Liam Healy, Sun Nov  4 2007 - 17:24
-;; Time-stamp: <2010-06-27 18:13:56EDT interpolation.lisp>
+;; Time-stamp: <2011-01-10 17:59:26EST interpolation.lisp>
 ;;
-;; Copyright 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2007, 2008, 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
@@ -37,7 +37,7 @@
   strictly ordered; the behavior for other arrangements is not defined."
   :initialize-suffix "init"
   :initialize-args
-  (((foreign-pointer xa) :pointer) ((foreign-pointer ya) :pointer) ((dim0 xa) sizet))
+  (((grid:foreign-pointer xa) :pointer) ((grid:foreign-pointer ya) :pointer) ((dim0 xa) sizet))
   :arglists-function
   (lambda (set)
     `((type &optional xa-or-size (ya nil ,set))
@@ -51,7 +51,7 @@
   "Make an interpolation object of type for size data-points."
   :initialize-suffix "init"
   :initialize-args
-  (((foreign-pointer xa) :pointer) ((foreign-pointer ya) :pointer) ((dim0 xa) sizet))
+  (((grid:foreign-pointer xa) :pointer) ((grid:foreign-pointer ya) :pointer) ((dim0 xa) sizet))
   :inputs (xa ya)
   :arglists-function
   (lambda (set)
diff --git a/interpolation/lookup.lisp b/interpolation/lookup.lisp
index fc329b701fbd4795aea46e5c88efe230e1545512..78b754c6c6bd84b42db90d1807196643541e142c 100644
--- a/interpolation/lookup.lisp
+++ b/interpolation/lookup.lisp
@@ -1,8 +1,8 @@
 ;; Index lookup and acceleration
 ;; Liam Healy, Sun Nov  4 2007 - 18:09
-;; Time-stamp: <2009-12-27 09:52:14EST lookup.lisp>
+;; Time-stamp: <2011-01-13 10:24:57EST lookup.lisp>
 ;;
-;; Copyright 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2007, 2008, 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
diff --git a/interpolation/spline-example.lisp b/interpolation/spline-example.lisp
index 1e870684efa29fc2e2d5e0165a7bf4bb80debbb5..1449b20523ba8919a08ca59485941b0d08e02fc8 100644
--- a/interpolation/spline-example.lisp
+++ b/interpolation/spline-example.lisp
@@ -1,6 +1,6 @@
 ;; Example spline
 ;; Liam Healy, Sat Nov 10 2007 - 21:18
-;; Time-stamp: <2010-08-07 21:37:07EDT spline-example.lisp>
+;; Time-stamp: <2011-05-26 12:37:34EDT spline-example.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -35,7 +35,7 @@
 	   (loop for i from 0.0d0 below 10.0d0
 	      collect (+ i (cos (expt i 2))))))
 	 (spline (make-spline +cubic-spline-interpolation+ xarr yarr)))
-    (loop for xi from (grid:gref xarr 0) below (grid:gref xarr 9) by step
+    (loop for xi from (grid:aref xarr 0) below (grid:aref xarr 9) by step
        collect (list xi (evaluate spline xi)))))
 
 (defun evaluate-integral-example (&optional (intervals 4))
diff --git a/linear-algebra/blas1.lisp b/linear-algebra/blas1.lisp
index 401def27e46c40e6a23e3ad11ab8e988b155c851..42660a81981cff8b38b8025b2ade77da2ed7f9e3 100644
--- a/linear-algebra/blas1.lisp
+++ b/linear-algebra/blas1.lisp
@@ -1,8 +1,8 @@
 ;; BLAS level 1, Vector operations
 ;; Liam Healy, Wed Apr 26 2006 - 15:23
-;; Time-stamp: <2010-07-07 14:25:01EDT blas1.lisp>
+;; Time-stamp: <2011-05-26 12:37:34EDT blas1.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -22,11 +22,11 @@
 
 ;;; /usr/include/gsl/gsl_blas.h
 
-(defmfun dot ((vec1 vector) (vec2 vector))
+(defmfun grid:inner ((vec1 vector) (vec2 vector))
   ("gsl_blas_" :type "dot" :suffix)
   (((mpointer vec1) :pointer) ((mpointer vec2) :pointer)
    (result (:pointer :element-c-type)))
-  :definition :generic
+  :definition :methods
   :element-types :float-complex
   :inputs (vec1 vec2)
   :documentation			; FDL
@@ -112,7 +112,7 @@
 (defmfun axpy
     (alpha (x vector)
 	   &optional
-	   (y (grid:make-foreign-array element-type :dimensions (dimensions x))))
+	   (y (grid:make-foreign-array element-type :dimensions (grid:dimensions x))))
   ;; This gets an error for complex types because you can't pass a
   ;; struct in CFFI yet.
   ("gsl_blas_" :type "axpy")
@@ -153,8 +153,8 @@
 
 (defmfun givens-rotation ((x vector) (y vector) (c vector) (s vector))
   ("gsl_blas_" :type "rotg")
-  (((foreign-pointer x) :pointer) ((foreign-pointer y) :pointer)
-   ((foreign-pointer c) :pointer) ((foreign-pointer s) :pointer))
+  (((grid:foreign-pointer x) :pointer) ((grid:foreign-pointer y) :pointer)
+   ((grid:foreign-pointer c) :pointer) ((grid:foreign-pointer s) :pointer))
   :definition :generic
   :element-types :float
   :inputs (x y c s)
@@ -182,9 +182,9 @@
 (defmfun modified-givens-rotation
     ((d1 vector) (d2 vector) (b1 vector) b2 (P vector))
   ("gsl_blas_" :type "rotmg")
-  (((foreign-pointer d1) :pointer) ((foreign-pointer d2) :pointer)
-   ((foreign-pointer b1) :pointer) (b2 :element-c-type)
-   ((foreign-pointer P) :pointer))
+  (((grid:foreign-pointer d1) :pointer) ((grid:foreign-pointer d2) :pointer)
+   ((grid:foreign-pointer b1) :pointer) (b2 :element-c-type)
+   ((grid:foreign-pointer P) :pointer))
   :definition :generic
   :element-types :float
   :inputs (d1 d2 b1 P)
@@ -210,7 +210,7 @@
 (generate-all-array-tests dot :float-complex
  (let ((v1 (array-default 8))
        (v2 (array-default 8)))
-   (dot v1 v2)))
+   (grid:inner v1 v2)))
 
 (generate-all-array-tests cdot :complex
  (let ((v1 (array-default 8))
@@ -264,7 +264,7 @@
        (sines (array-default 8 t))
        (cosines (array-default 8 t)))
    (loop for i below 8 do
-	(setf (grid:gref sines i) (sin (grid:gref angles i)))
-	(setf (grid:gref cosines i) (cos (grid:gref angles i))))
+	(setf (grid:aref sines i) (sin (grid:aref angles i)))
+	(setf (grid:aref cosines i) (cos (grid:aref angles i))))
    (givens-rotation v1 v2 cosines sines)
    (list (grid:copy-to v1) (grid:copy-to v2))))
diff --git a/linear-algebra/blas2.lisp b/linear-algebra/blas2.lisp
index b2fbe8a3842bad8ebc007108fea9eb874e0bfadc..2b421480ad72894a5a6913973bb1b248aa96869b 100644
--- a/linear-algebra/blas2.lisp
+++ b/linear-algebra/blas2.lisp
@@ -1,8 +1,8 @@
 ;; BLAS level 2, Matrix-vector operations
 ;; Liam Healy, Wed Apr 26 2006 - 21:08
-;; Time-stamp: <2010-07-07 14:25:00EDT blas2.lisp>
+;; Time-stamp: <2011-04-23 17:15:33EDT blas2.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -41,20 +41,20 @@
 ;;;;****************************************************************************
 
 (defun matrix-product-dimensions (a b)
-  (if (typep b 'matrix)
-      (list (first (dimensions a))
-	    (second (dimensions b)))
-      (first (dimensions a))))
+  (if (typep b 'grid:matrix)
+      (list (first (grid:dimensions a))
+	    (second (grid:dimensions b)))
+      (first (grid:dimensions a))))
 
 (defmfun matrix-product
-    ((A matrix) (x vector)
+    ((A grid:matrix) (x vector)
      &optional
      y
      (alpha 1) (beta 1) (TransA :notrans) TransB
      &aux
      (yarr
-      (grid:make-foreign-array-or-default
-       y (matrix-product-dimensions A x) nil element-type 0)))
+      (grid:ensure-foreign-array
+       y (matrix-product-dimensions A x) element-type 0)))
   ("gsl_blas_" :type "gemv")
   ((transa cblas-transpose) (alpha :element-c-type) ((mpointer A) :pointer)
    ((mpointer x) :pointer) (beta :element-c-type) ((mpointer yarr) :pointer))
@@ -74,7 +74,7 @@
   parameter TransB.")
 
 (defmfun matrix-product-triangular
-    ((A matrix) (x vector)
+    ((A grid:matrix) (x vector)
      &optional (alpha 1) (uplo :upper) (TransA :notrans)
      (diag :nonunit) (side :left))
   ("gsl_blas_" :type "trmv")
@@ -106,7 +106,7 @@
    are taken as unity and are not referenced.")
 
 (defmfun inverse-matrix-product
-    ((A matrix) (x vector)
+    ((A grid:matrix) (x vector)
      &optional (alpha 1) (uplo :upper) (TransA :notrans)
      (diag :nonunit) (side :left))
   ("gsl_blas_" :type "trsv")
@@ -137,7 +137,7 @@
    matrix A are taken as unity and are not referenced.")
 
 (defmfun matrix-product-symmetric
-    ((A matrix) (x vector)
+    ((A grid:matrix) (x vector)
      &optional y
      (alpha 1) (beta 1) (uplo :upper) (side :left)
      &aux
@@ -170,7 +170,7 @@
 
 #+fsbv
 (defmfun matrix-product-hermitian
-    ((A matrix) (x vector)
+    ((A grid:matrix) (x vector)
      &optional
      (y (grid:make-foreign-array element-type :dimensions (matrix-product-dimensions A x)
 		     :initial-element 0))
@@ -199,7 +199,7 @@
   are used. The imaginary elements of the diagonal are automatically
   set to zero.")
 
-(defmfun rank-1-update (alpha (x vector) (y vector) (A matrix))
+(defmfun rank-1-update (alpha (x vector) (y vector) (A grid:matrix))
   ("gsl_blas_" :type "ger" :suffix)
   ((alpha :element-c-type) ((mpointer x) :pointer)
    ((mpointer y) :pointer) ((mpointer A) :pointer))
@@ -211,7 +211,7 @@
    "The rank-1 update A = alpha x y^T + A of the matrix A.")
 
 #+fsbv
-(defmfun conjugate-rank-1-update (alpha (x vector) (y vector) (A matrix))
+(defmfun conjugate-rank-1-update (alpha (x vector) (y vector) (A grid:matrix))
   ("gsl_blas_" :type "gerc")
   ((alpha :element-c-type) ((mpointer x) :pointer)
    ((mpointer y) :pointer) ((mpointer A) :pointer))
@@ -223,7 +223,7 @@
   "The conjugate rank-1 update A = alpha x y^H + A of the matrix A.")
 
 (defmfun symmetric-rank-1-update
-    ((x vector) (A matrix)
+    ((x vector) (A grid:matrix)
      &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans))
   ("gsl_blas_" :type "syr")
   ((uplo cblas-uplo) (alpha :element-c-type)
@@ -249,7 +249,7 @@
 
 #+fsbv
 (defmfun hermitian-rank-1-update
-    ((x vector) (A matrix)
+    ((x vector) (A grid:matrix)
      &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans))
   ("gsl_blas_" :type "her")
   ((uplo cblas-uplo) (alpha :element-c-type)
@@ -276,7 +276,7 @@
   elements of the diagonal are automatically set to zero.")
 
 (defmfun symmetric-rank-2-update
-    ((x vector) (y vector) (A matrix)
+    ((x vector) (y vector) (A grid:matrix)
      &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans))
   ("gsl_blas_" :type "syr2")
   ((uplo cblas-uplo) (alpha :element-c-type)
@@ -303,7 +303,7 @@
 
 #+fsbv
 (defmfun hermitian-rank-2-update
-    ((x vector) (y vector) (A matrix)
+    ((x vector) (y vector) (A grid:matrix)
      &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans))
   ("gsl_blas_" :type "her2")
   ((uplo cblas-uplo) (alpha :element-c-type)
diff --git a/linear-algebra/blas3.lisp b/linear-algebra/blas3.lisp
index ab51b2a892fd69cf74bfe0099dcd332d24c98fcd..933448596d23930f85d2b1eb568f74ad87e1040d 100644
--- a/linear-algebra/blas3.lisp
+++ b/linear-algebra/blas3.lisp
@@ -1,8 +1,8 @@
 ;; BLAS level 3, Matrix-matrix operations
 ;; Liam Healy, Wed Apr 26 2006 - 21:08
-;; Time-stamp: <2010-07-07 14:25:00EDT blas3.lisp>
+;; Time-stamp: <2011-01-12 00:49:27EST blas3.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -34,7 +34,7 @@
 ;;;;****************************************************************************
 
 (defmfun matrix-product
-    ((A matrix) (B matrix)
+    ((A grid:matrix) (B grid:matrix)
      &optional
      C
      (alpha 1) (beta 1) (TransA :notrans) (TransB :notrans)
@@ -53,7 +53,7 @@
   :outputs (Carr))
 
 (defmfun matrix-product-symmetric
-    ((A matrix) (B matrix)
+    ((A grid:matrix) (B grid:matrix)
      &optional C (alpha 1) (beta 1) (uplo :upper) (side :left)
      &aux
      (Carr
@@ -71,7 +71,7 @@
 
 #+fsbv
 (defmfun matrix-product-hermitian
-    ((A matrix) (B matrix)
+    ((A grid:matrix) (B grid:matrix)
      &optional
      (C (grid:make-foreign-array element-type :dimensions (matrix-product-dimensions A B)
 		     :initial-element 0))
@@ -88,7 +88,7 @@
   :outputs (C))
 
 (defmfun matrix-product-triangular
-    ((A matrix) (B matrix)
+    ((A grid:matrix) (B grid:matrix)
      &optional (alpha 1) (uplo :upper) (TransA :notrans)
      (diag :nonunit) (side :left))
   ("gsl_blas_" :type "trmm")
@@ -101,7 +101,7 @@
   :outputs (B))
 
 (defmfun inverse-matrix-product
-    ((A matrix) (B matrix)
+    ((A grid:matrix) (B grid:matrix)
      &optional (alpha 1) (uplo :upper) (TransA :notrans)
      (diag :nonunit) (side :left))
   ;; This signals an error for complex arguments because you can't pass a
@@ -116,7 +116,7 @@
   :outputs (B))
 
 (defmfun symmetric-rank-1-update
-    ((A matrix) (C matrix)
+    ((A grid:matrix) (C grid:matrix)
      &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans))
   ("gsl_blas_" :type "syrk")
   ((uplo cblas-uplo) (trans cblas-transpose)
@@ -129,7 +129,7 @@
 
 #+fsbv
 (defmfun hermitian-rank-1-update
-    ((A matrix) (C matrix)
+    ((A grid:matrix) (C grid:matrix)
      &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans))
   ("gsl_blas_" :type "herk")
   ((uplo cblas-uplo) (trans cblas-transpose)
@@ -141,7 +141,7 @@
   :outputs (C))
 
 (defmfun symmetric-rank-2-update
-    ((A matrix) (B matrix) (C matrix)
+    ((A grid:matrix) (B grid:matrix) (C grid:matrix)
      &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans))
   ("gsl_blas_" :type "syr2k")
   ((uplo cblas-uplo) (trans cblas-transpose)
@@ -155,7 +155,7 @@
 
 #+fsbv
 (defmfun hermitian-rank-2-update
-    ((A matrix) (B matrix) (C matrix)
+    ((A grid:matrix) (B grid:matrix) (C grid:matrix)
      &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans))
   ("gsl_blas_" :type "her2k")
   ((uplo cblas-uplo) (trans cblas-transpose)
diff --git a/linear-algebra/cholesky.lisp b/linear-algebra/cholesky.lisp
index f75ba50e23e5a3174f87cd4261596aa1ab9f54d9..afa6239034f7113275d41adb5d2198a435d8a368 100644
--- a/linear-algebra/cholesky.lisp
+++ b/linear-algebra/cholesky.lisp
@@ -1,8 +1,8 @@
 ;; Cholesky Decomposition
 ;; Liam Healy, Wed May  3 2006 - 16:38
-;; Time-stamp: <2010-06-30 19:57:28EDT cholesky.lisp>
+;; Time-stamp: <2011-05-26 12:37:33EDT cholesky.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -34,7 +34,7 @@
 
 ;;; GSL version 1.10 introduced functions for complex matrices.
 
-(defmfun cholesky-decomposition ((A matrix))
+(defmfun cholesky-decomposition ((A grid:matrix))
   ("gsl_linalg" :complex "_cholesky_decomp")
   (((mpointer A) :pointer))
   :definition :generic
@@ -51,9 +51,9 @@
   returning the error input-domain.")
 
 (defmfun cholesky-solve
-    ((A matrix) (b vector) &optional x-spec
+    ((A grid:matrix) (b vector) &optional x-spec
      &aux
-     (x (grid:make-foreign-array-or-default x-spec (dimensions b) t)))
+     (x (grid:ensure-foreign-array x-spec (grid:dimensions b))))
   (("gsl_linalg" :complex "_cholesky_svx")
    ("gsl_linalg" :complex "_cholesky_solve"))
   ((((mpointer A) :pointer) ((mpointer b) :pointer))
@@ -98,7 +98,7 @@
   (let ((decomp (cholesky-decomposition (copy matrix))))
     (dotimes (row (dim0 matrix) decomp)
       (loop for col from (1+ row) below (dim1 matrix) do
-	   (setf (grid:gref decomp row col) 0.0d0)))
+	   (setf (grid:aref decomp row col) 0.0d0)))
     (matrix-product decomp decomp nil 1.0d0 0.0d0 :notrans :trans)))
 
 (defun test-cholesky-invert-dim (matrix)
diff --git a/linear-algebra/diagonal.lisp b/linear-algebra/diagonal.lisp
index cace5ac3e6b2ef4647f29c9fb9aedfc26464de4e..1eb71f2fcabe660ae62f0012c026a6852131e5a7 100644
--- a/linear-algebra/diagonal.lisp
+++ b/linear-algebra/diagonal.lisp
@@ -1,8 +1,8 @@
 ;; Tridiagonal and Bidiagonal matrices
 ;; Liam Healy, Thu May  4 2006 - 15:43
-;; Time-stamp: <2010-06-30 19:57:28EDT diagonal.lisp>
+;; Time-stamp: <2011-05-26 12:37:34EDT diagonal.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -35,7 +35,7 @@
 ;;; A = U T U^T where U is a unitary
 ;;; matrix and T is a real symmetric tridiagonal matrix.
 
-(defmfun tridiagonal-decomposition ((A matrix) tau)
+(defmfun tridiagonal-decomposition ((A grid:matrix) tau)
   (double-float "gsl_linalg_symmtd_decomp"
    complex-double-float "gsl_linalg_hermtd_decomp")
   (((mpointer A) :pointer) ((mpointer tau) :pointer))
@@ -53,7 +53,7 @@
    Q.  This storage scheme is the same as used by lapack.  The
    upper triangular part of A is not referenced.")
 
-(defmfun tridiagonal-unpack ((A matrix) tau Q diag subdiag)
+(defmfun tridiagonal-unpack ((A grid:matrix) tau Q diag subdiag)
   (double-float "gsl_linalg_symmtd_unpack"
    complex-double-float "gsl_linalg_hermtd_unpack")
   (((mpointer A) :pointer) ((mpointer tau) :pointer)
@@ -69,7 +69,7 @@
   orthogonal or unitary matrix Q, the vector of diagonal elements diag
   and the real vector of subdiagonal elements subdiag.")
 
-(defmfun tridiagonal-unpack-T ((A matrix) diag subdiag)
+(defmfun tridiagonal-unpack-T ((A grid:matrix) diag subdiag)
   (double-float "gsl_linalg_symmtd_unpack_T"
    complex-double-float "gsl_linalg_hermtd_unpack_T")
   (((mpointer A) :pointer) ((mpointer diag) :pointer)
@@ -255,11 +255,11 @@
 	  (subdiag (mvec (1- n) :initial-element 0.5d0)))
       (setf
        ;; i=0 matrix elements
-       (grid:gref diag 0) 1d0
-       (grid:gref superdiag 0) 0d0
-       (grid:gref b 0) (coerce (expt (1- n) 2) 'double-float)
+       (grid:aref diag 0) 1d0
+       (grid:aref superdiag 0) 0d0
+       (grid:aref b 0) (coerce (expt (1- n) 2) 'double-float)
        ;; i=n-1 matrix elements
-       (grid:gref diag (1- n)) 1d0
-       (grid:gref subdiag (- n 2)) 0d0
-       (grid:gref b (1- n)) 0d0)
+       (grid:aref diag (1- n)) 1d0
+       (grid:aref subdiag (- n 2)) 0d0
+       (grid:aref b (1- n)) 0d0)
       (solve-tridiagonal diag superdiag subdiag b x))))
diff --git a/linear-algebra/householder.lisp b/linear-algebra/householder.lisp
index 7545f90dc8299a2d2c91be49bf1563adeadbc8be..a903e68d7191cd2e6f07678300518d720835a912 100644
--- a/linear-algebra/householder.lisp
+++ b/linear-algebra/householder.lisp
@@ -1,8 +1,8 @@
 ;; Householder Transformations
 ;; Liam Healy, Wed May 10 2006 - 10:03
-;; Time-stamp: <2010-06-29 22:51:21EDT householder.lisp>
+;; Time-stamp: <2011-04-23 17:14:09EDT householder.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -87,7 +87,7 @@
 (defmfun householder-solve
     (A b &optional x-spec
        &aux
-       (x (grid:make-foreign-array-or-default x-spec (dimensions b) t)))
+       (x (grid:ensure-foreign-array x-spec (grid:dimensions b))))
   ("gsl_linalg_HH_svx" "gsl_linalg_HH_solve")
   ((((mpointer A) :pointer) ((mpointer b) :pointer))
    (((mpointer A) :pointer) ((mpointer b) :pointer)
diff --git a/linear-algebra/lu.lisp b/linear-algebra/lu.lisp
index fe24ced82be41dd5182aa22f6bbb88c9faf75319..4ece7b4c888a91afad005d7fdd8bb1586ffe3ed9 100644
--- a/linear-algebra/lu.lisp
+++ b/linear-algebra/lu.lisp
@@ -1,8 +1,8 @@
 ;; LU decomposition
 ;; Liam Healy, Thu Apr 27 2006 - 12:42
-;; Time-stamp: <2010-07-07 14:24:59EDT lu.lisp>
+;; Time-stamp: <2011-01-30 11:00:48EST lu.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -23,7 +23,7 @@
 ;;; /usr/include/gsl/gsl_linalg.h
 
 (defmfun LU-decomposition
-    ((A matrix) &optional (permutation (make-permutation (dim0 A))))
+    ((A grid:matrix) &optional (permutation (make-permutation (dim0 A))))
   ("gsl_linalg" :complex "_LU_decomp")
   (((mpointer A) :pointer) ((mpointer permutation) :pointer)
    (signum (:pointer :int)))
@@ -53,10 +53,10 @@
   Algorithm 3.4.1).")
 
 (defmfun LU-solve
-    ((A matrix) (b vector) permutation &optional x-spec
+    ((A grid:matrix) (b vector) permutation &optional x-spec
      &aux
      (x (if (eq x-spec t)
-	    (grid:make-foreign-array element-type :dimensions (dimensions b))
+	    (grid:make-foreign-array element-type :dimensions (grid:dimensions b))
 	    x-spec)))
   (("gsl_linalg" :complex "_LU_svx")
    ("gsl_linalg" :complex "_LU_solve"))
@@ -78,7 +78,7 @@
   will be computed there.  Otherwise it should be a supplied vector.")
 
 (defmfun LU-refine
-    ((A matrix) LU p (b vector) (x vector)
+    ((A grid:matrix) LU p (b vector) (x vector)
      &optional (residual (grid:make-foreign-array element-type :dimensions (dim0 A))))
   ("gsl_linalg" :complex "_LU_refine")
   (((mpointer A) :pointer) ((mpointer LU) :pointer)
@@ -95,7 +95,10 @@
   A x = b, using the LU decomposition of A into (LU,p). The initial
   residual r = A x - b is also computed and stored in residual. ")
 
-(defmfun LU-invert ((LU matrix) p inverse)
+(defmfun LU-invert
+    ((LU grid:matrix) p
+     &optional (inverse
+		(grid:make-foreign-array element-type :dimensions (grid:dimensions LU))))
   ("gsl_linalg" :complex "_LU_invert")
   (((mpointer LU) :pointer) ((mpointer p) :pointer)
    ((mpointer inverse) :pointer))
@@ -112,7 +115,7 @@
    the same result more efficiently and reliably (consult any
    introductory textbook on numerical linear algebra for details).")
 
- (defmfun LU-determinant ((LU matrix) signum)
+(defmfun LU-determinant ((LU grid:matrix) signum)
   ("gsl_linalg" :complex "_LU_det")
   (((mpointer LU) :pointer) (signum :int))
   :definition :generic
@@ -124,7 +127,7 @@
   decomposition, LU. The determinant is computed as the product of the
   diagonal elements of U and the sign of the row permutation signum.")
 
-(defmfun LU-log-determinant ((LU matrix))
+(defmfun LU-log-determinant ((LU grid:matrix))
   ("gsl_linalg" :complex "_LU_lndet")
   (((mpointer LU) :pointer))
   :definition :generic
@@ -137,7 +140,7 @@
    LU. This function may be useful if the direct computation of the
    determinant would overflow or underflow.")
 
-(defmfun LU-sgndet ((LU matrix) signum)
+(defmfun LU-sgndet ((LU grid:matrix) signum)
   ("gsl_linalg" :complex "_LU_sgndet")
   (((mpointer LU) :pointer) (signum :int))
   :definition :generic
@@ -148,28 +151,6 @@
   "Compute the sign or phase factor of the determinant of a matrix A,
   det(A)/|det(A)|, from its LU decomposition, LU.")
 
-;;; Invert a matrix using LU
-(export 'invert-matrix)
-(defun invert-matrix (mat)
-  "Invert the matrix."
-  (let* ((dim (first (dimensions mat)))
-	 (per (make-permutation dim))
-	 (inv (grid:make-foreign-array 'double-float :dimensions (list dim dim))))
-    (LU-decomposition mat per)
-    (lu-invert mat per inv)))
-
-;;; Examples and unit test
-
-;;; These are direct tests of matrix inversion
-
-(save-test
- lu
- (grid:copy-to
-  (invert-matrix
-   (grid:make-foreign-array 'double-float
-		:dimensions  '(2 2)
-		:initial-contents '(1.0d0 2.0d0 3.0d0 4.0d0)))))
-
 (generate-all-array-tests lu :doubles
  (let ((matrix (array-default '(4 4)))
        (vec (array-default '4 )))
@@ -192,7 +173,7 @@
    the index."
   (let* ((dim (dim0 matrix))
 	 (rhs (or vector
-		  (create-rhs-vector dim (element-type matrix)))))
+		  (create-rhs-vector dim (grid:element-type matrix)))))
     (multiple-value-bind (upper permutation signum)
 	(LU-decomposition (copy matrix))
       (declare (ignore signum))
diff --git a/linear-algebra/matrix-generation.lisp b/linear-algebra/matrix-generation.lisp
index 21645764859d726b5456943ddec4043a47f99330..902564b9e657505564269e965159dd85e71b2494 100644
--- a/linear-algebra/matrix-generation.lisp
+++ b/linear-algebra/matrix-generation.lisp
@@ -1,8 +1,8 @@
 ;; Generate matrices used in tests of linear algebra functions
 ;; Liam Healy 2009-09-19 18:28:31EDT matrix-generation.lisp
-;; Time-stamp: <2010-08-12 22:48:01EDT matrix-generation.lisp>
+;; Time-stamp: <2011-01-11 23:58:19EST matrix-generation.lisp>
 ;;
-;; 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
@@ -40,13 +40,13 @@
    :source function
    :destination-specification
    (if dim1
-       `((foreign-array ,dim0 ,dim1) ,element-type)
-       `((foreign-array ,dim0) ,element-type))))
+       `((grid:foreign-array ,dim0 ,dim1) ,element-type)
+       `((grid:foreign-array ,dim0) ,element-type))))
 
 (defun constant-matrix
     (constant dim0 &optional (dim1 dim0) (element-type 'double-float))
   (grid:make-grid
-   `((foreign-array ,dim0 ,dim1) ,element-type)
+   `((grid:foreign-array ,dim0 ,dim1) ,element-type)
    :initial-element constant))
 
 ;;;;****************************************************************************
diff --git a/linear-algebra/qr.lisp b/linear-algebra/qr.lisp
index cf7e52ebea86eb662c56583f0a71ea1c88dc259d..8dc33b9380a16947eceede28bd49fdf56b40a035 100644
--- a/linear-algebra/qr.lisp
+++ b/linear-algebra/qr.lisp
@@ -1,8 +1,8 @@
 ;; QR decomposition
 ;; Liam Healy 2008-02-17 11:05:20EST qr.lisp
-;; Time-stamp: <2010-06-30 19:57:28EDT qr.lisp>
+;; Time-stamp: <2011-05-26 12:37:33EDT qr.lisp>
 ;;
-;; Copyright 2008, 2009 Liam M. Healy
+;; Copyright 2008, 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
@@ -62,7 +62,7 @@
 (defmfun QR-solve
     (QR tau b &optional x-spec
 	&aux
-	(x (grid:make-foreign-array-or-default x-spec (dimensions b) t)))
+	(x (grid:ensure-foreign-array x-spec (grid:dimensions b))))
   ("gsl_linalg_QR_svx" "gsl_linalg_QR_solve")
   ((((mpointer QR) :pointer) ((mpointer tau) :pointer)
     ((mpointer b) :pointer))
@@ -129,7 +129,7 @@
 (defmfun QR-Rsolve
     (QR b &optional x-spec
        &aux
-       (x (grid:make-foreign-array-or-default x-spec (dimensions b) t)))
+       (x (grid:ensure-foreign-array x-spec (grid:dimensions b))))
   ("gsl_linalg_QR_Rsvx" "gsl_linalg_QR_Rsolve")
   ((((mpointer QR) :pointer) ((mpointer b) :pointer))
    (((mpointer QR) :pointer) ((mpointer b) :pointer) ((mpointer x) :pointer)))
@@ -149,7 +149,7 @@
     (QR tau
      &optional
      (Q (grid:make-foreign-array 'double-float :dimensions (list (dim0 QR) (dim0 QR))))
-     (R (grid:make-foreign-array 'double-float :dimensions (dimensions QR))))
+     (R (grid:make-foreign-array 'double-float :dimensions (grid:dimensions QR))))
   "gsl_linalg_QR_unpack"
   (((mpointer QR) :pointer) ((mpointer tau) :pointer)
    ((mpointer Q) :pointer) ((mpointer R) :pointer))
@@ -189,7 +189,7 @@
 (defmfun R-solve
     (R b &optional x-spec
        &aux
-       (x (grid:make-foreign-array-or-default x-spec (dimensions b) t)))
+       (x (grid:ensure-foreign-array x-spec (grid:dimensions b))))
   ("gsl_linalg_R_svx" "gsl_linalg_R_solve")
   ((((mpointer R) :pointer) ((mpointer b) :pointer))
    (((mpointer R) :pointer) ((mpointer b) :pointer) ((mpointer x) :pointer)))
@@ -258,7 +258,7 @@
 	     dim1 nil))
 	 (qr1
 	  (create-matrix
-	   (lambda (i j) (+ (grid:gref matrix i j) (* (grid:gref u i) (grid:gref v j))))
+	   (lambda (i j) (+ (grid:aref matrix i j) (* (grid:aref u i) (grid:aref v j))))
 	   dim0 dim1))
 	 (qr2 (copy matrix))
 	 (w (grid:make-foreign-array 'double-float :dimensions dim0 :initial-element 0)))
diff --git a/linear-algebra/qrpt.lisp b/linear-algebra/qrpt.lisp
index 6e093c4215513af0d3687eab167f84596ff7d33c..f38b300388d1e2cf901885610fcbb5367318d01f 100644
--- a/linear-algebra/qrpt.lisp
+++ b/linear-algebra/qrpt.lisp
@@ -1,8 +1,8 @@
 ;; QR with column pivoting
 ;; Liam Healy, Fri Apr 28 2006 - 16:53
-;; Time-stamp: <2010-06-29 22:51:20EDT qrpt.lisp>
+;; Time-stamp: <2011-04-23 17:15:46EDT qrpt.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -60,7 +60,7 @@
     (A
      &optional
      (q (grid:make-foreign-array 'double-float :dimensions (list (dim0 A) (dim0 A))))
-     (r (grid:make-foreign-array 'double-float :dimensions (dimensions A)))
+     (r (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A)))
      (tau (grid:make-foreign-array 'double-float :dimensions (min (dim0 A) (dim1 A))))
      (permutation (make-permutation (dim1 A)))
      (norm (grid:make-foreign-array 'double-float :dimensions (dim1 A))))
@@ -80,7 +80,7 @@
 (defmfun QRPT-solve
     (QR tau permutation b &optional x-spec
        &aux
-       (x (grid:make-foreign-array-or-default x-spec (dimensions b) t)))
+       (x (grid:ensure-foreign-array x-spec (grid:dimensions b))))
   ("gsl_linalg_QRPT_svx" "gsl_linalg_QRPT_solve")
   ((((mpointer QR) :pointer) ((mpointer tau) :pointer)
     ((mpointer permutation) :pointer) ((mpointer b) :pointer))
@@ -131,7 +131,7 @@
 (defmfun QRPT-Rsolve
     (QR permutation b &optional x-spec
        &aux
-       (x (grid:make-foreign-array-or-default x-spec (dimensions b) t)))
+       (x (grid:ensure-foreign-array x-spec (grid:dimensions b))))
   ("gsl_linalg_QRPT_Rsvx" "gsl_linalg_QRPT_Rsolve")
   ((((mpointer QR) :pointer) ((mpointer permutation) :pointer)
     ((mpointer b) :pointer))
@@ -180,7 +180,7 @@
 	(QR-unpack QRPT tau)
       (let* ((qr (matrix-product Q R))
 	     (ans (grid:make-foreign-array
-		   'double-float :dimensions (dimensions qr)
+		   'double-float :dimensions (grid:dimensions qr)
 		   ;; It shouldn't be necessary to initialize values
 		   ;; because we are going to setf every row,
 		   ;; Sat Dec 26 2009.
diff --git a/ordinary-differential-equations/evolution.lisp b/ordinary-differential-equations/evolution.lisp
index eff0e004c2072d763c0bce9b119086d66ea4cc4d..e851cbbfdfb828b750bfd9a056052308e93eaf2e 100644
--- a/ordinary-differential-equations/evolution.lisp
+++ b/ordinary-differential-equations/evolution.lisp
@@ -1,8 +1,8 @@
 ;; Evolution functions for ODE integration.
 ;; Liam Healy, Sun Sep 30 2007 - 14:31
-;; Time-stamp: <2010-06-27 18:13:51EDT evolution.lisp>
+;; Time-stamp: <2011-01-10 18:16:19EST evolution.lisp>
 ;;
-;; Copyright 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -21,7 +21,7 @@
 (in-package :gsl)
 
 (defmobject ode-evolution "gsl_odeiv_evolve"
-  ((dimensions sizet))
+  ((grid:dimensions sizet))
   "evolution for ordinary differential equations"
   :documentation "Make an object to advance the ODE solution."
   :initialize-suffix "reset"
@@ -32,9 +32,9 @@
   "gsl_odeiv_evolve_apply"
   (((mpointer evolution) :pointer) ((mpointer control) :pointer)
    ((mpointer stepper) :pointer)
-   ((callback-struct stepper) :pointer) ((foreign-pointer time) :pointer)
+   ((callback-struct stepper) :pointer) ((grid:foreign-pointer time) :pointer)
    (max-time :double)
-   ((foreign-pointer step-size) :pointer) ((foreign-pointer y) :pointer))
+   ((grid:foreign-pointer step-size) :pointer) ((grid:foreign-pointer y) :pointer))
   :inputs (time step-size y)
   :outputs (time step-size y)
   :callback-object ((stepper ode-stepper))
diff --git a/ordinary-differential-equations/ode-system.lisp b/ordinary-differential-equations/ode-system.lisp
index 1a65e116d5e53aa93dfff1ce88abf7a9a7bb24fb..2da9f906c695e47eabcf2d9e3fa5a553c139aada 100644
--- a/ordinary-differential-equations/ode-system.lisp
+++ b/ordinary-differential-equations/ode-system.lisp
@@ -1,8 +1,8 @@
 ;; ODE system setup
 ;; Liam Healy, Sun Apr 15 2007 - 14:19
-;; Time-stamp: <2011-04-08 09:20:01EDT ode-system.lisp>
+;; Time-stamp: <2011-05-26 12:37:33EDT ode-system.lisp>
 ;;
-;; Copyright 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2007, 2008, 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,16 +20,20 @@
 
 (in-package :gsl)
 
-(export '(with-ode-integration next-step))
+(export '(with-ode-integration))
 
 (defmacro with-ode-integration
     ((function time step-size max-time dependent dimensions
 	       &key jacobian (scalarsp t) (stepper '+step-rk8pd+)
 	       (absolute-error 1.0d-6) (relative-error 0.0d0))
      &body body)
-  "Environment for integration of ordinary differential equations."
-  ;; Note: the case jacobian=nil is not properly handled yet; it
-  ;; should put a null pointer into the struct that is passed to GSL.
+  "Environment for integration of ordinary differential equations when dependent variables are individually named scalars."
+  ;; Note: If the dependent variables are in a foreign array, it is
+  ;; best to call the ODE functions directly; this macro is just
+  ;; provided as a convenience if they are separate scalars.
+  ;; Note:
+  ;; the case jacobian=nil is not properly handled yet; it should put
+  ;; a null pointer into the struct that is passed to GSL.
   (let ((dep (make-symbol "DEP"))
 	(ctime (make-symbol "CTIME"))
 	(cstep (make-symbol "CSTEP")))
@@ -43,11 +47,11 @@
 	   (,ctime (grid:make-foreign-array 'double-float :dimensions 1))
 	   (,cstep (grid:make-foreign-array 'double-float :dimensions 1)))
        (symbol-macrolet
-	   ((,time (grid:gref ,ctime 0))
-	    (,step-size (grid:gref ,cstep 0))
+	   ((,time (grid:aref ,ctime 0))
+	    (,step-size (grid:aref ,cstep 0))
 	    ,@(loop for symb in dependent
 		 for i from 0
-		 collect `(,symb (grid:gref ,dep ,i))))
+		 collect `(,symb (grid:aref ,dep ,i))))
 	 (flet ((next-step ()
 		  (apply-evolution
 		   evolve ,ctime ,dep ,cstep control stepperobj ,max-time)))
diff --git a/ordinary-differential-equations/stepping.lisp b/ordinary-differential-equations/stepping.lisp
index b1deaa2023e35518d44ef502af8fda8aaee6a46c..6efc6754ce7a17a897607d1a55c0bc3d9c8f05a7 100644
--- a/ordinary-differential-equations/stepping.lisp
+++ b/ordinary-differential-equations/stepping.lisp
@@ -1,8 +1,8 @@
 ;; Stepping functions for ODE systems.
 ;; Liam Healy, Mon Sep 24 2007 - 21:33
-;; Time-stamp: <2010-06-27 18:13:51EDT stepping.lisp>
+;; Time-stamp: <2011-01-10 17:59:27EST stepping.lisp>
 ;;
-;; Copyright 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2007, 2008, 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
@@ -106,10 +106,10 @@ values):
   (((mpointer stepper) :pointer)
    (time :double)
    (step-size :double)
-   ((foreign-pointer y) :pointer)
-   ((foreign-pointer yerr) :pointer)
-   ((foreign-pointer dydt-in) :pointer)
-   ((foreign-pointer dydt-out) :pointer)
+   ((grid:foreign-pointer y) :pointer)
+   ((grid:foreign-pointer yerr) :pointer)
+   ((grid:foreign-pointer dydt-in) :pointer)
+   ((grid:foreign-pointer dydt-out) :pointer)
    ((callback-struct stepper) :pointer))
   :documentation			; FDL
   "Apply the stepping function stepper to the system of equations
diff --git a/polynomial.lisp b/polynomial.lisp
index db86ea47b60436bc75d06766e13c66ee4611c595..81065dd9462edae8b20061d7fd7dbbd8fe01669b 100644
--- a/polynomial.lisp
+++ b/polynomial.lisp
@@ -1,8 +1,8 @@
 ;; Polynomials
 ;; Liam Healy, Tue Mar 21 2006 - 18:33
-;; Time-stamp: <2010-07-07 14:18:55EDT polynomial.lisp>
+;; Time-stamp: <2011-01-10 17:47:56EST polynomial.lisp>
 ;;
-;; 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
@@ -29,10 +29,10 @@
 (defmfun evaluate
     ((coefficients grid:vector-double-float) (x float) &key divided-difference)
   ("gsl_poly_eval" "gsl_poly_dd_eval")
-  ((((foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
+  ((((grid:foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
     (x :double))
-   (((foreign-pointer divided-difference) :pointer)
-    ((foreign-pointer coefficients) :pointer)
+   (((grid:foreign-pointer divided-difference) :pointer)
+    ((grid:foreign-pointer coefficients) :pointer)
     ((dim0 coefficients) sizet)
     (x :double)))
   :definition :method
@@ -46,7 +46,7 @@
     ((coefficients grid:vector-double-float) (x complex)
      &key)
   "gsl_poly_complex_eval"
-  (((foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
+  (((grid:foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
    (x grid:complex-double-c))
   :definition :method
   :gsl-version (1 11)
@@ -60,7 +60,7 @@
     ((coefficients grid:vector-complex-double-float) (x complex)
      &key)
   "gsl_complex_poly_complex_eval"
-  (((foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
+  (((grid:foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
    (x grid:complex-double-c))
   :definition :method
   :gsl-version (1 11)
@@ -76,8 +76,8 @@
 (defmfun divided-difference
     (xa ya &optional (dd (grid:make-foreign-array 'double-float :dimensions (dim0 xa))))
   "gsl_poly_dd_init"
-  (((foreign-pointer dd) :pointer)
-   ((foreign-pointer xa) :pointer) ((foreign-pointer ya) :pointer)
+  (((grid:foreign-pointer dd) :pointer)
+   ((grid:foreign-pointer xa) :pointer) ((grid:foreign-pointer ya) :pointer)
    ((dim0 xa) sizet))
   :inputs (xa ya)
   :outputs (dd)
@@ -95,12 +95,12 @@
 	(coefficients (grid:make-foreign-array 'double-float :dimensions (dim0 xa)))
 	(workspace (grid:make-foreign-array 'double-float :dimensions (dim0 xa))))
   "gsl_poly_dd_taylor"
-  (((foreign-pointer coefficients) :pointer)
+  (((grid:foreign-pointer coefficients) :pointer)
    (xp :double)
-   ((foreign-pointer dd) :pointer)
-   ((foreign-pointer xa) :pointer)
+   ((grid:foreign-pointer dd) :pointer)
+   ((grid:foreign-pointer xa) :pointer)
    ((dim0 xa) sizet)
-   ((foreign-pointer workspace) :pointer))
+   ((grid:foreign-pointer workspace) :pointer))
   :inputs (dd xa)
   :outputs (coefficients)
   :documentation			; FDL
@@ -177,8 +177,8 @@
 			  :dimensions (1- (size coefficients))))
      (workspace (make-polynomial-complex-workspace (size coefficients))))
   "gsl_poly_complex_solve"
-  (((foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
-   ((mpointer workspace) :pointer) ((foreign-pointer answer) :pointer))
+  (((grid:foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
+   ((mpointer workspace) :pointer) ((grid:foreign-pointer answer) :pointer))
   :inputs (coefficients)
   :outputs (answer)
   :return (answer)
@@ -213,8 +213,10 @@
  ;; Example from GSL manual
  (grid:copy-to (polynomial-solve #m(-1.0d0 0.0d0 0.0d0 0.0d0 0.0d0 1.0d0)))
  ;; tests from gsl-1.11/poly/test.c
- (evaluate #m(1 0.5 0.3) 0.5d0)
- (evaluate #m(1 -1 1 -1 1 -1 1 -1 1 -1 1) 1.0d0)
+ (evaluate #m(1.0d0 0.5d0 0.3d0) 0.5d0)
+ (evaluate
+  #m(1.0d0 -1.0d0 1.0d0 -1.0d0 1.0d0 -1.0d0 1.0d0 -1.0d0 1.0d0 -1.0d0 1.0d0)
+  1.0d0)
  (solve-quadratic 4.0d0 -20.0d0 26.0d0)		  ; no roots
  (solve-quadratic 4.0d0 -20.0d0 25.0d0)		  ; one root
  (solve-quadratic 4.0d0 -20.0d0 21.0d0)		  ; two roots
@@ -242,10 +244,10 @@
  (solve-cubic-complex -57.0d0 1071.0d0 -6647.0d0)
  (solve-cubic-complex -11.0d0 -493.0d0 +6647.0d0)
  (solve-cubic-complex -143.0d0 5087.0d0 -50065.0d0)
- (grid:copy-to (polynomial-solve #m(-120 274 -225 85 -15 1.0)))
- (grid:copy-to (polynomial-solve #m(1 0 0 0 1 0 0 0 1)))
- (let* ((xa #m(0.16 0.97 1.94 2.74 3.58 3.73 4.70))
-	(ya #m(0.73 1.11 1.49 1.84 2.30 2.41 3.07))
+ (grid:copy-to (polynomial-solve #m(-120.0d0 274.0d0 -225.0d0 85.0d0 -15.0d0 1.0d0)))
+ (grid:copy-to (polynomial-solve #m(1.0d0 0.0d0 0.0d0 0.0d0 1.0d0 0.0d0 0.0d0 0.0d0 1.0d0)))
+ (let* ((xa #m(0.16d0 0.97d0 1.94d0 2.74d0 3.58d0 3.73d0 4.70d0))
+	(ya #m(0.73d0 1.11d0 1.49d0 1.84d0 2.30d0 2.41d0 3.07d0))
 	(dd (divided-difference xa ya)))
    (list
     (grid:copy-to dd)
diff --git a/random/dirichlet.lisp b/random/dirichlet.lisp
index a8928767dd46232bdf4781d197377ddc5274ec94..e1e493d3854e137ba0e24c52468d29347e281d25 100644
--- a/random/dirichlet.lisp
+++ b/random/dirichlet.lisp
@@ -1,8 +1,8 @@
 ;; Dirichlet distribution
 ;; Liam Healy, Sun Oct 29 2006
-;; Time-stamp: <2011-07-29 12:23:09EDT dirichlet.lisp>
+;; Time-stamp: <2011-07-29 12:09:55EDT dirichlet.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -28,9 +28,9 @@
   "gsl_ran_dirichlet"
   (((mpointer generator) :pointer)
    ((dim0 alpha) sizet)
-   ((foreign-pointer alpha) :pointer)
+   ((grid:foreign-pointer alpha) :pointer)
    ;; theta had better be at least as long as alpha, or they'll be trouble
-   ((foreign-pointer theta) :pointer))
+   ((grid:foreign-pointer theta) :pointer))
   :definition :method
   :inputs (alpha)
   :outputs (theta)
@@ -55,9 +55,9 @@
 (defmfun dirichlet-pdf (alpha theta)
   "gsl_ran_dirichlet_pdf"
   (((dim0 alpha) sizet)
-   ((foreign-pointer alpha) :pointer)
+   ((grid:foreign-pointer alpha) :pointer)
    ;; theta had better be at least as long as alpha, or they'll be trouble
-   ((foreign-pointer theta) :pointer))
+   ((grid:foreign-pointer theta) :pointer))
   :inputs (alpha theta)
   :c-return :double
   :documentation			; FDL
@@ -68,9 +68,9 @@
 (defmfun dirichlet-log-pdf (alpha theta)
   "gsl_ran_dirichlet_lnpdf"
   (((dim0 alpha) sizet)
-   ((foreign-pointer alpha) :pointer)
+   ((grid:foreign-pointer alpha) :pointer)
    ;; theta had better be at least as long as alpha, or they'll be trouble
-   ((foreign-pointer theta) :pointer))
+   ((grid:foreign-pointer theta) :pointer))
   :inputs (alpha theta)
   :c-return :double
   :documentation			; FDL
diff --git a/random/discrete.lisp b/random/discrete.lisp
index 0d8b0501126a04f00855770e5e1f816ab7430e6c..b88a550656b123eca7e595c562dd7481511870ed 100644
--- a/random/discrete.lisp
+++ b/random/discrete.lisp
@@ -1,8 +1,8 @@
 ;; Discrete random variables
 ;; Liam Healy, Sat Nov 11 2006 - 21:51
-;; Time-stamp: <2010-06-27 18:14:53EDT discrete.lisp>
+;; Time-stamp: <2011-01-10 17:59:28EST discrete.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -23,7 +23,7 @@
 ;;; /usr/include/gsl/gsl_randist.h
 
 (defmobject discrete-random "gsl_ran_discrete"
-  (((dim0 probabilities) sizet) ((foreign-pointer probabilities) :pointer))
+  (((dim0 probabilities) sizet) ((grid:foreign-pointer probabilities) :pointer))
   "lookup table for the discrete random number generator"
   :allocator "gsl_ran_discrete_preproc"
   :allocate-inputs (probabilities)
diff --git a/random/multinomial.lisp b/random/multinomial.lisp
index 6d492edd34f6936518667024447c0646a82fd590..adb12dbd847caee4bb193226b034ae3dcc34cd8c 100644
--- a/random/multinomial.lisp
+++ b/random/multinomial.lisp
@@ -1,8 +1,8 @@
 ;; Multinomial distribution
 ;; Liam Healy, Sat Nov 25 2006 - 16:00
-;; Time-stamp: <2010-07-07 14:24:58EDT multinomial.lisp>
+;; Time-stamp: <2011-01-10 17:59:29EST multinomial.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -31,9 +31,9 @@
   (((mpointer generator) :pointer) 
    ((dim0 probabilities) sizet)
    (sum sizet)
-   ((foreign-pointer probabilities) :pointer)
+   ((grid:foreign-pointer probabilities) :pointer)
    ;; technically, n should be a uint array, but integers work
-   ((foreign-pointer n) :pointer))
+   ((grid:foreign-pointer n) :pointer))
   :definition :method
   :inputs (p)
   :outputs (n)
@@ -56,7 +56,7 @@
 
 (defmfun multinomial-pdf (p n)
   "gsl_ran_multinomial_pdf"
-  (((dim0 p) sizet) ((foreign-pointer p) :pointer) ((foreign-pointer n) :pointer))
+  (((dim0 p) sizet) ((grid:foreign-pointer p) :pointer) ((grid:foreign-pointer n) :pointer))
   :inputs (p n)
   :c-return :double
   :documentation			; FDL
@@ -66,7 +66,7 @@
 
 (defmfun multinomial-log-pdf (p n)
   "gsl_ran_multinomial_lnpdf"
-  (((dim0 p) sizet) ((foreign-pointer p) :pointer) ((foreign-pointer n) :pointer))
+  (((dim0 p) sizet) ((grid:foreign-pointer p) :pointer) ((grid:foreign-pointer n) :pointer))
   :inputs (p n)
   :c-return :double
   :documentation			; FDL
diff --git a/random/quasi.lisp b/random/quasi.lisp
index 605de960aa905f861ad12bfd3bd3d0a5f1885309..50059e6e52009cf77d3288f97db8f8a44ff3500a 100644
--- a/random/quasi.lisp
+++ b/random/quasi.lisp
@@ -1,8 +1,8 @@
 ;; Quasi-random sequences in arbitrary dimensions.
 ;; Liam Healy, Sun Jul 16 2006 - 15:54
-;; Time-stamp: <2010-07-16 17:10:54EDT quasi.lisp>
+;; Time-stamp: <2011-01-10 17:59:29EST quasi.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -36,7 +36,7 @@
 
 (defmfun qrng-get (generator return-vector)
   "gsl_qrng_get"
-  (((mpointer generator) :pointer) ((foreign-pointer return-vector) :pointer))
+  (((mpointer generator) :pointer) ((grid:foreign-pointer return-vector) :pointer))
   :outputs (return-vector)
   :return (return-vector)
   :documentation			; FDL
diff --git a/random/shuffling-sampling.lisp b/random/shuffling-sampling.lisp
index 3e11719499ed2865a1af5059304d77e79eaab621..47756947a673f62536eb43f4d99a2e2ee0e6c802 100644
--- a/random/shuffling-sampling.lisp
+++ b/random/shuffling-sampling.lisp
@@ -1,8 +1,8 @@
 ;; Shuffling and sampling
 ;; Liam Healy, Sat Dec  2 2006 - 18:40
-;; Time-stamp: <2010-07-07 14:24:58EDT shuffling-sampling.lisp>
+;; Time-stamp: <2011-01-11 23:34:14EST shuffling-sampling.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -27,7 +27,7 @@
      &key base)
   "gsl_ran_shuffle"
   (((mpointer generator) :pointer)
-   ((foreign-pointer base) :pointer) ((dim0 base) sizet) ((grid:element-size base) sizet))
+   ((grid:foreign-pointer base) :pointer) ((dim0 base) sizet) ((grid:element-size base) sizet))
   :definition :method
   :inputs (base)
   :outputs (base)
@@ -46,12 +46,12 @@
      &aux
      (destarr
       (if (integerp dest)
-	  (grid:make-foreign-array (element-type src) :dimensions dest)
+	  (grid:make-foreign-array (grid:element-type src) :dimensions dest)
 	  dest)))
   "gsl_ran_choose"
   (((mpointer generator) :pointer)
-   ((foreign-pointer destarr) :pointer) ((dim0 destarr) sizet)
-   ((foreign-pointer src) :pointer) ((dim0 src) sizet) ((grid:element-size src) sizet))
+   ((grid:foreign-pointer destarr) :pointer) ((dim0 destarr) sizet)
+   ((grid:foreign-pointer src) :pointer) ((dim0 src) sizet) ((grid:element-size src) sizet))
   :definition :method
   :inputs (src)
   :outputs (destarr)
@@ -74,12 +74,12 @@
      &aux
      (destarr
       (if (integerp dest)
-	  (grid:make-foreign-array (element-type src) :dimensions dest)
+	  (grid:make-foreign-array (grid:element-type src) :dimensions dest)
 	  dest)))
   "gsl_ran_sample"
   (((mpointer generator) :pointer)
-   ((foreign-pointer destarr) :pointer) ((dim0 destarr) sizet)
-   ((foreign-pointer src) :pointer) ((dim0 src) sizet) ((grid:element-size src) sizet))
+   ((grid:foreign-pointer destarr) :pointer) ((dim0 destarr) sizet)
+   ((grid:foreign-pointer src) :pointer) ((dim0 src) sizet) ((grid:element-size src) sizet))
   :definition :method
   :inputs (src)
   :outputs (destarr)
diff --git a/random/spherical-vector.lisp b/random/spherical-vector.lisp
index 70f70667853f15f66968159f7c8f796d05c596fd..f8bd795c6fbbf387284dbfd1e9ca4251d2c127da 100644
--- a/random/spherical-vector.lisp
+++ b/random/spherical-vector.lisp
@@ -1,8 +1,8 @@
 ;; Spherical Vector distribution
 ;; Liam Healy, Sun Oct  22 2006
-;; Time-stamp: <2010-06-27 18:13:44EDT spherical-vector.lisp>
+;; Time-stamp: <2011-01-10 17:59:30EST spherical-vector.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -68,7 +68,7 @@
     ((generator random-number-generator) (type (eql :direction-Nd)) &key vector)
   "gsl_ran_dir_nd"
   (((mpointer generator) :pointer) ((dim0 vector) sizet)
-   ((foreign-pointer vector) :pointer))
+   ((grid:foreign-pointer vector) :pointer))
   :definition :method
   :c-return :void
   :outputs (vector)
diff --git a/series-acceleration.lisp b/series-acceleration.lisp
index 9497539cbc558cc1784474176e2430bbcac5f145..3d1cb8729c06c998b062def645ae7323020042c8 100644
--- a/series-acceleration.lisp
+++ b/series-acceleration.lisp
@@ -1,8 +1,8 @@
 ;; Series acceleration.
 ;; Liam Healy, Wed Nov 21 2007 - 18:41
-;; Time-stamp: <2010-08-07 21:41:14EDT series-acceleration.lisp>
+;; Time-stamp: <2011-05-26 12:37:29EDT series-acceleration.lisp>
 ;;
-;; Copyright 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2007, 2008, 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
@@ -38,7 +38,7 @@
 
 (defmfun accelerate (array levin)
   "gsl_sum_levin_u_accel"
-  (((foreign-pointer array) :pointer) ((dim0 array) sizet) ((mpointer levin) :pointer)
+  (((grid:foreign-pointer array) :pointer) ((dim0 array) sizet) ((mpointer levin) :pointer)
    (accelerated-sum (:pointer :double)) (abserr (:pointer :double)))
   :inputs (array)
   :documentation			; FDL
@@ -66,7 +66,7 @@
 
 (defmfun accelerate-truncated (array levin)
   "gsl_sum_levin_utrunc_accel"
-  (((foreign-pointer array) :pointer) ((dim0 array) sizet) ((mpointer levin) :pointer)
+  (((grid:foreign-pointer array) :pointer) ((dim0 array) sizet) ((mpointer levin) :pointer)
    (accelerated-sum (:pointer :double)) (abserr (:pointer :double)))
   :inputs (array)
   :documentation			; FDL
@@ -95,8 +95,8 @@
     (let ((levin (make-levin maxterms))
 	  (array (grid:make-foreign-array 'double-float :dimensions maxterms)))
       (dotimes (n maxterms)
-	(setf (grid:gref array n) (coerce (/ (expt (1+ n) 2)) 'double-float))
-	(incf sum (grid:gref array n)))
+	(setf (grid:aref array n) (coerce (/ (expt (1+ n) 2)) 'double-float))
+	(incf sum (grid:aref array n)))
       (multiple-value-bind (accelerated-sum error)
 	  (accelerate array levin)
 	(when print-explanation
diff --git a/solve-minimize-fit/linear-least-squares.lisp b/solve-minimize-fit/linear-least-squares.lisp
index c24a7857b4e60ef928b0bd7a65a1e2ab824490b1..a1482c80160baf91ba3ec5bf1a0ea994ed0d2a08 100644
--- a/solve-minimize-fit/linear-least-squares.lisp
+++ b/solve-minimize-fit/linear-least-squares.lisp
@@ -1,8 +1,8 @@
 ;; Linear least squares, or linear regression
 ;; Liam Healy <2008-01-21 12:41:46EST linear-least-squares.lisp>
-;; Time-stamp: <2010-06-30 19:57:28EDT linear-least-squares.lisp>
+;; Time-stamp: <2011-05-26 12:37:31EDT linear-least-squares.lisp>
 ;;
-;; Copyright 2008, 2009 Liam M. Healy
+;; Copyright 2008, 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
@@ -36,15 +36,15 @@
 (defmfun linear-fit
     (x y &optional weight (x-stride 1) (y-stride 1) (weight-stride 1))
   ("gsl_fit_linear" "gsl_fit_wlinear")
-  ((((foreign-pointer x) :pointer) (x-stride sizet)
-    ((foreign-pointer y) :pointer) (y-stride sizet)
+  ((((grid:foreign-pointer x) :pointer) (x-stride sizet)
+    ((grid:foreign-pointer y) :pointer) (y-stride sizet)
     ((dim0 x) sizet)
     (c0 (:pointer :double)) (c1 (:pointer :double))
     (cov00 (:pointer :double)) (cov01 (:pointer :double))
     (cov11 (:pointer :double)) (sumsq (:pointer :double)))
-   (((foreign-pointer x) :pointer) (x-stride sizet)
-    ((foreign-pointer weight) :pointer) (weight-stride sizet)
-    ((foreign-pointer y) :pointer) (y-stride sizet)
+   (((grid:foreign-pointer x) :pointer) (x-stride sizet)
+    ((grid:foreign-pointer weight) :pointer) (weight-stride sizet)
+    ((grid:foreign-pointer y) :pointer) (y-stride sizet)
     ((dim0 x) sizet)
     (c0 (:pointer :double)) (c1 (:pointer :double))
     (cov00 (:pointer :double)) (cov01 (:pointer :double))
@@ -85,14 +85,14 @@
 (defmfun multiplier-fit
     (x y &optional weight (x-stride 1) (y-stride 1) (weight-stride 1))
   ("gsl_fit_mul" "gsl_fit_wmul")
-  ((((foreign-pointer x) :pointer) (x-stride sizet)
-    ((foreign-pointer y) :pointer) (y-stride sizet)
+  ((((grid:foreign-pointer x) :pointer) (x-stride sizet)
+    ((grid:foreign-pointer y) :pointer) (y-stride sizet)
     ((dim0 x) sizet)
     (c1 (:pointer :double)) (cov11 (:pointer :double))
     (sumsq (:pointer :double)))
-   (((foreign-pointer x) :pointer) (x-stride sizet)
-    ((foreign-pointer weight) :pointer) (weight-stride sizet)
-    ((foreign-pointer y) :pointer) (y-stride sizet)
+   (((grid:foreign-pointer x) :pointer) (x-stride sizet)
+    ((grid:foreign-pointer weight) :pointer) (weight-stride sizet)
+    ((grid:foreign-pointer y) :pointer) (y-stride sizet)
     ((dim0 x) sizet)
     (c1 (:pointer :double)) (cov11 (:pointer :double))
     (sumsq (:pointer :double))))
@@ -284,7 +284,7 @@
     (x observations coefficients
        &optional
        (residuals
-	(grid:make-foreign-array 'double-float :dimensions (dimensions observations))))
+	(grid:make-foreign-array 'double-float :dimensions (grid:dimensions observations))))
   "gsl_multifit_linear_residuals"
   (((mpointer x) :pointer) ((mpointer observations) :pointer)
    ((mpointer coefficients) :pointer) ((mpointer residuals) :pointer))
@@ -315,15 +315,15 @@
 	(loop for i from 0 below (dim0 x)
 	   do
 	   (format t "data: ~12,5f ~12,5f ~12,5f~&"
-		   (grid:gref x i)
-		   (grid:gref y i)
-		   (/ (grid:gref w i))))
+		   (grid:aref x i)
+		   (grid:aref y i)
+		   (/ (grid:aref w i))))
 	(loop for i from -30 below 130 by 10 ; don't print everything
 	   for
-	   xf = (+ (grid:gref x 0)
+	   xf = (+ (grid:aref x 0)
 		   (* (/ i 100)
-		      (- (grid:gref x (1- (dim0 x)))
-			 (grid:gref x 0))))
+		      (- (grid:aref x (1- (dim0 x)))
+			 (grid:aref x 0))))
 	   do
 	   (multiple-value-bind (yf yferr)
 	       (linear-estimate xf c0 c1 cov00 cov01 cov11)
@@ -353,26 +353,26 @@
 	 (w (grid:make-foreign-array 'double-float :dimensions n)))
     (loop for i from 0
        for row in data do
-       (setf (grid:gref X i 0) 1.0d0
-	     (grid:gref X i 1) (first row)
-	     (grid:gref X i 2) (expt (first row) 2)
-	     (grid:gref y i) (second row)
-	     (grid:gref w i) (/ (expt (third row) 2))))
+       (setf (grid:aref X i 0) 1.0d0
+	     (grid:aref X i 1) (first row)
+	     (grid:aref X i 2) (expt (first row) 2)
+	     (grid:aref y i) (second row)
+	     (grid:aref w i) (/ (expt (third row) 2))))
     (multiple-value-bind (parameters cov chisq)
 	(linear-mfit X y 3 w)
       (when print-details
 	(format t "Best fit: Y = ~10,8f + ~10,8f X + ~10,8f X^2~&"
-		(grid:gref parameters 0) (grid:gref parameters 1) (grid:gref parameters 2))
+		(grid:aref parameters 0) (grid:aref parameters 1) (grid:aref parameters 2))
 	(format t "Covariance matrix:~&")
 	(format t "~10,8f ~10,8f ~10,8f~&"
-		(grid:gref cov 0 0) (grid:gref cov 0 1) (grid:gref cov 0 2))
+		(grid:aref cov 0 0) (grid:aref cov 0 1) (grid:aref cov 0 2))
 	(format t "~10,8f ~10,8f ~10,8f~&"
-		(grid:gref cov 1 0) (grid:gref cov 1 1) (grid:gref cov 1 2))
+		(grid:aref cov 1 0) (grid:aref cov 1 1) (grid:aref cov 1 2))
 	(format t "~10,8f ~10,8f ~10,8f~&"
-		(grid:gref cov 2 0) (grid:gref cov 2 1) (grid:gref cov 2 2))
+		(grid:aref cov 2 0) (grid:aref cov 2 1) (grid:aref cov 2 2))
 	(format t "Chisq = ~10,6f~&" chisq))
       (values
-       (grid:gref parameters 0) (grid:gref parameters 1) (grid:gref parameters 2)
+       (grid:aref parameters 0) (grid:aref parameters 1) (grid:aref parameters 2)
        chisq))))
 
 (save-test linear-least-squares
diff --git a/solve-minimize-fit/minimization-multi.lisp b/solve-minimize-fit/minimization-multi.lisp
index 687bf968239b937833179d9174faa535f079b432..0da173bbce9512436a5c9a0b0fee59915df7bee1 100644
--- a/solve-minimize-fit/minimization-multi.lisp
+++ b/solve-minimize-fit/minimization-multi.lisp
@@ -1,6 +1,6 @@
 ;; Multivariate minimization.
 ;; Liam Healy  <Tue Jan  8 2008 - 21:28>
-;; Time-stamp: <2010-07-13 11:45:28EDT minimization-multi.lisp>
+;; Time-stamp: <2011-05-26 12:37:32EDT minimization-multi.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -384,13 +384,13 @@
 	 (when print-steps
 	   (let ((x (solution minimizer)))
 	     (format t "~d~6t~10,6f~18t~10,6f~28t~12,9f~40t~8,3f~&"
-		     iter (grid:gref x 0) (grid:gref x 1)
+		     iter (grid:aref x 0) (grid:aref x 1)
 		     (function-value minimizer)
 		     size)))
 	 finally
 	 (return
 	   (let ((x (solution minimizer)))
-	     (values (grid:gref x 0) (grid:gref x 1) (function-value minimizer))))))))
+	     (values (grid:aref x 0) (grid:aref x 1) (function-value minimizer))))))))
 
 ;;; Example using derivatives, taking a vector argument.
 ;;; Note that these functions are written to read mpointers to
@@ -403,9 +403,9 @@
   ;; An alternative access to the passed-in vector would be to
   ;; bind a variable to
   ;; (make-foreign-array-from-mpointer mpointer 'double-float :vector)
-  ;; and then call grid:gref on it.
-  (let ((x (grid:gref xy 0))
-	(y (grid:gref xy 1))
+  ;; and then call grid:aref on it.
+  (let ((x (grid:aref xy 0))
+	(y (grid:aref xy 1))
 	(dp0 (aref *paraboloid-center* 0))
 	(dp1 (aref *paraboloid-center* 1)))
     (+ (* 10 (expt (- x dp0) 2))
@@ -413,19 +413,19 @@
        30)))
 
 (defun paraboloid-derivative (xy output)
-  (let ((x (grid:gref xy 0))
-	(y (grid:gref xy 1))
+  (let ((x (grid:aref xy 0))
+	(y (grid:aref xy 1))
 	(dp0 (aref *paraboloid-center* 0))
 	(dp1 (aref *paraboloid-center* 1)))
-    (setf (grid:gref output 0)
+    (setf (grid:aref output 0)
 	  (* 20 (- x dp0))
-	  (grid:gref output 1)
+	  (grid:aref output 1)
 	  (* 40 (- y dp1)))))
 
 (defun paraboloid-and-derivative
     (arguments-gv-pointer value-pointer derivative-gv-pointer)
   (prog1
-      (setf (grid:gref value-pointer 0)
+      (setf (grid:aref value-pointer 0)
 	    (paraboloid-vector arguments-gv-pointer))
     (paraboloid-derivative
      arguments-gv-pointer derivative-gv-pointer)))
@@ -455,12 +455,12 @@
        (when print-steps
 	 (let ((x (solution minimizer)))
 	   (format t "~d~6t~10,6f~18t~10,6f~28t~12,9f~&"
-		   iter (grid:gref x 0) (grid:gref x 1)
+		   iter (grid:aref x 0) (grid:aref x 1)
 		   (function-value minimizer))))
        finally
        (return
 	 (let ((x (solution minimizer)))
-	   (values (grid:gref x 0) (grid:gref x 1) (function-value minimizer)))))))
+	   (values (grid:aref x 0) (grid:aref x 1) (function-value minimizer)))))))
 
 (defun paraboloid-derivative-scalar (x y)
   (let ((dp0 (aref *paraboloid-center* 0))
@@ -499,12 +499,12 @@
        (when print-steps
 	 (let ((x (solution minimizer)))
 	   (format t "~d~6t~10,6f~18t~10,6f~28t~12,9f~&"
-		   iter (grid:gref x 0) (grid:gref x 1)
+		   iter (grid:aref x 0) (grid:aref x 1)
 		   (function-value minimizer))))
        finally
        (return
 	 (let ((x (solution minimizer)))
-	   (values (grid:gref x 0) (grid:gref x 1) (function-value minimizer)))))))
+	   (values (grid:aref x 0) (grid:aref x 1) (function-value minimizer)))))))
 
 (save-test minimization-multi
  (multimin-example-no-derivative +simplex-nelder-mead-on2+ nil)
diff --git a/solve-minimize-fit/nonlinear-least-squares.lisp b/solve-minimize-fit/nonlinear-least-squares.lisp
index 7879c134525dbc311b1c25b54492f8e4d4b20094..5761538a3471961aa7180e5b8383c8c599a6f402 100644
--- a/solve-minimize-fit/nonlinear-least-squares.lisp
+++ b/solve-minimize-fit/nonlinear-least-squares.lisp
@@ -1,6 +1,6 @@
 ;; Nonlinear least squares fitting.
 ;; Liam Healy, 2008-02-09 12:59:16EST nonlinear-least-squares.lisp
-;; Time-stamp: <2010-06-30 19:57:28EDT nonlinear-least-squares.lisp>
+;; Time-stamp: <2011-05-26 12:37:32EDT nonlinear-least-squares.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -301,7 +301,7 @@
    (let ((arr (grid:make-foreign-array 'double-float :dimensions number-of-observations))
 	 (rng (make-random-number-generator +mt19937+ 0)))
      (dotimes (i number-of-observations arr)
-       (setf (grid:gref arr i)
+       (setf (grid:aref arr i)
 	     (+ 1 (* 5 (exp (* -1/10 i)))
 		(sample rng :gaussian :sigma 0.1d0)))))
    :sigma
@@ -311,32 +311,32 @@
 (defun exponential-residual (x f)
   "Compute the negative of the residuals with the exponential model
    for the nonlinear least squares example."
-  (let ((A (grid:gref x 0))
-	(lambda (grid:gref x 1))
-	(b (grid:gref x 2)))
+  (let ((A (grid:aref x 0))
+	(lambda (grid:aref x 1))
+	(b (grid:aref x 2)))
     (symbol-macrolet
 	((y (exponent-fit-data-y *nlls-example-data*))
 	 (sigma (exponent-fit-data-sigma *nlls-example-data*)))
       (dotimes (i (exponent-fit-data-n *nlls-example-data*))
-	(setf (grid:gref f i)
+	(setf (grid:aref f i)
 	      ;; the difference model - observation = - residual
-	      (/ (- (+ (* A (exp (* (- lambda) i))) b) (grid:gref y i))
-		 (grid:gref sigma i)))))))
+	      (/ (- (+ (* A (exp (* (- lambda) i))) b) (grid:aref y i))
+		 (grid:aref sigma i)))))))
 
 (defun exponential-residual-derivative (x jacobian)
   "Compute the partial derivatives of the negative of the
    residuals with the exponential model
    for the nonlinear least squares example."
-  (let ((A (grid:gref x 0))
-	(lambda (grid:gref x 1)))
+  (let ((A (grid:aref x 0))
+	(lambda (grid:aref x 1)))
     (symbol-macrolet
 	  ((sigma (exponent-fit-data-sigma *nlls-example-data*)))
 	(dotimes (i (exponent-fit-data-n *nlls-example-data*))
 	  (let ((e (exp (* (- lambda) i)))
-		(s (grid:gref sigma i)))
-	  (setf (grid:gref jacobian i 0) (/ e s)
-		(grid:gref jacobian i 1) (* -1 i A (/ e s))
-		(grid:gref jacobian i 2) (/ s)))))))
+		(s (grid:aref sigma i)))
+	  (setf (grid:aref jacobian i 0) (/ e s)
+		(grid:aref jacobian i 1) (* -1 i A (/ e s))
+		(grid:aref jacobian i 2) (/ s)))))))
 
 (defun exponential-residual-fdf (x f jacobian)
   "Compute the function and partial derivatives of the negative of the
@@ -363,8 +363,8 @@
 		 '(exponential-residual
 		   exponential-residual-derivative exponential-residual-fdf)
 		 init nil)))
-      (macrolet ((fitx (i) `(grid:gref (solution fit) ,i))
-		 (err (i) `(sqrt (grid:gref covariance ,i ,i))))
+      (macrolet ((fitx (i) `(grid:aref (solution fit) ,i))
+		 (err (i) `(sqrt (grid:aref covariance ,i ,i))))
 	(when print-steps
 	  (format t "iter: ~d x = ~15,8f ~15,8f ~15,8f |f(x)|=~7,6g~&"
 		  0 (fitx 0) (fitx 1) (fitx 2)
diff --git a/solve-minimize-fit/roots-multi.lisp b/solve-minimize-fit/roots-multi.lisp
index 25b70dab625a91c9c2e56ad29cf1781cf7450412..718065eef14540203448734da494d36a62048c38 100644
--- a/solve-minimize-fit/roots-multi.lisp
+++ b/solve-minimize-fit/roots-multi.lisp
@@ -1,8 +1,8 @@
 ;;; Multivariate roots.                
 ;;; Liam Healy 2008-01-12 12:49:08
-;;; Time-stamp: <2010-07-13 09:52:54EDT roots-multi.lisp>
+;;; Time-stamp: <2011-05-26 12:37:31EDT roots-multi.lisp>
 ;;
-;; Copyright 2008, 2009 Liam M. Healy
+;; Copyright 2008, 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
@@ -54,7 +54,7 @@
     `((type &optional function-or-dimension (initial nil ,set) (scalarsp t))
       (:type type
 	     :dimensions
-	     (if ,set (dimensions initial) function-or-dimension))
+	     (if ,set (grid:dimensions initial) function-or-dimension))
       (:functions
        (list function-or-dimension) :initial initial :scalarsp scalarsp)))
   :inputs (initial))
@@ -91,7 +91,7 @@
 	    (scalarsp t))
       (:type type
 	     :dimensions
-	     (if ,set (dimensions initial) function-or-dimension))
+	     (if ,set (grid:dimensions initial) function-or-dimension))
       (:functions function-or-dimension :initial initial :scalarsp scalarsp)))
   :inputs (initial))
 
@@ -418,15 +418,15 @@
        (when print-steps
 	 (format t "iter=~d~8tx0=~12,8g~24tx1=~12,8g~38tf0=~12,8g~52tf1=~12,8g~&"
 		 iter
-		 (grid:gref argval 0)
-		 (grid:gref argval 1)
-		 (grid:gref fnval 0)
-		 (grid:gref fnval 1)))
+		 (grid:aref argval 0)
+		 (grid:aref argval 1)
+		 (grid:aref fnval 0)
+		 (grid:aref fnval 1)))
        finally (return
-		 (values (grid:gref argval 0)
-			 (grid:gref argval 1)
-			 (grid:gref fnval 0)
-			 (grid:gref fnval 1))))))
+		 (values (grid:aref argval 0)
+			 (grid:aref argval 1)
+			 (grid:aref fnval 0)
+			 (grid:aref fnval 1))))))
 
 (defun rosenbrock-df (arg0 arg1)
   "The partial derivatives of the Rosenbrock functions."
@@ -452,10 +452,10 @@
 	   (when print-steps
 	     (format t "iter=~d~8tx0=~12,8g~24tx1=~12,8g~38tf0=~12,8g~52tf1=~12,8g~&"
 		     iter
-		     (grid:gref argval 0)
-		     (grid:gref argval 1)
-		     (grid:gref fnval 0)
-		     (grid:gref fnval 1)))))
+		     (grid:aref argval 0)
+		     (grid:aref argval 1)
+		     (grid:aref fnval 0)
+		     (grid:aref fnval 1)))))
     (let ((max-iter 1000)
 	  (solver (make-multi-dimensional-root-solver-fdf
 		   method
@@ -473,10 +473,10 @@
 	       argval (solution solver))
 	 (print-state iter argval fnval)
 	 finally (return
-		   (values (grid:gref argval 0)
-			   (grid:gref argval 1)
-			   (grid:gref fnval 0)
-			   (grid:gref fnval 1)))))))
+		   (values (grid:aref argval 0)
+			   (grid:aref argval 1)
+			   (grid:aref fnval 0)
+			   (grid:aref fnval 1)))))))
 
 ;; To see step-by-step information as the solution progresses, make
 ;; the last argument T.
diff --git a/solve-minimize-fit/simulated-annealing.lisp b/solve-minimize-fit/simulated-annealing.lisp
index 1f1f3815df6b1364089ecc228f6b609c922af149..508d72ba057ea104c5647ab6154badb21b71f463 100644
--- a/solve-minimize-fit/simulated-annealing.lisp
+++ b/solve-minimize-fit/simulated-annealing.lisp
@@ -1,6 +1,6 @@
 ;; Simulated Annealing
 ;; Liam Healy Sun Feb 11 2007 - 17:23
-;; Time-stamp: <2010-08-19 15:51:55EDT simulated-annealing.lisp>
+;; Time-stamp: <2011-05-26 12:37:32EDT simulated-annealing.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -193,7 +193,7 @@
 ;;; Trivial example, Sec. 24.3.1
 
 (defun trivial-example-energy (state)
-  (let ((x (grid:gref state 0)))
+  (let ((x (grid:aref state 0)))
     (declare (type double-float x) (optimize (speed 3) (safety 1)))
     (* (exp (- (expt (1- x) 2))) (sin (* 8 x)))))
 
@@ -205,15 +205,15 @@
    ;; the dynamical environment.
    (ignore rng-mpointer)
    (special cl-generator))
-  (symbol-macrolet ((x (grid:gref state 0)))
+  (symbol-macrolet ((x (grid:aref state 0)))
     (let ((rand (sample cl-generator :uniform)))
       (declare (type double-float rand))
       (setf x (+  (the double-float x) (- (* 2.0d0 rand step-size) step-size))))))
 
 (defun trivial-example-metric (state1 state2)
   (declare (optimize (speed 3) (safety 1)))
-  (abs (- (the double-float (grid:gref state1 0))
-	  (the double-float (grid:gref state2 0)))))
+  (abs (- (the double-float (grid:aref state1 0))
+	  (the double-float (grid:aref state2 0)))))
 
 (defun simulated-annealing-example ()
   (simulated-annealing
@@ -235,7 +235,7 @@
 
 ;;; exp(-square(x-1))*sin(8*x) - exp(-square(x-1000))*0.89;
 (defun trivial-test-energy (state)
-  (let ((x (grid:gref state 0)))
+  (let ((x (grid:aref state 0)))
     (- (* (exp (- (expt (1- x) 2))) (sin (* 8 x)))
        (* 0.89d0 (exp (- (expt (- x 1000) 2)))))))
 
diff --git a/sorting.lisp b/sorting.lisp
index 8b196bb628ac716fe56c52ae7039e8f821602a60..6edcfc9bfcc5dd24cf662effbdd652222397e78d 100644
--- a/sorting.lisp
+++ b/sorting.lisp
@@ -1,8 +1,8 @@
 ;; Sorting
 ;; Liam Healy, Fri Apr 14 2006 - 20:20
-;; Time-stamp: <2010-07-07 14:24:54EDT sorting.lisp>
+;; Time-stamp: <2011-01-10 18:16:18EST sorting.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -75,7 +75,7 @@
 
 (defmfun msort ((v both))
   ("gsl_sort" :type)
-  (((foreign-pointer v) :pointer) (1 sizet) ((size v) sizet))
+  (((grid:foreign-pointer v) :pointer) (1 sizet) ((size v) sizet))
   :definition :generic
   :element-types :no-complex
   :c-return :void
@@ -99,7 +99,7 @@
 (defmfun sort-index ((permutation permutation) (vector vector))
   ("gsl_sort" :type "_index")
   (((mpointer permutation) :pointer)
-   ((foreign-pointer vector) :pointer)
+   ((grid:foreign-pointer vector) :pointer)
    (1 sizet) ((dim0 vector) sizet))
   :definition :generic
   :element-types :no-complex
@@ -138,7 +138,7 @@
 
 (defmfun sort-vector-smallest (dest (v vector))
   ("gsl_sort_vector" :type "_smallest")
-  (((foreign-pointer dest) :pointer) ((dim0 dest) sizet)
+  (((grid:foreign-pointer dest) :pointer) ((dim0 dest) sizet)
    ((mpointer v) :pointer))
   :definition :generic
   :element-types :no-complex
@@ -151,8 +151,8 @@
 
 (defmfun sort-smallest (dest (v both))
   ("gsl_sort" :type "_smallest")
-  (((foreign-pointer dest) :pointer) ((size dest) sizet)
-   ((foreign-pointer v) :pointer)
+  (((grid:foreign-pointer dest) :pointer) ((size dest) sizet)
+   ((grid:foreign-pointer v) :pointer)
    (1 sizet)				; stride, set to 1 for now
    ((size v) sizet))
   :definition :generic
@@ -166,10 +166,10 @@
 
 (defmfun sort-vector-smallest-index (combination (v vector))
   ("gsl_sort_vector" :type "_smallest_index")
-  (((foreign-pointer combination) :pointer) ((size combination) sizet)
+  (((grid:foreign-pointer combination) :pointer) ((size combination) sizet)
    ((mpointer v) :pointer)
    (1 sizet)				; stride, set to 1 for now
-   ((first (dimensions combination)) sizet))
+   ((first (grid:dimensions combination)) sizet))
   :definition :generic
   :element-types :no-complex
   :c-return :void
@@ -184,10 +184,10 @@
 
 (defmfun sort-smallest-index (combination (v vector))
   ("gsl_sort" :type "_smallest_index")
-  (((foreign-pointer combination) :pointer) ((size combination) sizet)
-   ((foreign-pointer v) :pointer)
+  (((grid:foreign-pointer combination) :pointer) ((size combination) sizet)
+   ((grid:foreign-pointer v) :pointer)
    (1 sizet)				; stride, set to 1 for now
-   ((first (dimensions combination)) sizet))
+   ((first (grid:dimensions combination)) sizet))
   :definition :generic
   :element-types :no-complex
   :c-return :void
@@ -202,7 +202,7 @@
 
 (defmfun sort-vector-largest (dest (v vector))
   ("gsl_sort_vector" :type "_largest")
-  (((foreign-pointer dest) :pointer) ((dim0 dest) sizet)
+  (((grid:foreign-pointer dest) :pointer) ((dim0 dest) sizet)
    ((mpointer v) :pointer))
   :definition :generic
   :element-types :no-complex
@@ -215,8 +215,8 @@
 
 (defmfun sort-largest (dest (v both))
   ("gsl_sort" :type "_largest")
-  (((foreign-pointer dest) :pointer) ((size dest) sizet)
-   ((foreign-pointer v) :pointer)
+  (((grid:foreign-pointer dest) :pointer) ((size dest) sizet)
+   ((grid:foreign-pointer v) :pointer)
    (1 sizet)				; stride, set to 1 for now
    ((size v) sizet))
   :definition :generic
@@ -230,10 +230,10 @@
 
 (defmfun sort-vector-largest-index (combination (v vector))
   ("gsl_sort_vector" :type "_largest_index")
-  (((foreign-pointer combination) :pointer) ((size combination) sizet)
+  (((grid:foreign-pointer combination) :pointer) ((size combination) sizet)
    ((mpointer v) :pointer)
    (1 sizet)				; stride, set to 1 for now
-   ((first (dimensions combination)) sizet))
+   ((first (grid:dimensions combination)) sizet))
   :definition :generic
   :element-types :no-complex
   :c-return :void
@@ -248,10 +248,10 @@
 
 (defmfun sort-largest-index (combination (v vector))
   ("gsl_sort" :type "_largest_index")
-  (((foreign-pointer combination) :pointer) ((size combination) sizet)
-   ((foreign-pointer v) :pointer)
+  (((grid:foreign-pointer combination) :pointer) ((size combination) sizet)
+   ((grid:foreign-pointer v) :pointer)
    (1 sizet)				; stride, set to 1 for now
-   ((first (dimensions combination)) sizet))
+   ((first (grid:dimensions combination)) sizet))
   :element-types :no-complex
   :definition :generic
   :c-return :void
diff --git a/special-functions/bessel.lisp b/special-functions/bessel.lisp
index da4735fb9a4db20782317df444a58fed9c749c32..d68eed81dff845c77c5052c2891ee1622a83791d 100644
--- a/special-functions/bessel.lisp
+++ b/special-functions/bessel.lisp
@@ -1,8 +1,8 @@
 ;; Bessel functions
 ;; Liam Healy, Fri Mar 17 2006 - 18:42
-;; Time-stamp: <2010-07-07 14:24:57EDT bessel.lisp>
+;; Time-stamp: <2011-01-10 17:59:32EST bessel.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -49,7 +49,7 @@
        &aux (array (vdf size-or-array)))
   "gsl_sf_bessel_Jn_array"
   ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double)
-   ((foreign-pointer array) :pointer))
+   ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "The values of the regular cylindrical Bessel functions J_n(x)
@@ -65,7 +65,7 @@
 
 (defmfun cylindrical-bessel-J-array-x (nu v &optional (mode :double))
   "gsl_sf_bessel_sequence_Jnu_e"
-  ((nu :double) (mode sf-mode) ((dim0 v) :int) ((foreign-pointer v) :pointer))
+  ((nu :double) (mode sf-mode) ((dim0 v) :int) ((grid:foreign-pointer v) :pointer))
   :inputs (v)
   :outputs (v)
   :documentation			; FDL
@@ -106,7 +106,7 @@
        &aux (array (vdf size-or-array)))
   "gsl_sf_bessel_Yn_array"
   ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double)
-   ((foreign-pointer array) :pointer))
+   ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "The values of the irregular cylindrical Bessel functions
@@ -150,7 +150,7 @@
        &aux (array (vdf size-or-array)))
   "gsl_sf_bessel_In_array"
   ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double)
-   ((foreign-pointer array) :pointer))
+   ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "The values of the regular modified cylindrical Bessel functions
@@ -188,7 +188,7 @@
        &aux (array (vdf size-or-array)))
   "gsl_sf_bessel_In_scaled_array"
   ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double)
-   ((foreign-pointer array) :pointer))
+   ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   ;; Bug in original documentation?  doesn't say "modified"
@@ -243,7 +243,7 @@
        &aux (array (vdf size-or-array)))
   "gsl_sf_bessel_Kn_array"
   ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double)
-   ((foreign-pointer array) :pointer))
+   ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "The values of the irregular modified cylindrical Bessel functions
@@ -278,7 +278,7 @@
        &aux (array (vdf size-or-array)))
   "gsl_sf_bessel_Kn_scaled_array"
   ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double)
-   ((foreign-pointer array) :pointer))
+   ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "The values of the scaled irregular cylindrical
@@ -342,7 +342,7 @@
     (x &optional (size-or-array *default-sf-array-size*)
        &aux (array (vdf size-or-array)))
   "gsl_sf_bessel_jl_array"
-  (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "The values of the regular spherical Bessel
@@ -354,7 +354,7 @@
     (x &optional (size-or-array *default-sf-array-size*)
        &aux (array (vdf size-or-array)))
   "gsl_sf_bessel_jl_steed_array"
-  (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "Uses Steed's method to compute the values of the regular spherical
@@ -395,7 +395,7 @@
     (x &optional (size-or-array *default-sf-array-size*)
        &aux (array (vdf size-or-array)))
   "gsl_sf_bessel_yl_array"
-  (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "The irregular spherical Bessel functions y_l(x) for l
@@ -435,7 +435,7 @@
     (x &optional (size-or-array *default-sf-array-size*)
        &aux (array (vdf size-or-array)))
   "gsl_sf_bessel_il_scaled_array"
-  (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "The values of the scaled regular modified cylindrical Bessel
@@ -475,7 +475,7 @@
     (x &optional (size-or-array *default-sf-array-size*)
        &aux (array (vdf size-or-array)))
   "gsl_sf_bessel_kl_scaled_array"
-  (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "The values of the scaled irregular modified spherical Bessel
diff --git a/special-functions/coulomb.lisp b/special-functions/coulomb.lisp
index 4601633e4804aae4e6039e216231d64bdf6e88e5..11d951533cd91bdf146368d0456dd47ebed7a178 100644
--- a/special-functions/coulomb.lisp
+++ b/special-functions/coulomb.lisp
@@ -1,8 +1,8 @@
 ;; Coulumb functions
 ;; Liam Healy, Sat Mar 18 2006 - 23:23
-;; Time-stamp: <2010-07-07 14:24:53EDT coulomb.lisp>
+;; Time-stamp: <2011-01-10 17:59:32EST coulomb.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -70,7 +70,7 @@
 	   &aux (fc-array (vdf size-or-array)))
   "gsl_sf_coulomb_wave_F_array"
   ((L-min :double) ((1- (dim0 fc-array)) :int) (eta :double) (x :double)
-   ((foreign-pointer fc-array) :pointer) (F-exponent (:pointer :double)))
+   ((grid:foreign-pointer fc-array) :pointer) (F-exponent (:pointer :double)))
   :outputs (fc-array)
   :return (fc-array (grid:dcref F-exponent))
   :documentation			; FDL
@@ -86,7 +86,7 @@
 	   (gc-array (vdf (or gc-size-or-array (dim0 fc-array)))))
   "gsl_sf_coulomb_wave_FG_array"
   ((L-min :double) ((1- (dim0 fc-array)) :int) (eta :double) (x :double)
-   ((foreign-pointer fc-array) :pointer) ((foreign-pointer gc-array) :pointer)
+   ((grid:foreign-pointer fc-array) :pointer) ((grid:foreign-pointer gc-array) :pointer)
    (F-exponent (:pointer :double)) (G-exponent (:pointer :double)))
   :outputs (fc-array gc-array)
   :return (fc-array gc-array (grid:dcref F-exponent) (grid:dcref G-exponent))
@@ -108,8 +108,8 @@
 	   (gcp-array (vdf (or gcp-size-or-array (dim0 fc-array)))))
   "gsl_sf_coulomb_wave_FGp_array"
   ((L-min :double) ((1- (dim0 fc-array)) :int) (eta :double) (x :double)
-   ((foreign-pointer fc-array) :pointer) ((foreign-pointer fcp-array) :pointer)
-   ((foreign-pointer gc-array) :pointer) ((foreign-pointer gcp-array) :pointer)
+   ((grid:foreign-pointer fc-array) :pointer) ((grid:foreign-pointer fcp-array) :pointer)
+   ((grid:foreign-pointer gc-array) :pointer) ((grid:foreign-pointer gcp-array) :pointer)
    (F-exponent (:pointer :double)) (G-exponent (:pointer :double)))
   :outputs (fc-array fcp-array gc-array gcp-array)
   :return
@@ -128,7 +128,7 @@
 	   &aux (fc-array (vdf size-or-array)))
   "gsl_sf_coulomb_wave_sphF_array"
   ((L-min :double) ((1- (dim0 fc-array)) :int) (eta :double) (x :double)
-   ((foreign-pointer fc-array) :pointer) (F-exponent (:pointer :double)))
+   ((grid:foreign-pointer fc-array) :pointer) (F-exponent (:pointer :double)))
   :outputs (fc-array)
   :return (fc-array (grid:dcref F-exponent))
   :documentation			; FDL
@@ -153,7 +153,7 @@
 	   &aux (array (vdf size-or-array)))
   "gsl_sf_coulomb_CL_array"
   ((L-min :double) ((1- (dim0 array)) :int) (eta :double)
-   ((foreign-pointer array) :pointer))
+   ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "The Coulomb wave function normalization constant C_L(\eta)
diff --git a/special-functions/gegenbauer.lisp b/special-functions/gegenbauer.lisp
index 87d83a52ecafa3fc568b26684984f8407a9dc2f3..53c7ed85d0b28a3bc8b0d755b7bc389658c622a5 100644
--- a/special-functions/gegenbauer.lisp
+++ b/special-functions/gegenbauer.lisp
@@ -1,8 +1,8 @@
 ;; Gegenbauer polynomials
 ;; Liam Healy, Fri Apr 28 2006 - 20:40
-;; Time-stamp: <2010-07-07 14:24:57EDT gegenbauer.lisp>
+;; Time-stamp: <2011-01-10 17:59:32EST gegenbauer.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -47,7 +47,7 @@
 	    &aux (array (vdf size-or-array)))
   "gsl_sf_gegenpoly_array"
   (((1- (dim0 array)) :int)
-   (lambda :double) (x :double) ((foreign-pointer array) :pointer))
+   (lambda :double) (x :double) ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "Compute an array of Gegenbauer polynomials C^{(\lambda)}_n(X)}
diff --git a/special-functions/legendre.lisp b/special-functions/legendre.lisp
index b19a98a104f64a016f897d4f04d45881f0d53564..37aecf370cfaad71856e190eb7e84ddfa4f14c33 100644
--- a/special-functions/legendre.lisp
+++ b/special-functions/legendre.lisp
@@ -1,8 +1,8 @@
 ;; Legendre functions
 ;; Liam Healy, Sat Apr 29 2006 - 19:16
-;; Time-stamp: <2010-07-07 14:24:57EDT legendre.lisp>
+;; Time-stamp: <2011-01-10 17:59:33EST legendre.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -54,7 +54,7 @@
     (x &optional (size-or-array *default-sf-array-size*)
        &aux (array (vdf size-or-array)))
   "gsl_sf_legendre_Pl_array"
-  (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "Compute an array of Legendre polynomials
@@ -64,7 +64,7 @@
     (x &optional (size-or-array *default-sf-array-size*)
        &aux (array (vdf size-or-array)))
   "gsl_sf_legendre_Pl_deriv_array"
-  (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "Compute an array of Legendre polynomials derivatives
@@ -115,7 +115,7 @@
        &aux (array (vdf size-or-array)))
   "gsl_sf_legendre_Plm_array"
   (((+ (dim0 array) m -1) :int) (m :int) (x :double)
-   ((foreign-pointer array) :pointer))
+   ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "An array of Legendre polynomials
@@ -129,7 +129,7 @@
        (derivatives (vdf derivatives-size-or-array)))
   "gsl_sf_legendre_Plm_deriv_array"
   (((+ (dim0 values) m -1) :int) (m :int) (x :double)
-   ((foreign-pointer values) :pointer) ((foreign-pointer derivatives) :pointer))
+   ((grid:foreign-pointer values) :pointer) ((grid:foreign-pointer derivatives) :pointer))
   :outputs (values derivatives)
   :documentation			; FDL
   "An array of Legendre polynomials
@@ -150,7 +150,7 @@
        &aux (array (vdf size-or-array)))
   "gsl_sf_legendre_sphPlm_array"
   (((+ (dim0 array) m -1) :int) (m :int) (x :double)
-   ((foreign-pointer array) :pointer))
+   ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "An array of normalized associated Legendre functions
@@ -164,7 +164,7 @@
        (derivatives (vdf derivatives-size-or-array)))
   "gsl_sf_legendre_sphPlm_deriv_array"
   (((+ (dim0 values) m -1) :int) (m :int) (x :double)
-   ((foreign-pointer values) :pointer) ((foreign-pointer derivatives) :pointer))
+   ((grid:foreign-pointer values) :pointer) ((grid:foreign-pointer derivatives) :pointer))
   :outputs (values derivatives)
   :documentation			; FDL
   "An array of normalized associated Legendre functions
@@ -270,7 +270,7 @@
 	    &aux (array (vdf size-or-array)))
   "gsl_sf_legendre_H3d_array"
   (((1- (dim0 array)) :int) (lambda :double) (eta :double)
-   ((foreign-pointer array) :pointer))
+   ((grid:foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "An array of radial eigenfunctions
diff --git a/special-functions/mathieu.lisp b/special-functions/mathieu.lisp
index 09a7bf731f4b5f1c1b710ec03af836f7685b0612..0e3e454c44af8dba4becc407c8e714463e510607 100644
--- a/special-functions/mathieu.lisp
+++ b/special-functions/mathieu.lisp
@@ -1,8 +1,8 @@
 ;; Mathieu functions
 ;; Liam Healy 2009-02-16 16:30:59EST mathieu.lisp
-;; Time-stamp: <2010-08-07 21:38:53EDT mathieu.lisp>
+;; Time-stamp: <2011-01-10 17:59:33EST mathieu.lisp>
 ;;
-;; 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
@@ -59,7 +59,7 @@
        &aux (size (vdf-size size-or-array)) (result-array (vdf size)))
   "gsl_sf_mathieu_a_array"
   ((minimum-order :int) ((+ minimum-order size -1) :int) (q :double)
-   ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer))
+   ((mpointer workspace) :pointer) ((grid:foreign-pointer result-array) :pointer))
   :gsl-version (1 9)
   :outputs (result-array)
   :return (result-array)
@@ -78,7 +78,7 @@
        &aux (size (vdf-size size-or-array)) (result-array (vdf size)))
   "gsl_sf_mathieu_b_array"
   ((minimum-order :int) ((+ minimum-order size -1) :int) (q :double)
-   ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer))
+   ((mpointer workspace) :pointer) ((grid:foreign-pointer result-array) :pointer))
   :gsl-version (1 9)
   :outputs (result-array)
   :return (result-array)
@@ -116,7 +116,7 @@
   "gsl_sf_mathieu_ce_array"
   ((minimum-order :int) ((+ minimum-order size -1) :int)
    (q :double) (x :double)
-   ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer))
+   ((mpointer workspace) :pointer) ((grid:foreign-pointer result-array) :pointer))
   :gsl-version (1 9)
   :outputs (result-array)
   :return (result-array)
@@ -136,7 +136,7 @@
   "gsl_sf_mathieu_se_array"
   ((minimum-order :int) ((+ minimum-order size -1) :int)
    (q :double) (x :double)
-   ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer))
+   ((mpointer workspace) :pointer) ((grid:foreign-pointer result-array) :pointer))
   :gsl-version (1 9)
   :outputs (result-array)
   :return (result-array)
@@ -182,7 +182,7 @@
   "gsl_sf_mathieu_Mc_array"
   ((j :int) (minimum-order :int) ((+ minimum-order size) :int)
    (q :double) (x :double)
-   ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer))
+   ((mpointer workspace) :pointer) ((grid:foreign-pointer result-array) :pointer))
   :gsl-version (1 9)
   :outputs (result-array)
   :return (result-array)
@@ -202,7 +202,7 @@
   "gsl_sf_mathieu_Ms_array"
   ((j :int) (minimum-order :int) ((+ minimum-order size) :int)
    (q :double) (x :double)
-   ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer))
+   ((mpointer workspace) :pointer) ((grid:foreign-pointer result-array) :pointer))
   :gsl-version (1 9)
   :outputs (result-array)
   :return (result-array)
diff --git a/special-functions/psi.lisp b/special-functions/psi.lisp
index deab62e145be1b3d85daabe015e243caa2eb515f..745f4c784870641be1147cc36cb3e690df069e86 100644
--- a/special-functions/psi.lisp
+++ b/special-functions/psi.lisp
@@ -1,8 +1,8 @@
 ;; Psi (digamma) functions
 ;; Liam Healy, Mon May  1 2006 - 22:11
-;; Time-stamp: <2009-12-27 10:10:00EST psi.lisp>
+;; Time-stamp: <2011-01-13 10:25:00EST psi.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
diff --git a/statistics/absolute-deviation.lisp b/statistics/absolute-deviation.lisp
index 64f598de83f4bf7b694f325f3605e1eb30384854..01381c34385186f6555f335928e79c54f2f3354e 100644
--- a/statistics/absolute-deviation.lisp
+++ b/statistics/absolute-deviation.lisp
@@ -1,8 +1,8 @@
 ;; Absolute deviation
 ;; Liam Healy, Sun Dec 31 2006 - 13:19
-;; Time-stamp: <2010-06-27 18:14:02EDT absolute-deviation.lisp>
+;; Time-stamp: <2011-01-10 17:59:33EST absolute-deviation.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -26,8 +26,8 @@
 (defmfun absolute-deviation ((data vector) &optional mean)
   (("gsl_stats" :type "_absdev")
    ("gsl_stats" :type "_absdev_m"))
-  ((((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
-   (((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)
+  ((((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
+   (((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)
     (mean :double)))
   :definition :generic
   :element-types :no-complex
@@ -48,11 +48,11 @@
 (defmfun weighted-absolute-deviation ((data vector) (weights vector) &optional mean)
   (("gsl_stats" :type "_wabsdev")
    ("gsl_stats" :type "_wabsdev_m"))
-  ((((foreign-pointer weights) :pointer) (1 :int)
-    ((foreign-pointer data) :pointer) (1 :int)
+  ((((grid:foreign-pointer weights) :pointer) (1 :int)
+    ((grid:foreign-pointer data) :pointer) (1 :int)
     ((dim0 data) sizet))
-   (((foreign-pointer weights) :pointer) (1 :int)
-    ((foreign-pointer data) :pointer) (1 :int)
+   (((grid:foreign-pointer weights) :pointer) (1 :int)
+    ((grid:foreign-pointer data) :pointer) (1 :int)
     ((dim0 data) sizet) (mean :double)))
   :definition :generic
   :element-types :float
diff --git a/statistics/autocorrelation.lisp b/statistics/autocorrelation.lisp
index 20d29fe261684e6ae639d9bd83ba7ffa6d2bb3d0..dc04aea517dd9839fb2f099c89de8ba6cf4e62f8 100644
--- a/statistics/autocorrelation.lisp
+++ b/statistics/autocorrelation.lisp
@@ -1,8 +1,8 @@
 ;; Autocorrelation
 ;; Liam Healy, Sun Dec 31 2006 - 13:19
-;; Time-stamp: <2010-06-27 18:14:03EDT autocorrelation.lisp>
+;; Time-stamp: <2011-01-10 17:59:34EST autocorrelation.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -26,8 +26,8 @@
 (defmfun autocorrelation ((data vector) &optional mean)
   (("gsl_stats" :type "_lag1_autocorrelation")
    ("gsl_stats" :type "_lag1_autocorrelation_m"))
-  ((((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
-   (((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)
+  ((((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
+   (((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)
     (mean :double)))
   :definition :generic
   :element-types :no-complex
diff --git a/statistics/covariance.lisp b/statistics/covariance.lisp
index 6d7ce75615333ce49930c0eee73670017c72715a..c1b79f16bc4d472d9e4f2781c7f1617bb8fa9a7c 100644
--- a/statistics/covariance.lisp
+++ b/statistics/covariance.lisp
@@ -1,8 +1,8 @@
 ;; Covariance
 ;; Liam Healy, Sun Dec 31 2006 - 13:19
-;; Time-stamp: <2010-06-27 18:14:03EDT covariance.lisp>
+;; Time-stamp: <2011-01-10 17:59:34EST covariance.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -27,10 +27,10 @@
     ((data1 vector) (data2 vector) &optional mean1 mean2)
   (("gsl_stats" :type "_covariance")
    ("gsl_stats" :type "_covariance_m"))
-  ((((foreign-pointer data1) :pointer) (1 :int)
-    ((foreign-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet))
-   (((foreign-pointer data1) :pointer) (1 :int)
-    ((foreign-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet)
+  ((((grid:foreign-pointer data1) :pointer) (1 :int)
+    ((grid:foreign-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet))
+   (((grid:foreign-pointer data1) :pointer) (1 :int)
+    ((grid:foreign-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet)
     (mean1 :double) (mean2 :double)))
   :definition :generic
   :element-types :no-complex
@@ -44,8 +44,8 @@
 
 (defmfun correlation ((data1 vector) (data2 vector))
   ("gsl_stats" :type "_correlation")
-  (((foreign-pointer data1) :pointer) (1 :int)
-    ((foreign-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet))
+  (((grid:foreign-pointer data1) :pointer) (1 :int)
+    ((grid:foreign-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet))
   :definition :generic
   :gsl-version (1 10)
   :element-types :no-complex
diff --git a/statistics/higher-moments.lisp b/statistics/higher-moments.lisp
index 179bbc012ba3c35ec1ee431bd8c1958b981c12b5..5dcab44deefa56696aca500fbc560a043f66bd06 100644
--- a/statistics/higher-moments.lisp
+++ b/statistics/higher-moments.lisp
@@ -1,8 +1,8 @@
 ;; Skewness and kurtosis.
 ;; Liam Healy, Sun Dec 31 2006 - 14:20
-;; Time-stamp: <2010-06-27 18:14:02EDT higher-moments.lisp>
+;; Time-stamp: <2011-01-10 17:59:34EST higher-moments.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -25,8 +25,8 @@
 (defmfun skewness ((data vector) &optional mean standard-deviation)
   (("gsl_stats" :type "_skew")
    ("gsl_stats" :type "_skew_m_sd"))
-  ((((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
-   (((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)
+  ((((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
+   (((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)
     (mean :double) (standard-deviation :double)))
   :definition :generic
   :element-types :no-complex
@@ -45,8 +45,8 @@
 (defmfun kurtosis ((data vector) &optional mean standard-deviation)
   (("gsl_stats" :type "_kurtosis")
    ("gsl_stats" :type "_kurtosis_m_sd"))
-  ((((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
-   (((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)
+  ((((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
+   (((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)
     (mean :double) (standard-deviation :double)))
   :definition :generic
   :element-types :no-complex
@@ -63,11 +63,11 @@
     ((data vector) (weights vector) &optional mean standard-deviation)
   (("gsl_stats" :type "_wskew")
    ("gsl_stats" :type "_wskew_m_sd"))
-  ((((foreign-pointer weights) :pointer) (1 :int)
-    ((foreign-pointer data) :pointer) (1 :int)
+  ((((grid:foreign-pointer weights) :pointer) (1 :int)
+    ((grid:foreign-pointer data) :pointer) (1 :int)
     ((dim0 data) sizet))
-   (((foreign-pointer weights) :pointer) (1 :int)
-    ((foreign-pointer data) :pointer) (1 :int)
+   (((grid:foreign-pointer weights) :pointer) (1 :int)
+    ((grid:foreign-pointer data) :pointer) (1 :int)
     ((dim0 data) sizet)
     (mean :double) (standard-deviation :double)))
   :definition :generic
@@ -82,11 +82,11 @@
     ((data vector) (weights vector) &optional mean standard-deviation)
   (("gsl_stats" :type "_wkurtosis")
    ("gsl_stats" :type "_wkurtosis_m_sd"))
-  ((((foreign-pointer weights) :pointer) (1 :int)
-    ((foreign-pointer data) :pointer) (1 :int)
+  ((((grid:foreign-pointer weights) :pointer) (1 :int)
+    ((grid:foreign-pointer data) :pointer) (1 :int)
     ((dim0 data) sizet))
-   (((foreign-pointer weights) :pointer) (1 :int)
-    ((foreign-pointer data) :pointer) (1 :int)
+   (((grid:foreign-pointer weights) :pointer) (1 :int)
+    ((grid:foreign-pointer data) :pointer) (1 :int)
     ((dim0 data) sizet)
     (mean :double) (standard-deviation :double)))
   :definition :generic
diff --git a/statistics/mean-variance.lisp b/statistics/mean-variance.lisp
index 60ccf98f66b68cab93f0959bdec88f63ddbd44eb..a0d7a81e85595c2506b65141561c37ca92d82f13 100644
--- a/statistics/mean-variance.lisp
+++ b/statistics/mean-variance.lisp
@@ -1,8 +1,8 @@
 ;; Mean, standard deviation, and variance    
 ;; Liam Healy, Sat Dec  2 2006 - 22:15
-;; Time-stamp: <2010-06-30 19:57:28EDT mean-variance.lisp>
+;; Time-stamp: <2011-05-26 12:37:30EDT mean-variance.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -29,7 +29,7 @@
 
 (defmfun mean ((array both))
   ("gsl_stats" :type "_mean")
-  (((foreign-pointer array) :pointer) (1 :int) ((size array) sizet))
+  (((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet))
   :definition :generic
   :element-types :no-complex
   :c-return :double
@@ -41,8 +41,8 @@
 
 (defmfun weighted-mean ((array both) (weights both))
   ("gsl_stats" :type "_wmean")
-  (((foreign-pointer weights) :pointer) (1 :int)
-   ((foreign-pointer array) :pointer) (1 :int)
+  (((grid:foreign-pointer weights) :pointer) (1 :int)
+   ((grid:foreign-pointer array) :pointer) (1 :int)
    ((size array) sizet))
   :definition :generic
   :element-types :float
@@ -60,8 +60,8 @@
 (defmfun variance ((array both) &optional mean)
   (("gsl_stats" :type "_variance")
    ("gsl_stats" :type "_variance_m"))
-  ((((foreign-pointer array) :pointer) (1 :int) ((size array) sizet))
-   (((foreign-pointer array) :pointer) (1 :int)
+  ((((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet))
+   (((grid:foreign-pointer array) :pointer) (1 :int)
    ((size array) sizet) (mean :double)))
   :definition :generic
   :element-types :no-complex
@@ -82,11 +82,11 @@
 (defmfun weighted-variance ((array both) (weights both) &optional mean)
   (("gsl_stats" :type "_wvariance")
    ("gsl_stats" :type "_wvariance_m"))
-  ((((foreign-pointer weights) :pointer) (1 :int)
-    ((foreign-pointer array) :pointer) (1 :int)
+  ((((grid:foreign-pointer weights) :pointer) (1 :int)
+    ((grid:foreign-pointer array) :pointer) (1 :int)
     ((size array) sizet))
-   (((foreign-pointer weights) :pointer) (1 :int)
-    ((foreign-pointer array) :pointer) (1 :int)
+   (((grid:foreign-pointer weights) :pointer) (1 :int)
+    ((grid:foreign-pointer array) :pointer) (1 :int)
     ((size array) sizet) (mean :double)))
   :definition :generic
   :element-types :float
@@ -108,8 +108,8 @@
 (defmfun standard-deviation ((array both) &optional mean)
   (("gsl_stats" :type "_sd")
    ("gsl_stats" :type "_sd_m"))
-  ((((foreign-pointer array) :pointer) (1 :int) ((size array) sizet))
-   (((foreign-pointer array) :pointer) (1 :int)
+  ((((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet))
+   (((grid:foreign-pointer array) :pointer) (1 :int)
    ((size array) sizet) (mean :double)))
   :definition :generic
   :element-types :no-complex
@@ -123,11 +123,11 @@
 (defmfun weighted-standard-deviation ((array both) (weights both) &optional mean)
   (("gsl_stats" :type "_wsd")
    ("gsl_stats" :type "_wsd_m"))
-  ((((foreign-pointer weights) :pointer) (1 :int)
-    ((foreign-pointer array) :pointer) (1 :int)
+  ((((grid:foreign-pointer weights) :pointer) (1 :int)
+    ((grid:foreign-pointer array) :pointer) (1 :int)
     ((size array) sizet))
-   (((foreign-pointer weights) :pointer) (1 :int)
-    ((foreign-pointer array) :pointer) (1 :int)
+   (((grid:foreign-pointer weights) :pointer) (1 :int)
+    ((grid:foreign-pointer array) :pointer) (1 :int)
     ((size array) sizet) (mean :double)))
   :definition :generic
   :element-types :float
@@ -144,7 +144,7 @@
 
 (defmfun variance-with-fixed-mean ((array both) mean)
   ("gsl_stats" :type "_variance_with_fixed_mean")
-  (((foreign-pointer array) :pointer) (1 :int)
+  (((grid:foreign-pointer array) :pointer) (1 :int)
    ((size array) sizet) (mean :double))
   :definition :generic
   :element-types :no-complex
@@ -160,7 +160,7 @@
 
 (defmfun standard-deviation-with-fixed-mean ((array both) mean)
   ("gsl_stats" :type "_sd_with_fixed_mean")
-  (((foreign-pointer array) :pointer) (1 :int)
+  (((grid:foreign-pointer array) :pointer) (1 :int)
    ((size array) sizet) (mean :double))
   :definition :generic
   :element-types :no-complex
@@ -178,8 +178,8 @@
 (defmfun weighted-variance-with-fixed-mean
     ((array both) (weights both) mean)
   ("gsl_stats" :type "_wvariance_with_fixed_mean")
-  (((foreign-pointer weights) :pointer) (1 :int)
-   ((foreign-pointer array) :pointer) (1 :int)
+  (((grid:foreign-pointer weights) :pointer) (1 :int)
+   ((grid:foreign-pointer array) :pointer) (1 :int)
    ((size array) sizet) (mean :double))
   :definition :generic
   :element-types :float
@@ -196,8 +196,8 @@
 (defmfun weighted-standard-deviation-with-fixed-mean
     ((array both) (weights both) mean)
   ("gsl_stats" :type "_wsd_with_fixed_mean")
-  (((foreign-pointer weights) :pointer) (1 :int)
-   ((foreign-pointer array) :pointer) (1 :int)
+  (((grid:foreign-pointer weights) :pointer) (1 :int)
+   ((grid:foreign-pointer array) :pointer) (1 :int)
    ((size array) sizet) (mean :double))
   :definition :generic
   :element-types :float
@@ -273,8 +273,8 @@
 (generate-all-array-tests weighted-mean :float
  (let ((v1 (array-default 8))
 	(v2 (array-default 8)))
-   (loop for i below (first (dimensions v2))
-      do (setf (grid:gref v2 i) (abs (grid:gref v2 i))))
+   (loop for i below (first (grid:dimensions v2))
+      do (setf (grid:aref v2 i) (abs (grid:aref v2 i))))
    (weighted-mean v1 v2)))
 |#
 
diff --git a/statistics/median-percentile.lisp b/statistics/median-percentile.lisp
index c29993dec1db1acae8dcda1f83217b084be567dd..67eb56bcca3e098690fb1a9e33baabbb541bc1a6 100644
--- a/statistics/median-percentile.lisp
+++ b/statistics/median-percentile.lisp
@@ -1,8 +1,8 @@
 ;; Median and percentile
 ;; Liam Healy, Sun Dec 31 2006 - 13:19
-;; Time-stamp: <2010-06-27 18:14:04EDT median-percentile.lisp>
+;; Time-stamp: <2011-01-10 17:59:35EST median-percentile.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -25,7 +25,7 @@
 
 (defmfun median ((sorted-data vector))
   ("gsl_stats" :type "_median_from_sorted_data")
-  (((foreign-pointer sorted-data) :pointer) (1 :int) ((dim0 sorted-data) sizet))
+  (((grid:foreign-pointer sorted-data) :pointer) (1 :int) ((dim0 sorted-data) sizet))
   :definition :generic
   :element-types :no-complex
   :c-return :double
@@ -44,7 +44,7 @@
 
 (defmfun quantile ((sorted-data vector) fraction)
   ("gsl_stats" :type "_quantile_from_sorted_data")
-  (((foreign-pointer sorted-data) :pointer) (1 :int) ((dim0 sorted-data) sizet)
+  (((grid:foreign-pointer sorted-data) :pointer) (1 :int) ((dim0 sorted-data) sizet)
    (fraction :double))
   :definition :generic
   :element-types :no-complex
diff --git a/test-unit/augment.lisp b/test-unit/augment.lisp
index 17ac0d5888da5ccc6327f4b5e2120e5dab420d48..a6fdd3275c87181649948a8ee4e57889d0ee9e34 100644
--- a/test-unit/augment.lisp
+++ b/test-unit/augment.lisp
@@ -1,8 +1,8 @@
 ;; Additional methods for lisp-unit
 ;; Liam Healy 2009-04-15 23:23:30EDT augment.lisp
-;; Time-stamp: <2010-07-07 14:24:56EDT augment.lisp>
+;; Time-stamp: <2011-01-10 18:19:07EST augment.lisp>
 ;;
-;; 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
@@ -23,7 +23,7 @@
 (defmethod lisp-unit:numerical-equal
     ((result1 grid:foreign-array) (result2 grid:foreign-array) &key (test #'lisp-unit:number-equal))
   "Return true if the arrays are numerically equal according to :TEST."
-  (when (equal (dimensions result1) (dimensions result2))
+  (when (equal (grid:dimensions result1) (grid:dimensions result2))
     (lisp-unit:numerical-equal (grid:copy-to result1) (grid:copy-to result2)
 			       :test test)))
 
diff --git a/tests/absolute-sum.lisp b/tests/absolute-sum.lisp
index fa1d6b7079279b1217d5ed4bef21e8eb1d60abca..e77374b57edf20984dd6f035592002436b027ae2 100644
--- a/tests/absolute-sum.lisp
+++ b/tests/absolute-sum.lisp
@@ -1,6 +1,6 @@
 ;; Regression test ABSOLUTE-SUM for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,13 +20,13 @@
 
 (LISP-UNIT:DEFINE-TEST ABSOLUTE-SUM
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST 157.99)
+   (LIST 157.99f0)
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
       (ABSOLUTE-SUM V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 157.99d0)
@@ -38,15 +38,14 @@
 	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
       (ABSOLUTE-SUM V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST 388.65997)
+   (LIST 388.65997f0)
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX
-	      SINGLE-FLOAT)
+	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) #C(49.27 -13.49)
-	      #C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0)
+	      #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))))
       (ABSOLUTE-SUM V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 388.65999999999997d0)
diff --git a/tests/axpy.lisp b/tests/axpy.lisp
index 8b014436c218e2ce8d6bb6e75fef2455e9452366..5b6677b947af6f24a9d78944a49a1dd3cbf94873 100644
--- a/tests/axpy.lisp
+++ b/tests/axpy.lisp
@@ -1,6 +1,6 @@
 ;; Regression test AXPY for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -21,18 +21,18 @@
 (LISP-UNIT:DEFINE-TEST AXPY
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #(1400.77 -284.0684 -147.7214 397.47382 -1369.3191
-      235.659 -1932.6083 485.93335))
+    #(1400.77f0 -284.0684f0 -147.7214f0 397.47382f0 -1369.3191f0
+      235.659f0 -1932.6083f0 485.93335f0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '(32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 -49.08)))
-	  (SCALAR -39.66))
+	    '(32.5f0 42.73f0 -17.24f0 43.31f0 -16.12f0 -8.25f0 21.44f0 -49.08f0)))
+	  (SCALAR -39.66f0))
       (grid:copy-to (AXPY SCALAR V1 V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -59,27 +59,27 @@
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #(#C(1808.3204 1422.3015) #C(-589.3992 234.75043)
-      #C(-1673.498 -1451.916) #C(-2599.8237 -1950.9608)
-      #C(784.81586 -3351.5815) #C(2845.531 -870.5343)
-      #C(222.45422 1149.8602) #C(-3308.3872 917.76044)))
+    #(#C(1808.3204f0 1422.3015f0) #C(-589.3992f0 234.75043f0)
+      #C(-1673.498f0 -1451.916f0) #C(-2599.8237f0 -1950.9608f0)
+      #C(784.81586f0 -3351.5815f0) #C(2845.531f0 -870.5343f0)
+      #C(222.45422f0 1149.8602f0) #C(-3308.3872f0 917.76044f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93)
-	      #C(34.12 -6.15) #C(49.27 -13.49) #C(32.5 42.73)
-	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0)
+	      #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	      #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25)
-	      #C(21.44 -49.08) #C(-39.66 -49.46)
-	      #C(19.68 -5.55) #C(-8.82 25.37)
-	      #C(-30.58 31.67))))
-	  (SCALAR #C(-39.66 -49.46)))
+	    '(#C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0)
+	      #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)
+	      #C(19.68f0 -5.55f0) #C(-8.82f0 25.37f0)
+	      #C(-30.58f0 31.67f0))))
+	  (SCALAR #C(-39.66f0 -49.46f0)))
       (GRID:COPY-TO (AXPY SCALAR V1 V2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/blas-copy.lisp b/tests/blas-copy.lisp
index bd0502b55de62325e59e9820ffc8794745b532ad..f2ad285dc7372a988d27e3961b5a6f10b3bad809 100644
--- a/tests/blas-copy.lisp
+++ b/tests/blas-copy.lisp
@@ -1,6 +1,6 @@
 ;; Regression test BLAS-COPY for GSLL, automatically generated
 ;;
-;; Copyright 2009, 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,11 +20,11 @@
 
 (LISP-UNIT:DEFINE-TEST BLAS-COPY
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(-34.5 8.24 3.29))
+   (LIST #(-34.5f0 8.24f0 3.29f0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
-	    'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5 8.24 3.29)))
+	    'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0)))
 	  (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
       (BLAS-COPY V1 V2)
       (GRID:COPY-TO V2))))
@@ -38,13 +38,13 @@
       (BLAS-COPY V1 V2)
       (GRID:COPY-TO V2))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)))
+   (LIST #(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3)))
diff --git a/tests/blas-swap.lisp b/tests/blas-swap.lisp
index 405442e1c64cd114ca0407ec15ad7961b5c63a3b..2cf69132db4b88f283ec1e6b56f0708e9af4598e 100644
--- a/tests/blas-swap.lisp
+++ b/tests/blas-swap.lisp
@@ -1,6 +1,6 @@
 ;; Regression test BLAS-SWAP for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,16 +20,16 @@
 
 (LISP-UNIT:DEFINE-TEST BLAS-SWAP
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST (LIST #(-8.93 34.12 -6.15) #(-34.5 8.24 3.29)))
+   (LIST (LIST #(-8.93f0 34.12f0 -6.15f0) #(-34.5f0 8.24f0 3.29f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '(-34.5 8.24 3.29)))
+	    '(-34.5f0 8.24f0 3.29f0)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '(-8.93 34.12 -6.15))))
+	    '(-8.93f0 34.12f0 -6.15f0))))
       (BLAS-SWAP V2 V1)
       (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -50,19 +50,19 @@
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
-     #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-     #(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))
+     #(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+     #(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)))))
+	    '(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)))))
       (BLAS-SWAP V2 V1)
       (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/cdot.lisp b/tests/cdot.lisp
index 59db2a942de63cd4c263afd22307d665240ed647..42af8212efcc600d58c4fc4376a3eaee1594021a 100644
--- a/tests/cdot.lisp
+++ b/tests/cdot.lisp
@@ -1,6 +1,6 @@
 ;; Regression test CDOT for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,22 +20,22 @@
 
 (LISP-UNIT:DEFINE-TEST CDOT
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #C(-6252.624 -6236.0503))
+   (LIST #C(-6252.624f0 -6236.0503f0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)
-	      #C(49.27 -13.49) #C(32.5 42.73)
-	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)
+	      #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	      #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25)
-	      #C(21.44 -49.08) #C(-39.66 -49.46)
-	      #C(19.68 -5.55) #C(-8.82 25.37) #C(-30.58 31.67)))))
+	    '(#C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0)
+	      #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)
+	      #C(19.68f0 -5.55f0) #C(-8.82f0 25.37f0) #C(-30.58f0 31.67f0)))))
       (CDOT V1 V2))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #C(-6252.624d0 -6236.050300000001d0))
diff --git a/tests/column.lisp b/tests/column.lisp
index fac955d630173ec70a0bea04ef5d31296f5eec05..d25e69c842aba1d493e860bcd526a776eb47a087 100644
--- a/tests/column.lisp
+++ b/tests/column.lisp
@@ -1,6 +1,6 @@
 ;; Regression test COLUMN for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,175 +19,175 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST COLUMN
-  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(8.24 34.12 -13.49))
-   (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'SINGLE-FLOAT
-	    :INITIAL-CONTENTS
-	    '((-34.5 8.24 3.29)
-	      (-8.93 34.12 -6.15)
-	      (49.27 -13.49 32.5))))
-	  (COL (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(8.24f0 34.12f0 -13.49f0))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((M1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '((-34.5f0 8.24f0 3.29f0)
+		   (-8.93f0 34.12f0 -6.15f0)
+		   (49.27f0 -13.49f0 32.5f0))))
+	       (COL (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
+	   (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(8.24d0 34.12d0 -13.49d0))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'DOUBLE-FLOAT :INITIAL-CONTENTS
-	    '((-34.5d0 8.24d0 3.29d0)
-	      (-8.93d0 34.12d0 -6.15d0)
-	      (49.27d0 -13.49d0 32.5d0))))
-	  (COL (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT :INITIAL-CONTENTS
+	       '((-34.5d0 8.24d0 3.29d0)
+		 (-8.93d0 34.12d0 -6.15d0)
+		 (49.27d0 -13.49d0 32.5d0))))
+	     (COL (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
+	 (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73)))
+   (LIST #(#C(3.29f0 -8.93f0) #C(-6.15f0 49.27f0) #C(32.5f0 42.73f0)))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX SINGLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
-	  (COL
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX SINGLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+		 (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+		 (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
+	     (COL
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3)))
+	 (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(3.29d0 -8.93d0) #C(-6.15d0 49.27d0)
       #C(32.5d0 42.73d0)))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX DOUBLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
-	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
-	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
-	  (COL
-	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT) :DIMENSIONS '3)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX DOUBLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+		 (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+		 (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	     (COL
+	      (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT) :DIMENSIONS '3)))
+	 (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-68 52 -5))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(SIGNED-BYTE 8)
-	    :INITIAL-CONTENTS
-	    '((-64 -68 71)
-	      (-91 52 -10)
-	      (73 -5 123))))
-	  (COL
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(SIGNED-BYTE 8)
-	    :DIMENSIONS '3)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 8)
+	       :INITIAL-CONTENTS
+	       '((-64 -68 71)
+		 (-91 52 -10)
+		 (73 -5 123))))
+	     (COL
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 8)
+	       :DIMENSIONS '3)))
+	 (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(44 163 215))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(UNSIGNED-BYTE 8)
-	    :INITIAL-CONTENTS
-	    '((67 44 189)
-	      (116 163 140)
-	      (161 215 98))))
-	  (COL
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(UNSIGNED-BYTE 8)
-	    :DIMENSIONS '3)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 8)
+	       :INITIAL-CONTENTS
+	       '((67 44 189)
+		 (116 163 140)
+		 (161 215 98))))
+	     (COL
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 8)
+	       :DIMENSIONS '3)))
+	 (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-68 52 -5))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(SIGNED-BYTE 16)
-	    :INITIAL-CONTENTS
-	    '((-64 -68 71)
-	      (-91 52 -10)
-	      (73 -5 123))))
-	  (COL
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(SIGNED-BYTE 16) :DIMENSIONS '3)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 16)
+	       :INITIAL-CONTENTS
+	       '((-64 -68 71)
+		 (-91 52 -10)
+		 (73 -5 123))))
+	     (COL
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 16) :DIMENSIONS '3)))
+	 (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(44 163 215))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(UNSIGNED-BYTE 16)
-	    :INITIAL-CONTENTS
-	    '((67 44 189)
-	      (116 163 140)
-	      (161 215 98))))
-	  (COL
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(UNSIGNED-BYTE 16)
-	    :DIMENSIONS '3)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 16)
+	       :INITIAL-CONTENTS
+	       '((67 44 189)
+		 (116 163 140)
+		 (161 215 98))))
+	     (COL
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 16)
+	       :DIMENSIONS '3)))
+	 (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-68 52 -5))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(SIGNED-BYTE 32)
-	    :INITIAL-CONTENTS
-	    '((-64 -68 71)
-	      (-91 52 -10)
-	      (73 -5 123))))
-	  (COL
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(SIGNED-BYTE 32) :DIMENSIONS '3)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 32)
+	       :INITIAL-CONTENTS
+	       '((-64 -68 71)
+		 (-91 52 -10)
+		 (73 -5 123))))
+	     (COL
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 32) :DIMENSIONS '3)))
+	 (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(44 163 215))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(UNSIGNED-BYTE 32)
-	    :INITIAL-CONTENTS
-	    '((67 44 189)
-	      (116 163 140)
-	      (161 215 98))))
-	  (COL
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(UNSIGNED-BYTE 32) :DIMENSIONS '3)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 32)
+	       :INITIAL-CONTENTS
+	       '((67 44 189)
+		 (116 163 140)
+		 (161 215 98))))
+	     (COL
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 32) :DIMENSIONS '3)))
+	 (GRID:COPY-TO (COLUMN M1 1 COL)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-68 52 -5))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(SIGNED-BYTE 64)
-	    :INITIAL-CONTENTS
-	    '((-64 -68 71)
-	      (-91 52 -10)
-	      (73 -5 123))))
-	  (COL
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(SIGNED-BYTE 64)
-	    :DIMENSIONS '3)))
-      (GRID:COPY-TO (COLUMN M1 1 COL)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 64)
+	       :INITIAL-CONTENTS
+	       '((-64 -68 71)
+		 (-91 52 -10)
+		 (73 -5 123))))
+	     (COL
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 64)
+	       :DIMENSIONS '3)))
+	 (GRID:COPY-TO (COLUMN M1 1 COL)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(44 163 215))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(UNSIGNED-BYTE 64)
-	    :INITIAL-CONTENTS
-	    '((67 44 189)
-	      (116 163 140)
-	      (161 215 98))))
-	  (COL
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(UNSIGNED-BYTE 64)
-	    :DIMENSIONS '3)))
-      (GRID:COPY-TO (COLUMN M1 1 COL))))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 64)
+	       :INITIAL-CONTENTS
+	       '((67 44 189)
+		 (116 163 140)
+		 (161 215 98))))
+	     (COL
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 64)
+	       :DIMENSIONS '3)))
+	 (GRID:COPY-TO (COLUMN M1 1 COL))))))
 
diff --git a/tests/correlation.lisp b/tests/correlation.lisp
index b05deb8870c95029d84a30b50812e783a43c12c1..1d66fd399c90c85e88d1d9edb47c1bc4a188591c 100644
--- a/tests/correlation.lisp
+++ b/tests/correlation.lisp
@@ -1,6 +1,6 @@
 ;; Regression test CORRELATION for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -24,10 +24,10 @@
                         (MULTIPLE-VALUE-LIST
                          (LET ((V1
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29)))
+                                             '(-34.5f0 8.24f0 3.29f0)))
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93 34.12 -6.15))))
+                                             '(-8.93f0 34.12f0 -6.15f0))))
                            (CORRELATION V1 V2))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 0.6345226817840662d0)
diff --git a/tests/covariance.lisp b/tests/covariance.lisp
index 16b5f83d2123eddb2157ca0c28bdd011471d2c8a..b64c07f18c5f6d8c414ebc0c437dce205e5c5f95 100644
--- a/tests/covariance.lisp
+++ b/tests/covariance.lisp
@@ -1,6 +1,6 @@
 ;; Regression test COVARIANCE for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -24,10 +24,10 @@
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-				    '(-34.5 8.24 3.29)))
+				    '(-34.5f0 8.24f0 3.29f0)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-				    '(-8.93 34.12 -6.15))))
+				    '(-8.93f0 34.12f0 -6.15f0))))
       (LET ((MEAN1 (MEAN V1)) (MEAN2 (MEAN V2)))
 	(COVARIANCE V1 V2 MEAN1 MEAN2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/dot.lisp b/tests/dot.lisp
index 6375c5541e4af028a7005e296ab3378e2b7e4a37..80b7873154d3bc0b8b5faf846da9addfa57db3cf 100644
--- a/tests/dot.lisp
+++ b/tests/dot.lisp
@@ -1,6 +1,6 @@
 ;; Regression test DOT for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,19 +20,19 @@
 
 (LISP-UNIT:DEFINE-TEST DOT
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST 6.5285645)
+   (LIST 6.5285645f0)
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '(32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 -49.08))))
-      (DOT V1 V2))))
+	    '(32.5f0 42.73f0 -17.24f0 43.31f0 -16.12f0 -8.25f0 21.44f0 -49.08f0))))
+      (GRID:INNER V1 V2))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 6.528400000000033d0)
    (MULTIPLE-VALUE-LIST
@@ -48,25 +48,25 @@
 	    '(32.5d0 42.73d0 -17.24d0 43.31d0
 	      -16.12d0 -8.25d0 21.44d0
 	      -49.08d0))))
-      (DOT V1 V2))))
+      (GRID:INNER V1 V2))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #C(625.9737 -4310.1177))
+   (LIST #C(625.9737f0 -4310.1177f0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)
-	      #C(49.27 -13.49) #C(32.5 42.73)
-	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)
+	      #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	      #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25)
-	      #C(21.44 -49.08) #C(-39.66 -49.46)
-	      #C(19.68 -5.55) #C(-8.82 25.37) #C(-30.58 31.67)))))
-      (DOT V1 V2))))
+	    '(#C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0)
+	      #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)
+	      #C(19.68f0 -5.55f0) #C(-8.82f0 25.37f0) #C(-30.58f0 31.67f0)))))
+      (GRID:INNER V1 V2))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #C(625.9736000000007d0 -4310.1183d0))
    (MULTIPLE-VALUE-LIST
@@ -87,4 +87,4 @@
 	      #C(-39.66d0 -49.46d0)
 	      #C(19.68d0 -5.55d0) #C(-8.82d0 25.37d0)
 	      #C(-30.58d0 31.67d0)))))
-      (DOT V1 V2)))))
+      (GRID:INNER V1 V2)))))
diff --git a/tests/euclidean-norm.lisp b/tests/euclidean-norm.lisp
index fcee147a020c60a5684d1d8c1d526e88b866152d..818d862dab50ba692d47425ab16604b747c23c67 100644
--- a/tests/euclidean-norm.lisp
+++ b/tests/euclidean-norm.lisp
@@ -1,6 +1,6 @@
 ;; Regression test EUCLIDEAN-NORM for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,13 +20,13 @@
 
 (LISP-UNIT:DEFINE-TEST EUCLIDEAN-NORM
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST 71.83472)
+   (LIST 71.83472f0)
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
       (EUCLIDEAN-NORM V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 71.83471653734007d0)
@@ -37,16 +37,16 @@
 	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
       (EUCLIDEAN-NORM V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST 115.80907)
+   (LIST 115.80907f0)
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93)
-	      #C(34.12 -6.15) #C(49.27 -13.49)
-	      #C(32.5 42.73) #C(-17.24 43.31)
-	      #C(-16.12 -8.25) #C(21.44 -49.08)))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0)
+	      #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0)
+	      #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)
+	      #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))))
       (EUCLIDEAN-NORM V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 115.8090670025452d0)
@@ -60,4 +60,3 @@
 	      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
 	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)))))
       (EUCLIDEAN-NORM V1)))))
-
diff --git a/tests/fast-fourier-transform.lisp b/tests/fast-fourier-transform.lisp
index dac5cda25708d500cfc06727e4576a1520da12f2..f6c7c34ffd5b0c42315affab14c41d717c913399 100644
--- a/tests/fast-fourier-transform.lisp
+++ b/tests/fast-fourier-transform.lisp
@@ -1,8 +1,8 @@
 ;; Fast fourier transform tests
 ;; Liam Healy 2010-08-14 11:58:26EDT fast-fourier-transform.lisp
-;; Time-stamp: <2010-09-04 17:07:32EDT fast-fourier-transform.lisp>
+;; Time-stamp: <2011-05-26 12:37:30EDT fast-fourier-transform.lisp>
 ;;
-;; Copyright 2010 Liam M. Healy
+;; Copyright 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
@@ -27,11 +27,11 @@
   "Make a grid that is all of the original array except that the
    stride points are excluded."
   (grid:make-foreign-array
-   (element-type array)
+   (grid:element-type array)
    :initial-contents
    (loop for i from 0 below (grid:total-size array)
       unless (zerop (mod i stride))
-      collect (grid:gref* array i))))
+      collect (grid:aref* array i))))
 
 (defun fft-complex-off-stride-check (vector stride offset)
   (loop with size = (size vector)
@@ -40,7 +40,7 @@
 	unless (lisp-unit:numerical-equal
 		 (complex (+ offset (* 2 i))
 			  (+ offset (* 2 i) 1))
-		 (grid:gref vector i))
+		 (grid:aref vector i))
 	return nil
 	finally
 	(return t)))
diff --git a/tests/givens.lisp b/tests/givens.lisp
index 5c90408d0fd76f048ca0b8f2a00a7e31b78ce28c..6f051969d792f54cce05d0bd1ff880e3bba4972e 100644
--- a/tests/givens.lisp
+++ b/tests/givens.lisp
@@ -1,6 +1,6 @@
 ;; Regression test GIVENS for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,66 +19,69 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST GIVENS
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST
-                          #(-47.39726 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)
-                          #(-0.6856937 42.73 -17.24 43.31 -16.12 -8.25 21.44
-                            -49.08)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(32.5 42.73 -17.24 43.31 -16.12
-                                               -8.25 21.44 -49.08)))
-                               (ANGLES
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-39.66 -49.46 19.68 -5.55 -8.82
-                                               25.37 -30.58 31.67)))
-                               (SINES
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8))
-                               (COSINES
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8)))
-                           (LOOP FOR I BELOW 8 DO
-                                 (SETF (GRID:GREF SINES I) (SIN (GRID:GREF ANGLES I)))
-                                 (SETF (GRID:GREF COSINES I)
-                                         (COS (GRID:GREF ANGLES I))))
-                           (GIVENS-ROTATION V1 V2 COSINES SINES)
-                           (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         (LIST
-                          #(-47.39725730461627d0 8.24d0 3.29d0 -8.93d0 34.12d0
-                            -6.15d0 49.27d0 -13.49d0)
-                          #(-0.6856936845760199d0 42.73d0 -17.24d0 43.31d0
-                            -16.12d0 -8.25d0 21.44d0 -49.08d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(32.5d0 42.73d0 -17.24d0 43.31d0
-                                               -16.12d0 -8.25d0 21.44d0
-                                               -49.08d0)))
-                               (ANGLES
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-39.66d0 -49.46d0 19.68d0
-                                               -5.55d0 -8.82d0 25.37d0 -30.58d0
-                                               31.67d0)))
-                               (SINES
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8))
-                               (COSINES
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8)))
-                           (LOOP FOR I BELOW 8 DO
-                                 (SETF (GRID:GREF SINES I) (SIN (GRID:GREF ANGLES I)))
-                                 (SETF (GRID:GREF COSINES I)
-                                         (COS (GRID:GREF ANGLES I))))
-                           (GIVENS-ROTATION V1 V2 COSINES SINES)
-                           (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST
+      (LIST
+       #(-47.39726f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)
+       #(-0.6856937f0 42.73f0 -17.24f0 43.31f0 -16.12f0 -8.25f0 21.44f0
+	 -49.08f0)))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))
+	       (V2
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(32.5f0 42.73f0 -17.24f0 43.31f0 -16.12f0 -8.25f0 21.44f0 -49.08f0)))
+	       (ANGLES
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-39.66f0 -49.46f0 19.68f0 -5.55f0 -8.82f0 25.37f0 -30.58f0 31.67f0)))
+	       (SINES
+		(GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8))
+	       (COSINES
+		(GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8)))
+	   (LOOP FOR I BELOW 8 DO
+	     (SETF (GRID:AREF SINES I) (SIN (GRID:AREF ANGLES I)))
+	     (SETF (GRID:AREF COSINES I)
+		   (COS (GRID:AREF ANGLES I))))
+	   (GIVENS-ROTATION V1 V2 COSINES SINES)
+	   (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    (LIST
+     #(-47.39725730461627d0 8.24d0 3.29d0 -8.93d0 34.12d0
+       -6.15d0 49.27d0 -13.49d0)
+     #(-0.6856936845760199d0 42.73d0 -17.24d0 43.31d0
+       -16.12d0 -8.25d0 21.44d0 -49.08d0)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(-34.5d0 8.24d0 3.29d0 -8.93d0
+					 34.12d0 -6.15d0 49.27d0
+					 -13.49d0)))
+	     (V2
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(32.5d0 42.73d0 -17.24d0 43.31d0
+					 -16.12d0 -8.25d0 21.44d0
+					 -49.08d0)))
+	     (ANGLES
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(-39.66d0 -49.46d0 19.68d0
+					 -5.55d0 -8.82d0 25.37d0 -30.58d0
+					 31.67d0)))
+	     (SINES
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8))
+	     (COSINES
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8)))
+	 (LOOP FOR I BELOW 8 DO
+	   (SETF (GRID:AREF SINES I) (SIN (GRID:AREF ANGLES I)))
+	   (SETF (GRID:AREF COSINES I)
+		 (COS (GRID:AREF ANGLES I))))
+	 (GIVENS-ROTATION V1 V2 COSINES SINES)
+	 (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2))))))
 
diff --git a/tests/hankel.lisp b/tests/hankel.lisp
index 92dba83c2623962bfdc7c74d27c2ce73a74d0e4c..461013ff9c8d893ed8b59bc9f65c331334ae9983 100644
--- a/tests/hankel.lisp
+++ b/tests/hankel.lisp
@@ -114,7 +114,7 @@
                          (LET ((HANK (MAKE-HANKEL 128 0.0d0 100.0d0))
                                (IN (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 128)))
                            (LOOP FOR N FROM 0 BELOW 128 DO
-                                 (SETF (GRID:GREF IN N)
+                                 (SETF (GRID:AREF IN N)
                                          (/
                                           (1+
                                            (EXPT (SAMPLE-X-HANKEL HANK N)
@@ -190,7 +190,7 @@
                          (LET ((HANK (MAKE-HANKEL 128 1.0d0 20.0d0))
                                (IN (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 128)))
                            (LOOP FOR N FROM 0 BELOW 128 DO
-                                 (SETF (GRID:GREF IN N)
+                                 (SETF (GRID:AREF IN N)
                                          (EXP (- (SAMPLE-X-HANKEL HANK N)))))
                            (grid:COPY-to (APPLY-HANKEL HANK IN)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -263,7 +263,7 @@
                          (LET ((HANK (MAKE-HANKEL 128 1.0d0 1.0d0))
                                (IN (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 128)))
                            (LOOP FOR N FROM 0 BELOW 128 DO
-                                 (SETF (GRID:GREF IN N)
+                                 (SETF (GRID:AREF IN N)
                                          (LET ((X (SAMPLE-X-HANKEL HANK N)))
                                            (* X (- 1 (EXPT X 2))))))
                            (grid:COPY-to (APPLY-HANKEL HANK IN))))))
diff --git a/tests/histogram.lisp b/tests/histogram.lisp
index d832eb4e9ecfe1771116095dc94a365c3bc55114..d37108b1954cb5cc561f3753ff30f841d3268c85 100644
--- a/tests/histogram.lisp
+++ b/tests/histogram.lisp
@@ -39,7 +39,7 @@
                                                              (INCREMENT HISTO
                                                                         6.9d0
                                                                         2.0d0)
-                                                             (GRID:GREF HISTO 1))))
+                                                             (GRID:AREF HISTO 1))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.0d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((HISTO
@@ -53,7 +53,7 @@
                                                              (INCREMENT HISTO
                                                                         6.9d0
                                                                         2.0d0)
-                                                             (GRID:GREF HISTO 2))))
+                                                             (GRID:AREF HISTO 2))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2.0d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((HISTO
@@ -67,7 +67,7 @@
                                                              (INCREMENT HISTO
                                                                         6.9d0
                                                                         2.0d0)
-                                                             (GRID:GREF HISTO 6))))
+                                                             (GRID:AREF HISTO 6))))
                        (LISP-UNIT:ASSERT-ERROR 'INPUT-DOMAIN
                                                (LET ((HISTO
                                                       (MAKE-HISTOGRAM 10)))
@@ -76,7 +76,7 @@
                                                                      10.0d0)
                                                  (INCREMENT HISTO 2.7d0)
                                                  (INCREMENT HISTO 6.9d0 2.0d0)
-                                                 (GRID:GREF HISTO 16)))
+                                                 (GRID:AREF HISTO 16)))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.0d0 10.0d0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((HISTO
diff --git a/tests/index-max.lisp b/tests/index-max.lisp
index 0752044424bfa9c51ca1c44dd9cec75660620056..0dff9495d5a1680649f9d9c5f29d36b655d14c2e 100644
--- a/tests/index-max.lisp
+++ b/tests/index-max.lisp
@@ -1,6 +1,6 @@
 ;; Regression test INDEX-MAX for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,49 +19,48 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST INDEX-MAX
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 6)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (INDEX-MAX V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 6)
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'SINGLE-FLOAT
-	    :INITIAL-CONTENTS
-	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
-      (INDEX-MAX V1))))
-  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST 6)
-   (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'DOUBLE-FLOAT
-	    :INITIAL-CONTENTS
-	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
-      (INDEX-MAX V1))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+	 (INDEX-MAX V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 4)
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX SINGLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)
-	      #C(49.27 -13.49) #C(32.5 42.73)
-	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
-      (INDEX-MAX V1))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX SINGLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)
+		 #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+		 #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))))
+	 (INDEX-MAX V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 4)
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX DOUBLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '(#C(-34.5d0 8.24d0)
-	      #C(3.29d0 -8.93d0)
-	      #C(34.12d0 -6.15d0)
-	      #C(49.27d0 -13.49d0)
-	      #C(32.5d0 42.73d0)
-	      #C(-17.24d0 43.31d0)
-	      #C(-16.12d0 -8.25d0)
-	      #C(21.44d0 -49.08d0)))))
-      (INDEX-MAX V1)))))
-
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX DOUBLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '(#C(-34.5d0 8.24d0)
+		 #C(3.29d0 -8.93d0)
+		 #C(34.12d0 -6.15d0)
+		 #C(49.27d0 -13.49d0)
+		 #C(32.5d0 42.73d0)
+		 #C(-17.24d0 43.31d0)
+		 #C(-16.12d0 -8.25d0)
+		 #C(21.44d0 -49.08d0)))))
+	 (INDEX-MAX V1)))))
diff --git a/tests/inverse-matrix-product.lisp b/tests/inverse-matrix-product.lisp
index 0730e9713a8ad77ecd4f0b32b9b6bd27210e4b1a..a5c7fb102b2451a267bb001778f7a467486ae680 100644
--- a/tests/inverse-matrix-product.lisp
+++ b/tests/inverse-matrix-product.lisp
@@ -1,6 +1,6 @@
 ;; Regression test INVERSE-MATRIX-PRODUCT for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -21,23 +21,23 @@
 (LISP-UNIT:DEFINE-TEST INVERSE-MATRIX-PRODUCT
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((-30.708971 5.3737082 -25.897392)
-	(-14.654706 -9.08723 6.96797)
-	(-29.71983 -24.015656 -29.949932)))
+    #2A((-30.708971f0 5.3737082f0 -25.897392f0)
+	(-14.654706f0 -9.08723f0 6.96797f0)
+	(-29.71983f0 -24.015656f0 -29.949932f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '((-34.5 8.24 3.29)
-	      (-8.93 34.12 -6.15)
-	      (49.27 -13.49 32.5))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '((42.73 -17.24 43.31)
-	      (-16.12 -8.25 21.44)
-	      (-49.08 -39.66 -49.46))))
-	  (S1 19.68))
+	    '((42.73f0 -17.24f0 43.31f0)
+	      (-16.12f0 -8.25f0 21.44f0)
+	      (-49.08f0 -39.66f0 -49.46f0))))
+	  (S1 19.68f0))
       (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -65,28 +65,28 @@
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(-28.191956 35.052914) #C(-13.378113 28.736774)
-	   #C(5.4411864 -3.0717967))
-	(#C(5.1555862 -11.330741) #C(-33.49236 -12.241006)
-	   #C(-10.527424 20.3357))
-	(#C(-0.71776515 27.669863) #C(20.046593 11.972884)
-	   #C(-1.5907472 4.2853727))))
+    #2A((#C(-28.191956f0 35.052914f0) #C(-13.378113f0 28.736774f0)
+	   #C(5.4411864f0 -3.0717967f0))
+	(#C(5.1555862f0 -11.330741f0) #C(-33.49236f0 -12.241006f0)
+	   #C(-10.527424f0 20.3357f0))
+	(#C(-0.71776515f0 27.669863f0) #C(20.046593f0 11.972884f0)
+	   #C(-1.5907472f0 4.2853727f0))))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '((#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))
-	      (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
-	      (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82)))))
-	  (S1 #C(19.68 -5.55)))
+	    '((#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0))
+	      (#C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0))
+	      (#C(-49.08f0 -39.66f0) #C(-49.46f0 19.68f0) #C(-5.55f0 -8.82f0)))))
+	  (S1 #C(19.68f0 -5.55f0)))
       (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -118,19 +118,19 @@
 	  (S1 #C(19.68d0 -5.55d0)))
       (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(-1.1747805 -0.26507667 1.3326154))
+   (LIST #(-1.1747805f0 -0.26507667f0 1.3326154f0))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '((-34.5 8.24 3.29)
-	      (-8.93 34.12 -6.15)
-	      (49.27 -13.49 32.5))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0))))
 	  (V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '(42.73 -17.24 43.31)))
-	  (S1 -16.12))
+	    '(42.73f0 -17.24f0 43.31f0)))
+	  (S1 -16.12f0))
       (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -150,22 +150,22 @@
       (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #(#C(-1.1218005 0.24990065) #C(-0.7679142 -0.9143634)
-      #C(0.4927793 -0.0056687724)))
+    #(#C(-1.1218005f0 0.24990065f0) #C(-0.7679142f0 -0.9143634f0)
+      #C(0.4927793f0 -0.0056687724f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
 	  (V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))))
-	  (S1 #C(-16.12 -8.25)))
+	    '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0))))
+	  (S1 #C(-16.12f0 -8.25f0)))
       (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/lu.lisp b/tests/lu.lisp
index 2fd3573c78065b3c40cd4993f06f87fcdd32f400..cedc999a82a068f93603c4be15d1ed4ed01e2812 100644
--- a/tests/lu.lisp
+++ b/tests/lu.lisp
@@ -1,7 +1,7 @@
 ;; Regression test LU for GSLL, automatically generated
 ;; with some manual changes to the results
 ;;
-;; 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,7 +20,7 @@
 
 (in-package :gsl)
 
-;;; Answers (except for invert-matrix)inserted from linalg/test.c
+;;; Answers inserted from linalg/test.c
 ;;; GSL has #define GSL_DBL_EPSILON        2.2204460492503131e-16
 ;;; which is 2x what double-float-epsilon is.
 (LISP-UNIT:DEFINE-TEST LU
@@ -129,14 +129,4 @@
 	    (MATRIX-PRODUCT-TRIANGULAR
 	     MATRIX
 	     (MATRIX-PRODUCT-TRIANGULAR MATRIX X 1 :UPPER :NOTRANS :NONUNIT)
-	     1 :LOWER :NOTRANS :UNIT))))))))
-  (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-   (LIST
-    #2A((-1.9999999999999998d0 1.0d0)
-	(1.4999999999999998d0 -0.49999999999999994d0)))
-   (MULTIPLE-VALUE-LIST
-    (GRID:COPY-TO
-     (INVERT-MATRIX
-      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 2)
-			       :INITIAL-CONTENTS
-			       '((1.0d0 2.0d0) (3.0d0 4.0d0))))))))
+	     1 :LOWER :NOTRANS :UNIT)))))))))
diff --git a/tests/matrix-add.lisp b/tests/matrix-add.lisp
index 9bf89281739d5a1935d38149aef66eafabfe2f48..51c633c2d5f2a74cdf1a944c89ffb546f5aebe64 100644
--- a/tests/matrix-add.lisp
+++ b/tests/matrix-add.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-ADD for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,151 +19,151 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-ADD
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((8.23 -9.0 46.600002)
-                             (-25.050001 25.869999 15.290001)
-                             (0.18999863 -53.15 -16.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((8.229999999999997d0 -8.999999999999998d0 46.6d0)
-                             (-25.05d0 25.869999999999997d0
-                              15.290000000000001d0)
-                             (0.19000000000000483d0 -53.15d0 -16.96d0)))
-                        (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((-32 -40 101) (-54 -21 -18) (58 -27 -65)))
-                        (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((95 54 208) (144 85 101) (197 68 64)))
-                        (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((-32 -40 101) (-54 -21 -18) (58 -27 191)))
-                        (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((95 54 208) (144 341 357) (197 324 320)))
-                        (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((-32 -40 101) (-54 -21 -18) (58 -27 191)))
-                        (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((95 54 208) (144 341 357) (197 324 320)))
-                        (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((-32 -40 101) (-54 -21 -18) (58 -27 191)))
-                        (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((95 54 208) (144 341 357) (197 324 320)))
-                        (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))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((8.23f0 -9.0f0 46.600002f0)
+	(-25.050001f0 25.869999f0 15.290001f0)
+	(0.18999863f0 -53.15f0 -16.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((8.229999999999997d0 -8.999999999999998d0 46.6d0)
+	(-25.05d0 25.869999999999997d0
+		  15.290000000000001d0)
+	(0.19000000000000483d0 -53.15d0 -16.96d0)))
+   (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((-32 -40 101) (-54 -21 -18) (58 -27 -65)))
+   (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((95 54 208) (144 85 101) (197 68 64)))
+   (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((-32 -40 101) (-54 -21 -18) (58 -27 191)))
+   (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((95 54 208) (144 341 357) (197 324 320)))
+   (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((-32 -40 101) (-54 -21 -18) (58 -27 191)))
+   (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((95 54 208) (144 341 357) (197 324 320)))
+   (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((-32 -40 101) (-54 -21 -18) (58 -27 191)))
+   (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((95 54 208) (144 341 357) (197 324 320)))
+   (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-div.lisp b/tests/matrix-div.lisp
index 5f7cd88ae2d07529fddd7af37ef26af8805d6709..f9ea4614867615d0f79ea3a2294aa6506e3c59ec 100644
--- a/tests/matrix-div.lisp
+++ b/tests/matrix-div.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-DIV 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,153 +19,153 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-DIV
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-0.8073953 -0.47795823 0.075963974)
-                             (0.5539702 -4.1357574 -0.28684703)
-                             (-1.0038712 0.3401412 -0.6570967)))
-                        (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((-0.8073952726421718d0 -0.4779582366589328d0
-                              0.07596398060494113d0)
-                             (0.553970223325062d0 -4.135757575757576d0
-                              -0.2868470149253731d0)
-                             (-1.0038712306438469d0 0.3401412002017146d0
-                              -0.6570966437525273d0)))
-                        (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((-2 -2 2) (-2 0 1) (-4 0 1)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (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((2 4 9) (4 0 0) (4 1 0)))
-                        (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((-2 -2 2) (-2 0 1) (-4 0 1)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (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((2 4 9) (4 0 0) (4 1 0)))
-                        (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((-2 -2 2) (-2 0 1) (-4 0 1)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (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((2 4 9) (4 0 0) (4 1 0)))
-                        (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((-2 -2 2) (-2 0 1) (-4 0 1)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (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((2 4 9) (4 0 0) (4 1 0)))
-                        (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))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-0.8073953f0 -0.47795823f0 0.075963974f0)
+	(0.5539702f0 -4.1357574f0 -0.28684703f0)
+	(-1.0038712f0 0.3401412f0 -0.6570967f0)))
+   (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((-0.8073952726421718d0 -0.4779582366589328d0
+			       0.07596398060494113d0)
+	(0.553970223325062d0 -4.135757575757576d0
+			     -0.2868470149253731d0)
+	(-1.0038712306438469d0 0.3401412002017146d0
+			       -0.6570966437525273d0)))
+   (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((-2 -2 2) (-2 0 1) (-4 0 1)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (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((2 4 9) (4 0 0) (4 1 0)))
+   (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((-2 -2 2) (-2 0 1) (-4 0 1)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (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((2 4 9) (4 0 0) (4 1 0)))
+   (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((-2 -2 2) (-2 0 1) (-4 0 1)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (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((2 4 9) (4 0 0) (4 1 0)))
+   (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((-2 -2 2) (-2 0 1) (-4 0 1)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (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((2 4 9) (4 0 0) (4 1 0)))
+   (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-max-index.lisp b/tests/matrix-max-index.lisp
index 56584303f6d505dae72507acde90073643c3a837..da899628ac263aacadd61e182af27bba0e219023 100644
--- a/tests/matrix-max-index.lisp
+++ b/tests/matrix-max-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-MAX-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,150 +19,140 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-MAX-INDEX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-34.5
-                                                                      8.24
-                                                                      3.29)
-                                                                     (-8.93
-                                                                      34.12
-                                                                      -6.15)
-                                                                     (49.27
-                                                                      -13.49
-                                                                      32.5)))))
-                                                             (MAX-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 0)
-                                                          (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)))))
-                                                             (MAX-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MAX-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MAX-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MAX-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MAX-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MAX-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MAX-INDEX M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MAX-INDEX M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MAX-INDEX M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 2 0)
+   (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)))))
+	 (MAX-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 2 0)
+   (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)))))
+	 (MAX-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MAX-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MAX-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MAX-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MAX-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MAX-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MAX-INDEX M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MAX-INDEX M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MAX-INDEX M1)))))
 
diff --git a/tests/matrix-max.lisp b/tests/matrix-max.lisp
index 30e64b5dc6e6d8b71409d10ec63ea7de2e0dd3e8..8ae559f9c419890b26563dc5bb3f918281ec4603 100644
--- a/tests/matrix-max.lisp
+++ b/tests/matrix-max.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-MAX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,150 +19,140 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-MAX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 49.27)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-34.5
-                                                                      8.24
-                                                                      3.29)
-                                                                     (-8.93
-                                                                      34.12
-                                                                      -6.15)
-                                                                     (49.27
-                                                                      -13.49
-                                                                      32.5)))))
-                                                             (MMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 49.27d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'DOUBLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-34.5d0
-                                                                      8.24d0
-                                                                      3.29d0)
-                                                                     (-8.93d0
-                                                                      34.12d0
-                                                                      -6.15d0)
-                                                                     (49.27d0
-                                                                      -13.49d0
-                                                                      32.5d0)))))
-                                                             (MMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MMAX M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MMAX M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MMAX M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 49.27f0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'SINGLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '((-34.5f0 8.24f0 3.29f0)
+		 (-8.93f0 34.12f0 -6.15f0)
+		 (49.27f0 -13.49f0 32.5f0)))))
+	 (MMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 49.27d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '((-34.5d0 8.24d0 3.29d0)
+		 (-8.93d0 34.12d0 -6.15d0)
+		 (49.27d0 -13.49d0 32.5d0)))))
+	 (MMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MMAX M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MMAX M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MMAX M1)))))
 
diff --git a/tests/matrix-mean.lisp b/tests/matrix-mean.lisp
index 481ca69878ed37e2b634572101e9eff31d60b85f..be183897625d19b73f7691522ac2e58cd1942b48 100644
--- a/tests/matrix-mean.lisp
+++ b/tests/matrix-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-MEAN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,123 +19,123 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 7.149999883439806d0)
-                        (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)))))
-                           (MEAN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7.15d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'DOUBLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-34.5d0
-                                                                      8.24d0
-                                                                      3.29d0)
-                                                                     (-8.93d0
-                                                                      34.12d0
-                                                                      -6.15d0)
-                                                                     (49.27d0
-                                                                      -13.49d0
-                                                                      32.5d0)))))
-                                                             (MEAN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MEAN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 132.55555555555554d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (MEAN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MEAN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 132.55555555555554d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (MEAN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MEAN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 132.55555555555554d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (MEAN M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MEAN M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 132.55555555555554d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (MEAN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 7.149999883439806d0)
+   (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)))))
+	 (MEAN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7.15d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 'DOUBLE-FLOAT
+						 :INITIAL-CONTENTS
+						 '((-34.5d0
+						    8.24d0
+						    3.29d0)
+						   (-8.93d0
+						    34.12d0
+						    -6.15d0)
+						   (49.27d0
+						    -13.49d0
+						    32.5d0)))))
+					   (MEAN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MEAN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 132.55555555555554d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (MEAN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MEAN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 132.55555555555554d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (MEAN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MEAN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 132.55555555555554d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (MEAN M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MEAN M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 132.55555555555554d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (MEAN M1)))))
 
diff --git a/tests/matrix-min-index.lisp b/tests/matrix-min-index.lisp
index 28caea195bc96f5ce85ee89f458908354a79e810..882876e51683124854090e5a805fe6450b8039ce 100644
--- a/tests/matrix-min-index.lisp
+++ b/tests/matrix-min-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-MIN-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,150 +19,140 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-MIN-INDEX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-34.5
-                                                                      8.24
-                                                                      3.29)
-                                                                     (-8.93
-                                                                      34.12
-                                                                      -6.15)
-                                                                     (49.27
-                                                                      -13.49
-                                                                      32.5)))))
-                                                             (MIN-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0)
-                                                          (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)))))
-                                                             (MIN-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MIN-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MIN-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MIN-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MIN-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MIN-INDEX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MIN-INDEX M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MIN-INDEX M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MIN-INDEX M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 0 0)
+   (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)))))
+	 (MIN-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 0 0)
+   (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)))))
+	 (MIN-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MIN-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MIN-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MIN-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MIN-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MIN-INDEX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MIN-INDEX M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MIN-INDEX M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MIN-INDEX M1)))))
 
diff --git a/tests/matrix-min.lisp b/tests/matrix-min.lisp
index e0fd59f895790e10f3b09bf1cda0ce1f7ee0ad06..4c7f7734251773dc56b84027da6abbf2c544dbd9 100644
--- a/tests/matrix-min.lisp
+++ b/tests/matrix-min.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-MIN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,150 +19,140 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-MIN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-34.5
-                                                                      8.24
-                                                                      3.29)
-                                                                     (-8.93
-                                                                      34.12
-                                                                      -6.15)
-                                                                     (49.27
-                                                                      -13.49
-                                                                      32.5)))))
-                                                             (MMIN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'DOUBLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-34.5d0
-                                                                      8.24d0
-                                                                      3.29d0)
-                                                                     (-8.93d0
-                                                                      34.12d0
-                                                                      -6.15d0)
-                                                                     (49.27d0
-                                                                      -13.49d0
-                                                                      32.5d0)))))
-                                                             (MMIN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MMIN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MMIN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MMIN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MMIN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MMIN M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MMIN M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MMIN M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MMIN M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST -34.5f0)
+   (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)))))
+	 (MMIN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST -34.5d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '((-34.5d0 8.24d0 3.29d0)
+		 (-8.93d0 34.12d0 -6.15d0)
+		 (49.27d0 -13.49d0 32.5d0)))))
+	 (MMIN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MMIN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MMIN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MMIN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MMIN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MMIN M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MMIN M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MMIN M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MMIN M1)))))
 
diff --git a/tests/matrix-minmax-index.lisp b/tests/matrix-minmax-index.lisp
index 960d408ce14de5ecfbee69a5833af51a37a89c55..8cc4626609e103ae1b24e66ea40e8ed74e1f1b02 100644
--- a/tests/matrix-minmax-index.lisp
+++ b/tests/matrix-minmax-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-MINMAX-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009,  2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,160 +19,155 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-MINMAX-INDEX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0 2 0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-34.5
-                                                                      8.24
-                                                                      3.29)
-                                                                     (-8.93
-                                                                      34.12
-                                                                      -6.15)
-                                                                     (49.27
-                                                                      -13.49
-                                                                      32.5)))))
-                                                             (MINMAX-INDEX
-                                                              M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0 2 0)
-                                                          (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)))))
-                                                             (MINMAX-INDEX
-                                                              M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MINMAX-INDEX
-                                                              M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MINMAX-INDEX
-                                                              M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MINMAX-INDEX
-                                                              M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MINMAX-INDEX
-                                                              M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MINMAX-INDEX
-                                                              M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MINMAX-INDEX
-                                                              M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MINMAX-INDEX
-                                                              M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MINMAX-INDEX
-                                                              M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 0 0 2 0)
+   (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)))))
+	 (MINMAX-INDEX
+	  M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0 2 0)
+				     (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)))))
+					   (MINMAX-INDEX
+					    M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MINMAX-INDEX
+					    M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MINMAX-INDEX
+					    M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MINMAX-INDEX
+					    M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MINMAX-INDEX
+					    M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MINMAX-INDEX
+					    M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MINMAX-INDEX
+					    M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MINMAX-INDEX
+					    M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MINMAX-INDEX
+					    M1)))))
 
diff --git a/tests/matrix-minmax.lisp b/tests/matrix-minmax.lisp
index 6e23b21c953a5188a620d1da3cfceb1e694e07e6..d6959d0092d6c63d477bf45b666a97427d6f6c5f 100644
--- a/tests/matrix-minmax.lisp
+++ b/tests/matrix-minmax.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-MINMAX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,143 +19,140 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-MINMAX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5 49.27)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-34.5
-                                                                      8.24
-                                                                      3.29)
-                                                                     (-8.93
-                                                                      34.12
-                                                                      -6.15)
-                                                                     (49.27
-                                                                      -13.49
-                                                                      32.5)))))
-                                                             (MINMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST -34.5d0 49.27d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0)))))
-                           (MINMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MINMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MINMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MINMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MINMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MINMAX M1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MINMAX M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((-64 -68
-                                                                      71)
-                                                                     (-91 52
-                                                                      -10)
-                                                                     (73 -5
-                                                                      123)))))
-                                                             (MINMAX M1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((M1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '((67 44
-                                                                      189)
-                                                                     (116 163
-                                                                      140)
-                                                                     (161 215
-                                                                      98)))))
-                                                             (MINMAX M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST -34.5f0 49.27f0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'SINGLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '((-34.5f0 8.24f0 3.29f0)
+		 (-8.93f0 34.12f0 -6.15f0)
+		 (49.27f0 -13.49f0 32.5f0)))))
+	 (MINMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST -34.5d0 49.27d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '((-34.5d0 8.24d0 3.29d0)
+		 (-8.93d0 34.12d0 -6.15d0)
+		 (49.27d0 -13.49d0 32.5d0)))))
+	 (MINMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MINMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MINMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MINMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MINMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MINMAX M1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MINMAX M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((-64 -68
+						    71)
+						   (-91 52
+						    -10)
+						   (73 -5
+						    123)))))
+					   (MINMAX M1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((M1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '((67 44
+						    189)
+						   (116 163
+						    140)
+						   (161 215
+						    98)))))
+					   (MINMAX M1)))))
 
diff --git a/tests/matrix-mult.lisp b/tests/matrix-mult.lisp
index 2778d32a5dd6783ed4db3dd45ee97f20ea56a36b..d38672fe01d0d6f4a58f599b2c5f8eba71af0ba6 100644
--- a/tests/matrix-mult.lisp
+++ b/tests/matrix-mult.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-MULT for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,169 +19,171 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST MATRIX-MULT
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-1474.1849 -142.05759 142.4899)
-                             (143.95161 -281.49 -131.856)
-                             (-2418.1716 535.01337 -1607.45)))
-                        (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((-1474.185d0 -142.05759999999998d0 142.4899d0)
-                             (143.9516d0 -281.48999999999995d0
-                              -131.85600000000002d0)
-                             (-2418.1716d0 535.0133999999999d0 -1607.45d0)))
-                        (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((0 -112 82) (-39 44 80) (-71 110 -84)))
-                        (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((84 184 7) (176 86 172) (164 139 252)))
-                        (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((-2048 -1904 2130)
-                             (-3367 -3796 80)
-                             (-1095 110 8364)))
-                        (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((1876 440 3591)
-                             (3248 29014 30380)
-                             (5796 23435 21756)))
-                        (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((-2048 -1904 2130)
-                             (-3367 -3796 80)
-                             (-1095 110 8364)))
-                        (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((1876 440 3591)
-                             (3248 29014 30380)
-                             (5796 23435 21756)))
-                        (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((-2048 -1904 2130)
-                             (-3367 -3796 80)
-                             (-1095 110 8364)))
-                        (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((1876 440 3591)
-                             (3248 29014 30380)
-                             (5796 23435 21756)))
-                        (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))))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-1474.1849f0 -142.05759f0 142.4899f0)
+	(143.95161f0 -281.49f0 -131.856f0)
+	(-2418.1716f0 535.01337f0 -1607.45f0)))
+   (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((-1474.185d0 -142.05759999999998d0 142.4899d0)
+	(143.9516d0 -281.48999999999995d0
+		    -131.85600000000002d0)
+	(-2418.1716d0 535.0133999999999d0 -1607.45d0)))
+   (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((0 -112 82) (-39 44 80) (-71 110 -84)))
+   (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((84 184 7) (176 86 172) (164 139 252)))
+   (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((-2048 -1904 2130)
+	(-3367 -3796 80)
+	(-1095 110 8364)))
+   (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((1876 440 3591)
+	(3248 29014 30380)
+	(5796 23435 21756)))
+   (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((-2048 -1904 2130)
+	(-3367 -3796 80)
+	(-1095 110 8364)))
+   (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((1876 440 3591)
+	(3248 29014 30380)
+	(5796 23435 21756)))
+   (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((-2048 -1904 2130)
+	(-3367 -3796 80)
+	(-1095 110 8364)))
+   (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((1876 440 3591)
+	(3248 29014 30380)
+	(5796 23435 21756)))
+   (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-product-nonsquare.lisp b/tests/matrix-product-nonsquare.lisp
index 451928f1b14e5a1b0bc051f07a28472b0b43a56c..d8a28910fe7c35ed5d07a5338f2a768184a7e974 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 bab6003626a9d729e4e72150e295eb4714ece2a8..92c9560ff515ebfbc684e37b7d1a689f790bd84a 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 8b6131ead4861dcd73794cf64e19ce3f5fdcd7ea..db48373800a5301f10f9d3a53f04cbadc321d53e 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-product.lisp b/tests/matrix-product.lisp
index 9f09852f3c1c64626d1a761c6ee9d8cdaed1344d..3dde525ff22793294160406fe288273b43dd7d15 100644
--- a/tests/matrix-product.lisp
+++ b/tests/matrix-product.lisp
@@ -1,6 +1,6 @@
 ;; Regression test MATRIX-PRODUCT for GSLL, automatically generated
 ;;
-;; Copyright 2009, 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,92 +21,92 @@
 (LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((74519.41 -16747.695 61311.69)
-	(27307.273 -6133.5903 -25711.75)
-	(-29088.719 83072.016 -11019.719)))
+    #2A((74519.41f0 -16747.695f0 61311.69f0)
+	(27307.273f0 -6133.5903f0 -25711.75f0)
+	(-29088.719f0 83072.016f0 -11019.719f0)))
    (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 M1 M2 M3 S1 S2)))))
+       (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 M1 M2 M3 S1 S2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((74519.41329d0 -16747.696061999995d0 61311.694176d0)
 	(27307.276670999996d0 -6133.589574d0 -25711.752344999997d0)
 	(-29088.718053000033d0 83072.022741d0 -11019.721527000016d0)))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'DOUBLE-FLOAT :INITIAL-CONTENTS
-	    '((-34.5d0 8.24d0 3.29d0)
-	      (-8.93d0 34.12d0 -6.15d0)
-	      (49.27d0 -13.49d0 32.5d0))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'DOUBLE-FLOAT :INITIAL-CONTENTS
-	    '((42.73d0 -17.24d0 43.31d0)
-	      (-16.12d0 -8.25d0 21.44d0)
-	      (-49.08d0 -39.66d0 -49.46d0))))
-	  (M3
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'DOUBLE-FLOAT :INITIAL-CONTENTS
-	    '((19.68d0 -5.55d0 -8.82d0)
-	      (25.37d0 -30.58d0 31.67d0)
-	      (29.36d0 -33.24d0 -27.03d0))))
-	  (S1 -41.67d0)
-	  (S2 42.0d0))
-      (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
+       (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 M1 M2 M3 S1 S2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(140927.64 -143005.16) #C(72986.305 -201162.86)
-	   #C(65956.16 9034.215))
-	(#C(-102500.125 118033.82) #C(-147775.0 58489.473)
-	   #C(-9582.236 190719.98))
-	(#C(-16551.412 336505.22) #C(-7668.242 385798.25)
-	   #C(45313.527 140641.6))))
+    #2A((#C(140927.64f0 -143005.16f0) #C(72986.305f0 -201162.86f0)
+	   #C(65956.16f0 9034.215f0))
+	(#C(-102500.125f0 118033.82f0) #C(-147775.0f0 58489.473f0)
+	   #C(-9582.236f0 190719.98f0))
+	(#C(-16551.412f0 336505.22f0) #C(-7668.242f0 385798.25f0)
+	   #C(45313.527f0 140641.6f0))))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX SINGLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX SINGLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))
-	      (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
-	      (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82)))))
-	  (M3
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX SINGLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(19.68 -5.55) #C(-8.82 25.37) #C(-30.58 31.67))
-	      (#C(25.37 -30.58) #C(31.67 29.36) #C(-33.24 -27.03))
-	      (#C(29.36 -33.24) #C(-27.03 -41.67) #C(42.0 -20.81)))))
-	  (S1 #C(-41.67 42.0))
-	  (S2 #C(42.0 -20.81)))
-      (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
+       (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)))))
+	     (M3
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX SINGLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '((#C(19.68f0 -5.55f0) #C(-8.82f0 25.37f0) #C(-30.58f0 31.67f0))
+		 (#C(25.37f0 -30.58f0) #C(31.67f0 29.36f0) #C(-33.24f0 -27.03f0))
+		 (#C(29.36f0 -33.24f0) #C(-27.03f0 -41.67f0) #C(42.0f0 -20.81f0)))))
+	     (S1 #C(-41.67f0 42.0f0))
+	     (S2 #C(42.0f0 -20.81f0)))
+	 (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -120,98 +120,98 @@
 	   #C(-7668.248943000013d0 385798.22976300004d0)
 	   #C(45313.51313299998d0 140641.59851399998d0))))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX DOUBLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
-	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
-	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
-	  (M2
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX DOUBLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))
-	      (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
-	      (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0)))))
-	  (M3
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX DOUBLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(19.68d0 -5.55d0) #C(-8.82d0 25.37d0) #C(-30.58d0 31.67d0))
-	      (#C(25.37d0 -30.58d0) #C(31.67d0 29.36d0) #C(-33.24d0 -27.03d0))
-	      (#C(29.36d0 -33.24d0) #C(-27.03d0 -41.67d0) #C(42.0d0 -20.81d0)))))
-	  (S1 #C(-41.67d0 42.0d0))
-	  (S2 #C(42.0d0 -20.81d0)))
-      (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX DOUBLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+		 (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+		 (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX DOUBLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '((#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))
+		 (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
+		 (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0)))))
+	     (M3
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX DOUBLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '((#C(19.68d0 -5.55d0) #C(-8.82d0 25.37d0) #C(-30.58d0 31.67d0))
+		 (#C(25.37d0 -30.58d0) #C(31.67d0 29.36d0) #C(-33.24d0 -27.03d0))
+		 (#C(29.36d0 -33.24d0) #C(-27.03d0 -41.67d0) #C(42.0d0 -20.81d0)))))
+	     (S1 #C(-41.67d0 42.0d0))
+	     (S2 #C(42.0d0 -20.81d0)))
+	 (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(72971.1 60998.137 -184676.98))
+   (LIST #(72971.1f0 60998.137f0 -184676.98f0))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '((-34.5 8.24 3.29)
-	      (-8.93 34.12 -6.15)
-	      (49.27 -13.49 32.5))))
-	  (V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '(42.73 -17.24 43.31)))
-	  (V2
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '(-16.12 -8.25 21.44)))
-	  (S1 -49.08)
-	  (S2 -39.66))
-      (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
+       (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)))
+	     (V2
+	      (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 M1 V1 V2 S1 S2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(72971.10171599999d0 60998.13393599999d0
       -184676.981676d0))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'DOUBLE-FLOAT :INITIAL-CONTENTS
-	    '((-34.5d0 8.24d0 3.29d0)
-	      (-8.93d0 34.12d0 -6.15d0)
-	      (49.27d0 -13.49d0 32.5d0))))
-	  (V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'DOUBLE-FLOAT :INITIAL-CONTENTS
-	    '(42.73d0 -17.24d0 43.31d0)))
-	  (V2
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'DOUBLE-FLOAT :INITIAL-CONTENTS
-	    '(-16.12d0 -8.25d0 21.44d0)))
-	  (S1 -49.08d0)
-	  (S2 -39.66d0))
-      (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT :INITIAL-CONTENTS
+	       '((-34.5d0 8.24d0 3.29d0)
+		 (-8.93d0 34.12d0 -6.15d0)
+		 (49.27d0 -13.49d0 32.5d0))))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT :INITIAL-CONTENTS
+	       '(42.73d0 -17.24d0 43.31d0)))
+	     (V2
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT :INITIAL-CONTENTS
+	       '(-16.12d0 -8.25d0 21.44d0)))
+	     (S1 -49.08d0)
+	     (S2 -39.66d0))
+	 (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #(#C(124163.57 -3332.2988) #C(119793.48 -166378.0)
-      #C(-189845.23 -81764.12)))
+    #(#C(124163.57f0 -3332.2988f0) #C(119793.48f0 -166378.0f0)
+      #C(-189845.23f0 -81764.12f0)))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX SINGLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
-	  (V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX SINGLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))))
-	  (V2
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX SINGLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '(#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))))
-	  (S1 #C(-49.08 -39.66))
-	  (S2 #C(-39.66 -49.46)))
-      (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
+       (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)))))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX SINGLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0))))
+	     (V2
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX SINGLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '(#C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0))))
+	     (S1 #C(-49.08f0 -39.66f0))
+	     (S2 #C(-39.66f0 -49.46f0)))
+	 (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -219,23 +219,23 @@
       #C(119793.47618999999d0 -166378.00423d0)
       #C(-189845.21679399998d0 -81764.10481799999d0)))
    (MULTIPLE-VALUE-LIST
-    (LET ((M1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX DOUBLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
-	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
-	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
-	  (V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX DOUBLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))))
-	  (V2
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX DOUBLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '(#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))))
-	  (S1 #C(-49.08d0 -39.66d0))
-	  (S2 #C(-39.66d0 -49.46d0)))
-      (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2))))))
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX DOUBLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
+		 (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
+		 (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX DOUBLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))))
+	     (V2
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX DOUBLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '(#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))))
+	     (S1 #C(-49.08d0 -39.66d0))
+	     (S2 #C(-39.66d0 -49.46d0)))
+	 (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2))))))
diff --git a/tests/matrix-set-all.lisp b/tests/matrix-set-all.lisp
index 0cf3ffdf39a3d2d4602b6a4d92f2e9c63b50adde..e87e73c13c2b457c31bbeca14f97eff8cc2dcda1 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 404839e6e55c9016f4637a6fb3f19e922beb5cef..a4ac57c4197a42ec6561f27d07e7b9fe98e44671 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 5d828d61f5995a64a8531673d6b48523fb7b4baf..990c48a0f54da54d2a0bf6ea025ddef869e32499 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 a89173a272fef59a4a3ab78ceca4e42ecaa0d18c..3112a4026075b5ee7a6be3f7991bb707fdf74a80 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 f03008bcc9c3460143d987466006ce755eac2b06..e0409c367d8fb5420e6e1c5ada8b44bfe91f5446 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 f34a2da4e905f6bd89cf6e248f3d54d9a67d0e8f..8b1421d72b3de0b5e8845b838489e35da26cbff2 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 7102432173be4c9537c71088bffd74a3291dbcde..d204d7f2966b972ef1d2f0e159bb909a8ef3c1cb 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 181803c49f793639d1a66a596401a3b0df6add29..1c5c094372a6f04399969f64b76f184d0b6fe3c9 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 78013e6fe8225ded4bf5d291adce35919484b7bd..b2407770a4bdf025add16a8217c3ab2f2248aeb4 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 6c66e156cbbc27dec7b7b3bd0a9613dd3031a31b..018852e0168bad94425277c7e48ef5aebc2f3ed6 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 4c376ae3105d17a81b6e19c5ace9251eb31a5e94..ec72c61800e129ea85ea48e9fdd0c910d3250f03 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 db95eafb16798d294dee4a77355f299425a0864b..c5744bd7880ac32126d46d6fdda295895c6821e2 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)))))
 
diff --git a/tests/permutation.lisp b/tests/permutation.lisp
index 435f0eb7b96ad6043114d36b043bc104f9e68b5e..a6ee02a9d420a60611b7613ee10f8c92355ebc8d 100644
--- a/tests/permutation.lisp
+++ b/tests/permutation.lisp
@@ -23,7 +23,7 @@
    (LIST 2)
    (MULTIPLE-VALUE-LIST
     (LET ((PERM-1 (MAKE-PERMUTATION 4 T)))
-      (grid:gref PERM-1 2))))
+      (grid:aref PERM-1 2))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 1 2 3))
    (MULTIPLE-VALUE-LIST
diff --git a/tests/rank-1-update.lisp b/tests/rank-1-update.lisp
index 0214352f4611da05f26312aa362b7cdf0e523346..b522c047dd2d71ebe035ffa1259f39187c462b4b 100644
--- a/tests/rank-1-update.lisp
+++ b/tests/rank-1-update.lisp
@@ -1,26 +1,42 @@
 ;; Regression test RANK-1-UPDATE for GSLL, automatically generated
+;;
+;; Copyright 2009, 2011 Liam M. Healy
+;; Distributed under the terms of the GNU General Public License
+;;
+;; This program is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+;;
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST RANK-1-UPDATE
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((33772.18 17310.045 -44960.434)
-	(-13648.694 -6946.5283 18135.074)
-	(34314.832 17523.164 -45541.547)))
+    #2A((33772.18f0 17310.045f0 -44960.434f0)
+	(-13648.694f0 -6946.5283f0 18135.074f0)
+	(34314.832f0 17523.164f0 -45541.547f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '((-34.5 8.24 3.29)
-	      (-8.93 34.12 -6.15)
-	      (49.27 -13.49 32.5))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0))))
 	  (V1
-	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(42.73 -17.24 43.31)))
+	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(42.73f0 -17.24f0 43.31f0)))
 	  (V2
-	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-16.12 -8.25 21.44)))
-	  (S1 -49.08))
+	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-16.12f0 -8.25f0 21.44f0)))
+	  (S1 -49.08f0))
       (GRID:COPY-TO (RANK-1-UPDATE S1 V1 V2 M1)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -43,31 +59,31 @@
       (GRID:COPY-TO (RANK-1-UPDATE S1 V1 V2 M1)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(37793.65 36629.23) #C(-101265.76 118286.42)
-	   #C(68357.26 171191.28))
-	(#C(36918.79 37780.418) #C(-104760.06 115889.945)
-	   #C(63820.45 173533.31))
-	(#C(-26166.797 1319.2356) #C(-8642.514 -77109.22)
-	   #C(-85661.76 -33283.21))))
+    #2A((#C(37793.65f0 36629.23f0) #C(-101265.76f0 118286.42f0)
+	   #C(68357.26f0 171191.28f0))
+	(#C(36918.79f0 37780.418f0) #C(-104760.06f0 115889.945f0)
+	   #C(63820.45f0 173533.31f0))
+	(#C(-26166.797f0 1319.2356f0) #C(-8642.514f0 -77109.22f0)
+	   #C(-85661.76f0 -33283.21f0))))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
 	  (V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))))
+	    '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0))))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))))
-	  (S1 #C(-49.08 -39.66)))
+	    '(#C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0))))
+	  (S1 #C(-49.08f0 -39.66f0)))
       (GRID:COPY-TO (RANK-1-UPDATE S1 V1 V2 M1)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/row.lisp b/tests/row.lisp
index abda2bbb8deafbe8ddf34699e71e14d32cc86a46..9440c8dc446c434df00844fb6938453d87f72b18 100644
--- a/tests/row.lisp
+++ b/tests/row.lisp
@@ -1,6 +1,6 @@
 ;; Regression test ROW for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,15 +20,15 @@
 
 (LISP-UNIT:DEFINE-TEST ROW
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(-8.93 34.12 -6.15))
+   (LIST #(-8.93f0 34.12f0 -6.15f0))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '((-34.5 8.24 3.29)
-	      (-8.93 34.12 -6.15)
-	      (49.27 -13.49 32.5))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0))))
 	  (ROW (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
       (GRID:COPY-TO (ROW M1 1 ROW)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -45,15 +45,15 @@
       (GRID:COPY-TO (ROW M1 1 ROW)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)))
+    #(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
 	  (ROW
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3)))
diff --git a/tests/scale.lisp b/tests/scale.lisp
index 5055a6c9c217bb68766ff0c1bd0777774603945e..4826c303e24e7374c71cba40f99a11bfbaa5e7a7 100644
--- a/tests/scale.lisp
+++ b/tests/scale.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SCALE for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -21,19 +21,19 @@
 (LISP-UNIT:DEFINE-TEST SCALE
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #(#C(-1121.25 267.8) #C(106.924995 -290.225)
-      #C(1108.9 -199.875) #C(1601.275 -438.425)
-      #C(1056.25 1388.725) #C(-560.3 1407.5751)
-      #C(-523.9 -268.125) #C(696.8 -1595.1001)))
+    #(#C(-1121.25f0 267.8f0) #C(106.924995f0 -290.225f0)
+      #C(1108.9f0 -199.875f0) #C(1601.275f0 -438.425f0)
+      #C(1056.25f0 1388.725f0) #C(-560.3f0 1407.5751f0)
+      #C(-523.9f0 -268.125f0) #C(696.8f0 -1595.1001f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)
-	      #C(49.27 -13.49) #C(32.5 42.73)
-	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))
-	  (SCALAR 32.5))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)
+	      #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	      #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))
+	  (SCALAR 32.5f0))
       (GRID:COPY-TO (SCALE SCALAR V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -54,14 +54,14 @@
 	  (SCALAR 32.5d0))
       (GRID:COPY-TO (SCALE SCALAR V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(-1121.25 267.8 106.924995 -290.225 1108.9 -199.875 1601.275 -438.425))
+   (LIST #(-1121.25f0 267.8f0 106.924995f0 -290.225f0 1108.9f0 -199.875f0 1601.275f0 -438.425f0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)))
-	  (SCALAR 32.5))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))
+	  (SCALAR 32.5f0))
       (GRID:COPY-TO (SCALE SCALAR V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -79,19 +79,19 @@
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #(#C(-1473.3452 -1206.385) #C(488.5039 -149.64331)
-      #C(1371.6895 1258.0725) #C(2177.7026 1666.8821)
-      #C(-769.6029 2777.45) #C(-2410.9363 670.9099)
-      #C(-171.37753 -956.9326) #C(2793.9885 -678.9689)))
+    #(#C(-1473.3452f0 -1206.385f0) #C(488.5039f0 -149.64331f0)
+      #C(1371.6895f0 1258.0725f0) #C(2177.7026f0 1666.8821f0)
+      #C(-769.6029f0 2777.45f0) #C(-2410.9363f0 670.9099f0)
+      #C(-171.37753f0 -956.9326f0) #C(2793.9885f0 -678.9689f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)
-	      #C(49.27 -13.49) #C(32.5 42.73)
-	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))
-	  (SCALAR #C(32.5 42.73)))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)
+	      #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	      #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))
+	  (SCALAR #C(32.5f0 42.73f0)))
       (GRID:COPY-TO (SCALE SCALAR V1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/set-basis.lisp b/tests/set-basis.lisp
index ab80bdf3d26a56eaf65408a646e6c4645a3a0bcb..3571e72b05fed0db43413cf5c2c7eb8a7f9d2c5f 100644
--- a/tests/set-basis.lisp
+++ b/tests/set-basis.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SET-BASIS for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,13 +20,13 @@
 
 (LISP-UNIT:DEFINE-TEST SET-BASIS
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0))
+   (LIST #(0.0f0 0.0f0 1.0f0 0.0f0 0.0f0 0.0f0 0.0f0 0.0f0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
       (SET-BASIS V1 2)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -42,16 +42,16 @@
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #(#C(0.0 0.0) #C(0.0 0.0) #C(1.0 0.0) #C(0.0 0.0)
-      #C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0)))
+    #(#C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(1.0f0 0.0f0) #C(0.0f0 0.0f0)
+      #C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(0.0f0 0.0f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93)
-	      #C(34.12 -6.15) #C(49.27 -13.49) #C(32.5 42.73)
-	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0)
+	      #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	      #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))))
       (SET-BASIS V1 2)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/set-identity.lisp b/tests/set-identity.lisp
index 97e06458ea1636decc64fbf511b64cc9f12a385e..d2b401db65688c36e4197cfa2697767d4f746416 100644
--- a/tests/set-identity.lisp
+++ b/tests/set-identity.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SET-IDENTITY for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,15 +20,15 @@
 
 (LISP-UNIT:DEFINE-TEST SET-IDENTITY
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #2A((1.0 0.0 0.0) (0.0 1.0 0.0) (0.0 0.0 1.0)))
+   (LIST #2A((1.0f0 0.0f0 0.0f0) (0.0f0 1.0f0 0.0f0) (0.0f0 0.0f0 1.0f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '((-34.5 8.24 3.29)
-	      (-8.93 34.12 -6.15)
-	      (49.27 -13.49 32.5)))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0)))))
       (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -46,17 +46,17 @@
       (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(1.0 0.0) #C(0.0 0.0) #C(0.0 0.0))
-	(#C(0.0 0.0) #C(1.0 0.0) #C(0.0 0.0))
-	(#C(0.0 0.0) #C(0.0 0.0) #C(1.0 0.0))))
+    #2A((#C(1.0f0 0.0f0) #C(0.0f0 0.0f0) #C(0.0f0 0.0f0))
+	(#C(0.0f0 0.0f0) #C(1.0f0 0.0f0) #C(0.0f0 0.0f0))
+	(#C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(1.0f0 0.0f0))))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))))
       (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/setf-column.lisp b/tests/setf-column.lisp
index 91b5ede0883a2b413dfb29090b35446c62787352..55a5691b3f0cb6baef7db0435205e4a41984eb8a 100644
--- a/tests/setf-column.lisp
+++ b/tests/setf-column.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SETF-COLUMN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -21,20 +21,20 @@
 (LISP-UNIT:DEFINE-TEST SETF-COLUMN
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((-34.5 8.24 42.73)
-	(-8.93 34.12 -17.24)
-	(49.27 -13.49 43.31)))
+    #2A((-34.5f0 8.24f0 42.73f0)
+	(-8.93f0 34.12f0 -17.24f0)
+	(49.27f0 -13.49f0 43.31f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '((-34.5 8.24 3.29)
-	      (-8.93 34.12 -6.15)
-	      (49.27 -13.49 32.5))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0))))
 	  (COL
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
-	    '(42.73 -17.24 43.31))))
+	    '(42.73f0 -17.24f0 43.31f0))))
       (SETF (COLUMN M1 2) COL)
       (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -57,22 +57,22 @@
       (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(42.73 -17.24))
-	(#C(-8.93 34.12) #C(-6.15 49.27) #C(43.31 -16.12))
-	(#C(49.27 -13.49) #C(32.5 42.73) #C(-8.25 21.44))))
+    #2A((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(42.73f0 -17.24f0))
+	(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(43.31f0 -16.12f0))
+	(#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-8.25f0 21.44f0))))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
 	  (COL
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44)))))
+	    '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)))))
       (SETF (COLUMN M1 2) COL)
       (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/setf-row.lisp b/tests/setf-row.lisp
index 688a0c9b45bf5cd8f2d44eaf553270a2124d01bd..a469859323742c5838dd42e6a4e7f362ee02bbcd 100644
--- a/tests/setf-row.lisp
+++ b/tests/setf-row.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SETF-ROW for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -21,21 +21,21 @@
 (LISP-UNIT:DEFINE-TEST SETF-ROW
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((-34.5 8.24 3.29)
-	(-8.93 34.12 -6.15)
-	(42.73 -17.24 43.31)))
+    #2A((-34.5f0 8.24f0 3.29f0)
+	(-8.93f0 34.12f0 -6.15f0)
+	(42.73f0 -17.24f0 43.31f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '((-34.5 8.24 3.29)
-	      (-8.93 34.12 -6.15)
-	      (49.27 -13.49 32.5))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0))))
 	  (ROW
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
-	    :INITIAL-CONTENTS '(42.73 -17.24 43.31))))
+	    :INITIAL-CONTENTS '(42.73f0 -17.24f0 43.31f0))))
       (SETF (ROW M1 2) ROW)
       (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -59,22 +59,21 @@
       (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	(#C(42.73 -17.24) #C(43.31 -16.12)
-	   #C(-8.25 21.44))))
+    #2A((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0))))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))
 	  (ROW
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
-	    :INITIAL-CONTENTS '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44)))))
+	    :INITIAL-CONTENTS '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)))))
       (SETF (ROW M1 2) ROW)
       (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/sort-matrix-largest.lisp b/tests/sort-matrix-largest.lisp
index e2c737000cf3e20eed1ba4e77f7b42cf353582be..0703f60320eed8f61c66481b80317279cf6ddf48 100644
--- a/tests/sort-matrix-largest.lisp
+++ b/tests/sort-matrix-largest.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-MATRIX-LARGEST for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,124 +19,126 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-MATRIX-LARGEST
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((49.27 34.12 32.5) (8.24 3.29 -6.15)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((49.27d0 34.12d0 32.5d0) (8.24d0 3.29d0 -6.15d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((123 73 71) (52 -5 -10)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((215 189 163) (161 140 116)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((123 73 71) (52 -5 -10)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((215 189 163) (161 140 116)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((123 73 71) (52 -5 -10)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((215 189 163) (161 140 116)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((123 73 71) (52 -5 -10)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((215 189 163) (161 140 116)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-LARGEST M2 M1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #2A((49.27f0 34.12f0 32.5f0) (8.24f0 3.29f0 -6.15f0)))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((M1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '((-34.5f0 8.24f0 3.29f0)
+		   (-8.93f0 34.12f0 -6.15f0)
+		   (49.27f0 -13.49f0 32.5f0))))
+	       (M2
+		(GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3))))
+	   (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((49.27d0 34.12d0 32.5d0) (8.24d0 3.29d0 -6.15d0)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '((-34.5d0 8.24d0 3.29d0)
+					 (-8.93d0 34.12d0 -6.15d0)
+					 (49.27d0 -13.49d0 32.5d0))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((123 73 71) (52 -5 -10)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((215 189 163) (161 140 116)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((123 73 71) (52 -5 -10)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((215 189 163) (161 140 116)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((123 73 71) (52 -5 -10)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((215 189 163) (161 140 116)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((123 73 71) (52 -5 -10)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((215 189 163) (161 140 116)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-LARGEST M2 M1))))))
 
diff --git a/tests/sort-matrix-smallest.lisp b/tests/sort-matrix-smallest.lisp
index 36e10a61e0cc82be7da37800d290e15bf437eefa..8e7ef7ad21daffb66bfbf9762ccdeccc2728aeaf 100644
--- a/tests/sort-matrix-smallest.lisp
+++ b/tests/sort-matrix-smallest.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-MATRIX-SMALLEST for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,125 +19,126 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-MATRIX-SMALLEST
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-34.5 -13.49 -8.93) (-6.15 3.29 8.24)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5d0 -13.49d0 -8.93d0)
-                             (-6.15d0 3.29d0 8.24d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98))))
-                               (M2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS
-                                             '(2 3))))
-                           (GRID:COPY-TO (SORT-SMALLEST M2 M1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #2A((-34.5f0 -13.49f0 -8.93f0) (-6.15f0 3.29f0 8.24f0)))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((M1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT :INITIAL-CONTENTS
+		 '((-34.5f0 8.24f0 3.29f0)
+		   (-8.93f0 34.12f0 -6.15f0)
+		   (49.27f0 -13.49f0 32.5f0))))
+	       (M2
+		(GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3))))
+	   (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5d0 -13.49d0 -8.93d0)
+	(-6.15d0 3.29d0 8.24d0)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '((-34.5d0 8.24d0 3.29d0)
+					 (-8.93d0 34.12d0 -6.15d0)
+					 (49.27d0 -13.49d0 32.5d0))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98))))
+	     (M2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS
+				       '(2 3))))
+	 (GRID:COPY-TO (SORT-SMALLEST M2 M1))))))
 
diff --git a/tests/sort-matrix.lisp b/tests/sort-matrix.lisp
index 90cb6129e372f995369d01e6e542819b3764e9e2..a79066b040721dab794259e1289ae8967feb790a 100644
--- a/tests/sort-matrix.lisp
+++ b/tests/sort-matrix.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-MATRIX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,101 +19,103 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-MATRIX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5 -13.49 -8.93)
-                             (-6.15 3.29 8.24)
-                             (32.5 34.12 49.27)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5 8.24 3.29)
-                                               (-8.93 34.12 -6.15)
-                                               (49.27 -13.49 32.5)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #2A((-34.5d0 -13.49d0 -8.93d0)
-                             (-6.15d0 3.29d0 8.24d0)
-                             (32.5d0 34.12d0 49.27d0)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '((-34.5d0 8.24d0 3.29d0)
-                                               (-8.93d0 34.12d0 -6.15d0)
-                                               (49.27d0 -13.49d0 32.5d0)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((-64 -68 71) (-91 52 -10)
-                                               (73 -5 123)))))
-                           (GRID:COPY-TO (MSORT M1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((M1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '((67 44 189) (116 163 140)
-                                               (161 215 98)))))
-                           (GRID:COPY-TO (MSORT M1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST
+      #2A((-34.5f0 -13.49f0 -8.93f0)
+	  (-6.15f0 3.29f0 8.24f0)
+	  (32.5f0 34.12f0 49.27f0)))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((M1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '((-34.5f0 8.24f0 3.29f0)
+		   (-8.93f0 34.12f0 -6.15f0)
+		   (49.27f0 -13.49f0 32.5f0)))))
+	   (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #2A((-34.5d0 -13.49d0 -8.93d0)
+	(-6.15d0 3.29d0 8.24d0)
+	(32.5d0 34.12d0 49.27d0)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '((-34.5d0 8.24d0 3.29d0)
+					 (-8.93d0 34.12d0 -6.15d0)
+					 (49.27d0 -13.49d0 32.5d0)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((-64 -68 71) (-91 52 -10)
+					 (73 -5 123)))))
+	 (GRID:COPY-TO (MSORT M1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
+   (MULTIPLE-VALUE-LIST
+       (LET ((M1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '((67 44 189) (116 163 140)
+					 (161 215 98)))))
+	 (GRID:COPY-TO (MSORT M1))))))
 
diff --git a/tests/sort-vector-index.lisp b/tests/sort-vector-index.lisp
index dd0dc70d438d623cfbf414356752a17ed0d593f0..16819a9aa29789cd5899627db93dcf61aa497f5f 100644
--- a/tests/sort-vector-index.lisp
+++ b/tests/sort-vector-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-VECTOR-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,106 +19,106 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-VECTOR-INDEX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(0 7 3 5 2 1 4 6))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(0 7 3 5 2 1 4 6))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(3 1 0 5 7 4 2 6))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(1 0 3 5 6 4 2 7))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(3 1 0 5 7 4 2 6))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(1 0 3 5 6 4 2 7))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(3 1 0 5 7 4 2 6))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(1 0 3 5 6 4 2 7))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(3 1 0 5 7 4 2 6))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(1 0 3 5 6 4 2 7))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((PERM (MAKE-PERMUTATION 8))
-                               (V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (SORT-VECTOR-INDEX PERM V1)
-                           (GRID:COPY-TO PERM)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(0 7 3 5 2 1 4 6))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((PERM (MAKE-PERMUTATION 8))
+	       (V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (SORT-VECTOR-INDEX PERM V1)
+	   (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(0 7 3 5 2 1 4 6))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(3 1 0 5 7 4 2 6))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(1 0 3 5 6 4 2 7))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(3 1 0 5 7 4 2 6))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(1 0 3 5 6 4 2 7))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(3 1 0 5 7 4 2 6))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(1 0 3 5 6 4 2 7))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(3 1 0 5 7 4 2 6))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(1 0 3 5 6 4 2 7))
+   (MULTIPLE-VALUE-LIST
+       (LET ((PERM (MAKE-PERMUTATION 8))
+	     (V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (SORT-VECTOR-INDEX PERM V1)
+	 (GRID:COPY-TO PERM)))))
 
diff --git a/tests/sort-vector-largest-index.lisp b/tests/sort-vector-largest-index.lisp
index 3e2c0e76c411e852421f7520b540967d1999b1d2..01d7bbaa163c3cfd524254943dea2081f8cf7af6 100644
--- a/tests/sort-vector-largest-index.lisp
+++ b/tests/sort-vector-largest-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-VECTOR-LARGEST-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,176 +19,170 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-VECTOR-LARGEST-INDEX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 4 1))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 4 1))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'DOUBLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5d0
-                                                                     8.24d0
-                                                                     3.29d0
-                                                                     -8.93d0
-                                                                     34.12d0
-                                                                     -6.15d0
-                                                                     49.27d0
-                                                                     -13.49d0))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST-INDEX
-                                                               COMB V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(6 4 1))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((COMB (MAKE-COMBINATION 8 3 NIL))
+	       (V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (GRID:COPY-TO
+	    (SORT-VECTOR-LARGEST-INDEX
+	     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 4 1))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 'DOUBLE-FLOAT
+						 :INITIAL-CONTENTS
+						 '(-34.5d0
+						   8.24d0
+						   3.29d0
+						   -8.93d0
+						   34.12d0
+						   -6.15d0
+						   49.27d0
+						   -13.49d0))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST-INDEX
+					     COMB V1))))))
 
diff --git a/tests/sort-vector-largest.lisp b/tests/sort-vector-largest.lisp
index 0b6fc92dcf549853201dc0a2d9da90e0dfc373f4..30b528f1d39c3a93490e1d691f744cd09a08a2e9 100644
--- a/tests/sort-vector-largest.lisp
+++ b/tests/sort-vector-largest.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-VECTOR-LARGEST for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,193 +19,194 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-VECTOR-LARGEST
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(49.27 34.12 8.24))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(32.5 42.73 -17.24))))
-                           (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(49.27d0 34.12d0 8.24d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(32.5d0 42.73d0 -17.24d0))))
-                           (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-LARGEST
-                                                               V2 V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(49.27f0 34.12f0 8.24f0))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))
+	       (V2
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(32.5f0 42.73f0 -17.24f0))))
+	   (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(49.27d0 34.12d0 8.24d0))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(-34.5d0 8.24d0 3.29d0 -8.93d0
+					 34.12d0 -6.15d0 49.27d0
+					 -13.49d0)))
+	     (V2
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(32.5d0 42.73d0 -17.24d0))))
+	 (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-LARGEST
+					     V2 V1))))))
 
diff --git a/tests/sort-vector-smallest-index.lisp b/tests/sort-vector-smallest-index.lisp
index 1aede641df89f116dc9fd61a5327354e0e3352d9..078279d0f41d0e2915053b212f388f1695df65aa 100644
--- a/tests/sort-vector-smallest-index.lisp
+++ b/tests/sort-vector-smallest-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-VECTOR-SMALLEST-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,176 +19,168 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-VECTOR-SMALLEST-INDEX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 7 3))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 7 3))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'DOUBLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5d0
-                                                                     8.24d0
-                                                                     3.29d0
-                                                                     -8.93d0
-                                                                     34.12d0
-                                                                     -6.15d0
-                                                                     49.27d0
-                                                                     -13.49d0))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((COMB
-                                                                  (MAKE-COMBINATION
-                                                                   8 3 NIL))
-                                                                 (V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST-INDEX
-                                                               COMB V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(0 7 3))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((COMB (MAKE-COMBINATION 8 3 NIL))
+	       (V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (GRID:COPY-TO (SORT-VECTOR-SMALLEST-INDEX COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 7 3))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 'DOUBLE-FLOAT
+						 :INITIAL-CONTENTS
+						 '(-34.5d0
+						   8.24d0
+						   3.29d0
+						   -8.93d0
+						   34.12d0
+						   -6.15d0
+						   49.27d0
+						   -13.49d0))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((COMB
+						(MAKE-COMBINATION
+						 8 3 NIL))
+					       (V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST-INDEX
+					     COMB V1))))))
 
diff --git a/tests/sort-vector-smallest.lisp b/tests/sort-vector-smallest.lisp
index 485b04c68fd7b231328fec5d3a44a289fd2f4f3d..99594965ac4ad8637861abbb3d009ffaa9ff3334 100644
--- a/tests/sort-vector-smallest.lisp
+++ b/tests/sort-vector-smallest.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-VECTOR-SMALLEST for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,193 +19,195 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-VECTOR-SMALLEST
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-34.5 -13.49 -8.93))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(32.5 42.73 -17.24))))
-                           (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-34.5d0 -13.49d0 -8.93d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(32.5d0 42.73d0 -17.24d0))))
-                           (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(123 32
-                                                                     28))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(98 28
-                                                                     10))))
-                                                             (GRID:COPY-TO
-                                                              (SORT-VECTOR-SMALLEST
-                                                               V2 V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(-34.5f0 -13.49f0 -8.93f0))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))
+	       (V2
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(32.5f0 42.73f0 -17.24f0))))
+	   (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-34.5d0 -13.49d0 -8.93d0))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(-34.5d0 8.24d0 3.29d0 -8.93d0
+					 34.12d0 -6.15d0 49.27d0
+					 -13.49d0)))
+	     (V2
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(32.5d0 42.73d0 -17.24d0))))
+	 (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(123 32
+						   28))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(98 28
+						   10))))
+					   (GRID:COPY-TO
+					    (SORT-VECTOR-SMALLEST
+					     V2 V1))))))
 
diff --git a/tests/sort-vector.lisp b/tests/sort-vector.lisp
index b101ffff7aad09d2799d5543c308ae90393b330c..deb0ad0f74e967f6da8ded50900a6a1eaaca6bc5 100644
--- a/tests/sort-vector.lisp
+++ b/tests/sort-vector.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SORT-VECTOR for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,89 +19,89 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST SORT-VECTOR
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-34.5 -13.49 -8.93 -6.15 3.29 8.24 34.12 49.27))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-34.5d0 -13.49d0 -8.93d0 -6.15d0 3.29d0 8.24d0
-                           34.12d0 49.27d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-91 -68 -64 -10 -5 52 71 73))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(44 67 116 140 161 163 189 215))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-91 -68 -64 -10 -5 52 71 73))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(44 67 116 140 161 163 189 215))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-91 -68 -64 -10 -5 52 71 73))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(44 67 116 140 161 163 189 215))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-91 -68 -64 -10 -5 52 71 73))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (GRID:COPY-TO (SORT-VECTOR V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(44 67 116 140 161 163 189 215))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (GRID:COPY-TO (SORT-VECTOR V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST
+      #(-34.5f0 -13.49f0 -8.93f0 -6.15f0 3.29f0 8.24f0 34.12f0 49.27f0))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(-34.5d0 -13.49d0 -8.93d0 -6.15d0 3.29d0 8.24d0
+      34.12d0 49.27d0))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(-34.5d0 8.24d0 3.29d0 -8.93d0
+					 34.12d0 -6.15d0 49.27d0
+					 -13.49d0))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-91 -68 -64 -10 -5 52 71 73))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(44 67 116 140 161 163 189 215))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-91 -68 -64 -10 -5 52 71 73))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(44 67 116 140 161 163 189 215))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-91 -68 -64 -10 -5 52 71 73))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(44 67 116 140 161 163 189 215))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(-91 -68 -64 -10 -5 52 71 73))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (SORT-VECTOR V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(44 67 116 140 161 163 189 215))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (SORT-VECTOR V1))))))
 
diff --git a/tests/swap-columns.lisp b/tests/swap-columns.lisp
index 58253aec9050987f1e7d01a045066108e24c0e08..93bf963d5209bce2ab3dd4f7d2c43e696472dba9 100644
--- a/tests/swap-columns.lisp
+++ b/tests/swap-columns.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SWAP-COLUMNS for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -21,17 +21,17 @@
 (LISP-UNIT:DEFINE-TEST SWAP-COLUMNS
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((-34.5 3.29 8.24)
-	(-8.93 -6.15 34.12)
-	(49.27 32.5 -13.49)))
+    #2A((-34.5f0 3.29f0 8.24f0)
+	(-8.93f0 -6.15f0 34.12f0)
+	(49.27f0 32.5f0 -13.49f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '((-34.5 8.24 3.29)
-	      (-8.93 34.12 -6.15)
-	      (49.27 -13.49 32.5)))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0)))))
       (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -49,18 +49,18 @@
       (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(-34.5 8.24) #C(34.12 -6.15) #C(3.29 -8.93))
-	(#C(-8.93 34.12) #C(-13.49 32.5) #C(-6.15 49.27))
-	(#C(49.27 -13.49) #C(-17.24 43.31)
-	   #C(32.5 42.73))))
+    #2A((#C(-34.5f0 8.24f0) #C(34.12f0 -6.15f0) #C(3.29f0 -8.93f0))
+	(#C(-8.93f0 34.12f0) #C(-13.49f0 32.5f0) #C(-6.15f0 49.27f0))
+	(#C(49.27f0 -13.49f0) #C(-17.24f0 43.31f0)
+	   #C(32.5f0 42.73f0))))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))))
       (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/swap-elements.lisp b/tests/swap-elements.lisp
index 1a1fa95d034d7fd06c100ddef1bd2f22628c6026..ef41c52d7d95b81becc125e83644624dae9603d6 100644
--- a/tests/swap-elements.lisp
+++ b/tests/swap-elements.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SWAP-ELEMENTS for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -21,13 +21,13 @@
 (LISP-UNIT:DEFINE-TEST SWAP-ELEMENTS
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #(-34.5 8.24 -6.15 -8.93 34.12 3.29 49.27 -13.49))
+    #(-34.5f0 8.24f0 -6.15f0 -8.93f0 34.12f0 3.29f0 49.27f0 -13.49f0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
+	    '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
       (SWAP-ELEMENTS V1 2 5)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -43,16 +43,16 @@
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #(#C(-34.5 8.24) #C(3.29 -8.93) #C(-17.24 43.31)
-      #C(49.27 -13.49) #C(32.5 42.73) #C(34.12 -6.15)
-      #C(-16.12 -8.25) #C(21.44 -49.08)))
+    #(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(-17.24f0 43.31f0)
+      #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(34.12f0 -6.15f0)
+      #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) #C(49.27 -13.49)
-	      #C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0)
+	      #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))))
       (SWAP-ELEMENTS V1 2 5)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/swap-row-column.lisp b/tests/swap-row-column.lisp
index 21863d94bff16e718299b83c01c671abdd553304..892973a63416f280bc32e6ff754fe25bc2af3ee9 100644
--- a/tests/swap-row-column.lisp
+++ b/tests/swap-row-column.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SWAP-ROW-COLUMN for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -21,17 +21,17 @@
 (LISP-UNIT:DEFINE-TEST SWAP-ROW-COLUMN
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((3.29 -6.15 32.5)
-	(-8.93 34.12 8.24)
-	(49.27 -13.49 -34.5)))
+    #2A((3.29f0 -6.15f0 32.5f0)
+	(-8.93f0 34.12f0 8.24f0)
+	(49.27f0 -13.49f0 -34.5f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '((-34.5 8.24 3.29)
-	      (-8.93 34.12 -6.15)
-	      (49.27 -13.49 32.5)))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0)))))
       (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -49,17 +49,17 @@
       (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(34.12 -6.15) #C(-13.49 32.5) #C(-17.24 43.31))
-	(#C(-8.93 34.12) #C(-6.15 49.27) #C(3.29 -8.93))
-	(#C(49.27 -13.49) #C(32.5 42.73) #C(-34.5 8.24))))
+    #2A((#C(34.12f0 -6.15f0) #C(-13.49f0 32.5f0) #C(-17.24f0 43.31f0))
+	(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(3.29f0 -8.93f0))
+	(#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-34.5f0 8.24f0))))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))))
       (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/swap-rows.lisp b/tests/swap-rows.lisp
index b2c80c339de811b92d22b4b8cfd5584e1433652a..ce11e4463d7b8c44d019e937be6fb6f0ccc7d20e 100644
--- a/tests/swap-rows.lisp
+++ b/tests/swap-rows.lisp
@@ -1,6 +1,6 @@
 ;; Regression test SWAP-ROWS for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -21,17 +21,17 @@
 (LISP-UNIT:DEFINE-TEST SWAP-ROWS
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((-8.93 34.12 -6.15)
-	(-34.5 8.24 3.29)
-	(49.27 -13.49 32.5)))
+    #2A((-8.93f0 34.12f0 -6.15f0)
+	(-34.5f0 8.24f0 3.29f0)
+	(49.27f0 -13.49f0 32.5f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS
-	    '((-34.5 8.24 3.29)
-	      (-8.93 34.12 -6.15)
-	      (49.27 -13.49 32.5)))))
+	    '((-34.5f0 8.24f0 3.29f0)
+	      (-8.93f0 34.12f0 -6.15f0)
+	      (49.27f0 -13.49f0 32.5f0)))))
       (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -49,18 +49,18 @@
       (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #2A((#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	(#C(49.27 -13.49) #C(32.5 42.73)
-	   #C(-17.24 43.31))))
+    #2A((#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	(#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+	   #C(-17.24f0 43.31f0))))
    (MULTIPLE-VALUE-LIST
     (LET ((M1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
-	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
+	    '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))
+	      (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+	      (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))))
       (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/vector-add.lisp b/tests/vector-add.lisp
index 1bd99ee9e67b12a8362ced38d6d927cc47524a8e..ea7a01643851e73e8a572cab1c89d7a17c9d22d2 100644
--- a/tests/vector-add.lisp
+++ b/tests/vector-add.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-ADD for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -22,14 +22,14 @@
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
     (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-		 '(-43.43 42.36 -2.8600001)))
+		 '(-43.43f0 42.36f0 -2.8600001f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-			'(-34.5 8.24 3.29)))
+			'(-34.5f0 8.24f0 3.29f0)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-			'(-8.93 34.12 -6.15))))
+			'(-8.93f0 34.12f0 -6.15f0))))
       (ELT+ V1 V2))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/vector-div.lisp b/tests/vector-div.lisp
index 0d628edd334cbb61f483262126f56152f9c2dabf..e05282e7d2027ad04bda4a49635e6b920f0be90a 100644
--- a/tests/vector-div.lisp
+++ b/tests/vector-div.lisp
@@ -20,14 +20,14 @@
 
 (LISP-UNIT:DEFINE-TEST VECTOR-DIV
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(3.8633816 0.24150059 -0.5349593))
+                        (LIST #(3.8633816f0 0.24150059f0 -0.5349593f0))
                         (MULTIPLE-VALUE-LIST
                          (LET ((V1
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29)))
+                                             '(-34.5f0 8.24f0 3.29f0)))
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93 34.12 -6.15))))
+                                             '(-8.93f0 34.12f0 -6.15f0))))
                            (GRID:COPY-TO (ELT/ V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
diff --git a/tests/vector-max-index.lisp b/tests/vector-max-index.lisp
index bf98bb0abc126af57f10bfcb4747445011acebea..fbf6199152421da6264f0e992b8a5f60040088c6 100644
--- a/tests/vector-max-index.lisp
+++ b/tests/vector-max-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MAX-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,126 +19,96 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-MAX-INDEX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'DOUBLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5d0
-                                                                     8.24d0
-                                                                     3.29d0
-                                                                     -8.93d0
-                                                                     34.12d0
-                                                                     -6.15d0
-                                                                     49.27d0
-                                                                     -13.49d0))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MAX-INDEX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MAX-INDEX V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MAX-INDEX V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MAX-INDEX V1)))))
-
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 6)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+	 (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 8)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 7)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 8)
+	       :INITIAL-CONTENTS
+	       '(67 44 189 116 163 140 161 215))))
+	 (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 16)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 7)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 16)
+	       :INITIAL-CONTENTS
+	       '(67 44 189 116 163 140 161 215))))
+	 (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 32)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MAX-INDEX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 7)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE
+		 32)
+	       :INITIAL-CONTENTS
+	       '(67 44 189 116 163 140 161 215))))
+	 (MAX-INDEX V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 6)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 64)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MAX-INDEX V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 7)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 64)
+	       :INITIAL-CONTENTS
+	       '(67 44 189 116 163 140 161 215))))
+	 (MAX-INDEX V1)))))
diff --git a/tests/vector-max.lisp b/tests/vector-max.lisp
index 130d92fb82db7a543a0de916b36f49520799ad47..d28fc53251da7621af033a91d25d514d77031ad3 100644
--- a/tests/vector-max.lisp
+++ b/tests/vector-max.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MAX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,105 +19,94 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-MAX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 8.24)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'SINGLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 8.24d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'DOUBLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5d0
-                                                                     8.24d0
-                                                                     3.29d0))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71))))
-                                                             (MMAX V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189))))
-                                                             (MMAX V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71))))
-                                                             (MMAX V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189))))
-                                                             (MMAX V1)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 8.24f0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0))))
+	   (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 8.24d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '(-34.5d0 8.24d0 3.29d0))))
+	 (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 71)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 8)
+	       :INITIAL-CONTENTS '(-64 -68 71))))
+	 (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 189)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 8)
+	       :INITIAL-CONTENTS '(67 44 189))))
+	 (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 71)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 16)
+	       :INITIAL-CONTENTS '(-64 -68 71))))
+	 (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 189)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 16)
+	       :INITIAL-CONTENTS
+	       '(67 44 189))))
+	 (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 71)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 32)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71))))
+	 (MMAX V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 189)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE
+		 32)
+	       :INITIAL-CONTENTS
+	       '(67 44
+		 189))))
+	 (MMAX V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 71)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 64)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71))))
+	 (MMAX V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 189)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 64)
+	       :INITIAL-CONTENTS
+	       '(67 44 189))))
+	 (MMAX V1)))))
 
diff --git a/tests/vector-mean.lisp b/tests/vector-mean.lisp
index 257240f90bede5b32ce9705370ccdf3e2809fe74..62ed0c2911c60c20b574726478494919c9a95585 100644
--- a/tests/vector-mean.lisp
+++ b/tests/vector-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MEAN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,121 +19,92 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 3.9812498688697815d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49))))
-                           (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3.98125d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   'DOUBLE-FLOAT
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-34.5d0
-                                                                     8.24d0
-                                                                     3.29d0
-                                                                     -8.93d0
-                                                                     34.12d0
-                                                                     -6.15d0
-                                                                     49.27d0
-                                                                     -13.49d0))))
-                                                             (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MEAN V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MEAN V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (MEAN V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (MEAN V1)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 3.9812498688697815d0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 3.98125d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+	 (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST -5.25d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 8)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 136.875d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 8)
+	       :INITIAL-CONTENTS
+	       '(67 44 189 116 163 140 161 215))))
+	 (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST -5.25d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 16)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 136.875d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 16)
+	       :INITIAL-CONTENTS
+	       '(67 44 189 116 163 140 161 215))))
+	 (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST -5.25d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 32)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (MEAN V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE 32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189 116 163 140 161 215))))
+					   (MEAN V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE 64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71 -91 52 -10 73 -5))))
+					   (MEAN V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE 64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189 116 163 140 161 215))))
+					   (MEAN V1)))))
 
diff --git a/tests/vector-min-index.lisp b/tests/vector-min-index.lisp
index 61b5bdc0655da436e7ebfc0bc5ca21626b09fc86..2f6f6bb088ee6066e7fc9778b1291de7c5ab85e2 100644
--- a/tests/vector-min-index.lisp
+++ b/tests/vector-min-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MIN-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -25,12 +25,12 @@
                                                                   (GRID:MAKE-FOREIGN-ARRAY
                                                                    'SINGLE-FLOAT
                                                                    :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49))))
+                                                                   '(-34.5f0 8.24f0
+                                                                     3.29f0 -8.93f0
+                                                                     34.12f0
+                                                                     -6.15f0
+                                                                     49.27f0
+                                                                     -13.49f0))))
                                                              (MIN-INDEX V1))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0)
                                                           (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-min.lisp b/tests/vector-min.lisp
index 543313949c8c83c8c10abd80a62c1c7f4965023b..dffc7c74b7ce1e14c5f02426bb8fc47717b9651e 100644
--- a/tests/vector-min.lisp
+++ b/tests/vector-min.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MIN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,14 +19,13 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-MIN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5)
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5f0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
                                                                   (GRID:MAKE-FOREIGN-ARRAY
                                                                    'SINGLE-FLOAT
                                                                    :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29))))
+                                                                   '(-34.5f0 8.24f0 3.29f0))))
                                                              (MMIN V1))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0)
                                                           (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-minmax-index.lisp b/tests/vector-minmax-index.lisp
index 16c0da8efca4d79703ba2cfd87df1324644dfa1b..9c8aef726dddaf39585998ec93908239f4f744ea 100644
--- a/tests/vector-minmax-index.lisp
+++ b/tests/vector-minmax-index.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MINMAX-INDEX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -25,12 +25,12 @@
                                                                   (GRID:MAKE-FOREIGN-ARRAY
                                                                    'SINGLE-FLOAT
                                                                    :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29 -8.93
-                                                                     34.12
-                                                                     -6.15
-                                                                     49.27
-                                                                     -13.49))))
+                                                                   '(-34.5f0 8.24f0
+                                                                     3.29f0 -8.93f0
+                                                                     34.12f0
+                                                                     -6.15f0
+                                                                     49.27f0
+                                                                     -13.49f0))))
                                                              (MINMAX-INDEX
                                                               V1))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 6)
diff --git a/tests/vector-minmax.lisp b/tests/vector-minmax.lisp
index 8589a4fef2c268061e167b4e8615d83dc2fd0d38..e827d6b3f4c45ca6fdfaf46a7183c779f841f12b 100644
--- a/tests/vector-minmax.lisp
+++ b/tests/vector-minmax.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MINMAX for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,14 +19,13 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-MINMAX
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5 8.24)
+                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5f0 8.24f0)
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
                                                                   (GRID:MAKE-FOREIGN-ARRAY
                                                                    'SINGLE-FLOAT
                                                                    :INITIAL-CONTENTS
-                                                                   '(-34.5 8.24
-                                                                     3.29))))
+                                                                   '(-34.5f0 8.24f0 3.29f0))))
                                                              (MINMAX V1))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0 8.24d0)
                                                           (MULTIPLE-VALUE-LIST
diff --git a/tests/vector-mult.lisp b/tests/vector-mult.lisp
index 604d4d7083b1b81df91078e2ee5bfda0532d5383..03d8786106257beaa6673158708a3e8bd32db76d 100644
--- a/tests/vector-mult.lisp
+++ b/tests/vector-mult.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-MULT for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,14 +20,14 @@
 
 (LISP-UNIT:DEFINE-TEST VECTOR-MULT
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(308.08502 281.14877 -20.2335))
+                        (LIST #(308.08502f0 281.14877f0 -20.2335f0))
                         (MULTIPLE-VALUE-LIST
                          (LET ((V1
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29)))
+                                             '(-34.5f0 8.24f0 3.29f0)))
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93 34.12 -6.15))))
+                                             '(-8.93f0 34.12f0 -6.15f0))))
                            (GRID:COPY-TO (ELT* V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(308.085d0 281.1488d0 -20.233500000000003d0))
diff --git a/tests/vector-reverse.lisp b/tests/vector-reverse.lisp
index 7b753f8a9e36b62e3d776d2773e8b4d685ecc18e..e0bd759e7dfcaae5438e2bf5654ae1fd719353ba 100644
--- a/tests/vector-reverse.lisp
+++ b/tests/vector-reverse.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-REVERSE for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,40 +19,40 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-REVERSE
-  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST
-    #(-13.49 49.27 -6.15 34.12 -8.93 3.29 8.24 -34.5))
-   (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'SINGLE-FLOAT
-	    :INITIAL-CONTENTS '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST
+      #(-13.49f0 49.27f0 -6.15f0 34.12f0 -8.93f0 3.29f0 8.24f0 -34.5f0))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(-13.49d0 49.27d0 -6.15d0 34.12d0 -8.93d0 3.29d0
       8.24d0 -34.5d0))
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    'DOUBLE-FLOAT
-	    :INITIAL-CONTENTS
-	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
-    #(#C(21.44 -49.08) #C(-16.12 -8.25) #C(-17.24 43.31)
-      #C(32.5 42.73) #C(49.27 -13.49) #C(34.12 -6.15)
-      #C(3.29 -8.93) #C(-34.5 8.24)))
+    #(#C(21.44f0 -49.08f0) #C(-16.12f0 -8.25f0) #C(-17.24f0 43.31f0)
+      #C(32.5f0 42.73f0) #C(49.27f0 -13.49f0) #C(34.12f0 -6.15f0)
+      #C(3.29f0 -8.93f0) #C(-34.5f0 8.24f0)))
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX SINGLE-FLOAT)
-	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)
-	      #C(49.27 -13.49) #C(32.5 42.73)
-	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX SINGLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)
+		 #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)
+		 #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(21.44d0 -49.08d0) #C(-16.12d0 -8.25d0)
@@ -60,79 +60,79 @@
       #C(49.27d0 -13.49d0) #C(34.12d0 -6.15d0)
       #C(3.29d0 -8.93d0) #C(-34.5d0 8.24d0)))
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(COMPLEX DOUBLE-FLOAT)
-				    :INITIAL-CONTENTS
-				    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
-				      #C(34.12d0 -6.15d0) #C(49.27d0 -13.49d0)
-				      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
-				      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(COMPLEX DOUBLE-FLOAT)
+	       :INITIAL-CONTENTS
+	       '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
+		 #C(34.12d0 -6.15d0) #C(49.27d0 -13.49d0)
+		 #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
+		 #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-5 73 -10 52 -91 71 -68 -64))
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(SIGNED-BYTE 8)
-	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 8)
+	       :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(215 161 140 163 116 189 44 67))
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(UNSIGNED-BYTE 8)
-	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 8)
+	       :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-5 73 -10 52 -91 71 -68 -64))
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(SIGNED-BYTE 16)
-	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 16)
+	       :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(215 161 140 163 116 189 44 67))
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(UNSIGNED-BYTE 16)
-	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 16)
+	       :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-5 73 -10 52 -91 71 -68 -64))
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(SIGNED-BYTE 32)
-	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 32)
+	       :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(215 161 140 163 116 189 44 67))
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(UNSIGNED-BYTE 32)
-	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 32)
+	       :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-5 73 -10 52 -91 71 -68 -64))
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(SIGNED-BYTE 64)
-	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 64)
+	       :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(215 161 140 163 116 189 44 67))
    (MULTIPLE-VALUE-LIST
-    (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY
-	    '(UNSIGNED-BYTE 64)
-	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
-      (GRID:COPY-TO (VECTOR-REVERSE V1))))))
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(UNSIGNED-BYTE 64)
+	       :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
+	 (GRID:COPY-TO (VECTOR-REVERSE V1))))))
 
diff --git a/tests/vector-set-all.lisp b/tests/vector-set-all.lisp
index 9d2b34692b66eb1e4a428390275b7ad0dba717ba..41f4c9403e4f50c45223dee2e7c9a3bd4b5b5fc1 100644
--- a/tests/vector-set-all.lisp
+++ b/tests/vector-set-all.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-SET-ALL for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,10 +20,10 @@
 
 (LISP-UNIT:DEFINE-TEST VECTOR-SET-ALL
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-   (LIST #(-34.5 -34.5 -34.5))
+   (LIST #(-34.5f0 -34.5f0 -34.5f0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
-      (GRID:COPY-TO (SET-ALL V1 -34.5)))))
+      (GRID:COPY-TO (SET-ALL V1 -34.5f0)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST #(-34.5d0 -34.5d0 -34.5d0))
    (MULTIPLE-VALUE-LIST
@@ -31,12 +31,12 @@
       (GRID:COPY-TO (SET-ALL V1 -34.5d0)))))
   #+fsbv
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
-   (LIST #(#C(-34.5 8.24) #C(-34.5 8.24) #C(-34.5 8.24)))
+   (LIST #(#C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
 			:DIMENSIONS '3)))
-      (GRID:COPY-TO (SET-ALL V1 #C(-34.5 8.24))))))
+      (GRID:COPY-TO (SET-ALL V1 #C(-34.5f0 8.24f0))))))
   #+fsbv
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
diff --git a/tests/vector-set-zero.lisp b/tests/vector-set-zero.lisp
index a996afdf736a856f83692c18d6661247df1c9c1d..26cf9efe25d1c03a1fef6efc0150d811b99991b5 100644
--- a/tests/vector-set-zero.lisp
+++ b/tests/vector-set-zero.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-SET-ZERO for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,10 +20,10 @@
 
 (LISP-UNIT:DEFINE-TEST VECTOR-SET-ZERO
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(0.0 0.0 0.0))
+   (LIST #(0.0f0 0.0f0 0.0f0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
-	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5 8.24 3.29))))
+	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0))))
       (SET-ZERO V1)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -34,12 +34,12 @@
       (SET-ZERO V1)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST #(#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0)))
+   (LIST #(#C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(0.0f0 0.0f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
-	    :INITIAL-CONTENTS '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)))))
+	    :INITIAL-CONTENTS '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)))))
       (SET-ZERO V1)
       (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/vector-standard-deviation-with-fixed-mean.lisp b/tests/vector-standard-deviation-with-fixed-mean.lisp
index 461606835516fe0a43401cdd9bb1142ed0d23685..2da23145f83bbcd23169a89ae8c5e39ce478b226 100644
--- a/tests/vector-standard-deviation-with-fixed-mean.lisp
+++ b/tests/vector-standard-deviation-with-fixed-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-STANDARD-DEVIATION-WITH-FIXED-MEAN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,86 +19,87 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-STANDARD-DEVIATION-WITH-FIXED-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 25.08341998337271d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 25.08342004068624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 61.216317269172606d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 54.81659762334762d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 61.216317269172606d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 54.81659762334762d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 61.216317269172606d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 54.81659762334762d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 61.216317269172606d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 54.81659762334762d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 25.08341998337271d0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 25.08342004068624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(-34.5d0 8.24d0 3.29d0 -8.93d0
+					 34.12d0 -6.15d0 49.27d0
+					 -13.49d0))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 61.216317269172606d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 54.81659762334762d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 61.216317269172606d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 54.81659762334762d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 61.216317269172606d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 54.81659762334762d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 61.216317269172606d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 54.81659762334762d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))))
 
diff --git a/tests/vector-standard-deviation-with-mean.lisp b/tests/vector-standard-deviation-with-mean.lisp
index 70861eef49453862a0d292b14f23630d1b74fa7c..4742663cc80367b381b41130cea0e551c56fba9c 100644
--- a/tests/vector-standard-deviation-with-mean.lisp
+++ b/tests/vector-standard-deviation-with-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-STANDARD-DEVIATION-WITH-MEAN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,86 +19,85 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-STANDARD-DEVIATION-WITH-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 26.815303904668458d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 26.815303965939197d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1 (MEAN V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1 (MEAN V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 26.815303904668458d0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 26.815303965939197d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT
+	       :INITIAL-CONTENTS '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1 (MEAN V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1 (MEAN V1))))))
 
diff --git a/tests/vector-standard-deviation.lisp b/tests/vector-standard-deviation.lisp
index 1fde788bae6930fd73bd77614c2860a6615a4a6d..083ee98dcfd217c56e1afca24bb8addd20791794 100644
--- a/tests/vector-standard-deviation.lisp
+++ b/tests/vector-standard-deviation.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-STANDARD-DEVIATION for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,86 +19,87 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-STANDARD-DEVIATION
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 26.815303904668458d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 26.815303965939197d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 65.44299591465624d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (STANDARD-DEVIATION V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 58.60140783291814d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(67 44 189 116 163 140 161 215))))
-                           (STANDARD-DEVIATION V1)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 26.815303904668458d0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 26.815303965939197d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(-34.5d0 8.24d0 3.29d0 -8.93d0
+					 34.12d0 -6.15d0 49.27d0
+					 -13.49d0))))
+	 (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 65.44299591465624d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (STANDARD-DEVIATION V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 58.60140783291814d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(67 44 189 116 163 140 161 215))))
+	 (STANDARD-DEVIATION V1)))))
 
diff --git a/tests/vector-sub.lisp b/tests/vector-sub.lisp
index ec1875e09a2f6f3c0a483c9f5748f3012361c5d0..a6c77915116abfa0615ddad9a397319aa549ba10 100644
--- a/tests/vector-sub.lisp
+++ b/tests/vector-sub.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-SUB for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,147 +19,147 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-SUB
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(-25.57 -25.88 9.440001))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93 34.12 -6.15))))
-                           (GRID:COPY-TO (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST
-                         #(-25.57d0 -25.879999999999995d0 9.440000000000001d0))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-8.93d0 34.12d0 -6.15d0))))
-                           (GRID:COPY-TO (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-91 52
-                                                                     -10))))
-                                                             (GRID:COPY-TO
-                                                              (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(207 137 49))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44
-                                                                     189)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(116 163
-                                                                     140))))
-                                                             (GRID:COPY-TO
-                                                              (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-91 52
-                                                                     -10))))
-                                                             (GRID:COPY-TO
-                                                              (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(65487 65417 49))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(67 44 189)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS '(116 163 140))))
-                           (GRID:COPY-TO (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-91 52
-                                                                     -10))))
-                                                             (GRID:COPY-TO
-                                                              (ELT- V1 V2)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(4294967247 4294967177 49))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS '(67 44 189)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS '(116 163 140))))
-                           (GRID:COPY-TO (ELT- V1 V2)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68
-                                                                     71)))
-                                                                 (V2
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-91 52
-                                                                     -10))))
-                                                             (GRID:COPY-TO
-                                                              (ELT- V1 V2)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST #(18446744073709551567 18446744073709551497 49))
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS '(67 44 189)))
-                               (V2
-                                (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS '(116 163 140))))
-                           (GRID:COPY-TO (ELT- V1 V2))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST #(-25.57f0 -25.88f0 9.440001f0))
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
+					 '(-34.5f0 8.24f0 3.29f0)))
+	       (V2
+		(GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
+					 '(-8.93f0 34.12f0 -6.15f0))))
+	   (GRID:COPY-TO (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST
+    #(-25.57d0 -25.879999999999995d0 9.440000000000001d0))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(-34.5d0 8.24d0 3.29d0)))
+	     (V2
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(-8.93d0 34.12d0 -6.15d0))))
+	 (GRID:COPY-TO (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(-64 -68
+						   71)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(-91 52
+						   -10))))
+					   (GRID:COPY-TO
+					    (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(207 137 49))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44
+						   189)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(116 163
+						   140))))
+					   (GRID:COPY-TO
+					    (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(-64 -68
+						   71)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(-91 52
+						   -10))))
+					   (GRID:COPY-TO
+					    (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(65487 65417 49))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS '(67 44 189)))
+	     (V2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
+				       :INITIAL-CONTENTS '(116 163 140))))
+	 (GRID:COPY-TO (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(-64 -68
+						   71)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(-91 52
+						   -10))))
+					   (GRID:COPY-TO
+					    (ELT- V1 V2)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(4294967247 4294967177 49))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS '(67 44 189)))
+	     (V2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
+				       :INITIAL-CONTENTS '(116 163 140))))
+	 (GRID:COPY-TO (ELT- V1 V2)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68
+						   71)))
+					       (V2
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(-91 52
+						   -10))))
+					   (GRID:COPY-TO
+					    (ELT- V1 V2)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST #(18446744073709551567 18446744073709551497 49))
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS '(67 44 189)))
+	     (V2
+	      (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
+				       :INITIAL-CONTENTS '(116 163 140))))
+	 (GRID:COPY-TO (ELT- V1 V2))))))
 
diff --git a/tests/vector-swap.lisp b/tests/vector-swap.lisp
index 0284afebb65f359f9b902b8099dcd034d605bec7..c9ed03b64c95addab524c204940028cfa5049851 100644
--- a/tests/vector-swap.lisp
+++ b/tests/vector-swap.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-SWAP for GSLL, automatically generated
 ;;
-;; Copyright 2009, 2010 Liam M. Healy
+;; Copyright 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -20,16 +20,16 @@
 
 (LISP-UNIT:DEFINE-TEST VECTOR-SWAP
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-   (LIST (LIST #(-8.93 34.12 -6.15) #(-34.5 8.24 3.29)))
+   (LIST (LIST #(-8.93f0 34.12f0 -6.15f0) #(-34.5f0 8.24f0 3.29f0)))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
-	    :INITIAL-CONTENTS '(-34.5 8.24 3.29)))
+	    :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0)))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
-	    :INITIAL-CONTENTS '(-8.93 34.12 -6.15))))
+	    :INITIAL-CONTENTS '(-8.93f0 34.12f0 -6.15f0))))
       (SWAP V2 V1)
       (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -50,19 +50,19 @@
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
-     #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
-     #(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))
+     #(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))
+     #(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))
+	    '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))))
 	  (V2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS
-	    '(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)))))
+	    '(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)))))
       (SWAP V2 V1)
       (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
diff --git a/tests/vector-variance-with-fixed-mean.lisp b/tests/vector-variance-with-fixed-mean.lisp
index 17101679afe1f835334ee262d7e5d2a362856375..abc6a545a9a010f2469600d4fcb052a6d40a7d1a 100644
--- a/tests/vector-variance-with-fixed-mean.lisp
+++ b/tests/vector-variance-with-fixed-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-VARIANCE-WITH-FIXED-MEAN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,123 +19,123 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-VARIANCE-WITH-FIXED-MEAN
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 629.1779580622615d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49))))
-                           (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 629.1779609375001d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0))))
-                           (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(SIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(-64 -68 71
-                                                                     -91 52 -10
-                                                                     73 -5))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1)))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE-WITH-FIXED-MEAN
-                                                              V1 (MEAN V1))))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 629.1779580622615d0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 629.1779609375001d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
+				       '(-34.5d0 8.24d0 3.29d0 -8.93d0
+					 34.12d0 -6.15d0 49.27d0
+					 -13.49d0))))
+	 (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(SIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(-64 -68 71
+						   -91 52 -10
+						   73 -5))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1)))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE-WITH-FIXED-MEAN
+					    V1 (MEAN V1))))))
 
diff --git a/tests/vector-variance-with-mean.lisp b/tests/vector-variance-with-mean.lisp
index fd2ba2dd1137af8ad41d1e886ef8828d549b6f20..775a540a620a09fc12c6f37ca99313708a9e267c 100644
--- a/tests/vector-variance-with-mean.lisp
+++ b/tests/vector-variance-with-mean.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-VARIANCE-WITH-MEAN for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -24,8 +24,8 @@
                         (MULTIPLE-VALUE-LIST
                          (LET ((V1
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49))))
+                                             '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0
+                                               -6.15f0 49.27f0 -13.49f0))))
                            (VARIANCE V1 (MEAN V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 719.0605267857144d0)
diff --git a/tests/vector-variance.lisp b/tests/vector-variance.lisp
index 0d64116a247dea4bcdb00dc18e14085193b68464..45aa4f51f0dc0c6a751e2e461eebe75ad141499b 100644
--- a/tests/vector-variance.lisp
+++ b/tests/vector-variance.lisp
@@ -1,6 +1,6 @@
 ;; Regression test VECTOR-VARIANCE for GSLL, automatically generated
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -19,102 +19,105 @@
 (in-package :gsl)
 
 (LISP-UNIT:DEFINE-TEST VECTOR-VARIANCE
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 719.0605234997274d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5 8.24 3.29 -8.93 34.12
-                                               -6.15 49.27 -13.49))))
-                           (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 719.0605267857144d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-                                             '(-34.5d0 8.24d0 3.29d0 -8.93d0
-                                               34.12d0 -6.15d0 49.27d0
-                                               -13.49d0))))
-                           (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 4282.785714285714d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     8)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 4282.785714285714d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     16)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 4282.785714285714d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (VARIANCE V1))))
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     32)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
-                        (LIST 4282.785714285714d0)
-                        (MULTIPLE-VALUE-LIST
-                         (LET ((V1
-                                (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
-                                             :INITIAL-CONTENTS
-                                             '(-64 -68 71 -91 52 -10 73 -5))))
-                           (VARIANCE V1))))
-		       #+int64
-                       (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
-                                                          (MULTIPLE-VALUE-LIST
-                                                           (LET ((V1
-                                                                  (GRID:MAKE-FOREIGN-ARRAY
-                                                                   '(UNSIGNED-BYTE
-                                                                     64)
-                                                                   :INITIAL-CONTENTS
-                                                                   '(67 44 189
-                                                                     116 163
-                                                                     140 161
-                                                                     215))))
-                                                             (VARIANCE V1)))))
+    (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+     (LIST 719.0605234997274d0)
+     (MULTIPLE-VALUE-LIST
+	 (LET ((V1
+		(GRID:MAKE-FOREIGN-ARRAY
+		 'SINGLE-FLOAT
+		 :INITIAL-CONTENTS
+		 '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))))
+	   (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 719.0605267857144d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       'DOUBLE-FLOAT
+	       :INITIAL-CONTENTS
+	       '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
+	 (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4282.785714285714d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY
+	       '(SIGNED-BYTE 8)
+	       :INITIAL-CONTENTS
+	       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   8)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4282.785714285714d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   16)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4282.785714285714d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (VARIANCE V1))))
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   32)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
+   (LIST 4282.785714285714d0)
+   (MULTIPLE-VALUE-LIST
+       (LET ((V1
+	      (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
+				       :INITIAL-CONTENTS
+				       '(-64 -68 71 -91 52 -10 73 -5))))
+	 (VARIANCE V1))))
+  #+int64
+  (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0)
+				     (MULTIPLE-VALUE-LIST
+					 (LET ((V1
+						(GRID:MAKE-FOREIGN-ARRAY
+						 '(UNSIGNED-BYTE
+						   64)
+						 :INITIAL-CONTENTS
+						 '(67 44 189
+						   116 163
+						   140 161
+						   215))))
+					   (VARIANCE V1)))))
 
diff --git a/wavelet.lisp b/wavelet.lisp
index 7fda318cb691d0f6d17d4ce30bf8f8109a24270d..1ab3aac38604b790569d96bd4ee825310c28b612 100644
--- a/wavelet.lisp
+++ b/wavelet.lisp
@@ -1,8 +1,8 @@
 ;; Wavelet transforms.
 ;; Liam Healy, Mon Nov 26 2007 - 20:43
-;; Time-stamp: <2010-07-07 14:24:54EDT wavelet.lisp>
+;; Time-stamp: <2011-05-26 12:37:28EDT wavelet.lisp>
 ;;
-;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2006, 2007, 2008, 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
@@ -105,7 +105,7 @@
 
 (defmfun wavelet-transform (wavelet data stride direction workspace)
   "gsl_wavelet_transform"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    (stride sizet) ((dim0 data) sizet) ((forward-backward direction) :int)
    ((mpointer workspace) :pointer))
   :documentation			; FDL
@@ -131,7 +131,7 @@
 
 (defmfun wavelet-transform-forward (wavelet data stride workspace)
   "gsl_wavelet_transform_forward"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    (stride sizet) ((dim0 data) sizet) ((mpointer workspace) :pointer))
   :documentation			; FDL
   "Compute in-place forward and inverse discrete wavelet
@@ -153,7 +153,7 @@
 
 (defmfun wavelet-transform-inverse (wavelet data stride workspace)
   "gsl_wavelet_transform_inverse"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    (stride sizet) ((dim0 data) sizet) ((mpointer workspace) :pointer))
   :documentation			; FDL
   "Compute in-place inverse discrete wavelet
@@ -179,7 +179,7 @@
 
 (defmfun wavelet-2d-transform (wavelet data tda direction workspace)
   "gsl_wavelet2d_transform"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    (tda sizet) ((dim0 data) sizet) ((dim1 data) sizet)
    ((forward-backward direction) :int) ((mpointer workspace) :pointer))
   :documentation			; FDL
@@ -199,7 +199,7 @@
 
 (defmfun wavelet-2d-transform-forward (wavelet data tda workspace)
   "gsl_wavelet2d_transform_forward"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    (tda sizet) ((dim0 data) sizet) ((dim1 data) sizet)
    ((mpointer workspace) :pointer))
   :documentation			; FDL
@@ -217,7 +217,7 @@
 
 (defmfun wavelet-2d-transform-inverse (wavelet data tda workspace)
   "gsl_wavelet2d_transform_inverse"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    (tda sizet) ((dim0 data) sizet) ((dim1 data) sizet)
    ((mpointer workspace) :pointer))
   :documentation			; FDL
@@ -233,28 +233,28 @@
 
 (defmfun wavelet-2d-transform-matrix (wavelet data direction workspace)
   "gsl_wavelet2d_transform_matrix"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    ((forward-backward direction) :int) ((mpointer workspace) :pointer))
   :documentation			; FDL
   "Compute the two-dimensional in-place wavelet transform on a matrix.")
 
 (defmfun wavelet-2d-transform-matrix-forward (wavelet data workspace)
   "gsl_wavelet2d_transform_matrix_forward"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    ((mpointer workspace) :pointer))
   :documentation			; FDL
   "Compute the two-dimensional in-place wavelet transform on a matrix.")
 
 (defmfun wavelet-2d-transform-matrix-inverse (wavelet data workspace)
   "gsl_wavelet2d_transform_matrix_inverse"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    ((mpointer workspace) :pointer))
   :documentation			; FDL
   "Compute the two-dimensional in-place wavelet transform on a matrix.")
 
 (defmfun wavelet-2d-nonstandard-transform (wavelet data tda direction workspace)
   "gsl_wavelet2d_nstransform"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    (tda sizet) ((dim0 data) sizet) ((dim1 data) sizet) (direction :int)
    ((mpointer workspace) :pointer))
   :documentation			; FDL
@@ -262,7 +262,7 @@
 
 (defmfun wavelet-2d-nonstandard-transform-forward (wavelet data tda workspace)
   "gsl_wavelet2d_nstransform_forward"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    (tda sizet) ((dim0 data) sizet) ((dim1 data) sizet)
    ((mpointer workspace) :pointer))
   :documentation			; FDL
@@ -270,7 +270,7 @@
 
 (defmfun wavelet-2d-nonstandard-transform-inverse (wavelet data tda workspace)
   "gsl_wavelet2d_nstransform_inverse"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    (tda sizet) ((dim0 data) sizet) ((dim1 data) sizet)
    ((mpointer workspace) :pointer))
   :documentation			; FDL
@@ -278,7 +278,7 @@
 
 (defmfun wavelet-2d-nonstandard-transform-matrix (wavelet data direction workspace)
   "gsl_wavelet2d_nstransform_matrix"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    (direction :int) ((mpointer workspace) :pointer))
   :documentation
   "Compute the non-standard form of the two-dimensional in-place wavelet
@@ -286,7 +286,7 @@
 
 (defmfun wavelet-2d-nonstandard-transform-matrix-forward (wavelet data workspace)
   "gsl_wavelet2d_nstransform_matrix_forward"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    ((mpointer workspace) :pointer))
   :documentation			; FDL
   "Compute the non-standard form of the two-dimensional in-place wavelet
@@ -294,7 +294,7 @@
 
 (defmfun wavelet-2d-nonstandard-transform-matrix-inverse (wavelet data workspace)
   "gsl_wavelet2d_nstransform_matrix_inverse"
-  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer)
    ((mpointer workspace) :pointer))
   :documentation			; FDL
   "Compute the non-standard form of the two-dimensional in-place wavelet
@@ -388,13 +388,13 @@
     (let ((absvector (grid:make-foreign-array 'double-float :dimensions n))
 	  (permutation (make-permutation n)))
       (dotimes (i n)
-	(setf (grid:gref absvector i) (abs (grid:gref vector i))))
+	(setf (grid:aref absvector i) (abs (grid:aref vector i))))
       ;; Sort and set to 0 all but the largest 20.
       (sort-vector-index permutation absvector)
       (dotimes (i (- n 20))
-	(setf (grid:gref vector (grid:gref permutation i))
+	(setf (grid:aref vector (grid:aref permutation i))
 	      0.0d0))) ;; Transform back
-    (dotimes (i n) (format t "~&~a" (grid:gref vector i)))
+    (dotimes (i n) (format t "~&~a" (grid:aref vector i)))
     (wavelet-transform-inverse wavelet vector 1 workspace)
     (grid:copy-to vector)))