From 2597eaeca4989a7936133d090eb154e13bbd1b84 Mon Sep 17 00:00:00 2001
From: "Liam M. Healy" <lnp@healy.washington.dc.us>
Date: Wed, 7 Jul 2010 14:52:28 -0400
Subject: [PATCH] Use grid:copy-to instead of cl-array

Do not use cl-array in tests because it isn't always available.  The
safer way is by doing a copy out to a new CL array.
---
 calculus/numerical-integration.lisp       |  4 +-
 data/array-tests.lisp                     | 62 +++++++++++------------
 data/combination.lisp                     |  4 +-
 data/permutation.lisp                     |  4 +-
 eigensystems/symmetric-hermitian.lisp     |  6 +--
 fast-fourier-transforms/example.lisp      |  4 +-
 hankel.lisp                               | 13 ++---
 histogram/histogram.lisp                  | 10 ++--
 init/mobject.lisp                         |  4 +-
 linear-algebra/blas1.lisp                 | 14 ++---
 linear-algebra/blas2.lisp                 | 14 ++---
 linear-algebra/blas3.lisp                 | 14 ++---
 linear-algebra/exponential.lisp           |  4 +-
 linear-algebra/lu.lisp                    |  6 +--
 polynomial.lisp                           | 18 +++----
 random/dirichlet.lisp                     |  4 +-
 random/generators.lisp                    |  6 +--
 random/multinomial.lisp                   |  4 +-
 random/quasi.lisp                         |  8 +--
 random/shuffling-sampling.lisp            |  8 +--
 sorting.lisp                              | 20 ++++----
 special-functions/bessel.lisp             | 26 +++++-----
 special-functions/coulomb.lisp            | 12 ++---
 special-functions/gegenbauer.lisp         |  4 +-
 special-functions/legendre.lisp           | 14 ++---
 special-functions/mathieu.lisp            |  8 +--
 test-unit/augment.lisp                    |  4 +-
 tests/axpy.lisp                           |  8 +--
 tests/bessel.lisp                         | 22 ++++----
 tests/blas-copy.lisp                      |  8 +--
 tests/blas-swap.lisp                      |  8 +--
 tests/column.lisp                         | 24 ++++-----
 tests/combination.lisp                    |  6 +--
 tests/coulomb.lisp                        | 12 ++---
 tests/dirichlet.lisp                      |  2 +-
 tests/gegenbauer.lisp                     |  2 +-
 tests/givens.lisp                         |  4 +-
 tests/hankel.lisp                         | 16 +++---
 tests/inverse-matrix-product.lisp         | 16 +++---
 tests/legendre.lisp                       | 12 ++---
 tests/lu.lisp                             |  6 +--
 tests/mathieu.lisp                        |  6 +--
 tests/matrix-add-scalar.lisp              | 20 ++++----
 tests/matrix-add.lisp                     | 20 ++++----
 tests/matrix-div.lisp                     | 20 ++++----
 tests/matrix-mult-scalar.lisp             | 20 ++++----
 tests/matrix-mult.lisp                    | 20 ++++----
 tests/matrix-product-hermitian.lisp       |  8 +--
 tests/matrix-product-nonsquare.lisp       |  8 +--
 tests/matrix-product-symmetric.lisp       |  8 +--
 tests/matrix-product-triangular.lisp      | 16 +++---
 tests/matrix-product.lisp                 | 16 +++---
 tests/matrix-set-all.lisp                 | 24 ++++-----
 tests/matrix-set-zero.lisp                | 24 ++++-----
 tests/matrix-sub.lisp                     | 20 ++++----
 tests/matrix-swap.lisp                    | 24 ++++-----
 tests/matrix-transpose-copy.lisp          | 24 ++++-----
 tests/matrix-transpose.lisp               | 24 ++++-----
 tests/multinomial.lisp                    |  2 +-
 tests/numerical-integration.lisp          |  5 +-
 tests/permutation.lisp                    | 10 ++--
 tests/polynomial.lisp                     | 21 ++++----
 tests/quasi-random-number-generators.lisp |  2 +-
 tests/row.lisp                            | 24 ++++-----
 tests/scale.lisp                          | 12 ++---
 tests/set-basis.lisp                      | 24 ++++-----
 tests/set-identity.lisp                   | 24 ++++-----
 tests/setf-column.lisp                    | 24 ++++-----
 tests/setf-row.lisp                       | 24 ++++-----
 tests/shuffling-sampling.lisp             |  6 +--
 tests/sort-matrix-largest.lisp            | 20 ++++----
 tests/sort-matrix-smallest.lisp           | 20 ++++----
 tests/sort-matrix.lisp                    | 20 ++++----
 tests/sort-vector-index.lisp              | 20 ++++----
 tests/sort-vector-largest-index.lisp      | 20 ++++----
 tests/sort-vector-largest.lisp            | 20 ++++----
 tests/sort-vector-smallest-index.lisp     | 20 ++++----
 tests/sort-vector-smallest.lisp           | 20 ++++----
 tests/sort-vector.lisp                    | 20 ++++----
 tests/swap-columns.lisp                   | 24 ++++-----
 tests/swap-elements.lisp                  | 24 ++++-----
 tests/swap-row-column.lisp                | 24 ++++-----
 tests/swap-rows.lisp                      | 24 ++++-----
 tests/vector-add-scalar.lisp              | 20 ++++----
 tests/vector-div.lisp                     | 20 ++++----
 tests/vector-mult-scalar.lisp             | 20 ++++----
 tests/vector-mult.lisp                    | 20 ++++----
 tests/vector-reverse.lisp                 | 24 ++++-----
 tests/vector-set-all.lisp                 | 24 ++++-----
 tests/vector-set-zero.lisp                | 24 ++++-----
 tests/vector-sub.lisp                     | 20 ++++----
 tests/vector-swap.lisp                    | 24 ++++-----
 wavelet.lisp                              |  6 +--
 93 files changed, 695 insertions(+), 708 deletions(-)

diff --git a/calculus/numerical-integration.lisp b/calculus/numerical-integration.lisp
index a4a9921b..d40cc871 100644
--- a/calculus/numerical-integration.lisp
+++ b/calculus/numerical-integration.lisp
@@ -1,6 +1,6 @@
 ;; Numerical integration
 ;; Liam Healy, Wed Jul  5 2006 - 23:14
-;; Time-stamp: <2010-07-06 23:26:39EDT numerical-integration.lisp>
+;; Time-stamp: <2010-07-07 14:21:55EDT numerical-integration.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -367,6 +367,6 @@
  (integration-QAGil (integration-test-myfn2 1.0d0) 1.0d0 1.0d-7 0.0d0 1000)
  (integration-QAGp
   'integration-test-f454
-  (copy (vector 0.0d0 1.0d0 (sqrt 2.0d0) 3.0d0) :grid-type 'foreign-array)
+  (grid:copy-to (vector 0.0d0 1.0d0 (sqrt 2.0d0) 3.0d0))
   0.0d0 1.0d-3 1000)
  (integration-QAWc 'integration-test-f459 -1.0d0 5.0d0 0.0d0 0.0d0 1.0d-3 1000))
diff --git a/data/array-tests.lisp b/data/array-tests.lisp
index 74a0aac7..d061b84b 100644
--- a/data/array-tests.lisp
+++ b/data/array-tests.lisp
@@ -1,6 +1,6 @@
 ;; Tests of array functions 
 ;; Liam Healy 2008-10-20 22:41:48EDT array-tests.lisp
-;; Time-stamp: <2010-07-06 23:51:52EDT array-tests.lisp>
+;; Time-stamp: <2010-07-07 14:25:02EDT array-tests.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -32,33 +32,33 @@
 
 (generate-all-array-tests vector-set-all #+fsbv t #-fsbv :no-complex
  (let ((v1 (array-default 3 t)))
-   (cl-array (set-all v1 (scalar-default)))))
+   (grid:copy-to (set-all v1 (scalar-default)))))
 
 (generate-all-array-tests matrix-set-all #+fsbv t #-fsbv :no-complex
  (let ((m1 (array-default '(3 3) t)))
-   (cl-array (set-all m1 (scalar-default)))))
+   (grid:copy-to (set-all m1 (scalar-default)))))
 
 (generate-all-array-tests vector-set-zero t
  (let ((v1 (array-default 3)))
    (set-zero v1)
-   (cl-array v1)))
+   (grid:copy-to v1)))
 
 (generate-all-array-tests matrix-set-zero t
  (let ((m1 (array-default '(3 3))))
    (set-zero m1)
-   (cl-array m1)))
+   (grid:copy-to m1)))
 
 (generate-all-array-tests vector-swap t
  (let ((v1 (array-default 3))
        (v2 (array-default 3)))
    (swap v2 v1)
-   (list (cl-array v1) (cl-array v2))))
+   (list (grid:copy-to v1) (grid:copy-to v2))))
 
 (generate-all-array-tests matrix-swap t
  (let ((m1 (array-default '(3 3)))
        (m2 (array-default '(3 3))))
    (swap m2 m1)
-   (list (cl-array m1) (cl-array m2))))
+   (list (grid:copy-to m1) (grid:copy-to m2))))
 
 ;;;;****************************************************************************
 ;;;; Arithmetic operations
@@ -74,53 +74,53 @@
 (generate-all-array-tests matrix-add :no-complex
  (let ((m1 (array-default '(3 3)))
        (m2 (array-default '(3 3))))
-   (cl-array (elt+ m1 m2))))
+   (grid:copy-to (elt+ m1 m2))))
 
 (generate-all-array-tests vector-sub :no-complex
  (let ((v1 (array-default 3))
        (v2 (array-default 3)))
-   (cl-array (elt- v1 v2))))
+   (grid:copy-to (elt- v1 v2))))
 
 (generate-all-array-tests matrix-sub :no-complex
  (let ((m1 (array-default '(3 3)))
        (m2 (array-default '(3 3))))
-   (cl-array (elt- m1 m2))))
+   (grid:copy-to (elt- m1 m2))))
 
 (generate-all-array-tests vector-mult :no-complex
  (let ((v1 (array-default 3))
        (v2 (array-default 3)))
-   (cl-array (elt* v1 v2))))
+   (grid:copy-to (elt* v1 v2))))
 
 (generate-all-array-tests matrix-mult :no-complex
  (let ((m1 (array-default '(3 3)))
        (m2 (array-default '(3 3))))
-   (cl-array (elt* m1 m2))))
+   (grid:copy-to (elt* m1 m2))))
 
 (generate-all-array-tests vector-div :no-complex
  (let ((v1 (array-default 3))
        (v2 (array-default 3)))
-   (cl-array (elt/ v1 v2))))
+   (grid:copy-to (elt/ v1 v2))))
 
 (generate-all-array-tests matrix-div :no-complex
  (let ((m1 (array-default '(3 3)))
        (m2 (array-default '(3 3))))
-   (cl-array (elt/ m1 m2))))
+   (grid:copy-to (elt/ m1 m2))))
 
 (generate-all-array-tests vector-mult-scalar :no-complex
  (let ((v1 (array-default 3)))
-   (cl-array (elt* v1 1.39d0))))
+   (grid:copy-to (elt* v1 1.39d0))))
 
 (generate-all-array-tests matrix-mult-scalar :no-complex
  (let ((m1 (array-default '(3 3))))
-   (cl-array (elt* m1 1.39d0))))
+   (grid:copy-to (elt* m1 1.39d0))))
 
 (generate-all-array-tests vector-add-scalar :no-complex
  (let ((v1 (array-default 3)))
-   (cl-array (elt+ v1 18.19d0))))
+   (grid:copy-to (elt+ v1 18.19d0))))
 
 (generate-all-array-tests matrix-add-scalar :no-complex
  (let ((m1 (array-default '(3 3))))
-   (cl-array (elt+ m1 18.19d0))))
+   (grid:copy-to (elt+ m1 18.19d0))))
 
 ;;;;****************************************************************************
 ;;;; Maximum and minimum elements
@@ -183,16 +183,16 @@
 (generate-all-array-tests set-basis t
  (let ((v1 (array-default 8)))
    (set-basis v1 2)
-   (cl-array v1)))
+   (grid:copy-to v1)))
 
 (generate-all-array-tests swap-elements t
  (let ((v1 (array-default 8)))
    (swap-elements v1 2 5)
-   (cl-array v1)))
+   (grid:copy-to v1)))
 
 (generate-all-array-tests vector-reverse t
  (let ((v1 (array-default 8)))
-   (cl-array (vector-reverse v1))))
+   (grid:copy-to (vector-reverse v1))))
 
 ;;;;****************************************************************************
 ;;;; Matrix-only function definitions
@@ -200,47 +200,47 @@
 
 (generate-all-array-tests set-identity t
  (let ((m1 (array-default '(3 3))))
-   (cl-array (set-identity m1))))
+   (grid:copy-to (set-identity m1))))
 
 (generate-all-array-tests row t
  (let ((m1 (array-default '(3 3)))
        (row (array-default 3 t)))
-   (cl-array (row m1 1 row))))
+   (grid:copy-to (row m1 1 row))))
 
 (generate-all-array-tests setf-row t
  (let ((m1 (array-default '(3 3)))
 	(row (array-default 3)))
    (setf (row m1 2) row)
-   (cl-array m1)))
+   (grid:copy-to m1)))
 
 (generate-all-array-tests column t
  (let ((m1 (array-default '(3 3)))
        (col (array-default 3 t)))
-   (cl-array (column m1 1 col))))
+   (grid:copy-to (column m1 1 col))))
 
 (generate-all-array-tests setf-column t
  (let ((m1 (array-default '(3 3)))
 	(col (array-default 3)))
    (setf (column m1 2) col)
-   (cl-array m1)))
+   (grid:copy-to m1)))
 
 (generate-all-array-tests swap-rows t
  (let ((m1 (array-default '(3 3))))
-   (cl-array (swap-rows m1 0 1))))
+   (grid:copy-to (swap-rows m1 0 1))))
 
 (generate-all-array-tests swap-columns t
  (let ((m1 (array-default '(3 3))))
-   (cl-array (swap-columns m1 1 2))))
+   (grid:copy-to (swap-columns m1 1 2))))
 
 (generate-all-array-tests swap-row-column t
  (let ((m1 (array-default '(3 3))))
-   (cl-array (swap-row-column m1 0 2))))
+   (grid:copy-to (swap-row-column m1 0 2))))
 
 (generate-all-array-tests matrix-transpose* t
  (let ((m1 (array-default '(3 3))))
-   (cl-array (matrix-transpose* m1))))
+   (grid:copy-to (matrix-transpose* m1))))
 
 (generate-all-array-tests matrix-transpose t
  (let ((m1 (array-default '(3 3)))
        (m2 (array-default '(3 3) t)))
-   (cl-array (matrix-transpose m1 m2))))
+   (grid:copy-to (matrix-transpose m1 m2))))
diff --git a/data/combination.lisp b/data/combination.lisp
index 6814fadc..9dec8981 100644
--- a/data/combination.lisp
+++ b/data/combination.lisp
@@ -1,6 +1,6 @@
 ;; Combinations
 ;; Liam Healy, Sun Mar 26 2006 - 11:51
-;; Time-stamp: <2010-07-01 21:13:06EDT combination.lisp>
+;; Time-stamp: <2010-07-07 14:30:07EDT combination.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -94,7 +94,7 @@
   "Initialize the combination c to the lexicographically
    last combination, i.e. (n-k,n-k+1,...,n-1).")
 
-(defmfun grid:copy-to-destination ((source combination) (destination combination))
+(defmfun grid::copy-to-destination ((source combination) (destination combination))
   "gsl_combination_memcpy"
   (((mpointer destination) :pointer)
    ((mpointer source) :pointer))
diff --git a/data/permutation.lisp b/data/permutation.lisp
index 8e6d248f..fd4943ee 100644
--- a/data/permutation.lisp
+++ b/data/permutation.lisp
@@ -1,6 +1,6 @@
 ;; Permutations
 ;; Liam Healy, Sun Mar 26 2006 - 11:51
-;; Time-stamp: <2010-07-01 21:12:59EDT permutation.lisp>
+;; Time-stamp: <2010-07-07 14:30:06EDT permutation.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -79,7 +79,7 @@
   "Initialize the permutation p to the identity, i.e.
    (0,1,2,...,n-1).")
 
-(defmfun grid:copy-to-destination ((source permutation) (destination permutation))
+(defmfun grid::copy-to-destination ((source permutation) (destination permutation))
   "gsl_permutation_memcpy"
   (((mpointer destination) :pointer)
    ((mpointer source) :pointer))
diff --git a/eigensystems/symmetric-hermitian.lisp b/eigensystems/symmetric-hermitian.lisp
index 507003d5..38404d2c 100644
--- a/eigensystems/symmetric-hermitian.lisp
+++ b/eigensystems/symmetric-hermitian.lisp
@@ -1,6 +1,6 @@
 ;; Eigenvectors and eigenvalues
 ;; Liam Healy, Sun May 21 2006 - 19:52
-;; Time-stamp: <2010-06-29 22:15:24EDT symmetric-hermitian.lisp>
+;; Time-stamp: <2010-07-07 14:25:01EDT symmetric-hermitian.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -155,7 +155,7 @@
  (let ((m1 (array-default '(5 5))))
    (multiple-value-bind (eval evec)
        (eigenvalues-eigenvectors (elt+ m1 (matrix-transpose-copy m1)))
-     (list (cl-array eval) (cl-array evec)))))
+     (list (grid:copy-to eval) (grid:copy-to evec)))))
 |#
 
 (defun eigenvalue-eigenvectors-example ()
@@ -165,7 +165,7 @@
 		-10.0d0 30.0d0 0.0d0 ^
 		0.0d0 0.0d0 40.0d0)))
     (eigenvalues-eigenvectors mat evals evecs)
-    (values (cl-array evals) (cl-array evecs))))
+    (values (grid:copy-to evals) (grid:copy-to evecs))))
 
 (save-test eigensystems
 	   (eigenvalue-eigenvectors-example))
diff --git a/fast-fourier-transforms/example.lisp b/fast-fourier-transforms/example.lisp
index fb68b20e..5b8d9665 100644
--- a/fast-fourier-transforms/example.lisp
+++ b/fast-fourier-transforms/example.lisp
@@ -1,6 +1,6 @@
 ;; Example FFT: transform a pulse (using the "clean" fft interface)
 ;; Sumant Oemrawsingh, Sat Oct 31 2009 - 00:24
-;; Time-stamp: <2010-07-06 23:16:03EDT example.lisp>
+;; Time-stamp: <2010-07-07 14:21:55EDT example.lisp>
 ;;
 ;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -147,7 +147,7 @@
 		:initial-contents
 		(map 'list
 		     (lambda (x) (/ x (floor (size backward) stride)))
-		     (copy backward :grid-type 'array))))))
+		     (grid:copy-to backward))))))
 	(multiple-value-bind (forward inverse)
 	    (test-real-fft-noise random-vector :stride stride)
 	  (values dft-random-vector forward random-vector inverse)))))
diff --git a/hankel.lisp b/hankel.lisp
index 392f07d2..dbf4bb3c 100644
--- a/hankel.lisp
+++ b/hankel.lisp
@@ -1,6 +1,6 @@
 ;; Discrete Hankel Transforms.
 ;; Liam Healy, Sat Dec  8 2007 - 16:50
-;; Time-stamp: <2010-07-06 23:13:16EDT hankel.lisp>
+;; Time-stamp: <2010-07-07 14:19:28EDT hankel.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -69,8 +69,7 @@
 
 
 (save-test hankel					; tests from dht/test.c
- (copy (apply-hankel (make-hankel 3 1.0d0 1.0d0) #m(1.0d0 2.0d0 3.0d0))
-       :grid-type 'array)
+ (grid:copy-to (apply-hankel (make-hankel 3 1.0d0 1.0d0) #m(1.0d0 2.0d0 3.0d0)))
  ;; Exact, forward-inverse transform should be accurate to 2e-5
  (let ((hank (make-hankel 3 1.0d0 1.0d0)))
    (copy
@@ -84,16 +83,14 @@
    (loop for n from 0 below 128
       do (setf (grid:gref in n)
 	       (/ (1+ (expt (sample-x-hankel hank n) 2)))))
-   (copy (apply-hankel hank in)
-	 :grid-type 'array))
+   (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)
  ;; expected accuracy only about 2%
  (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)))))
-   (copy (apply-hankel hank in)
-	 :grid-type 'array))
+   (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)))
@@ -101,4 +98,4 @@
       do (setf (grid:gref in n)
 	       (let ((x (sample-x-hankel hank n)))
 		 (* x (- 1 (expt x 2))))))
-   (copy (apply-hankel hank in) :grid-type 'array)))
+   (grid:copy-to (apply-hankel hank in))))
diff --git a/histogram/histogram.lisp b/histogram/histogram.lisp
index d9cf6df7..50857f37 100644
--- a/histogram/histogram.lisp
+++ b/histogram/histogram.lisp
@@ -1,6 +1,6 @@
 ;; The histogram structure
 ;; Liam Healy, Mon Jan  1 2007 - 11:32
-;; Time-stamp: <2010-07-01 21:14:48EDT histogram.lisp>
+;; Time-stamp: <2010-07-07 14:30:30EDT histogram.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -79,7 +79,7 @@
   :definition :method
   :return (histogram))
 
-(defmfun grid:copy-to-destination ((source histogram) (destination histogram))
+(defmfun grid::copy-to-destination ((source histogram) (destination histogram))
   "gsl_histogram_memcpy"
   (((mpointer destination) :pointer) ((mpointer source) :pointer))
   :definition :method
@@ -91,7 +91,7 @@
    an exact copy of the former.
    The two histograms must be of the same size.")
 
-(defmfun grid:copy-to-destination ((source histogram2d) (destination histogram2d))
+(defmfun grid::copy-to-destination ((source histogram2d) (destination histogram2d))
   "gsl_histogram2d_memcpy"
   (((mpointer destination) :pointer) ((mpointer source) :pointer))
   :definition :method
@@ -103,14 +103,14 @@
    an exact copy of the former.
    The two histograms must be of the same size.")
 
-(defmfun grid:copy-making-destination ((source histogram))
+(defmfun grid::copy-making-destination ((source histogram))
   "gsl_histogram_clone"
   (((mpointer source) :pointer))
   :definition :method
   :c-return :pointer
   :index copy)
 
-(defmfun grid:copy-making-destination ((source histogram2d))
+(defmfun grid::copy-making-destination ((source histogram2d))
   "gsl_histogram2d_clone"
   (((mpointer source) :pointer))
   :definition :method
diff --git a/init/mobject.lisp b/init/mobject.lisp
index f21c7f41..7e96d9c0 100644
--- a/init/mobject.lisp
+++ b/init/mobject.lisp
@@ -1,6 +1,6 @@
 ;; Definition of GSL objects and ways to use them.
 ;; Liam Healy, Sun Dec  3 2006 - 10:21
-;; Time-stamp: <2010-07-01 19:37:25EDT mobject.lisp>
+;; Time-stamp: <2010-07-07 14:30:30EDT mobject.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -351,7 +351,7 @@
 ;;;;****************************************************************************
 
 #|
-(defmethod grid:copy-making-destination :around ((object mobject))
+(defmethod grid::copy-making-destination :around ((object mobject))
   (if (next-method-p)
       ;; The subclass method should only return the malloced
       ;; mpointer (as from a "_clone" function); it will be put into
diff --git a/linear-algebra/blas1.lisp b/linear-algebra/blas1.lisp
index f3888cc5..401def27 100644
--- a/linear-algebra/blas1.lisp
+++ b/linear-algebra/blas1.lisp
@@ -1,6 +1,6 @@
 ;; BLAS level 1, Vector operations
 ;; Liam Healy, Wed Apr 26 2006 - 15:23
-;; Time-stamp: <2010-06-30 19:57:28EDT blas1.lisp>
+;; Time-stamp: <2010-07-07 14:25:01EDT blas1.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -233,29 +233,29 @@
  (let ((v1 (array-default 3))
 	(v2 (array-default 3)))
    (blas-swap v2 v1)
-   (list (cl-array v1) (cl-array v2))))
+   (list (grid:copy-to v1) (grid:copy-to v2))))
 
 (generate-all-array-tests blas-copy :float-complex
  (let ((v1 (array-default 3))
 	(v2 (array-default 3 t)))
    (blas-copy v1 v2)
-   (cl-array v2)))
+   (grid:copy-to v2)))
 
 (generate-all-array-tests axpy :float-complex
  (let ((v1 (array-default 8))
 	(v2 (array-default 8))
 	(scalar (scalar-default)))
-   (cl-array (axpy scalar v1 v2))))
+   (grid:copy-to (axpy scalar v1 v2))))
 
 (generate-all-array-tests scale #+fsbv :float-complex #-fsbv :float
  (let ((v1 (array-default 8))
 	(scalar (scalar-default)))
-   (cl-array (scale scalar v1))))
+   (grid:copy-to (scale scalar v1))))
 
 (generate-all-array-tests scale :complex
  (let ((v1 (array-default 8))
        (scalar (scalar-default t)))
-   (cl-array (scale scalar v1))))
+   (grid:copy-to (scale scalar v1))))
 
 (generate-all-array-tests givens :float
  (let ((v1 (array-default 8))
@@ -267,4 +267,4 @@
 	(setf (grid:gref sines i) (sin (grid:gref angles i)))
 	(setf (grid:gref cosines i) (cos (grid:gref angles i))))
    (givens-rotation v1 v2 cosines sines)
-   (list (cl-array v1) (cl-array v2))))
+   (list (grid:copy-to v1) (grid:copy-to v2))))
diff --git a/linear-algebra/blas2.lisp b/linear-algebra/blas2.lisp
index 9475881c..ce0213e1 100644
--- a/linear-algebra/blas2.lisp
+++ b/linear-algebra/blas2.lisp
@@ -1,6 +1,6 @@
 ;; BLAS level 2, Matrix-vector operations
 ;; Liam Healy, Wed Apr 26 2006 - 21:08
-;; Time-stamp: <2010-06-29 22:15:24EDT blas2.lisp>
+;; Time-stamp: <2010-07-07 14:25:00EDT blas2.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -340,21 +340,21 @@
        (v2 (array-default 3))
        (s1 (scalar-default))
        (s2 (scalar-default)))
-   (cl-array (matrix-product m1 v1 v2 s1 s2))))
+   (grid:copy-to (matrix-product m1 v1 v2 s1 s2))))
 
 (generate-all-array-tests matrix-product-triangular
 			  #+fsbv :float-complex #-fsbv :float
  (let ((m1 (array-default '(3 3)))
        (v1 (array-default 3))
        (s1 (scalar-default)))
-   (cl-array (matrix-product-triangular m1 v1 s1))))
+   (grid:copy-to (matrix-product-triangular m1 v1 s1))))
 
 (generate-all-array-tests inverse-matrix-product
 			  #+fsbv :float-complex #-fsbv :float
  (let ((m1 (array-default '(3 3)))
        (v1 (array-default 3))
        (s1 (scalar-default)))
-   (cl-array (inverse-matrix-product m1 v1 s1))))
+   (grid:copy-to (inverse-matrix-product m1 v1 s1))))
 
 (generate-all-array-tests matrix-product-symmetric :float
  (let ((m1 (array-default '(3 3)))
@@ -362,7 +362,7 @@
 	(v3 (array-default 3))
 	(s1 (scalar-default))
 	(s2 (scalar-default)))
-   (cl-array (matrix-product-symmetric m1 v1 v3 s1 s2))))
+   (grid:copy-to (matrix-product-symmetric m1 v1 v3 s1 s2))))
 
 #+fsbv
 (generate-all-array-tests matrix-product-hermitian :complex
@@ -371,7 +371,7 @@
        (v2 (array-default 3))
        (s1 (scalar-default))
        (s2 (scalar-default)))
-   (cl-array (matrix-product-hermitian m1 v1 v2 s1 s2))))
+   (grid:copy-to (matrix-product-hermitian m1 v1 v2 s1 s2))))
 
 #|
 ;;; Error, needs to be tracked down
@@ -383,5 +383,5 @@
 	(v1 (array-default 3))
 	(v2 (array-default 3))
 	(s1 (scalar-default)))
-   (cl-array (rank-1-update s1 v1 v2 m1))))
+   (grid:copy-to (rank-1-update s1 v1 v2 m1))))
 |#
diff --git a/linear-algebra/blas3.lisp b/linear-algebra/blas3.lisp
index 1b504ecf..ab51b2a8 100644
--- a/linear-algebra/blas3.lisp
+++ b/linear-algebra/blas3.lisp
@@ -1,6 +1,6 @@
 ;; BLAS level 3, Matrix-matrix operations
 ;; Liam Healy, Wed Apr 26 2006 - 21:08
-;; Time-stamp: <2010-06-29 22:15:23EDT blas3.lisp>
+;; Time-stamp: <2010-07-07 14:25:00EDT blas3.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -177,26 +177,26 @@
        (m3 (array-default '(3 3)))
        (s1 (scalar-default))
        (s2 (scalar-default)))
-   (cl-array (matrix-product m1 m2 m3 s1 s2))))
+   (grid:copy-to (matrix-product m1 m2 m3 s1 s2))))
 
 (generate-all-array-tests matrix-product-nonsquare :float-complex
  (let ((m1 (array-default '(2 3)))
        (m2 (array-default '(3 2))))
-   (cl-array (matrix-product m1 m2))))
+   (grid:copy-to (matrix-product m1 m2))))
 
 (generate-all-array-tests matrix-product-triangular
 			  #+fsbv :float-complex #-fsbv :float
  (let ((m1 (array-default '(3 3)))
        (m2 (array-default '(3 3)))
        (s1 (scalar-default)))
-   (cl-array (matrix-product-triangular m1 m2 s1))))
+   (grid:copy-to (matrix-product-triangular m1 m2 s1))))
 
 (generate-all-array-tests inverse-matrix-product 
 			  #+fsbv :float-complex #-fsbv :float
  (let ((m1 (array-default '(3 3)))
        (m2 (array-default '(3 3)))
        (s1 (scalar-default)))
-   (cl-array (inverse-matrix-product m1 m2 s1))))
+   (grid:copy-to (inverse-matrix-product m1 m2 s1))))
 
 (generate-all-array-tests matrix-product-symmetric :float
  (let ((m1 (array-default '(3 3)))
@@ -204,7 +204,7 @@
        (m3 (array-default '(3 3)))
        (s1 (scalar-default))
        (s2 (scalar-default)))
-   (cl-array (matrix-product-symmetric m1 m2 m3 s1 s2))))
+   (grid:copy-to (matrix-product-symmetric m1 m2 m3 s1 s2))))
 
 #+fsbv
 (generate-all-array-tests matrix-product-hermitian :complex
@@ -213,4 +213,4 @@
        (m3 (array-default '(3 3)))
        (s1 (scalar-default))
        (s2 (scalar-default)))
-   (cl-array (matrix-product-hermitian m1 m2 m3 s1 s2))))
+   (grid:copy-to (matrix-product-hermitian m1 m2 m3 s1 s2))))
diff --git a/linear-algebra/exponential.lisp b/linear-algebra/exponential.lisp
index 688d420f..828cce90 100644
--- a/linear-algebra/exponential.lisp
+++ b/linear-algebra/exponential.lisp
@@ -1,6 +1,6 @@
 ;; Exponential of a matrix
 ;; Liam Healy 2008-08-10 17:25:35EDT exponential.lisp
-;; Time-stamp: <2010-06-29 22:15:23EDT exponential.lisp>
+;; Time-stamp: <2010-07-07 14:25:00EDT exponential.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -41,7 +41,7 @@
 ;;; when exponentiated gives [[cos x,  sin x], [-sin x,  cos x]]
 (let ((mat #m(0.0d0 1.0d0 ^ -1.0d0 0.0d0))
        (exp (grid:make-foreign-array 'double-float :dimensions '(2 2))))
-  (cl-array (matrix-exponential mat exp)))
+  (grid:copy-to (matrix-exponential mat exp)))
 #2A((0.5403023058681384d0 0.841470984807895d0)
     (-0.841470984807895d0 0.5403023058681384d0))
 |#
diff --git a/linear-algebra/lu.lisp b/linear-algebra/lu.lisp
index bcc9084e..fe24ced8 100644
--- a/linear-algebra/lu.lisp
+++ b/linear-algebra/lu.lisp
@@ -1,6 +1,6 @@
 ;; LU decomposition
 ;; Liam Healy, Thu Apr 27 2006 - 12:42
-;; Time-stamp: <2010-06-29 22:15:23EDT lu.lisp>
+;; Time-stamp: <2010-07-07 14:24:59EDT lu.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -164,7 +164,7 @@
 
 (save-test
  lu
- (cl-array
+ (grid:copy-to
   (invert-matrix
    (grid:make-foreign-array 'double-float
 		:dimensions  '(2 2)
@@ -176,7 +176,7 @@
    (multiple-value-bind (matrix perm)
        (lu-decomposition matrix)
     (let ((x (lu-solve matrix vec perm)))
-      (cl-array
+      (grid:copy-to
        (permute-inverse
 	perm
 	(matrix-product-triangular
diff --git a/polynomial.lisp b/polynomial.lisp
index f5506fc4..db86ea47 100644
--- a/polynomial.lisp
+++ b/polynomial.lisp
@@ -1,6 +1,6 @@
 ;; Polynomials
 ;; Liam Healy, Tue Mar 21 2006 - 18:33
-;; Time-stamp: <2010-07-06 23:17:06EDT polynomial.lisp>
+;; Time-stamp: <2010-07-07 14:18:55EDT polynomial.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -211,8 +211,7 @@
  (solve-cubic -6.0d0 -13.0d0 42.0d0)
  (solve-cubic-complex -1.0d0 1.0d0 -1.0d0)
  ;; Example from GSL manual
- (copy (polynomial-solve #m(-1.0d0 0.0d0 0.0d0 0.0d0 0.0d0 1.0d0))
-        :grid-type 'array)
+ (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)
@@ -243,18 +242,15 @@
  (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)
- (copy (polynomial-solve #m(-120 274 -225 85 -15 1.0))
-        :grid-type 'array)
- (copy (polynomial-solve #m(1 0 0 0 1 0 0 0 1))
-        :grid-type 'array)
+ (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))
 	(dd (divided-difference xa ya)))
    (list
-    (copy dd :grid-type 'array)
+    (grid:copy-to dd)
     (map 'vector (lambda (x) (evaluate xa x :divided-difference dd))
-	 (copy xa :grid-type 'array))
+	 (grid:copy-to xa))
     (map 'vector
 	 (lambda (x) (evaluate (taylor-divided-difference 1.5d0 dd xa) (- x 1.5d0)))
-	 (copy xa :grid-type 'array)))))
-
+	 (grid:copy-to xa)))))
diff --git a/random/dirichlet.lisp b/random/dirichlet.lisp
index 34f3f2ec..4d0f7f6a 100644
--- a/random/dirichlet.lisp
+++ b/random/dirichlet.lisp
@@ -1,6 +1,6 @@
 ;; Dirichlet distribution
 ;; Liam Healy, Sun Oct 29 2006
-;; Time-stamp: <2010-06-27 18:13:44EDT dirichlet.lisp>
+;; Time-stamp: <2010-07-07 14:24:59EDT dirichlet.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -83,7 +83,7 @@
 (save-test dirichlet
  (let ((rng (make-random-number-generator +mt19937+ 0))
        (alpha #m(1.0d0 2.0d0 3.0d0 4.0d0)))
-   (cl-array (sample rng :dirichlet :alpha alpha)))
+   (grid:copy-to (sample rng :dirichlet :alpha alpha)))
  (let ((alpha #m(1.0d0 2.0d0 3.0d0 4.0d0))
        (theta #m(1.0d0 2.0d0 3.0d0 4.0d0)))
    (dirichlet-pdf alpha theta))
diff --git a/random/generators.lisp b/random/generators.lisp
index f2677e3a..045b245b 100644
--- a/random/generators.lisp
+++ b/random/generators.lisp
@@ -1,6 +1,6 @@
 ;; Generators of random numbers.
 ;; Liam Healy, Sat Jul 15 2006 - 14:43
-;; Time-stamp: <2010-07-01 21:15:11EDT generators.lisp>
+;; Time-stamp: <2010-07-07 14:30:30EDT generators.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -176,7 +176,7 @@
 ;;;; Copying state
 ;;;;****************************************************************************
 
-(defmfun grid:copy-to-destination
+(defmfun grid::copy-to-destination
     ((source random-number-generator) (destination random-number-generator))
   "gsl_rng_memcpy"
   (((mpointer destination) :pointer) ((mpointer source) :pointer))
@@ -188,7 +188,7 @@
    making destination into an exact copy
    of source.  The two generators must be of the same type.")
 
-(defmfun grid:copy-making-destination ((instance random-number-generator))
+(defmfun grid::copy-making-destination ((instance random-number-generator))
   "gsl_rng_clone" (((mpointer instance) :pointer))
   :definition :method
   :c-return :pointer
diff --git a/random/multinomial.lisp b/random/multinomial.lisp
index 3e9a3b76..6d492edd 100644
--- a/random/multinomial.lisp
+++ b/random/multinomial.lisp
@@ -1,6 +1,6 @@
 ;; Multinomial distribution
 ;; Liam Healy, Sat Nov 25 2006 - 16:00
-;; Time-stamp: <2010-06-29 22:15:17EDT multinomial.lisp>
+;; Time-stamp: <2010-07-07 14:24:58EDT multinomial.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -78,7 +78,7 @@
 (save-test multinomial
  (let ((rng (make-random-number-generator +mt19937+ 0))
        (p #m(0.1d0 0.2d0 0.3d0 0.4d0)))
-   (cl-array (sample rng :multinomial :sum 8 :probabilities p)))
+   (grid:copy-to (sample rng :multinomial :sum 8 :probabilities p)))
  (let ((p #m(0.1d0 0.2d0 0.3d0 0.4d0))
        (n #31m(5 0 1 2)))
    (multinomial-pdf p N))
diff --git a/random/quasi.lisp b/random/quasi.lisp
index f1b05689..6544eba2 100644
--- a/random/quasi.lisp
+++ b/random/quasi.lisp
@@ -1,6 +1,6 @@
 ;; Quasi-random sequences in arbitrary dimensions.
 ;; Liam Healy, Sun Jul 16 2006 - 15:54
-;; Time-stamp: <2010-07-01 21:15:03EDT quasi.lisp>
+;; Time-stamp: <2010-07-07 14:30:06EDT quasi.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -64,7 +64,7 @@
   :export nil
   :index gsl-random-state)
 
-(defmfun grid:copy-to-destination
+(defmfun grid::copy-to-destination
     ((source quasi-random-number-generator)
      (destination quasi-random-number-generator))
   "gsl_qrng_memcpy"
@@ -76,7 +76,7 @@
    pre-existing generator dest, making dest into an exact copy
    of src.  The two generators must be of the same type.")
 
-(defmfun grid:copy-making-destination ((instance quasi-random-number-generator))
+(defmfun grid::copy-making-destination ((instance quasi-random-number-generator))
   "gsl_qrng_clone" (((mpointer instance) :pointer))
   :definition :method
   :c-return :pointer
@@ -121,4 +121,4 @@
 	  (vec (grid:make-foreign-array 'double-float :dimensions 2)))
      (loop repeat 5
 	   do (qrng-get gen vec)
-	   append (coerce (cl-array vec) 'list))))
+	   append (coerce (grid:copy-to vec) 'list))))
diff --git a/random/shuffling-sampling.lisp b/random/shuffling-sampling.lisp
index b92ea491..3e117194 100644
--- a/random/shuffling-sampling.lisp
+++ b/random/shuffling-sampling.lisp
@@ -1,6 +1,6 @@
 ;; Shuffling and sampling
 ;; Liam Healy, Sat Dec  2 2006 - 18:40
-;; Time-stamp: <2010-06-29 22:15:18EDT shuffling-sampling.lisp>
+;; Time-stamp: <2010-07-07 14:24:58EDT shuffling-sampling.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -94,10 +94,10 @@
 (save-test shuffling-sampling
  (let ((rng (make-random-number-generator +mt19937+ 0))
        (v1 #31m(1 2 3 4 5 6 7 8)))
-   (cl-array (sample rng :shuffle :base v1)))
+   (grid:copy-to (sample rng :shuffle :base v1)))
  (let ((rng (make-random-number-generator +mt19937+ 0))
        (v1 #31m(1 2 3 4 5 6 7 8)))
-   (cl-array (sample rng :choose-random :src v1 :dest 4)))
+   (grid:copy-to (sample rng :choose-random :src v1 :dest 4)))
  (let ((rng (make-random-number-generator +mt19937+ 0))
        (v1 #31m(1 2 3 4 5 6 7 8)))
-   (cl-array (sample rng :random-sample :src v1 :dest 10))))
+   (grid:copy-to (sample rng :random-sample :src v1 :dest 10))))
diff --git a/sorting.lisp b/sorting.lisp
index 592374ba..8b196bb6 100644
--- a/sorting.lisp
+++ b/sorting.lisp
@@ -1,6 +1,6 @@
 ;; Sorting
 ;; Liam Healy, Fri Apr 14 2006 - 20:20
-;; Time-stamp: <2010-06-27 18:13:49EDT sorting.lisp>
+;; Time-stamp: <2010-07-07 14:24:54EDT sorting.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -271,44 +271,44 @@
 (generate-all-array-tests sort-vector :no-complex
  (let ((v1 (array-default 8)))
    ;; or you can use msort
-   (cl-array (sort-vector v1))))
+   (grid:copy-to (sort-vector v1))))
 
 (generate-all-array-tests sort-matrix :no-complex
  (let ((m1 (array-default '(3 3))))
-   (cl-array (msort m1))))
+   (grid:copy-to (msort m1))))
 
 (generate-all-array-tests sort-vector-index :no-complex
  (let ((perm (make-permutation 8))
 	(v1 (array-default 8)))
    (sort-vector-index perm v1)
-   (cl-array perm)))
+   (grid:copy-to perm)))
 
 (generate-all-array-tests sort-vector-smallest :no-complex
  (let ((v1 (array-default 8))
 	(v2 (array-default 3)))
-   (cl-array (sort-vector-smallest v2 v1))))
+   (grid:copy-to (sort-vector-smallest v2 v1))))
 
 (generate-all-array-tests sort-matrix-smallest :no-complex
  (let ((m1 (array-default '(3 3)))
 	(m2 (array-default '(2 3) t)))
-   (cl-array (sort-smallest m2 m1))))
+   (grid:copy-to (sort-smallest m2 m1))))
 
 (generate-all-array-tests sort-vector-smallest-index :no-complex
  (let ((comb (make-combination 8 3 nil))
 	(v1 (array-default 8)))
-   (cl-array (sort-vector-smallest-index comb v1))))
+   (grid:copy-to (sort-vector-smallest-index comb v1))))
 
 (generate-all-array-tests sort-vector-largest :no-complex
  (let ((v1 (array-default 8))
 	(v2 (array-default 3)))
-   (cl-array (sort-vector-largest v2 v1))))
+   (grid:copy-to (sort-vector-largest v2 v1))))
 
 (generate-all-array-tests sort-matrix-largest :no-complex
  (let ((m1 (array-default '(3 3)))
 	(m2 (array-default '(2 3) t)))
-   (cl-array (sort-largest m2 m1))))
+   (grid:copy-to (sort-largest m2 m1))))
 
 (generate-all-array-tests sort-vector-largest-index :no-complex
  (let ((comb (make-combination 8 3 nil))
 	(v1 (array-default 8)))
-   (cl-array (sort-vector-largest-index comb v1))))
+   (grid:copy-to (sort-vector-largest-index comb v1))))
diff --git a/special-functions/bessel.lisp b/special-functions/bessel.lisp
index 2a54878a..da4735fb 100644
--- a/special-functions/bessel.lisp
+++ b/special-functions/bessel.lisp
@@ -1,6 +1,6 @@
 ;; Bessel functions
 ;; Liam Healy, Fri Mar 17 2006 - 18:42
-;; Time-stamp: <2010-06-29 22:15:22EDT bessel.lisp>
+;; Time-stamp: <2010-07-07 14:24:57EDT bessel.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -515,65 +515,65 @@
 	   (cylindrical-bessel-J0 4.0d0)
 	   (cylindrical-bessel-J1 4.0d0)
 	   (cylindrical-bessel-J 2 4.0d0)
-	   (cl-array (cylindrical-bessel-J-array-order 2.0d0 4 2))
+	   (grid:copy-to (cylindrical-bessel-J-array-order 2.0d0 4 2))
 	   (cylindrical-bessel-Y0 4.0d0)
 	   (cylindrical-bessel-Y1 4.0d0)
 	   (cylindrical-bessel-Y 3 4.0d0)
 	   (let ((besarr (grid:make-foreign-array 'double-float :dimensions 4)))
 	     (cylindrical-bessel-Yn-array 2.0d0 besarr 2)
-	     (cl-array besarr))
+	     (grid:copy-to besarr))
 	   (cylindrical-bessel-I0 4.0d0)
 	   (cylindrical-bessel-I1 4.0d0)
 	   (cylindrical-bessel-I 3 4.0d0)
 	   (cylindrical-bessel-I 3.0d0 4.0d0)
 	   (let ((besarr (grid:make-foreign-array 'double-float :dimensions 4)))
 	     (cylindrical-bessel-In-array 2.0d0 besarr 2)
-	     (cl-array besarr))
+	     (grid:copy-to besarr))
 	   (cylindrical-bessel-I0-scaled 4.0d0)
 	   (cylindrical-bessel-I1-scaled 4.0d0)
 	   (cylindrical-bessel-I-scaled 3 4.0d0)
 	   (cylindrical-bessel-I-scaled 3.0d0 4.0d0)
 	   (let ((besarr (grid:make-foreign-array 'double-float :dimensions 4)))
 	     (cylindrical-bessel-In-scaled-array 2.0d0 besarr 2)
-	     (cl-array besarr))
+	     (grid:copy-to besarr))
 	   (cylindrical-bessel-K0 4.0d0)
 	   (cylindrical-bessel-K1 4.0d0)
 	   (cylindrical-bessel-K 2 4.0d0)
 	   (cylindrical-bessel-K 3.0d0 4.0d0)
 	   (let ((besarr (grid:make-foreign-array 'double-float :dimensions 4)))
 	     (cylindrical-bessel-Kn-array 2.0d0 besarr 2)
-	     (cl-array besarr))
+	     (grid:copy-to besarr))
 	   (cylindrical-bessel-K0-scaled 4.0d0)
 	   (cylindrical-bessel-K1-scaled 4.0d0)
 	   (cylindrical-bessel-K-scaled 2 4.0d0)
 	   (cylindrical-bessel-K-scaled 3.0d0 4.0d0)
 	   (let ((besarr (grid:make-foreign-array 'double-float :dimensions 4)))
 	     (cylindrical-bessel-Kn-array 2.0d0 besarr 2)
-	     (cl-array besarr))
+	     (grid:copy-to besarr))
 	   (spherical-bessel-j0 4.0d0)
 	   (spherical-bessel-j1 4.0d0)
 	   (spherical-bessel-j2 4.0d0)
 	   (spherical-bessel-jl 3 4.0d0)
 	   (let ((besarr (grid:make-foreign-array 'double-float :dimensions 4)))
 	     (spherical-bessel-jl-array 4.0d0 besarr)
-	     (cl-array besarr))
+	     (grid:copy-to besarr))
 	   (let ((besarr (grid:make-foreign-array 'double-float :dimensions 4)))
 	     (spherical-bessel-jl-steed-array 4.0d0 besarr)
-	     (cl-array besarr))
+	     (grid:copy-to besarr))
 	   (spherical-bessel-y0 4.0d0)
 	   (spherical-bessel-y1 4.0d0)
 	   (spherical-bessel-y2 4.0d0)
 	   (spherical-bessel-yl 2 4.0d0)
 	   (let ((besarr (grid:make-foreign-array 'double-float :dimensions 4)))
 	     (spherical-bessel-yl-array 4.0d0 besarr)
-	     (cl-array besarr))
+	     (grid:copy-to besarr))
 	   (spherical-bessel-i0-scaled 4.0d0)
 	   (spherical-bessel-i1-scaled 4.0d0)
 	   (spherical-bessel-i2-scaled 4.0d0)
 	   (spherical-bessel-il-scaled 3 4.0d0)
 	   (let ((besarr (grid:make-foreign-array 'double-float :dimensions 4)))
 	     (spherical-bessel-il-scaled-array 4.0d0 besarr)
-	     (cl-array besarr))
+	     (grid:copy-to besarr))
 	   (spherical-bessel-k0-scaled 4.0d0)
 	   (spherical-bessel-k1-scaled 4.0d0)
 
@@ -581,9 +581,9 @@
 	   (spherical-bessel-kl-scaled 3 4.0d0)
 	   (let ((besarr (grid:make-foreign-array 'double-float :dimensions 4)))
 	     (spherical-bessel-kl-scaled-array 4.0d0 besarr)
-	     (cl-array besarr))
+	     (grid:copy-to besarr))
 	   (cylindrical-bessel-J 3.0d0 4.0d0)
-	   (cl-array (cylindrical-bessel-J-array-x 0.5d0 #m(1.0d0 2.0d0 3.0d0)))
+	   (grid:copy-to (cylindrical-bessel-J-array-x 0.5d0 #m(1.0d0 2.0d0 3.0d0)))
 	   (cylindrical-bessel-Y 3.0d0 4.0d0)
 	   (bessel-lnKnu 3.0d0 4.0d0)
 	   (bessel-zero-J0 5)
diff --git a/special-functions/coulomb.lisp b/special-functions/coulomb.lisp
index d62f63fb..4601633e 100644
--- a/special-functions/coulomb.lisp
+++ b/special-functions/coulomb.lisp
@@ -1,6 +1,6 @@
 ;; Coulumb functions
 ;; Liam Healy, Sat Mar 18 2006 - 23:23
-;; Time-stamp: <2010-06-29 22:15:22EDT coulomb.lisp>
+;; Time-stamp: <2010-07-07 14:24:53EDT coulomb.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -148,7 +148,7 @@
   "The Coulomb wave function normalization constant C_L(\eta)
    for L > -1.")
 
-(defmfun coulomb-CL-array
+(defmfun coulomb-cl-array
     (L-min eta &optional (size-or-array *default-sf-array-size*)
 	   &aux (array (vdf size-or-array)))
   "gsl_sf_coulomb_CL_array"
@@ -169,14 +169,14 @@
  (coulomb-wave-FG 0.0d0 1.0d0 2.0d0 0)
  (let ((arr (grid:make-foreign-array 'double-float :dimensions 3)))
    (coulomb-wave-F-array 0.0d0 1.0d0 2.0d0 arr)
-   (cl-array arr))
+   (grid:copy-to arr))
  (coulomb-wave-fg 1.0d0 2.0d0 2.5d0 1)
  (let ((Farr (grid:make-foreign-array 'double-float :dimensions 3))
        (Garr (grid:make-foreign-array 'double-float :dimensions 3)))
    (coulomb-wave-FG-array 1.5d0 1.0d0 1.0d0 Farr Garr)
-   (append (coerce (cl-array Farr) 'list) (coerce (cl-array Garr) 'list)))
+   (append (coerce (grid:copy-to Farr) 'list) (coerce (grid:copy-to Garr) 'list)))
  (let ((arr (grid:make-foreign-array 'double-float :dimensions 3)))
-   (coulomb-wave-sphF-array  0.0d0 1.0d0 2.0d0 arr) (cl-array arr))
+   (coulomb-wave-sphF-array  0.0d0 1.0d0 2.0d0 arr) (grid:copy-to arr))
  (coulomb-cl 1.0d0 2.5d0)
  (let ((cl (grid:make-foreign-array 'double-float :dimensions 3)))
-   (coulomb-CL-array 0.0d0 1.0d0 cl) (cl-array cl)))
+   (coulomb-CL-array 0.0d0 1.0d0 cl) (grid:copy-to cl)))
diff --git a/special-functions/gegenbauer.lisp b/special-functions/gegenbauer.lisp
index 6279f4ba..87d83a52 100644
--- a/special-functions/gegenbauer.lisp
+++ b/special-functions/gegenbauer.lisp
@@ -1,6 +1,6 @@
 ;; Gegenbauer polynomials
 ;; Liam Healy, Fri Apr 28 2006 - 20:40
-;; Time-stamp: <2010-06-27 18:13:48EDT gegenbauer.lisp>
+;; Time-stamp: <2010-07-07 14:24:57EDT gegenbauer.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -62,4 +62,4 @@
   (gegenbauer-2 1.0d0 3.0d0)
   (gegenbauer-3 1.0d0 3.0d0)
   (gegenbauer 4 1.0d0 3.0d0)
-  (cl-array (gegenbauer-array 1.0d0 3.0d0 4)))
+  (grid:copy-to (gegenbauer-array 1.0d0 3.0d0 4)))
diff --git a/special-functions/legendre.lisp b/special-functions/legendre.lisp
index dc6cc87e..b19a98a1 100644
--- a/special-functions/legendre.lisp
+++ b/special-functions/legendre.lisp
@@ -1,6 +1,6 @@
 ;; Legendre functions
 ;; Liam Healy, Sat Apr 29 2006 - 19:16
-;; Time-stamp: <2010-06-29 22:15:19EDT legendre.lisp>
+;; Time-stamp: <2010-07-07 14:24:57EDT legendre.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -289,26 +289,26 @@
   (legendre-Pl 4 0.3d0)
   (let ((arr (grid:make-foreign-array 'double-float :dimensions 4)))
       (legendre-Pl-array 0.5d0 arr)
-      (cl-array arr))
+      (grid:copy-to arr))
   (legendre-Q0 3.3d0)
   (legendre-Q1 3.3d0)
   (legendre-Ql 2 3.3d0)
   (legendre-Plm 4 3 0.5d0)
   (let ((arr (grid:make-foreign-array 'double-float :dimensions 4)))
       (legendre-Plm-array 2 0.5d0 arr)
-      (cl-array arr))
+      (grid:copy-to arr))
   (let ((val (grid:make-foreign-array 'double-float :dimensions 4))
 	(deriv (grid:make-foreign-array 'double-float :dimensions 4)))
       (legendre-Plm-deriv-array 2 0.5d0 val deriv)
-      (cl-array deriv))
+      (grid:copy-to deriv))
   (legendre-sphplm 1200 1100 0.3d0)
   (let ((arr (grid:make-foreign-array 'double-float :dimensions 4)))
       (legendre-sphPlm-array 4 0.5d0 arr)
-      (cl-array arr))
+      (grid:copy-to arr))
   (let ((val (grid:make-foreign-array 'double-float :dimensions 4))
 	   (deriv (grid:make-foreign-array 'double-float :dimensions 4)))
 	(legendre-sphPlm-deriv-array 4 0.5d0 val deriv)
-	(cl-array deriv))
+	(grid:copy-to deriv))
   (legendre-conicalp-half 3.5d0 10.0d0)
   (legendre-conicalp-mhalf 3.5d0 10.0d0)
   (legendre-conicalp-0 3.5d0 10.0d0)
@@ -320,4 +320,4 @@
   (legendre-h3d 4 1.0d0 0.5d0)
   (let ((arr (grid:make-foreign-array 'double-float :dimensions 4)))
       (legendre-h3d-array 1.0d0 0.5d0 arr)
-      (cl-array arr)))
+      (grid:copy-to arr)))
diff --git a/special-functions/mathieu.lisp b/special-functions/mathieu.lisp
index 6f5b389f..96b80c24 100644
--- a/special-functions/mathieu.lisp
+++ b/special-functions/mathieu.lisp
@@ -1,6 +1,6 @@
 ;; Mathieu functions
 ;; Liam Healy 2009-02-16 16:30:59EST mathieu.lisp
-;; Time-stamp: <2010-06-27 18:13:47EDT mathieu.lisp>
+;; Time-stamp: <2010-07-07 14:24:56EDT mathieu.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -290,6 +290,6 @@
 	   (mathieu-se 15 15.0d0 (/ pi 2))
 	   (mathieu-se 15 20.0d0 (/ pi 2))
 	   (mathieu-se 15 25.0d0 (/ pi 2))
-	   (cl-array (mathieu-ce-array 0.0d0 (/ pi 2) 6))
-	   (cl-array (mathieu-ce-array 20.0d0 0.0d0 16))
-	   (cl-array (mathieu-se-array 20.0d0 (/ pi 2) 15 1)))
+	   (grid:copy-to (mathieu-ce-array 0.0d0 (/ pi 2) 6))
+	   (grid:copy-to (mathieu-ce-array 20.0d0 0.0d0 16))
+	   (grid:copy-to (mathieu-se-array 20.0d0 (/ pi 2) 15 1)))
diff --git a/test-unit/augment.lisp b/test-unit/augment.lisp
index be6a2345..17ac0d58 100644
--- a/test-unit/augment.lisp
+++ b/test-unit/augment.lisp
@@ -1,6 +1,6 @@
 ;; Additional methods for lisp-unit
 ;; Liam Healy 2009-04-15 23:23:30EDT augment.lisp
-;; Time-stamp: <2010-06-29 22:51:21EDT augment.lisp>
+;; Time-stamp: <2010-07-07 14:24:56EDT augment.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -24,7 +24,7 @@
     ((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))
-    (lisp-unit:numerical-equal (cl-array result1) (cl-array result2)
+    (lisp-unit:numerical-equal (grid:copy-to result1) (grid:copy-to result2)
 			       :test test)))
 
 ;;; See cdf/test.c
diff --git a/tests/axpy.lisp b/tests/axpy.lisp
index 63bf5dff..8b014436 100644
--- a/tests/axpy.lisp
+++ b/tests/axpy.lisp
@@ -33,7 +33,7 @@
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
 	    '(32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 -49.08)))
 	  (SCALAR -39.66))
-      (CL-ARRAY (AXPY SCALAR V1 V2)))))
+      (grid:copy-to (AXPY SCALAR V1 V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(1400.77d0 -284.06839999999994d0 -147.7214d0
@@ -55,7 +55,7 @@
 	      -16.12d0 -8.25d0 21.44d0
 	      -49.08d0)))
 	  (SCALAR -39.66d0))
-      (CL-ARRAY (AXPY SCALAR V1 V2)))))
+      (GRID:COPY-TO (AXPY SCALAR V1 V2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -80,7 +80,7 @@
 	      #C(19.68 -5.55) #C(-8.82 25.37)
 	      #C(-30.58 31.67))))
 	  (SCALAR #C(-39.66 -49.46)))
-      (CL-ARRAY (AXPY SCALAR V1 V2)))))
+      (GRID:COPY-TO (AXPY SCALAR V1 V2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -110,4 +110,4 @@
 	      #C(-39.66d0 -49.46d0) #C(19.68d0 -5.55d0)
 	      #C(-8.82d0 25.37d0) #C(-30.58d0 31.67d0))))
 	  (SCALAR #C(-39.66d0 -49.46d0)))
-      (CL-ARRAY (AXPY SCALAR V1 V2))))))
+      (GRID:COPY-TO (AXPY SCALAR V1 V2))))))
diff --git a/tests/bessel.lisp b/tests/bessel.lisp
index fba86466..27e755d0 100644
--- a/tests/bessel.lisp
+++ b/tests/bessel.lisp
@@ -31,7 +31,7 @@
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    #(0.35283402861563773d0 0.12894324947440206d0
      0.033995719807568436d0 0.007039629755871686d0)
-   (cl-array (cylindrical-bessel-J-array-order 2.0d0 4 2)))
+   (grid:copy-to (cylindrical-bessel-J-array-order 2.0d0 4 2)))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST -0.016940739325064968d0 1.8993556609468549d-16)
    (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-Y0 4.0d0)))
@@ -49,7 +49,7 @@
     (LET ((BESARR
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
       (CYLINDRICAL-BESSEL-YN-ARRAY 2.0d0 BESARR 2)
-      (CL-ARRAY BESARR))))
+      (GRID:COPY-TO BESARR))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 11.301921952136329d0 2.7297681442535893d-14)
    (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-I0 4.0d0)))
@@ -70,7 +70,7 @@
     (LET ((BESARR
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
       (CYLINDRICAL-BESSEL-IN-ARRAY 2.0d0 BESARR 2)
-      (CL-ARRAY BESARR))))
+      (GRID:COPY-TO BESARR))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 0.2070019212239867d0 2.241925168997723d-16)
    (MULTIPLE-VALUE-LIST
@@ -94,7 +94,7 @@
     (LET ((BESARR
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
       (CYLINDRICAL-BESSEL-IN-SCALED-ARRAY 2.0d0 BESARR 2)
-      (CL-ARRAY BESARR))))
+      (GRID:COPY-TO BESARR))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 0.011159676085853023d0 2.0424662435034432d-17)
    (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-K0 4.0d0)))
@@ -130,7 +130,7 @@
     (LET ((BESARR
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
       (CYLINDRICAL-BESSEL-KN-ARRAY 2.0d0 BESARR 2)
-      (CL-ARRAY BESARR))))
+      (GRID:COPY-TO BESARR))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST -0.18920062382698205d0 1.6804391107692678d-16)
    (MULTIPLE-VALUE-LIST (SPHERICAL-BESSEL-J0 4.0d0)))
@@ -151,7 +151,7 @@
     (LET ((BESARR
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
       (SPHERICAL-BESSEL-JL-ARRAY 4.0d0 BESARR)
-      (CL-ARRAY BESARR))))
+      (GRID:COPY-TO BESARR))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(-0.18920062382698208d0 0.11611074925915742d0
@@ -160,7 +160,7 @@
     (LET ((BESARR
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
       (SPHERICAL-BESSEL-JL-STEED-ARRAY 4.0d0 BESARR)
-      (CL-ARRAY BESARR))))
+      (GRID:COPY-TO BESARR))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 0.16341090521590299d0 1.4513803955642766d-16)
    (MULTIPLE-VALUE-LIST (SPHERICAL-BESSEL-Y0 4.0d0)))
@@ -181,7 +181,7 @@
     (LET ((BESARR
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
       (SPHERICAL-BESSEL-YL-ARRAY 4.0d0 BESARR)
-      (CL-ARRAY BESARR))))
+      (GRID:COPY-TO BESARR))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 0.12495806717151219d0 5.5492529314587895d-17)
    (MULTIPLE-VALUE-LIST
@@ -206,7 +206,7 @@
     (LET ((BESARR
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
       (SPHERICAL-BESSEL-IL-SCALED-ARRAY 4.0d0 BESARR)
-      (CL-ARRAY BESARR))))
+      (GRID:COPY-TO BESARR))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 0.39269908169872414d0 1.743934249004316d-16)
    (MULTIPLE-VALUE-LIST
@@ -231,7 +231,7 @@
     (LET ((BESARR
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
       (SPHERICAL-BESSEL-KL-SCALED-ARRAY 4.0d0 BESARR)
-      (CL-ARRAY BESARR))))
+      (GRID:COPY-TO BESARR))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 0.43017147387562193d0 7.641380397338472d-16)
    (MULTIPLE-VALUE-LIST (cylindrical-bessel-J 3.0d0 4.0d0)))
@@ -240,7 +240,7 @@
     #(0.6713967071418024d0 0.5130161365618323d0
       0.06500818287738516d0))
    (MULTIPLE-VALUE-LIST
-    (cl-array (cylindrical-bessel-J-array-x 0.5d0 #m(1.0d0 2.0d0 3.0d0)))))
+    (grid:copy-to (cylindrical-bessel-J-array-x 0.5d0 #m(1.0d0 2.0d0 3.0d0)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST -0.1820221159534852d0 2.020851441225493d-15)
    (MULTIPLE-VALUE-LIST (cylindrical-bessel-Y 3.0d0 4.0d0)))
diff --git a/tests/blas-copy.lisp b/tests/blas-copy.lisp
index 51f8eba0..bd0502b5 100644
--- a/tests/blas-copy.lisp
+++ b/tests/blas-copy.lisp
@@ -27,7 +27,7 @@
 	    'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5 8.24 3.29)))
 	  (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
       (BLAS-COPY V1 V2)
-      (CL-ARRAY V2))))
+      (GRID:COPY-TO V2))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-34.5d0 8.24d0 3.29d0))
    (MULTIPLE-VALUE-LIST
@@ -36,7 +36,7 @@
 	    'DOUBLE-FLOAT :INITIAL-CONTENTS '(-34.5d0 8.24d0 3.29d0)))
 	  (V2 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
       (BLAS-COPY V1 V2)
-      (CL-ARRAY V2))))
+      (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)))
    (MULTIPLE-VALUE-LIST
@@ -49,7 +49,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3)))
       (BLAS-COPY V1 V2)
-      (CL-ARRAY V2))))
+      (GRID:COPY-TO V2))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
@@ -65,4 +65,4 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX DOUBLE-FLOAT) :DIMENSIONS '3)))
       (BLAS-COPY V1 V2)
-      (CL-ARRAY V2)))))
+      (GRID:COPY-TO V2)))))
diff --git a/tests/blas-swap.lisp b/tests/blas-swap.lisp
index 28a36abd..405442e1 100644
--- a/tests/blas-swap.lisp
+++ b/tests/blas-swap.lisp
@@ -31,7 +31,7 @@
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
 	    '(-8.93 34.12 -6.15))))
       (BLAS-SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST #(-8.93d0 34.12d0 -6.15d0)
@@ -46,7 +46,7 @@
 	    'DOUBLE-FLOAT :INITIAL-CONTENTS
 	    '(-8.93d0 34.12d0 -6.15d0))))
       (BLAS-SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
@@ -64,7 +64,7 @@
 	    :INITIAL-CONTENTS
 	    '(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)))))
       (BLAS-SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
@@ -84,4 +84,4 @@
 	    :INITIAL-CONTENTS
 	    '(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0)))))
       (BLAS-SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2))))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2))))))
diff --git a/tests/column.lisp b/tests/column.lisp
index 9ecaebc5..fac955d6 100644
--- a/tests/column.lisp
+++ b/tests/column.lisp
@@ -30,7 +30,7 @@
 	      (-8.93 34.12 -6.15)
 	      (49.27 -13.49 32.5))))
 	  (COL (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
-      (CL-ARRAY (COLUMN M1 1 COL)))))
+      (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(8.24d0 34.12d0 -13.49d0))
    (MULTIPLE-VALUE-LIST
@@ -41,7 +41,7 @@
 	      (-8.93d0 34.12d0 -6.15d0)
 	      (49.27d0 -13.49d0 32.5d0))))
 	  (COL (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
-      (CL-ARRAY (COLUMN M1 1 COL)))))
+      (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)))
    (MULTIPLE-VALUE-LIST
@@ -55,7 +55,7 @@
 	  (COL
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3)))
-      (CL-ARRAY (COLUMN M1 1 COL)))))
+      (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(3.29d0 -8.93d0) #C(-6.15d0 49.27d0)
@@ -70,7 +70,7 @@
 	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
 	  (COL
 	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT) :DIMENSIONS '3)))
-      (CL-ARRAY (COLUMN M1 1 COL)))))
+      (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-68 52 -5))
    (MULTIPLE-VALUE-LIST
@@ -85,7 +85,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 8)
 	    :DIMENSIONS '3)))
-      (CL-ARRAY (COLUMN M1 1 COL)))))
+      (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(44 163 215))
    (MULTIPLE-VALUE-LIST
@@ -100,7 +100,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 8)
 	    :DIMENSIONS '3)))
-      (CL-ARRAY (COLUMN M1 1 COL)))))
+      (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-68 52 -5))
    (MULTIPLE-VALUE-LIST
@@ -114,7 +114,7 @@
 	  (COL
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 16) :DIMENSIONS '3)))
-      (CL-ARRAY (COLUMN M1 1 COL)))))
+      (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(44 163 215))
    (MULTIPLE-VALUE-LIST
@@ -129,7 +129,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 16)
 	    :DIMENSIONS '3)))
-      (CL-ARRAY (COLUMN M1 1 COL)))))
+      (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-68 52 -5))
    (MULTIPLE-VALUE-LIST
@@ -143,7 +143,7 @@
 	  (COL
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 32) :DIMENSIONS '3)))
-      (CL-ARRAY (COLUMN M1 1 COL)))))
+      (GRID:COPY-TO (COLUMN M1 1 COL)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(44 163 215))
    (MULTIPLE-VALUE-LIST
@@ -157,7 +157,7 @@
 	  (COL
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 32) :DIMENSIONS '3)))
-      (CL-ARRAY (COLUMN M1 1 COL)))))
+      (GRID:COPY-TO (COLUMN M1 1 COL)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-68 52 -5))
@@ -173,7 +173,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 64)
 	    :DIMENSIONS '3)))
-      (CL-ARRAY (COLUMN M1 1 COL)))))
+      (GRID:COPY-TO (COLUMN M1 1 COL)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(44 163 215))
@@ -189,5 +189,5 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 64)
 	    :DIMENSIONS '3)))
-      (CL-ARRAY (COLUMN M1 1 COL))))))
+      (GRID:COPY-TO (COLUMN M1 1 COL))))))
 
diff --git a/tests/combination.lisp b/tests/combination.lisp
index e6389017..0958580f 100644
--- a/tests/combination.lisp
+++ b/tests/combination.lisp
@@ -34,14 +34,14 @@
    (MULTIPLE-VALUE-LIST
     (LET ((COMB (MAKE-COMBINATION 4 2)))
       (INIT-FIRST COMB)
-      (LOOP COLLECT (COPY-SEQ (CL-ARRAY COMB)) WHILE
+      (LOOP COLLECT (COPY-SEQ (GRID:COPY-TO COMB)) WHILE
 	   (COMBINATION-NEXT COMB)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST (LIST #(2 3) #(1 3) #(1 2) #(0 3) #(0 2) #(0 1)))
    (MULTIPLE-VALUE-LIST
     (LET ((COMB (MAKE-COMBINATION 4 2)))
       (INIT-LAST COMB)
-      (LOOP COLLECT (COPY-SEQ (CL-ARRAY COMB)) WHILE
+      (LOOP COLLECT (COPY-SEQ (GRID:COPY-TO COMB)) WHILE
 	   (COMBINATION-PREVIOUS COMB)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -52,6 +52,6 @@
     (LOOP FOR I FROM 0 TO 4 APPEND
 	 (LET ((COMB (MAKE-COMBINATION 4 I)))
 	   (INIT-FIRST COMB)
-	   (LOOP COLLECT (COPY-SEQ (CL-ARRAY COMB)) WHILE
+	   (LOOP COLLECT (COPY-SEQ (GRID:COPY-TO COMB)) WHILE
 		(COMBINATION-NEXT COMB)))))))
 
diff --git a/tests/coulomb.lisp b/tests/coulomb.lisp
index b7ac7ad3..4abbf936 100644
--- a/tests/coulomb.lisp
+++ b/tests/coulomb.lisp
@@ -40,7 +40,7 @@
                         (MULTIPLE-VALUE-LIST
                          (LET ((ARR (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 3)))
                            (COULOMB-WAVE-F-ARRAY 0.0d0 1.0d0 2.0d0 ARR)
-                           (CL-ARRAY ARR))))
+                           (GRID:COPY-TO ARR))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 0.07161779967468254d0 0.1278101031568499d0
                               2.2510703464871114d0 -1.4245543587641651d0 0.0d0
@@ -58,8 +58,8 @@
                          (LET ((FARR (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 3))
                                (GARR (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 3)))
                            (COULOMB-WAVE-FG-ARRAY 1.5d0 1.0d0 1.0d0 FARR GARR)
-                           (APPEND (COERCE (CL-ARRAY FARR) 'LIST)
-                                   (COERCE (CL-ARRAY GARR) 'LIST)))))
+                           (APPEND (COERCE (GRID:COPY-TO FARR) 'LIST)
+                                   (COERCE (GRID:COPY-TO GARR) 'LIST)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #(0.33089080691634065d0 0.18070642887252675d0
@@ -67,7 +67,7 @@
                         (MULTIPLE-VALUE-LIST
                          (LET ((ARR (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 3)))
                            (COULOMB-WAVE-SPHF-ARRAY 0.0d0 1.0d0 2.0d0 ARR)
-                           (CL-ARRAY ARR))))
+                           (GRID:COPY-TO ARR))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 0.0013809146441856027d0 2.759621819430441d-17)
                         (MULTIPLE-VALUE-LIST (COULOMB-CL 1.0d0 2.5d0)))
@@ -77,6 +77,6 @@
                            0.011428736368066591d0))
                         (MULTIPLE-VALUE-LIST
                          (LET ((CL (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 3)))
-                           (COULOMB-CL-ARRAY 0.0d0 1.0d0 CL)
-                           (CL-ARRAY CL)))))
+                           (COULOMB-cl-array 0.0d0 1.0d0 CL)
+                           (GRID:COPY-TO CL)))))
 
diff --git a/tests/dirichlet.lisp b/tests/dirichlet.lisp
index 1e36a5b0..d2736355 100644
--- a/tests/dirichlet.lisp
+++ b/tests/dirichlet.lisp
@@ -26,7 +26,7 @@
    (MULTIPLE-VALUE-LIST
     (let ((rng (make-random-number-generator +mt19937+ 0))
 	  (alpha #m(1.0d0 2.0d0 3.0d0 4.0d0)))
-      (cl-array (sample rng :dirichlet :alpha alpha)))))
+      (grid:copy-to (sample rng :dirichlet :alpha alpha)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 1080.0000000000025d0)
    (MULTIPLE-VALUE-LIST
diff --git a/tests/gegenbauer.lisp b/tests/gegenbauer.lisp
index d3f3f8d8..2a6fcff8 100644
--- a/tests/gegenbauer.lisp
+++ b/tests/gegenbauer.lisp
@@ -36,5 +36,5 @@
                         (MULTIPLE-VALUE-LIST
                          (LET ((ARR (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
                            (GEGENBAUER-ARRAY 1.0d0 3.0d0 ARR)
-                           (CL-ARRAY ARR)))))
+                           (GRID:COPY-TO ARR)))))
 
diff --git a/tests/givens.lisp b/tests/givens.lisp
index ef781a3b..5c90408d 100644
--- a/tests/givens.lisp
+++ b/tests/givens.lisp
@@ -47,7 +47,7 @@
                                  (SETF (GRID:GREF COSINES I)
                                          (COS (GRID:GREF ANGLES I))))
                            (GIVENS-ROTATION V1 V2 COSINES SINES)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+                           (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          (LIST
@@ -80,5 +80,5 @@
                                  (SETF (GRID:GREF COSINES I)
                                          (COS (GRID:GREF ANGLES I))))
                            (GIVENS-ROTATION V1 V2 COSINES SINES)
-                           (LIST (CL-ARRAY V1) (CL-ARRAY V2))))))
+                           (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2))))))
 
diff --git a/tests/hankel.lisp b/tests/hankel.lisp
index 57b2a554..92dba83c 100644
--- a/tests/hankel.lisp
+++ b/tests/hankel.lisp
@@ -24,19 +24,18 @@
                          #(0.3752546494075203d0 -0.13350787269556064d0
                            0.0446799251438404d0))
                         (MULTIPLE-VALUE-LIST
-                         (COPY
+                         (grid:COPY-to
                           (APPLY-HANKEL (MAKE-HANKEL 3 1.0d0 1.0d0)
                                         (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT
                                                      :INITIAL-CONTENTS
-                                                     '(1.0d0 2.0d0 3.0d0)))
-                           :grid-type 'ARRAY)))
+                                                     '(1.0d0 2.0d0 3.0d0))))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #(1.000011918676266d0 1.9999790476647115d0
                            3.000035803234508d0))
                         (MULTIPLE-VALUE-LIST
                          (LET ((HANK (MAKE-HANKEL 3 1.0d0 1.0d0)))
-                           (COPY
+                           (grid:COPY-to
                             (ELT* (EXPT (BESSEL-ZERO-J1 4) 2)
                                   (APPLY-HANKEL HANK
                                                 (APPLY-HANKEL HANK
@@ -44,8 +43,7 @@
                                                                'DOUBLE-FLOAT
                                                                :INITIAL-CONTENTS
                                                                '(1.0d0 2.0d0
-                                                                 3.0d0)))))
-                             :grid-type 'ARRAY))))
+                                                                 3.0d0)))))))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #(3.999613382195876d0 2.9590494996797356d0
@@ -121,7 +119,7 @@
                                           (1+
                                            (EXPT (SAMPLE-X-HANKEL HANK N)
                                                  2)))))
-                           (COPY (APPLY-HANKEL HANK IN)  :grid-type 'ARRAY))))
+                           (grid:COPY-to (APPLY-HANKEL HANK IN)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #(0.18148296716239096d0 0.29470565030732726d0
@@ -194,7 +192,7 @@
                            (LOOP FOR N FROM 0 BELOW 128 DO
                                  (SETF (GRID:GREF IN N)
                                          (EXP (- (SAMPLE-X-HANKEL HANK N)))))
-                           (COPY (APPLY-HANKEL HANK IN) :grid-type 'ARRAY))))
+                           (grid:COPY-to (APPLY-HANKEL HANK IN)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #(0.05727421417071144d0 -0.0069532329565967065d0
@@ -268,5 +266,5 @@
                                  (SETF (GRID:GREF IN N)
                                          (LET ((X (SAMPLE-X-HANKEL HANK N)))
                                            (* X (- 1 (EXPT X 2))))))
-                           (COPY (APPLY-HANKEL HANK IN) :grid-type 'ARRAY)))))
+                           (grid:COPY-to (APPLY-HANKEL HANK IN))))))
 
diff --git a/tests/inverse-matrix-product.lisp b/tests/inverse-matrix-product.lisp
index 3949bdb7..0730e971 100644
--- a/tests/inverse-matrix-product.lisp
+++ b/tests/inverse-matrix-product.lisp
@@ -38,7 +38,7 @@
 	      (-16.12 -8.25 21.44)
 	      (-49.08 -39.66 -49.46))))
 	  (S1 19.68))
-      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
+      (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((-30.708968222785604d0 5.373707833953741d0
@@ -61,7 +61,7 @@
 	      (-16.12d0 -8.25d0 21.44d0)
 	      (-49.08d0 -39.66d0 -49.46d0))))
 	  (S1 19.68d0))
-      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
+      (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -87,7 +87,7 @@
 	      (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
 	      (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82)))))
 	  (S1 #C(19.68 -5.55)))
-      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
+      (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -116,7 +116,7 @@
 	      (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
 	      (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0)))))
 	  (S1 #C(19.68d0 -5.55d0)))
-      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
+      (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-1.1747805 -0.26507667 1.3326154))
    (MULTIPLE-VALUE-LIST
@@ -131,7 +131,7 @@
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
 	    '(42.73 -17.24 43.31)))
 	  (S1 -16.12))
-      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
+      (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(-1.1747804927980594d0 -0.26507665253855167d0
@@ -147,7 +147,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
 				    '(42.73d0 -17.24d0 43.31d0)))
 	  (S1 -16.12d0))
-      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
+      (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)
@@ -166,7 +166,7 @@
 	    :INITIAL-CONTENTS
 	    '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))))
 	  (S1 #C(-16.12 -8.25)))
-      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
+      (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(-1.1218005239477833d0 0.2499006037347623d0)
@@ -186,5 +186,5 @@
 	    :INITIAL-CONTENTS
 	    '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))))
 	  (S1 #C(-16.12d0 -8.25d0)))
-      (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1))))))
+      (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 V1 S1))))))
 
diff --git a/tests/legendre.lisp b/tests/legendre.lisp
index e9622690..352e9ee4 100644
--- a/tests/legendre.lisp
+++ b/tests/legendre.lisp
@@ -41,7 +41,7 @@
                         (MULTIPLE-VALUE-LIST
                          (LET ((ARR (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
                            (LEGENDRE-PL-ARRAY 0.5d0 ARR)
-                           (CL-ARRAY ARR))))
+                           (GRID:COPY-TO ARR))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 0.3128529498822064d0 1.3893461931245028d-16)
                         (MULTIPLE-VALUE-LIST (LEGENDRE-Q0 3.3d0)))
@@ -59,7 +59,7 @@
                         (MULTIPLE-VALUE-LIST
                          (LET ((ARR (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
                            (LEGENDRE-PLM-ARRAY 2 0.5d0 ARR)
-                           (CL-ARRAY ARR))))
+                           (GRID:COPY-TO ARR))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(-3.0d0 3.75d0 33.75d0 55.78125d0))
                         (MULTIPLE-VALUE-LIST
@@ -67,7 +67,7 @@
                                (DERIV
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
                            (LEGENDRE-PLM-DERIV-ARRAY 2 0.5d0 VAL DERIV)
-                           (CL-ARRAY DERIV))))
+                           (GRID:COPY-TO DERIV))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST 0.30366280894310793d0 3.5267592419993454d-14)
                         (MULTIPLE-VALUE-LIST
@@ -79,7 +79,7 @@
                         (MULTIPLE-VALUE-LIST
                          (LET ((ARR (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
                            (LEGENDRE-SPHPLM-ARRAY 4 0.5d0 ARR)
-                           (CL-ARRAY ARR))))
+                           (GRID:COPY-TO ARR))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #(-0.6637990386674741d0 -0.2751965434323283d0
@@ -89,7 +89,7 @@
                                (DERIV
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
                            (LEGENDRE-SPHPLM-DERIV-ARRAY 4 0.5d0 VAL DERIV)
-                           (CL-ARRAY DERIV))))
+                           (GRID:COPY-TO DERIV))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST -0.1255299048878925d0 1.3395992025650077d-15)
                         (MULTIPLE-VALUE-LIST
@@ -131,5 +131,5 @@
                         (MULTIPLE-VALUE-LIST
                          (LET ((ARR (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 4)))
                            (LEGENDRE-H3D-ARRAY 1.0d0 0.5d0 ARR)
-                           (CL-ARRAY ARR)))))
+                           (GRID:COPY-TO ARR)))))
 
diff --git a/tests/lu.lisp b/tests/lu.lisp
index fdcaebeb..e96bb178 100644
--- a/tests/lu.lisp
+++ b/tests/lu.lisp
@@ -89,7 +89,7 @@
 	    (MATRIX PERM)
 	  (LU-DECOMPOSITION MATRIX)
 	(LET ((X (LU-SOLVE MATRIX VEC PERM)))
-	  (CL-ARRAY
+	  (GRID:COPY-TO
 	   (PERMUTE-INVERSE PERM
 			    (MATRIX-PRODUCT-TRIANGULAR
 			     MATRIX
@@ -123,7 +123,7 @@
 	    (MATRIX PERM)
 	  (LU-DECOMPOSITION MATRIX)
 	(LET ((X (LU-SOLVE MATRIX VEC PERM)))
-	  (CL-ARRAY
+	  (GRID:COPY-TO
 	   (PERMUTE-INVERSE
 	    PERM
 	    (MATRIX-PRODUCT-TRIANGULAR
@@ -135,7 +135,7 @@
     #2A((-1.9999999999999998d0 1.0d0)
 	(1.4999999999999998d0 -0.49999999999999994d0)))
    (MULTIPLE-VALUE-LIST
-    (CL-ARRAY
+    (GRID:COPY-TO
      (INVERT-MATRIX
       (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 2)
 			       :INITIAL-CONTENTS
diff --git a/tests/mathieu.lisp b/tests/mathieu.lisp
index bca7dd43..ba077395 100644
--- a/tests/mathieu.lisp
+++ b/tests/mathieu.lisp
@@ -315,7 +315,7 @@
 	-1.8369701987210297d-16 1.0d0
 	3.061616997868383d-16))
      (MULTIPLE-VALUE-LIST
-      (CL-ARRAY (MATHIEU-CE-ARRAY 0.0d0 (/ PI 2) 6)))))
+      (GRID:COPY-TO (MATHIEU-CE-ARRAY 0.0d0 (/ PI 2) 6)))))
   (let ((lisp-unit:*epsilon* 1.0d-6))
     (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
      (LIST
@@ -328,7 +328,7 @@
 	1.0767085541408374d0 1.0641859681403019d0
 	1.054606963632144d0 1.0470843441628828d0))
      (MULTIPLE-VALUE-LIST
-      (CL-ARRAY (MATHIEU-CE-ARRAY 20.0d0 0.0d0 16)))))
+      (GRID:COPY-TO (MATHIEU-CE-ARRAY 20.0d0 0.0d0 16)))))
   (let ((lisp-unit:*epsilon* 1.0d-6))
     (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
      (LIST
@@ -341,5 +341,5 @@
 	0.9433025704899831d0 8.979725089944524d-16
 	-0.9570452540612865d0))
      (MULTIPLE-VALUE-LIST
-      (CL-ARRAY (MATHIEU-SE-ARRAY 20.0d0 (/ PI 2) 15 1))))))
+      (GRID:COPY-TO (MATHIEU-SE-ARRAY 20.0d0 (/ PI 2) 15 1))))))
 
diff --git a/tests/matrix-add-scalar.lisp b/tests/matrix-add-scalar.lisp
index 6dc2ff24..4a7b7d3e 100644
--- a/tests/matrix-add-scalar.lisp
+++ b/tests/matrix-add-scalar.lisp
@@ -30,7 +30,7 @@
                                              '((-34.5 8.24 3.29)
                                                (-8.93 34.12 -6.15)
                                                (49.27 -13.49 32.5)))))
-                           (CL-ARRAY (ELT+ M1 18.19d0)))))
+                           (GRID:COPY-TO (ELT+ M1 18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((-16.31d0 26.43d0 21.48d0)
@@ -43,7 +43,7 @@
                                              '((-34.5d0 8.24d0 3.29d0)
                                                (-8.93d0 34.12d0 -6.15d0)
                                                (49.27d0 -13.49d0 32.5d0)))))
-                           (CL-ARRAY (ELT+ M1 18.19d0)))))
+                           (GRID:COPY-TO (ELT+ M1 18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-45 -49 89) (-72 70 8) (91 13 -115)))
                         (MULTIPLE-VALUE-LIST
@@ -51,7 +51,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
-                           (CL-ARRAY (ELT+ M1 18.19d0)))))
+                           (GRID:COPY-TO (ELT+ M1 18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((85 62 207) (134 181 158) (179 233 116)))
                         (MULTIPLE-VALUE-LIST
@@ -60,7 +60,7 @@
                                              :INITIAL-CONTENTS
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
-                           (CL-ARRAY (ELT+ M1 18.19d0)))))
+                           (GRID:COPY-TO (ELT+ M1 18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-45 -49 89) (-72 70 8) (91 13 141)))
                         (MULTIPLE-VALUE-LIST
@@ -69,7 +69,7 @@
                                              :INITIAL-CONTENTS
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
-                           (CL-ARRAY (ELT+ M1 18.19d0)))))
+                           (GRID:COPY-TO (ELT+ M1 18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((85 62 207) (134 181 158) (179 233 116)))
                         (MULTIPLE-VALUE-LIST
@@ -78,7 +78,7 @@
                                              :INITIAL-CONTENTS
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
-                           (CL-ARRAY (ELT+ M1 18.19d0)))))
+                           (GRID:COPY-TO (ELT+ M1 18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-45 -49 89) (-72 70 8) (91 13 141)))
                         (MULTIPLE-VALUE-LIST
@@ -87,7 +87,7 @@
                                              :INITIAL-CONTENTS
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
-                           (CL-ARRAY (ELT+ M1 18.19d0)))))
+                           (GRID:COPY-TO (ELT+ M1 18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((85 62 207) (134 181 158) (179 233 116)))
                         (MULTIPLE-VALUE-LIST
@@ -96,7 +96,7 @@
                                              :INITIAL-CONTENTS
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
-                           (CL-ARRAY (ELT+ M1 18.19d0)))))
+                           (GRID:COPY-TO (ELT+ M1 18.19d0)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-45 -49 89) (-72 70 8) (91 13 141)))
@@ -106,7 +106,7 @@
                                              :INITIAL-CONTENTS
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
-                           (CL-ARRAY (ELT+ M1 18.19d0)))))
+                           (GRID:COPY-TO (ELT+ M1 18.19d0)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((85 62 207) (134 181 158) (179 233 116)))
@@ -116,5 +116,5 @@
                                              :INITIAL-CONTENTS
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
-                           (CL-ARRAY (ELT+ M1 18.19d0))))))
+                           (GRID:COPY-TO (ELT+ M1 18.19d0))))))
 
diff --git a/tests/matrix-add.lisp b/tests/matrix-add.lisp
index 07680ac5..9bf89281 100644
--- a/tests/matrix-add.lisp
+++ b/tests/matrix-add.lisp
@@ -35,7 +35,7 @@
                                              '((42.73 -17.24 43.31)
                                                (-16.12 -8.25 21.44)
                                                (-49.08 -39.66 -49.46)))))
-                           (CL-ARRAY (ELT+ M1 M2)))))
+                           (GRID:COPY-TO (ELT+ M1 M2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((8.229999999999997d0 -8.999999999999998d0 46.6d0)
@@ -53,7 +53,7 @@
                                              '((42.73d0 -17.24d0 43.31d0)
                                                (-16.12d0 -8.25d0 21.44d0)
                                                (-49.08d0 -39.66d0 -49.46d0)))))
-                           (CL-ARRAY (ELT+ M1 M2)))))
+                           (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
@@ -65,7 +65,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT+ M1 M2)))))
+                           (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
@@ -79,7 +79,7 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT+ M1 M2)))))
+                           (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
@@ -93,7 +93,7 @@
                                              :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT+ M1 M2)))))
+                           (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
@@ -107,7 +107,7 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT+ M1 M2)))))
+                           (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
@@ -121,7 +121,7 @@
                                              :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT+ M1 M2)))))
+                           (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
@@ -135,7 +135,7 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT+ M1 M2)))))
+                           (GRID:COPY-TO (ELT+ M1 M2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191)))
@@ -150,7 +150,7 @@
                                              :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT+ M1 M2)))))
+                           (GRID:COPY-TO (ELT+ M1 M2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((95 54 208) (144 341 357) (197 324 320)))
@@ -165,5 +165,5 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT+ M1 M2))))))
+                           (GRID:COPY-TO (ELT+ M1 M2))))))
 
diff --git a/tests/matrix-div.lisp b/tests/matrix-div.lisp
index 5b34b46d..5f7cd88a 100644
--- a/tests/matrix-div.lisp
+++ b/tests/matrix-div.lisp
@@ -35,7 +35,7 @@
                                              '((42.73 -17.24 43.31)
                                                (-16.12 -8.25 21.44)
                                                (-49.08 -39.66 -49.46)))))
-                           (CL-ARRAY (ELT/ M1 M2)))))
+                           (GRID:COPY-TO (ELT/ M1 M2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((-0.8073952726421718d0 -0.4779582366589328d0
@@ -55,7 +55,7 @@
                                              '((42.73d0 -17.24d0 43.31d0)
                                                (-16.12d0 -8.25d0 21.44d0)
                                                (-49.08d0 -39.66d0 -49.46d0)))))
-                           (CL-ARRAY (ELT/ M1 M2)))))
+                           (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
@@ -67,7 +67,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT/ M1 M2)))))
+                           (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
@@ -81,7 +81,7 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT/ M1 M2)))))
+                           (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
@@ -95,7 +95,7 @@
                                              :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT/ M1 M2)))))
+                           (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
@@ -109,7 +109,7 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT/ M1 M2)))))
+                           (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
@@ -123,7 +123,7 @@
                                              :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT/ M1 M2)))))
+                           (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
@@ -137,7 +137,7 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT/ M1 M2)))))
+                           (GRID:COPY-TO (ELT/ M1 M2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1)))
@@ -152,7 +152,7 @@
                                              :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT/ M1 M2)))))
+                           (GRID:COPY-TO (ELT/ M1 M2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((2 4 9) (4 0 0) (4 1 0)))
@@ -167,5 +167,5 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT/ M1 M2))))))
+                           (GRID:COPY-TO (ELT/ M1 M2))))))
 
diff --git a/tests/matrix-mult-scalar.lisp b/tests/matrix-mult-scalar.lisp
index e1b76a9a..d0dd1f2a 100644
--- a/tests/matrix-mult-scalar.lisp
+++ b/tests/matrix-mult-scalar.lisp
@@ -30,7 +30,7 @@
                                              '((-34.5 8.24 3.29)
                                                (-8.93 34.12 -6.15)
                                                (49.27 -13.49 32.5)))))
-                           (CL-ARRAY (ELT* M1 1.39d0)))))
+                           (GRID:COPY-TO (ELT* M1 1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((-47.955d0 11.4536d0 4.5731d0)
@@ -42,7 +42,7 @@
                                              '((-34.5d0 8.24d0 3.29d0)
                                                (-8.93d0 34.12d0 -6.15d0)
                                                (49.27d0 -13.49d0 32.5d0)))))
-                           (CL-ARRAY (ELT* M1 1.39d0)))))
+                           (GRID:COPY-TO (ELT* M1 1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-88 -94 98) (-126 72 -13) (101 -6 -86)))
                         (MULTIPLE-VALUE-LIST
@@ -50,7 +50,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
-                           (CL-ARRAY (ELT* M1 1.39d0)))))
+                           (GRID:COPY-TO (ELT* M1 1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((93 61 6) (161 226 194) (223 42 136)))
                         (MULTIPLE-VALUE-LIST
@@ -59,7 +59,7 @@
                                              :INITIAL-CONTENTS
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
-                           (CL-ARRAY (ELT* M1 1.39d0)))))
+                           (GRID:COPY-TO (ELT* M1 1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-88 -94 98) (-126 72 -13) (101 -6 170)))
                         (MULTIPLE-VALUE-LIST
@@ -68,7 +68,7 @@
                                              :INITIAL-CONTENTS
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
-                           (CL-ARRAY (ELT* M1 1.39d0)))))
+                           (GRID:COPY-TO (ELT* M1 1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((93 61 262) (161 226 194) (223 298 136)))
                         (MULTIPLE-VALUE-LIST
@@ -77,7 +77,7 @@
                                              :INITIAL-CONTENTS
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
-                           (CL-ARRAY (ELT* M1 1.39d0)))))
+                           (GRID:COPY-TO (ELT* M1 1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-88 -94 98) (-126 72 -13) (101 -6 170)))
                         (MULTIPLE-VALUE-LIST
@@ -86,7 +86,7 @@
                                              :INITIAL-CONTENTS
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
-                           (CL-ARRAY (ELT* M1 1.39d0)))))
+                           (GRID:COPY-TO (ELT* M1 1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((93 61 262) (161 226 194) (223 298 136)))
                         (MULTIPLE-VALUE-LIST
@@ -95,7 +95,7 @@
                                              :INITIAL-CONTENTS
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
-                           (CL-ARRAY (ELT* M1 1.39d0)))))
+                           (GRID:COPY-TO (ELT* M1 1.39d0)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-88 -94 98) (-126 72 -13) (101 -6 170)))
@@ -105,7 +105,7 @@
                                              :INITIAL-CONTENTS
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
-                           (CL-ARRAY (ELT* M1 1.39d0)))))
+                           (GRID:COPY-TO (ELT* M1 1.39d0)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((93 61 262) (161 226 194) (223 298 136)))
@@ -115,5 +115,5 @@
                                              :INITIAL-CONTENTS
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
-                           (CL-ARRAY (ELT* M1 1.39d0))))))
+                           (GRID:COPY-TO (ELT* M1 1.39d0))))))
 
diff --git a/tests/matrix-mult.lisp b/tests/matrix-mult.lisp
index 92ee63fb..2778d32a 100644
--- a/tests/matrix-mult.lisp
+++ b/tests/matrix-mult.lisp
@@ -35,7 +35,7 @@
                                              '((42.73 -17.24 43.31)
                                                (-16.12 -8.25 21.44)
                                                (-49.08 -39.66 -49.46)))))
-                           (CL-ARRAY (ELT* M1 M2)))))
+                           (GRID:COPY-TO (ELT* M1 M2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((-1474.185d0 -142.05759999999998d0 142.4899d0)
@@ -53,7 +53,7 @@
                                              '((42.73d0 -17.24d0 43.31d0)
                                                (-16.12d0 -8.25d0 21.44d0)
                                                (-49.08d0 -39.66d0 -49.46d0)))))
-                           (CL-ARRAY (ELT* M1 M2)))))
+                           (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
@@ -65,7 +65,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT* M1 M2)))))
+                           (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
@@ -79,7 +79,7 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT* M1 M2)))))
+                           (GRID:COPY-TO (ELT* M1 M2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((-2048 -1904 2130)
@@ -96,7 +96,7 @@
                                              :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT* M1 M2)))))
+                           (GRID:COPY-TO (ELT* M1 M2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((1876 440 3591)
@@ -113,7 +113,7 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT* M1 M2)))))
+                           (GRID:COPY-TO (ELT* M1 M2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((-2048 -1904 2130)
@@ -130,7 +130,7 @@
                                              :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT* M1 M2)))))
+                           (GRID:COPY-TO (ELT* M1 M2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((1876 440 3591)
@@ -147,7 +147,7 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT* M1 M2)))))
+                           (GRID:COPY-TO (ELT* M1 M2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
@@ -165,7 +165,7 @@
                                              :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT* M1 M2)))))
+                           (GRID:COPY-TO (ELT* M1 M2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
@@ -183,5 +183,5 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT* M1 M2))))))
+                           (GRID:COPY-TO (ELT* M1 M2))))))
 
diff --git a/tests/matrix-product-hermitian.lisp b/tests/matrix-product-hermitian.lisp
index 39712734..6bc1bfb0 100644
--- a/tests/matrix-product-hermitian.lisp
+++ b/tests/matrix-product-hermitian.lisp
@@ -52,7 +52,7 @@
 	      (#C(29.36 -33.24) #C(-27.03 -41.67) #C(42.0 -20.81)))))
 	  (S1 #C(-41.67 42.0))
 	  (S2 #C(42.0 -20.81)))
-      (CL-ARRAY
+      (GRID:COPY-TO
        (MATRIX-PRODUCT-HERMITIAN M1 M2 M3 S1 S2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -89,7 +89,7 @@
 	      (#C(29.36d0 -33.24d0) #C(-27.03d0 -41.67d0) #C(42.0d0 -20.81d0)))))
 	  (S1 #C(-41.67d0 42.0d0))
 	  (S2 #C(42.0d0 -20.81d0)))
-      (CL-ARRAY
+      (GRID:COPY-TO
        (MATRIX-PRODUCT-HERMITIAN M1 M2 M3 S1 S2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -115,7 +115,7 @@
 	    '(#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))))
 	  (S1 #C(-49.08 -39.66))
 	  (S2 #C(-39.66 -49.46)))
-      (CL-ARRAY
+      (GRID:COPY-TO
        (MATRIX-PRODUCT-HERMITIAN M1 V1 V2 S1 S2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -142,6 +142,6 @@
 	    '(#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))))
 	  (S1 #C(-49.08d0 -39.66d0))
 	  (S2 #C(-39.66d0 -49.46d0)))
-      (CL-ARRAY
+      (GRID:COPY-TO
        (MATRIX-PRODUCT-HERMITIAN M1 V1 V2 S1 S2))))))
 
diff --git a/tests/matrix-product-nonsquare.lisp b/tests/matrix-product-nonsquare.lisp
index aa30b3c0..451928f1 100644
--- a/tests/matrix-product-nonsquare.lisp
+++ b/tests/matrix-product-nonsquare.lisp
@@ -32,7 +32,7 @@
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
 	    '((49.27 -13.49) (32.5 42.73)
 	      (-17.24 43.31)))))
-      (CL-ARRAY (MATRIX-PRODUCT M1 M2)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT M1 M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((-1488.7346d0 959.9901d0)
@@ -49,7 +49,7 @@
 	    '((49.27d0 -13.49d0)
 	      (32.5d0 42.73d0)
 	      (-17.24d0 43.31d0)))))
-      (CL-ARRAY (MATRIX-PRODUCT M1 M2)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT M1 M2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -71,7 +71,7 @@
 	    '((#C(49.27 -13.49) #C(32.5 42.73))
 	      (#C(32.5 42.73) #C(-17.24 43.31))
 	      (#C(-17.24 43.31) #C(-16.12 -8.25))))))
-      (CL-ARRAY (MATRIX-PRODUCT M1 M2)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT M1 M2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -93,5 +93,5 @@
 	    '((#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0))
 	      (#C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))
 	      (#C(-17.24d0 43.31d0) #C(-16.12d0 -8.25d0))))))
-      (CL-ARRAY (MATRIX-PRODUCT M1 M2))))))
+      (GRID:COPY-TO (MATRIX-PRODUCT M1 M2))))))
 
diff --git a/tests/matrix-product-symmetric.lisp b/tests/matrix-product-symmetric.lisp
index ba0fefa6..bab60036 100644
--- a/tests/matrix-product-symmetric.lisp
+++ b/tests/matrix-product-symmetric.lisp
@@ -42,7 +42,7 @@
                                                (29.36 -33.24 -27.03))))
                                (S1 -41.67)
                                (S2 42.0))
-                           (CL-ARRAY
+                           (GRID:COPY-TO
                             (MATRIX-PRODUCT-SYMMETRIC M1 M2 M3 S1 S2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
@@ -70,7 +70,7 @@
                                                (29.36d0 -33.24d0 -27.03d0))))
                                (S1 -41.67d0)
                                (S2 42.0d0))
-                           (CL-ARRAY
+                           (GRID:COPY-TO
                             (MATRIX-PRODUCT-SYMMETRIC M1 M2 M3 S1 S2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(72971.1 24989.41 -82037.61))
@@ -88,7 +88,7 @@
                                              '(-16.12 -8.25 21.44)))
                                (S1 -49.08)
                                (S2 -39.66))
-                           (CL-ARRAY
+                           (GRID:COPY-TO
                             (MATRIX-PRODUCT-SYMMETRIC M1 V1 V3 S1 S2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
@@ -108,6 +108,6 @@
                                              '(-16.12d0 -8.25d0 21.44d0)))
                                (S1 -49.08d0)
                                (S2 -39.66d0))
-                           (CL-ARRAY
+                           (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 20015c8a..8b6131ea 100644
--- a/tests/matrix-product-triangular.lisp
+++ b/tests/matrix-product-triangular.lisp
@@ -38,7 +38,7 @@
 	      (-16.12 -8.25 21.44)
 	      (-49.08 -39.66 -49.46))))
 	  (S1 19.68))
-      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((-34803.82416d0 7799.550047999999d0 -29131.375104000002d0)
@@ -58,7 +58,7 @@
 	      (-16.12d0 -8.25d0 21.44d0)
 	      (-49.08d0 -39.66d0 -49.46d0))))
 	  (S1 19.68d0))
-      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -81,7 +81,7 @@
 	      (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
 	      (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82)))))
 	  (S1 #C(19.68 -5.55)))
-      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -110,7 +110,7 @@
 	      (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
 	      (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0)))))
 	  (S1 #C(19.68d0 -5.55d0)))
-      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-1473.7527 -854.58527 1407.5751))
    (MULTIPLE-VALUE-LIST
@@ -125,7 +125,7 @@
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
 	    '(42.73 -17.24 43.31)))
 	  (S1 -16.12))
-      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-1473.7527d0 -854.5853d0 1407.575d0))
    (MULTIPLE-VALUE-LIST
@@ -140,7 +140,7 @@
 	    'DOUBLE-FLOAT :INITIAL-CONTENTS
 	    '(42.73d0 -17.24d0 43.31d0)))
 	  (S1 -16.12d0))
-      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -160,7 +160,7 @@
 	    :INITIAL-CONTENTS
 	    '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))))
 	  (S1 #C(-16.12 -8.25)))
-      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -181,5 +181,5 @@
 	    :INITIAL-CONTENTS
 	    '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0))))
 	  (S1 #C(-16.12d0 -8.25d0)))
-      (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1))))))
+      (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1))))))
 
diff --git a/tests/matrix-product.lisp b/tests/matrix-product.lisp
index 70ae43af..9f09852f 100644
--- a/tests/matrix-product.lisp
+++ b/tests/matrix-product.lisp
@@ -45,7 +45,7 @@
 	      (29.36 -33.24 -27.03))))
 	  (S1 -41.67)
 	  (S2 42.0))
-      (CL-ARRAY (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((74519.41329d0 -16747.696061999995d0 61311.694176d0)
@@ -72,7 +72,7 @@
 	      (29.36d0 -33.24d0 -27.03d0))))
 	  (S1 -41.67d0)
 	  (S2 42.0d0))
-      (CL-ARRAY (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -106,7 +106,7 @@
 	      (#C(29.36 -33.24) #C(-27.03 -41.67) #C(42.0 -20.81)))))
 	  (S1 #C(-41.67 42.0))
 	  (S2 #C(42.0 -20.81)))
-      (CL-ARRAY (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -143,7 +143,7 @@
 	      (#C(29.36d0 -33.24d0) #C(-27.03d0 -41.67d0) #C(42.0d0 -20.81d0)))))
 	  (S1 #C(-41.67d0 42.0d0))
 	  (S2 #C(42.0d0 -20.81d0)))
-      (CL-ARRAY (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(72971.1 60998.137 -184676.98))
    (MULTIPLE-VALUE-LIST
@@ -163,7 +163,7 @@
 	    '(-16.12 -8.25 21.44)))
 	  (S1 -49.08)
 	  (S2 -39.66))
-      (CL-ARRAY (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(72971.10171599999d0 60998.13393599999d0
@@ -185,7 +185,7 @@
 	    '(-16.12d0 -8.25d0 21.44d0)))
 	  (S1 -49.08d0)
 	  (S2 -39.66d0))
-      (CL-ARRAY (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -211,7 +211,7 @@
 	    '(#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))))
 	  (S1 #C(-49.08 -39.66))
 	  (S2 #C(-39.66 -49.46)))
-      (CL-ARRAY (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
+      (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -238,4 +238,4 @@
 	    '(#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))))
 	  (S1 #C(-49.08d0 -39.66d0))
 	  (S2 #C(-39.66d0 -49.46d0)))
-      (CL-ARRAY (MATRIX-PRODUCT M1 V1 V2 S1 S2))))))
+      (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 d239d798..0cf3ffdf 100644
--- a/tests/matrix-set-all.lisp
+++ b/tests/matrix-set-all.lisp
@@ -27,7 +27,7 @@
                         (MULTIPLE-VALUE-LIST
                          (LET ((M1
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(3 3))))
-                           (CL-ARRAY (SET-ALL M1 -34.5)))))
+                           (GRID:COPY-TO (SET-ALL M1 -34.5)))))
                        (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((-34.5d0 -34.5d0 -34.5d0)
@@ -36,7 +36,7 @@
                         (MULTIPLE-VALUE-LIST
                          (LET ((M1
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(3 3))))
-                           (CL-ARRAY (SET-ALL M1 -34.5d0)))))
+                           (GRID:COPY-TO (SET-ALL M1 -34.5d0)))))
 		       #+fsbv
                        (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
                         (LIST
@@ -47,7 +47,7 @@
                          (LET ((M1
                                 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
                                              :DIMENSIONS '(3 3))))
-                           (CL-ARRAY (SET-ALL M1 #C(-34.5 8.24))))))
+                           (GRID:COPY-TO (SET-ALL M1 #C(-34.5 8.24))))))
 		       #+fsbv
                        (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
                         (LIST
@@ -61,49 +61,49 @@
                          (LET ((M1
                                 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
                                              :DIMENSIONS '(3 3))))
-                           (CL-ARRAY (SET-ALL M1 #C(-34.5d0 8.24d0))))))
+                           (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))))
-                           (CL-ARRAY (SET-ALL M1 -64)))))
+                           (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))))
-                           (CL-ARRAY (SET-ALL M1 67)))))
+                           (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))))
-                           (CL-ARRAY (SET-ALL M1 -64)))))
+                           (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))))
-                           (CL-ARRAY (SET-ALL M1 67)))))
+                           (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))))
-                           (CL-ARRAY (SET-ALL M1 -64)))))
+                           (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))))
-                           (CL-ARRAY (SET-ALL M1 67)))))
+                           (GRID:COPY-TO (SET-ALL M1 67)))))
 		       #+int64
                        (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64)))
@@ -111,7 +111,7 @@
                          (LET ((M1
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS
                                              '(3 3))))
-                           (CL-ARRAY (SET-ALL M1 -64)))))
+                           (GRID:COPY-TO (SET-ALL M1 -64)))))
 		       #+int64
                        (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((67 67 67) (67 67 67) (67 67 67)))
@@ -119,5 +119,5 @@
                          (LET ((M1
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS
                                              '(3 3))))
-                           (CL-ARRAY (SET-ALL M1 67))))))
+                           (GRID:COPY-TO (SET-ALL M1 67))))))
 
diff --git a/tests/matrix-set-zero.lisp b/tests/matrix-set-zero.lisp
index be65d0f3..404839e6 100644
--- a/tests/matrix-set-zero.lisp
+++ b/tests/matrix-set-zero.lisp
@@ -29,7 +29,7 @@
 	      (-8.93 34.12 -6.15)
 	      (49.27 -13.49 32.5)))))
       (SET-ZERO M1)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((0.0d0 0.0d0 0.0d0)
@@ -43,7 +43,7 @@
 	      (-8.93d0 34.12d0 -6.15d0)
 	      (49.27d0 -13.49d0 32.5d0)))))
       (SET-ZERO M1)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0))
@@ -58,7 +58,7 @@
 	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
 	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
       (SET-ZERO M1)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0))
@@ -74,7 +74,7 @@
 	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
 	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))))
       (SET-ZERO M1)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
    (MULTIPLE-VALUE-LIST
@@ -83,7 +83,7 @@
 	    '(SIGNED-BYTE 8) :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
       (SET-ZERO M1)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
    (MULTIPLE-VALUE-LIST
@@ -94,7 +94,7 @@
 	    '((67 44 189) (116 163 140)
 	      (161 215 98)))))
       (SET-ZERO M1)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
    (MULTIPLE-VALUE-LIST
@@ -105,7 +105,7 @@
 	    '((-64 -68 71) (-91 52 -10)
 	      (73 -5 123)))))
       (SET-ZERO M1)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
    (MULTIPLE-VALUE-LIST
@@ -115,7 +115,7 @@
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
       (SET-ZERO M1)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
    (MULTIPLE-VALUE-LIST
@@ -125,7 +125,7 @@
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
       (SET-ZERO M1)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
    (MULTIPLE-VALUE-LIST
@@ -135,7 +135,7 @@
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
       (SET-ZERO M1)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
@@ -146,7 +146,7 @@
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
       (SET-ZERO M1)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((0 0 0) (0 0 0) (0 0 0)))
@@ -157,5 +157,5 @@
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
       (SET-ZERO M1)
-      (CL-ARRAY M1)))))
+      (GRID:COPY-TO M1)))))
 
diff --git a/tests/matrix-sub.lisp b/tests/matrix-sub.lisp
index cb9b638b..f34a2da4 100644
--- a/tests/matrix-sub.lisp
+++ b/tests/matrix-sub.lisp
@@ -35,7 +35,7 @@
                                              '((42.73 -17.24 43.31)
                                                (-16.12 -8.25 21.44)
                                                (-49.08 -39.66 -49.46)))))
-                           (CL-ARRAY (ELT- M1 M2)))))
+                           (GRID:COPY-TO (ELT- M1 M2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((-77.22999999999999d0 25.479999999999997d0
@@ -55,7 +55,7 @@
                                              '((42.73d0 -17.24d0 43.31d0)
                                                (-16.12d0 -8.25d0 21.44d0)
                                                (-49.08d0 -39.66d0 -49.46d0)))))
-                           (CL-ARRAY (ELT- M1 M2)))))
+                           (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
@@ -67,7 +67,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT- M1 M2)))))
+                           (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
@@ -81,7 +81,7 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT- M1 M2)))))
+                           (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
@@ -95,7 +95,7 @@
                                              :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT- M1 M2)))))
+                           (GRID:COPY-TO (ELT- M1 M2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((39 34 170) (88 65521 65459) (125 106 65412)))
@@ -110,7 +110,7 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT- M1 M2)))))
+                           (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
@@ -124,7 +124,7 @@
                                              :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT- M1 M2)))))
+                           (GRID:COPY-TO (ELT- M1 M2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((39 34 170)
@@ -141,7 +141,7 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT- M1 M2)))))
+                           (GRID:COPY-TO (ELT- M1 M2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55)))
@@ -156,7 +156,7 @@
                                              :INITIAL-CONTENTS
                                              '((32 28 30) (37 -73 -8)
                                                (-15 -22 68)))))
-                           (CL-ARRAY (ELT- M1 M2)))))
+                           (GRID:COPY-TO (ELT- M1 M2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
@@ -174,5 +174,5 @@
                                              :INITIAL-CONTENTS
                                              '((28 10 19) (28 178 217)
                                                (36 109 222)))))
-                           (CL-ARRAY (ELT- M1 M2))))))
+                           (GRID:COPY-TO (ELT- M1 M2))))))
 
diff --git a/tests/matrix-swap.lisp b/tests/matrix-swap.lisp
index 266c16b3..71024321 100644
--- a/tests/matrix-swap.lisp
+++ b/tests/matrix-swap.lisp
@@ -42,7 +42,7 @@
 	      (-16.12 -8.25 21.44)
 	      (-49.08 -39.66 -49.46)))))
       (SWAP M2 M1)
-      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
@@ -66,7 +66,7 @@
 	      (-16.12d0 -8.25d0 21.44d0)
 	      (-49.08d0 -39.66d0 -49.46d0)))))
       (SWAP M2 M1)
-      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
@@ -93,7 +93,7 @@
 	      (#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46))
 	      (#C(-49.08 -39.66) #C(-49.46 19.68) #C(-5.55 -8.82))))))
       (SWAP M2 M1)
-      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
@@ -119,7 +119,7 @@
 	      (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0))
 	      (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) #C(-5.55d0 -8.82d0))))))
       (SWAP M2 M1)
-      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+      (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))
@@ -134,7 +134,7 @@
 				    '((32 28 30) (37 -73 -8)
 				      (-15 -22 68)))))
       (SWAP M2 M1)
-      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+      (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))
@@ -151,7 +151,7 @@
 				    '((28 10 19) (28 178 217)
 				      (36 109 222)))))
       (SWAP M2 M1)
-      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+      (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))
@@ -168,7 +168,7 @@
 				    '((32 28 30) (37 -73 -8)
 				      (-15 -22 68)))))
       (SWAP M2 M1)
-      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+      (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))
@@ -185,7 +185,7 @@
 				    '((28 10 19) (28 178 217)
 				      (36 109 222)))))
       (SWAP M2 M1)
-      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+      (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))
@@ -202,7 +202,7 @@
 				    '((32 28 30) (37 -73 -8)
 				      (-15 -22 68)))))
       (SWAP M2 M1)
-      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+      (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))
@@ -219,7 +219,7 @@
 				    '((28 10 19) (28 178 217)
 				      (36 109 222)))))
       (SWAP M2 M1)
-      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -237,7 +237,7 @@
 				    '((32 28 30) (37 -73 -8)
 				      (-15 -22 68)))))
       (SWAP M2 M1)
-      (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))
+      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -255,5 +255,5 @@
 				    '((28 10 19) (28 178 217)
 				      (36 109 222)))))
       (SWAP M2 M1)
-      (LIST (CL-ARRAY M1) (CL-ARRAY M2))))))
+      (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))))
 
diff --git a/tests/matrix-transpose-copy.lisp b/tests/matrix-transpose-copy.lisp
index 681db8c3..5284e86c 100644
--- a/tests/matrix-transpose-copy.lisp
+++ b/tests/matrix-transpose-copy.lisp
@@ -33,7 +33,7 @@
 	      (49.27 -13.49 32.5))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(3 3))))
-      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((-34.5d0 -8.93d0 49.27d0)
@@ -48,7 +48,7 @@
 	      (49.27d0 -13.49d0 32.5d0))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(3 3))))
-      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+      (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))
@@ -64,7 +64,7 @@
 	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31)))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '(3 3))))
-      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((#C(-34.5d0 8.24d0) #C(-8.93d0 34.12d0) #C(49.27d0 -13.49d0))
@@ -80,7 +80,7 @@
 	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT) :DIMENSIONS '(3 3))))
-      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
    (MULTIPLE-VALUE-LIST
@@ -90,7 +90,7 @@
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS '(3 3))))
-      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
    (MULTIPLE-VALUE-LIST
@@ -102,7 +102,7 @@
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 8) :DIMENSIONS '(3 3))))
-      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
    (MULTIPLE-VALUE-LIST
@@ -113,7 +113,7 @@
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS '(3 3))))
-      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
    (MULTIPLE-VALUE-LIST
@@ -124,7 +124,7 @@
 	    '((67 44 189) (116 163 140) (161 215 98))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS '(3 3))))
-      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
    (MULTIPLE-VALUE-LIST
@@ -136,7 +136,7 @@
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS
 				    '(3 3))))
-      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
    (MULTIPLE-VALUE-LIST
@@ -148,7 +148,7 @@
 	      (161 215 98))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS '(3 3))))
-      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
@@ -160,7 +160,7 @@
 	    '((-64 -68 71) (-1 52 -10) (73 -5 123))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS '(3 3))))
-      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
@@ -171,5 +171,5 @@
 				    '((67 44 189) (116 163 140) (161 215 98))))
 	  (M2
 	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS '(3 3))))
-      (CL-ARRAY (MATRIX-TRANSPOSE M1 M2))))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2))))))
 
diff --git a/tests/matrix-transpose.lisp b/tests/matrix-transpose.lisp
index 906f07d8..78013e6f 100644
--- a/tests/matrix-transpose.lisp
+++ b/tests/matrix-transpose.lisp
@@ -31,7 +31,7 @@
 	    '((-34.5 8.24 3.29)
 	      (-8.93 34.12 -6.15)
 	      (49.27 -13.49 32.5)))))
-      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE* M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((-34.5d0 -8.93d0 49.27d0)
@@ -44,7 +44,7 @@
 	    '((-34.5d0 8.24d0 3.29d0)
 	      (-8.93d0 34.12d0 -6.15d0)
 	      (49.27d0 -13.49d0 32.5d0)))))
-      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+      (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))
@@ -59,7 +59,7 @@
 	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
 	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
 	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
-      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE* M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((#C(-34.5d0 8.24d0) #C(-8.93d0 34.12d0)
@@ -76,7 +76,7 @@
 	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
 	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
 	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))))
-      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE* M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
    (MULTIPLE-VALUE-LIST
@@ -84,7 +84,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 8) :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE* M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
    (MULTIPLE-VALUE-LIST
@@ -93,7 +93,7 @@
 	    '(UNSIGNED-BYTE 8)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE* M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
    (MULTIPLE-VALUE-LIST
@@ -102,7 +102,7 @@
 	    '(SIGNED-BYTE 16)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE* M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
    (MULTIPLE-VALUE-LIST
@@ -111,7 +111,7 @@
 	    '(UNSIGNED-BYTE 16)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE* M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
    (MULTIPLE-VALUE-LIST
@@ -120,7 +120,7 @@
 	    '(SIGNED-BYTE 32)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE* M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
    (MULTIPLE-VALUE-LIST
@@ -129,7 +129,7 @@
 	    '(UNSIGNED-BYTE 32)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE* M1)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123)))
@@ -139,7 +139,7 @@
 	    '(SIGNED-BYTE 64)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (MATRIX-TRANSPOSE* M1)))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE* M1)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 116 161) (44 163 215) (189 140 98)))
@@ -149,5 +149,5 @@
 	    '(UNSIGNED-BYTE 64)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (MATRIX-TRANSPOSE* M1))))))
+      (GRID:COPY-TO (MATRIX-TRANSPOSE* M1))))))
 
diff --git a/tests/multinomial.lisp b/tests/multinomial.lisp
index def0fa0b..b54562d5 100644
--- a/tests/multinomial.lisp
+++ b/tests/multinomial.lisp
@@ -24,7 +24,7 @@
    (MULTIPLE-VALUE-LIST
     (let ((rng (make-random-number-generator +mt19937+ 0))
 	  (p #m(0.1d0 0.2d0 0.3d0 0.4d0)))
-      (cl-array (sample rng :multinomial :sum 8 :probabilities p)))))
+      (grid:copy-to (sample rng :multinomial :sum 8 :probabilities p)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST 8.064000000000026d-5)
    (MULTIPLE-VALUE-LIST
diff --git a/tests/numerical-integration.lisp b/tests/numerical-integration.lisp
index e92f8b4c..36222eb7 100644
--- a/tests/numerical-integration.lisp
+++ b/tests/numerical-integration.lisp
@@ -223,9 +223,8 @@
    (LIST 52.740806116727164d0 1.7557038486870624d-4)
    (MULTIPLE-VALUE-LIST
     (INTEGRATION-QAGP 'INTEGRATION-TEST-F454
-		      (COPY
-		       (VECTOR 0.0d0 1.0d0 (SQRT 2.0d0) 3.0d0)
-		       :grid-type 'foreign-array)
+		      (grid:COPY-to
+		       (VECTOR 0.0d0 1.0d0 (SQRT 2.0d0) 3.0d0))
 		      0.0d0 0.001d0 1000)))
   (let ((lisp-unit:*epsilon* 1.0d-9))
     (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
diff --git a/tests/permutation.lisp b/tests/permutation.lisp
index 939e7525..d131e8e1 100644
--- a/tests/permutation.lisp
+++ b/tests/permutation.lisp
@@ -31,7 +31,7 @@
                                                            (LET ((PERM-1
                                                                   (MAKE-PERMUTATION
                                                                    4 T)))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               PERM-1))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 2 1 0))
                                                           (MULTIPLE-VALUE-LIST
@@ -40,7 +40,7 @@
                                                                    4 T)))
                                                              (SET-IDENTITY
                                                               PERM-1)
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (PERMUTATION-REVERSE
                                                                PERM-1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 3 1 2))
@@ -61,7 +61,7 @@
                                                               PERM-1)
                                                              (PERMUTATION-INVERSE
                                                               PERM-2 PERM-1)
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               PERM-2))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 3 2 1))
                                                           (MULTIPLE-VALUE-LIST
@@ -72,7 +72,7 @@
                                                               PERM-1)
                                                              (SWAP-ELEMENTS
                                                               PERM-1 1 3)
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               PERM-1))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(33 44 11 22))
                                                           (MULTIPLE-VALUE-LIST
@@ -94,7 +94,7 @@
                                                               PERM-1 0 2)
                                                              (PERMUTE
                                                               PERM-1 INTVEC)
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               INTVEC))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3)
                                                           (MULTIPLE-VALUE-LIST
diff --git a/tests/polynomial.lisp b/tests/polynomial.lisp
index ba95eb33..c1ce2534 100644
--- a/tests/polynomial.lisp
+++ b/tests/polynomial.lisp
@@ -74,12 +74,11 @@
       #C(0.3090169943749475d0 -0.951056516295153d0)
       #C(0.9999999999999999d0 0.0d0)))
    (MULTIPLE-VALUE-LIST
-    (COPY
+    (grid:COPY-to
      (POLYNOMIAL-SOLVE
       (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
 			       '(-1.0d0 0.0d0 0.0d0 0.0d0 0.0d0
-				 1.0d0)))
-      :grid-type 'ARRAY)))
+				 1.0d0))))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST 1.3250000029802322d0)
    (MULTIPLE-VALUE-LIST
@@ -225,11 +224,10 @@
       #C(4.000000000000085d0 0.0d0)
       #C(4.9999999999999964d0 0.0d0)))
    (MULTIPLE-VALUE-LIST
-    (COPY
+    (grid:COPY-to
      (POLYNOMIAL-SOLVE
       (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-			       '(-120 274 -225 85 -15 1.0)))
-      :grid-type 'ARRAY)))
+			       '(-120 274 -225 85 -15 1.0))))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(-0.8660254037844393d0 0.49999999999999983d0)
@@ -241,11 +239,10 @@
       #C(0.8660254037844388d0 0.4999999999999996d0)
       #C(0.8660254037844388d0 -0.4999999999999996d0)))
    (MULTIPLE-VALUE-LIST
-    (COPY
+    (grid:COPY-to
      (POLYNOMIAL-SOLVE
       (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
-			       '(1 0 0 0 1 0 0 0 1)))
-      :grid-type 'ARRAY)))
+			       '(1 0 0 0 1 0 0 0 1))))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
@@ -271,16 +268,16 @@
 				     '(0.73 1.11 1.49 1.84 2.3 2.41
 				       3.07)))
 	   (DD (DIVIDED-DIFFERENCE XA YA)))
-      (LIST (COPY DD  :grid-type 'ARRAY)
+      (LIST (grid:COPY-to DD)
 	    (MAP 'VECTOR
 		 (LAMBDA (X)
 		   (EVALUATE XA X :DIVIDED-DIFFERENCE DD))
-		 (COPY XA  :grid-type 'ARRAY))
+		 (grid:COPY-to XA))
 	    (MAP 'VECTOR
 		 (LAMBDA (X)
 		   (EVALUATE
 		    (TAYLOR-DIVIDED-DIFFERENCE 1.5d0 DD
 					       XA)
 		    (- X 1.5d0)))
-		 (COPY XA  :grid-type 'ARRAY)))))))
+		 (grid:COPY-to XA)))))))
 
diff --git a/tests/quasi-random-number-generators.lisp b/tests/quasi-random-number-generators.lisp
index d3948654..7564874f 100644
--- a/tests/quasi-random-number-generators.lisp
+++ b/tests/quasi-random-number-generators.lisp
@@ -27,4 +27,4 @@
     (LET ((GEN (MAKE-QUASI-RANDOM-NUMBER-GENERATOR +SOBOL+ 2))
 	  (VEC (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 2)))
       (LOOP REPEAT 5 DO (QRNG-GET GEN VEC) APPEND
-	   (COERCE (CL-ARRAY VEC) 'LIST))))))
+	   (COERCE (GRID:COPY-TO VEC) 'LIST))))))
diff --git a/tests/row.lisp b/tests/row.lisp
index c04c514a..d59e66cc 100644
--- a/tests/row.lisp
+++ b/tests/row.lisp
@@ -30,7 +30,7 @@
 	      (-8.93 34.12 -6.15)
 	      (49.27 -13.49 32.5))))
 	  (ROW (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
-      (CL-ARRAY (ROW M1 1 ROW)))))
+      (GRID:COPY-TO (ROW M1 1 ROW)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-8.93d0 34.12d0 -6.15d0))
    (MULTIPLE-VALUE-LIST
@@ -42,7 +42,7 @@
 	      (-8.93d0 34.12d0 -6.15d0)
 	      (49.27d0 -13.49d0 32.5d0))))
 	  (ROW (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
-      (CL-ARRAY (ROW M1 1 ROW)))))
+      (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)))
@@ -57,7 +57,7 @@
 	  (ROW
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3)))
-      (CL-ARRAY (ROW M1 1 ROW)))))
+      (GRID:COPY-TO (ROW M1 1 ROW)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0)
@@ -72,7 +72,7 @@
 	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)))))
 	  (ROW
 	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT) :DIMENSIONS '3)))
-      (CL-ARRAY (ROW M1 1 ROW)))))
+      (GRID:COPY-TO (ROW M1 1 ROW)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-91 52 -10))
    (MULTIPLE-VALUE-LIST
@@ -84,7 +84,7 @@
 	      (-91 52 -10)
 	      (73 -5 123))))
 	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS '3)))
-      (CL-ARRAY
+      (GRID:COPY-TO
        (ROW M1
 	    1 ROW)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -98,7 +98,7 @@
 	      (116 163 140)
 	      (161 215 98))))
 	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS '3)))
-      (CL-ARRAY (ROW M1 1 ROW)))))
+      (GRID:COPY-TO (ROW M1 1 ROW)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-91 52 -10))
    (MULTIPLE-VALUE-LIST
@@ -110,7 +110,7 @@
 	      (-91 52 -10)
 	      (73 -5 123))))
 	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS '3)))
-      (CL-ARRAY
+      (GRID:COPY-TO
        (ROW M1
 	    1 ROW)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -124,7 +124,7 @@
 	      (116 163 140)
 	      (161 215 98))))
 	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS '3)))
-      (CL-ARRAY (ROW M1 1 ROW)))))
+      (GRID:COPY-TO (ROW M1 1 ROW)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-91 52 -10))
    (MULTIPLE-VALUE-LIST
@@ -136,7 +136,7 @@
 	      (-91 52 -10)
 	      (73 -5 123))))
 	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS '3)))
-      (CL-ARRAY (ROW M1 1 ROW)))))
+      (GRID:COPY-TO (ROW M1 1 ROW)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(116 163 140))
    (MULTIPLE-VALUE-LIST
@@ -148,7 +148,7 @@
 	      (116 163 140)
 	      (161 215 98))))
 	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS '3)))
-      (CL-ARRAY (ROW M1 1 ROW)))))
+      (GRID:COPY-TO (ROW M1 1 ROW)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-91 52 -10))
@@ -161,7 +161,7 @@
 	      (-91 52 -10)
 	      (73 -5 123))))
 	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS '3)))
-      (CL-ARRAY (ROW M1 1 ROW)))))
+      (GRID:COPY-TO (ROW M1 1 ROW)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(116 163 140))
@@ -174,5 +174,5 @@
 	      (116 163 140)
 	      (161 215 98))))
 	  (ROW (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS '3)))
-      (CL-ARRAY (ROW M1 1 ROW))))))
+      (GRID:COPY-TO (ROW M1 1 ROW))))))
 
diff --git a/tests/scale.lisp b/tests/scale.lisp
index d015c20e..5055a6c9 100644
--- a/tests/scale.lisp
+++ b/tests/scale.lisp
@@ -34,7 +34,7 @@
 	      #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))
-      (CL-ARRAY (SCALE SCALAR V1)))))
+      (GRID:COPY-TO (SCALE SCALAR V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(-1121.25d0 267.8d0)
@@ -52,7 +52,7 @@
 	      #C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
 	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0))))
 	  (SCALAR 32.5d0))
-      (CL-ARRAY (SCALE SCALAR V1)))))
+      (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))
    (MULTIPLE-VALUE-LIST
@@ -62,7 +62,7 @@
 	    :INITIAL-CONTENTS
 	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)))
 	  (SCALAR 32.5))
-      (CL-ARRAY (SCALE SCALAR V1)))))
+      (GRID:COPY-TO (SCALE SCALAR V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(-1121.25d0 267.8d0 106.925d0 -290.22499999999997d0
@@ -75,7 +75,7 @@
 	    '(-34.5d0 8.24d0 3.29d0 -8.93d0
 	      34.12d0 -6.15d0 49.27d0 -13.49d0)))
 	  (SCALAR 32.5d0))
-      (CL-ARRAY (SCALE SCALAR V1)))))
+      (GRID:COPY-TO (SCALE SCALAR V1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -92,7 +92,7 @@
 	      #C(49.27 -13.49) #C(32.5 42.73)
 	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))
 	  (SCALAR #C(32.5 42.73)))
-      (CL-ARRAY (SCALE SCALAR V1)))))
+      (GRID:COPY-TO (SCALE SCALAR V1)))))
   #+fsbv
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -114,4 +114,4 @@
 	      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
 	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0))))
 	  (SCALAR #C(32.5d0 42.73d0)))
-      (CL-ARRAY (SCALE SCALAR V1))))))
+      (GRID:COPY-TO (SCALE SCALAR V1))))))
diff --git a/tests/set-basis.lisp b/tests/set-basis.lisp
index 7e09aa7f..ab80bdf3 100644
--- a/tests/set-basis.lisp
+++ b/tests/set-basis.lisp
@@ -28,7 +28,7 @@
 	    :INITIAL-CONTENTS
 	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
       (SET-BASIS V1 2)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(0.0d0 0.0d0 1.0d0 0.0d0 0.0d0 0.0d0 0.0d0 0.0d0))
@@ -39,7 +39,7 @@
 	    :INITIAL-CONTENTS
 	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
       (SET-BASIS V1 2)
-      (CL-ARRAY V1))))
+      (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)
@@ -53,7 +53,7 @@
 	      #C(34.12 -6.15) #C(49.27 -13.49) #C(32.5 42.73)
 	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
       (SET-BASIS V1 2)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(1.0d0 0.0d0)
@@ -69,7 +69,7 @@
 	      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
 	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)))))
       (SET-BASIS V1 2)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 1 0 0 0 0 0))
    (MULTIPLE-VALUE-LIST
@@ -79,7 +79,7 @@
 	    :INITIAL-CONTENTS
 	    '(-64 -68 71 -91 52 -10 73 -5))))
       (SET-BASIS V1 2)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 1 0 0 0 0 0))
    (MULTIPLE-VALUE-LIST
@@ -89,7 +89,7 @@
 	    :INITIAL-CONTENTS
 	    '(67 44 189 116 163 140 161 215))))
       (SET-BASIS V1 2)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 1 0 0 0 0 0))
    (MULTIPLE-VALUE-LIST
@@ -99,7 +99,7 @@
 	    :INITIAL-CONTENTS
 	    '(-64 -68 71 -91 52 -10 73 -5))))
       (SET-BASIS V1 2)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 1 0 0 0 0 0))
    (MULTIPLE-VALUE-LIST
@@ -109,7 +109,7 @@
 	    :INITIAL-CONTENTS
 	    '(67 44 189 116 163 140 161 215))))
       (SET-BASIS V1 2)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 1 0 0 0 0 0))
    (MULTIPLE-VALUE-LIST
@@ -119,7 +119,7 @@
 	    :INITIAL-CONTENTS
 	    '(-64 -68 71 -91 52 -10 73 -5))))
       (SET-BASIS V1 2)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 1 0 0 0 0 0))
    (MULTIPLE-VALUE-LIST
@@ -129,7 +129,7 @@
 	    :INITIAL-CONTENTS
 	    '(67 44 189 116 163 140 161 215))))
       (SET-BASIS V1 2)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 1 0 0 0 0 0))
@@ -140,7 +140,7 @@
 	    :INITIAL-CONTENTS
 	    '(-64 -68 71 -91 52 -10 73 -5))))
       (SET-BASIS V1 2)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 1 0 0 0 0 0))
@@ -151,4 +151,4 @@
 	    :INITIAL-CONTENTS
 	    '(67 44 189 116 163 140 161 215))))
       (SET-BASIS V1 2)
-      (CL-ARRAY V1)))))
+      (GRID:COPY-TO V1)))))
diff --git a/tests/set-identity.lisp b/tests/set-identity.lisp
index 496b3c5c..97e06458 100644
--- a/tests/set-identity.lisp
+++ b/tests/set-identity.lisp
@@ -29,7 +29,7 @@
 	    '((-34.5 8.24 3.29)
 	      (-8.93 34.12 -6.15)
 	      (49.27 -13.49 32.5)))))
-      (CL-ARRAY (SET-IDENTITY M1)))))
+      (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((1.0d0 0.0d0 0.0d0)
@@ -43,7 +43,7 @@
 	    '((-34.5d0 8.24d0 3.29d0)
 	      (-8.93d0 34.12d0 -6.15d0)
 	      (49.27d0 -13.49d0 32.5d0)))))
-      (CL-ARRAY (SET-IDENTITY M1)))))
+      (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))
@@ -57,7 +57,7 @@
 	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
 	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
 	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
-      (CL-ARRAY (SET-IDENTITY M1)))))
+      (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((#C(1.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0))
@@ -72,7 +72,7 @@
 	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
 	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
 	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))))
-      (CL-ARRAY (SET-IDENTITY M1)))))
+      (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
    (MULTIPLE-VALUE-LIST
@@ -81,7 +81,7 @@
 	    '(SIGNED-BYTE 8)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SET-IDENTITY M1)))))
+      (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
    (MULTIPLE-VALUE-LIST
@@ -90,7 +90,7 @@
 	    '(UNSIGNED-BYTE 8)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SET-IDENTITY M1)))))
+      (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
    (MULTIPLE-VALUE-LIST
@@ -99,7 +99,7 @@
 	    '(SIGNED-BYTE 16)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SET-IDENTITY M1)))))
+      (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
    (MULTIPLE-VALUE-LIST
@@ -108,7 +108,7 @@
 	    '(UNSIGNED-BYTE 16)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SET-IDENTITY M1)))))
+      (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
    (MULTIPLE-VALUE-LIST
@@ -117,7 +117,7 @@
 	    '(SIGNED-BYTE 32)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SET-IDENTITY M1)))))
+      (GRID:COPY-TO (SET-IDENTITY M1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
    (MULTIPLE-VALUE-LIST
@@ -126,7 +126,7 @@
 	    '(UNSIGNED-BYTE 32)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SET-IDENTITY M1)))))
+      (GRID:COPY-TO (SET-IDENTITY M1)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
@@ -136,7 +136,7 @@
 	    '(SIGNED-BYTE 64)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SET-IDENTITY M1)))))
+      (GRID:COPY-TO (SET-IDENTITY M1)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((1 0 0) (0 1 0) (0 0 1)))
@@ -146,5 +146,5 @@
 	    '(UNSIGNED-BYTE 64)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SET-IDENTITY M1))))))
+      (GRID:COPY-TO (SET-IDENTITY M1))))))
 
diff --git a/tests/setf-column.lisp b/tests/setf-column.lisp
index d1f13c2c..91b5ede0 100644
--- a/tests/setf-column.lisp
+++ b/tests/setf-column.lisp
@@ -36,7 +36,7 @@
 	    'SINGLE-FLOAT :INITIAL-CONTENTS
 	    '(42.73 -17.24 43.31))))
       (SETF (COLUMN M1 2) COL)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((-34.5d0 8.24d0 42.73d0)
@@ -54,7 +54,7 @@
 	    'DOUBLE-FLOAT :INITIAL-CONTENTS
 	    '(42.73d0 -17.24d0 43.31d0))))
       (SETF (COLUMN M1 2) COL)
-      (CL-ARRAY M1))))
+      (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))
@@ -74,7 +74,7 @@
 	    :INITIAL-CONTENTS
 	    '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44)))))
       (SETF (COLUMN M1 2) COL)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(42.73d0 -17.24d0))
@@ -94,7 +94,7 @@
 	    :INITIAL-CONTENTS
 	    '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0)))))
       (SETF (COLUMN M1 2) COL)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30)))
    (MULTIPLE-VALUE-LIST
@@ -107,7 +107,7 @@
 	    '(SIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '(32 28 30))))
       (SETF (COLUMN M1 2) COL)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 44 28) (116 163 10) (161 215 19)))
    (MULTIPLE-VALUE-LIST
@@ -120,7 +120,7 @@
 	    '(UNSIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '(28 10 19))))
       (SETF (COLUMN M1 2) COL)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30)))
    (MULTIPLE-VALUE-LIST
@@ -134,7 +134,7 @@
 	    '(SIGNED-BYTE 16)
 	    :INITIAL-CONTENTS '(32 28 30))))
       (SETF (COLUMN M1 2) COL)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 44 28) (116 163 10) (161 215 19)))
    (MULTIPLE-VALUE-LIST
@@ -146,7 +146,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 16) :INITIAL-CONTENTS '(28 10 19))))
       (SETF (COLUMN M1 2) COL)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30)))
    (MULTIPLE-VALUE-LIST
@@ -159,7 +159,7 @@
 	    '(SIGNED-BYTE 32)
 	    :INITIAL-CONTENTS '(32 28 30))))
       (SETF (COLUMN M1 2) COL)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 44 28) (116 163 10) (161 215 19)))
    (MULTIPLE-VALUE-LIST
@@ -173,7 +173,7 @@
 	    '(UNSIGNED-BYTE 32)
 	    :INITIAL-CONTENTS '(28 10 19))))
       (SETF (COLUMN M1 2) COL)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30)))
@@ -187,7 +187,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 64) :INITIAL-CONTENTS '(32 28 30))))
       (SETF (COLUMN M1 2) COL)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 44 28) (116 163 10) (161 215 19)))
@@ -200,5 +200,5 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 64) :INITIAL-CONTENTS '(28 10 19))))
       (SETF (COLUMN M1 2) COL)
-      (CL-ARRAY M1)))))
+      (GRID:COPY-TO M1)))))
 
diff --git a/tests/setf-row.lisp b/tests/setf-row.lisp
index 6c6e332d..688a0c9b 100644
--- a/tests/setf-row.lisp
+++ b/tests/setf-row.lisp
@@ -37,7 +37,7 @@
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS '(42.73 -17.24 43.31))))
       (SETF (ROW M1 2) ROW)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((-34.5d0 8.24d0 3.29d0)
@@ -56,7 +56,7 @@
 	    'DOUBLE-FLOAT
 	    :INITIAL-CONTENTS '(42.73d0 -17.24d0 43.31d0))))
       (SETF (ROW M1 2) ROW)
-      (CL-ARRAY M1))))
+      (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))
@@ -76,7 +76,7 @@
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44)))))
       (SETF (ROW M1 2) ROW)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
@@ -96,7 +96,7 @@
 	    :INITIAL-CONTENTS
 	    '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0)))))
       (SETF (ROW M1 2) ROW)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30)))
    (MULTIPLE-VALUE-LIST
@@ -110,7 +110,7 @@
 	    '(SIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '(32 28 30))))
       (SETF (ROW M1 2) ROW)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 44 189) (116 163 140) (28 10 19)))
    (MULTIPLE-VALUE-LIST
@@ -124,7 +124,7 @@
 	    '(UNSIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '(28 10 19))))
       (SETF (ROW M1 2) ROW)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30)))
    (MULTIPLE-VALUE-LIST
@@ -138,7 +138,7 @@
 	    '(SIGNED-BYTE 16)
 	    :INITIAL-CONTENTS '(32 28 30))))
       (SETF (ROW M1 2) ROW)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 44 189) (116 163 140) (28 10 19)))
    (MULTIPLE-VALUE-LIST
@@ -151,7 +151,7 @@
 	    '(UNSIGNED-BYTE 16)
 	    :INITIAL-CONTENTS '(28 10 19))))
       (SETF (ROW M1 2) ROW)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30)))
    (MULTIPLE-VALUE-LIST
@@ -163,7 +163,7 @@
 	  (ROW
 	   (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :INITIAL-CONTENTS '(32 28 30))))
       (SETF (ROW M1 2) ROW)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 44 189) (116 163 140) (28 10 19)))
    (MULTIPLE-VALUE-LIST
@@ -177,7 +177,7 @@
 	    '(UNSIGNED-BYTE 32)
 	    :INITIAL-CONTENTS '(28 10 19))))
       (SETF (ROW M1 2) ROW)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30)))
@@ -192,7 +192,7 @@
 	    '(SIGNED-BYTE 64)
 	    :INITIAL-CONTENTS '(32 28 30))))
       (SETF (ROW M1 2) ROW)
-      (CL-ARRAY M1))))
+      (GRID:COPY-TO M1))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 44 189) (116 163 140) (28 10 19)))
@@ -206,5 +206,5 @@
 	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
 				    :INITIAL-CONTENTS '(28 10 19))))
       (SETF (ROW M1 2) ROW)
-      (CL-ARRAY M1)))))
+      (GRID:COPY-TO M1)))))
 
diff --git a/tests/shuffling-sampling.lisp b/tests/shuffling-sampling.lisp
index e1198415..814e08c7 100644
--- a/tests/shuffling-sampling.lisp
+++ b/tests/shuffling-sampling.lisp
@@ -24,16 +24,16 @@
    (MULTIPLE-VALUE-LIST
     (let ((rng (make-random-number-generator +mt19937+ 0))
 	  (v1 #31m(1 2 3 4 5 6 7 8)))
-      (cl-array (sample rng :shuffle :base v1)))))
+      (grid:copy-to (sample rng :shuffle :base v1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(2 3 5 8))
    (MULTIPLE-VALUE-LIST
     (let ((rng (make-random-number-generator +mt19937+ 0))
 	  (v1 #31m(1 2 3 4 5 6 7 8)))
-      (cl-array (sample rng :choose-random :src v1 :dest 4)))))
+      (grid:copy-to (sample rng :choose-random :src v1 :dest 4)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(8 2 3 8 2 4 8 6 5 6))
    (MULTIPLE-VALUE-LIST
     (let ((rng (make-random-number-generator +mt19937+ 0))
 	  (v1 #31m(1 2 3 4 5 6 7 8)))
-      (cl-array (sample rng :random-sample :src v1 :dest 10))))))
+      (grid:copy-to (sample rng :random-sample :src v1 :dest 10))))))
diff --git a/tests/sort-matrix-largest.lisp b/tests/sort-matrix-largest.lisp
index 93bac319..e2c73700 100644
--- a/tests/sort-matrix-largest.lisp
+++ b/tests/sort-matrix-largest.lisp
@@ -29,7 +29,7 @@
                                                (49.27 -13.49 32.5))))
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3))))
-                           (CL-ARRAY (SORT-LARGEST M2 M1)))))
+                           (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)))
@@ -41,7 +41,7 @@
                                                (49.27d0 -13.49d0 32.5d0))))
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 3))))
-                           (CL-ARRAY (SORT-LARGEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((123 73 71) (52 -5 -10)))
                         (MULTIPLE-VALUE-LIST
@@ -52,7 +52,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-LARGEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((215 189 163) (161 140 116)))
                         (MULTIPLE-VALUE-LIST
@@ -64,7 +64,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-LARGEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((123 73 71) (52 -5 -10)))
                         (MULTIPLE-VALUE-LIST
@@ -76,7 +76,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-LARGEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((215 189 163) (161 140 116)))
                         (MULTIPLE-VALUE-LIST
@@ -88,7 +88,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-LARGEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((123 73 71) (52 -5 -10)))
                         (MULTIPLE-VALUE-LIST
@@ -100,7 +100,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-LARGEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((215 189 163) (161 140 116)))
                         (MULTIPLE-VALUE-LIST
@@ -112,7 +112,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-LARGEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((123 73 71) (52 -5 -10)))
@@ -125,7 +125,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-LARGEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-LARGEST M2 M1)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((215 189 163) (161 140 116)))
@@ -138,5 +138,5 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-LARGEST M2 M1))))))
+                           (GRID:COPY-TO (SORT-LARGEST M2 M1))))))
 
diff --git a/tests/sort-matrix-smallest.lisp b/tests/sort-matrix-smallest.lisp
index 42c44b00..36e10a61 100644
--- a/tests/sort-matrix-smallest.lisp
+++ b/tests/sort-matrix-smallest.lisp
@@ -29,7 +29,7 @@
                                                (49.27 -13.49 32.5))))
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3))))
-                           (CL-ARRAY (SORT-SMALLEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((-34.5d0 -13.49d0 -8.93d0)
@@ -42,7 +42,7 @@
                                                (49.27d0 -13.49d0 32.5d0))))
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 3))))
-                           (CL-ARRAY (SORT-SMALLEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-91 -68 -64) (-10 -5 52)))
                         (MULTIPLE-VALUE-LIST
@@ -53,7 +53,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-SMALLEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((44 67 98) (116 140 161)))
                         (MULTIPLE-VALUE-LIST
@@ -65,7 +65,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-SMALLEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-91 -68 -64) (-10 -5 52)))
                         (MULTIPLE-VALUE-LIST
@@ -77,7 +77,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-SMALLEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((44 67 98) (116 140 161)))
                         (MULTIPLE-VALUE-LIST
@@ -89,7 +89,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-SMALLEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-91 -68 -64) (-10 -5 52)))
                         (MULTIPLE-VALUE-LIST
@@ -101,7 +101,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-SMALLEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((44 67 98) (116 140 161)))
                         (MULTIPLE-VALUE-LIST
@@ -113,7 +113,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-SMALLEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-91 -68 -64) (-10 -5 52)))
@@ -126,7 +126,7 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-SMALLEST M2 M1)))))
+                           (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((44 67 98) (116 140 161)))
@@ -139,5 +139,5 @@
                                (M2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS
                                              '(2 3))))
-                           (CL-ARRAY (SORT-SMALLEST M2 M1))))))
+                           (GRID:COPY-TO (SORT-SMALLEST M2 M1))))))
 
diff --git a/tests/sort-matrix.lisp b/tests/sort-matrix.lisp
index 164516cb..90cb6129 100644
--- a/tests/sort-matrix.lisp
+++ b/tests/sort-matrix.lisp
@@ -30,7 +30,7 @@
                                              '((-34.5 8.24 3.29)
                                                (-8.93 34.12 -6.15)
                                                (49.27 -13.49 32.5)))))
-                           (CL-ARRAY (MSORT M1)))))
+                           (GRID:COPY-TO (MSORT M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #2A((-34.5d0 -13.49d0 -8.93d0)
@@ -42,7 +42,7 @@
                                              '((-34.5d0 8.24d0 3.29d0)
                                                (-8.93d0 34.12d0 -6.15d0)
                                                (49.27d0 -13.49d0 32.5d0)))))
-                           (CL-ARRAY (MSORT M1)))))
+                           (GRID:COPY-TO (MSORT M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
                         (MULTIPLE-VALUE-LIST
@@ -50,7 +50,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
-                           (CL-ARRAY (MSORT M1)))))
+                           (GRID:COPY-TO (MSORT M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
                         (MULTIPLE-VALUE-LIST
@@ -59,7 +59,7 @@
                                              :INITIAL-CONTENTS
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
-                           (CL-ARRAY (MSORT M1)))))
+                           (GRID:COPY-TO (MSORT M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
                         (MULTIPLE-VALUE-LIST
@@ -68,7 +68,7 @@
                                              :INITIAL-CONTENTS
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
-                           (CL-ARRAY (MSORT M1)))))
+                           (GRID:COPY-TO (MSORT M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
                         (MULTIPLE-VALUE-LIST
@@ -77,7 +77,7 @@
                                              :INITIAL-CONTENTS
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
-                           (CL-ARRAY (MSORT M1)))))
+                           (GRID:COPY-TO (MSORT M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
                         (MULTIPLE-VALUE-LIST
@@ -86,7 +86,7 @@
                                              :INITIAL-CONTENTS
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
-                           (CL-ARRAY (MSORT M1)))))
+                           (GRID:COPY-TO (MSORT M1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
                         (MULTIPLE-VALUE-LIST
@@ -95,7 +95,7 @@
                                              :INITIAL-CONTENTS
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
-                           (CL-ARRAY (MSORT M1)))))
+                           (GRID:COPY-TO (MSORT M1)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123)))
@@ -105,7 +105,7 @@
                                              :INITIAL-CONTENTS
                                              '((-64 -68 71) (-91 52 -10)
                                                (73 -5 123)))))
-                           (CL-ARRAY (MSORT M1)))))
+                           (GRID:COPY-TO (MSORT M1)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #2A((44 67 98) (116 140 161) (163 189 215)))
@@ -115,5 +115,5 @@
                                              :INITIAL-CONTENTS
                                              '((67 44 189) (116 163 140)
                                                (161 215 98)))))
-                           (CL-ARRAY (MSORT M1))))))
+                           (GRID:COPY-TO (MSORT M1))))))
 
diff --git a/tests/sort-vector-index.lisp b/tests/sort-vector-index.lisp
index 92320b16..dd0dc70d 100644
--- a/tests/sort-vector-index.lisp
+++ b/tests/sort-vector-index.lisp
@@ -28,7 +28,7 @@
                                              '(-34.5 8.24 3.29 -8.93 34.12
                                                -6.15 49.27 -13.49))))
                            (SORT-VECTOR-INDEX PERM V1)
-                           (CL-ARRAY PERM))))
+                           (GRID:COPY-TO PERM))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(0 7 3 5 2 1 4 6))
                         (MULTIPLE-VALUE-LIST
@@ -39,7 +39,7 @@
                                                34.12d0 -6.15d0 49.27d0
                                                -13.49d0))))
                            (SORT-VECTOR-INDEX PERM V1)
-                           (CL-ARRAY PERM))))
+                           (GRID:COPY-TO PERM))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(3 1 0 5 7 4 2 6))
                         (MULTIPLE-VALUE-LIST
@@ -48,7 +48,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (SORT-VECTOR-INDEX PERM V1)
-                           (CL-ARRAY PERM))))
+                           (GRID:COPY-TO PERM))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(1 0 3 5 6 4 2 7))
                         (MULTIPLE-VALUE-LIST
@@ -58,7 +58,7 @@
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
                            (SORT-VECTOR-INDEX PERM V1)
-                           (CL-ARRAY PERM))))
+                           (GRID:COPY-TO PERM))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(3 1 0 5 7 4 2 6))
                         (MULTIPLE-VALUE-LIST
@@ -68,7 +68,7 @@
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (SORT-VECTOR-INDEX PERM V1)
-                           (CL-ARRAY PERM))))
+                           (GRID:COPY-TO PERM))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(1 0 3 5 6 4 2 7))
                         (MULTIPLE-VALUE-LIST
@@ -78,7 +78,7 @@
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
                            (SORT-VECTOR-INDEX PERM V1)
-                           (CL-ARRAY PERM))))
+                           (GRID:COPY-TO PERM))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(3 1 0 5 7 4 2 6))
                         (MULTIPLE-VALUE-LIST
@@ -88,7 +88,7 @@
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (SORT-VECTOR-INDEX PERM V1)
-                           (CL-ARRAY PERM))))
+                           (GRID:COPY-TO PERM))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(1 0 3 5 6 4 2 7))
                         (MULTIPLE-VALUE-LIST
@@ -98,7 +98,7 @@
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
                            (SORT-VECTOR-INDEX PERM V1)
-                           (CL-ARRAY PERM))))
+                           (GRID:COPY-TO PERM))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(3 1 0 5 7 4 2 6))
@@ -109,7 +109,7 @@
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
                            (SORT-VECTOR-INDEX PERM V1)
-                           (CL-ARRAY PERM))))
+                           (GRID:COPY-TO PERM))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(1 0 3 5 6 4 2 7))
@@ -120,5 +120,5 @@
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
                            (SORT-VECTOR-INDEX PERM V1)
-                           (CL-ARRAY PERM)))))
+                           (GRID:COPY-TO PERM)))))
 
diff --git a/tests/sort-vector-largest-index.lisp b/tests/sort-vector-largest-index.lisp
index 44a3d739..3e2c0e76 100644
--- a/tests/sort-vector-largest-index.lisp
+++ b/tests/sort-vector-largest-index.lisp
@@ -34,7 +34,7 @@
                                                                      -6.15
                                                                      49.27
                                                                      -13.49))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 4 1))
@@ -54,7 +54,7 @@
                                                                      -6.15d0
                                                                      49.27d0
                                                                      -13.49d0))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
@@ -70,7 +70,7 @@
                                                                    '(-64 -68 71
                                                                      -91 52 -10
                                                                      73 -5))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
@@ -87,7 +87,7 @@
                                                                      116 163
                                                                      140 161
                                                                      215))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
@@ -103,7 +103,7 @@
                                                                    '(-64 -68 71
                                                                      -91 52 -10
                                                                      73 -5))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
@@ -120,7 +120,7 @@
                                                                      116 163
                                                                      140 161
                                                                      215))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4))
@@ -136,7 +136,7 @@
                                                                    '(-64 -68 71
                                                                      -91 52 -10
                                                                      73 -5))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4))
@@ -153,7 +153,7 @@
                                                                      116 163
                                                                      140 161
                                                                      215))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST-INDEX
                                                                COMB V1)))))
 		       #+int64
@@ -170,7 +170,7 @@
                                                                    '(-64 -68 71
                                                                      -91 52 -10
                                                                      73 -5))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST-INDEX
                                                                COMB V1)))))
 		       #+int64
@@ -188,7 +188,7 @@
                                                                      116 163
                                                                      140 161
                                                                      215))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST-INDEX
                                                                COMB V1))))))
 
diff --git a/tests/sort-vector-largest.lisp b/tests/sort-vector-largest.lisp
index 682417dc..0b6fc92d 100644
--- a/tests/sort-vector-largest.lisp
+++ b/tests/sort-vector-largest.lisp
@@ -29,7 +29,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
                                              '(32.5 42.73 -17.24))))
-                           (CL-ARRAY (SORT-VECTOR-LARGEST V2 V1)))))
+                           (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(49.27d0 34.12d0 8.24d0))
                         (MULTIPLE-VALUE-LIST
@@ -41,7 +41,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
                                              '(32.5d0 42.73d0 -17.24d0))))
-                           (CL-ARRAY (SORT-VECTOR-LARGEST V2 V1)))))
+                           (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -59,7 +59,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(123 32
                                                                      28))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST
                                                                V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
@@ -80,7 +80,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(98 28
                                                                      10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST
                                                                V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
@@ -100,7 +100,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(123 32
                                                                      28))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST
                                                                V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
@@ -121,7 +121,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(98 28
                                                                      10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST
                                                                V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52))
@@ -141,7 +141,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(123 32
                                                                      28))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST
                                                                V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163))
@@ -162,7 +162,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(98 28
                                                                      10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST
                                                                V2 V1)))))
 		       #+int64
@@ -183,7 +183,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(123 32
                                                                      28))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-LARGEST
                                                                V2 V1)))))
 		       #+int64
@@ -205,7 +205,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(98 28
                                                                      10))))
-                                                             (CL-ARRAY
+                                                             (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 fbd4c7ca..1aede641 100644
--- a/tests/sort-vector-smallest-index.lisp
+++ b/tests/sort-vector-smallest-index.lisp
@@ -34,7 +34,7 @@
                                                                      -6.15
                                                                      49.27
                                                                      -13.49))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 7 3))
@@ -54,7 +54,7 @@
                                                                      -6.15d0
                                                                      49.27d0
                                                                      -13.49d0))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
@@ -70,7 +70,7 @@
                                                                    '(-64 -68 71
                                                                      -91 52 -10
                                                                      73 -5))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
@@ -87,7 +87,7 @@
                                                                      116 163
                                                                      140 161
                                                                      215))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
@@ -103,7 +103,7 @@
                                                                    '(-64 -68 71
                                                                      -91 52 -10
                                                                      73 -5))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
@@ -120,7 +120,7 @@
                                                                      116 163
                                                                      140 161
                                                                      215))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0))
@@ -136,7 +136,7 @@
                                                                    '(-64 -68 71
                                                                      -91 52 -10
                                                                      73 -5))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST-INDEX
                                                                COMB V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3))
@@ -153,7 +153,7 @@
                                                                      116 163
                                                                      140 161
                                                                      215))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST-INDEX
                                                                COMB V1)))))
 		       #+int64
@@ -170,7 +170,7 @@
                                                                    '(-64 -68 71
                                                                      -91 52 -10
                                                                      73 -5))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST-INDEX
                                                                COMB V1)))))
 		       #+int64
@@ -188,7 +188,7 @@
                                                                      116 163
                                                                      140 161
                                                                      215))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST-INDEX
                                                                COMB V1))))))
 
diff --git a/tests/sort-vector-smallest.lisp b/tests/sort-vector-smallest.lisp
index 65b810fd..485b04c6 100644
--- a/tests/sort-vector-smallest.lisp
+++ b/tests/sort-vector-smallest.lisp
@@ -29,7 +29,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
                                              '(32.5 42.73 -17.24))))
-                           (CL-ARRAY (SORT-VECTOR-SMALLEST V2 V1)))))
+                           (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(-34.5d0 -13.49d0 -8.93d0))
                         (MULTIPLE-VALUE-LIST
@@ -41,7 +41,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
                                              '(32.5d0 42.73d0 -17.24d0))))
-                           (CL-ARRAY (SORT-VECTOR-SMALLEST V2 V1)))))
+                           (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -59,7 +59,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(123 32
                                                                      28))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST
                                                                V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
@@ -80,7 +80,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(98 28
                                                                      10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST
                                                                V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
@@ -100,7 +100,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(123 32
                                                                      28))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST
                                                                V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
@@ -121,7 +121,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(98 28
                                                                      10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST
                                                                V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64))
@@ -141,7 +141,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(123 32
                                                                      28))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST
                                                                V2 V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116))
@@ -162,7 +162,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(98 28
                                                                      10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST
                                                                V2 V1)))))
 		       #+int64
@@ -183,7 +183,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(123 32
                                                                      28))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST
                                                                V2 V1)))))
 		       #+int64
@@ -205,7 +205,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(98 28
                                                                      10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (SORT-VECTOR-SMALLEST
                                                                V2 V1))))))
 
diff --git a/tests/sort-vector.lisp b/tests/sort-vector.lisp
index 892d611a..b101ffff 100644
--- a/tests/sort-vector.lisp
+++ b/tests/sort-vector.lisp
@@ -27,7 +27,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
                                              '(-34.5 8.24 3.29 -8.93 34.12
                                                -6.15 49.27 -13.49))))
-                           (CL-ARRAY (SORT-VECTOR V1)))))
+                           (GRID:COPY-TO (SORT-VECTOR V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #(-34.5d0 -13.49d0 -8.93d0 -6.15d0 3.29d0 8.24d0
@@ -38,14 +38,14 @@
                                              '(-34.5d0 8.24d0 3.29d0 -8.93d0
                                                34.12d0 -6.15d0 49.27d0
                                                -13.49d0))))
-                           (CL-ARRAY (SORT-VECTOR V1)))))
+                           (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))))
-                           (CL-ARRAY (SORT-VECTOR V1)))))
+                           (GRID:COPY-TO (SORT-VECTOR V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(44 67 116 140 161 163 189 215))
                         (MULTIPLE-VALUE-LIST
@@ -53,7 +53,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8)
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
-                           (CL-ARRAY (SORT-VECTOR V1)))))
+                           (GRID:COPY-TO (SORT-VECTOR V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(-91 -68 -64 -10 -5 52 71 73))
                         (MULTIPLE-VALUE-LIST
@@ -61,7 +61,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
-                           (CL-ARRAY (SORT-VECTOR V1)))))
+                           (GRID:COPY-TO (SORT-VECTOR V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(44 67 116 140 161 163 189 215))
                         (MULTIPLE-VALUE-LIST
@@ -69,7 +69,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
-                           (CL-ARRAY (SORT-VECTOR V1)))))
+                           (GRID:COPY-TO (SORT-VECTOR V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(-91 -68 -64 -10 -5 52 71 73))
                         (MULTIPLE-VALUE-LIST
@@ -77,7 +77,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
-                           (CL-ARRAY (SORT-VECTOR V1)))))
+                           (GRID:COPY-TO (SORT-VECTOR V1)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(44 67 116 140 161 163 189 215))
                         (MULTIPLE-VALUE-LIST
@@ -85,7 +85,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
-                           (CL-ARRAY (SORT-VECTOR V1)))))
+                           (GRID:COPY-TO (SORT-VECTOR V1)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(-91 -68 -64 -10 -5 52 71 73))
@@ -94,7 +94,7 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
                                              :INITIAL-CONTENTS
                                              '(-64 -68 71 -91 52 -10 73 -5))))
-                           (CL-ARRAY (SORT-VECTOR V1)))))
+                           (GRID:COPY-TO (SORT-VECTOR V1)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(44 67 116 140 161 163 189 215))
@@ -103,5 +103,5 @@
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
                                              :INITIAL-CONTENTS
                                              '(67 44 189 116 163 140 161 215))))
-                           (CL-ARRAY (SORT-VECTOR V1))))))
+                           (GRID:COPY-TO (SORT-VECTOR V1))))))
 
diff --git a/tests/swap-columns.lisp b/tests/swap-columns.lisp
index 6691ce29..58253aec 100644
--- a/tests/swap-columns.lisp
+++ b/tests/swap-columns.lisp
@@ -32,7 +32,7 @@
 	    '((-34.5 8.24 3.29)
 	      (-8.93 34.12 -6.15)
 	      (49.27 -13.49 32.5)))))
-      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+      (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((-34.5d0 3.29d0 8.24d0)
@@ -46,7 +46,7 @@
 	    '((-34.5d0 8.24d0 3.29d0)
 	      (-8.93d0 34.12d0 -6.15d0)
 	      (49.27d0 -13.49d0 32.5d0)))))
-      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+      (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))
@@ -61,7 +61,7 @@
 	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
 	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
 	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
-      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+      (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((#C(-34.5d0 8.24d0) #C(34.12d0 -6.15d0) #C(3.29d0 -8.93d0))
@@ -75,7 +75,7 @@
 	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
 	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
 	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))))
-      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+      (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5)))
    (MULTIPLE-VALUE-LIST
@@ -84,7 +84,7 @@
 	    '(SIGNED-BYTE 8)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+      (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 189 44) (116 140 163) (161 98 215)))
    (MULTIPLE-VALUE-LIST
@@ -93,7 +93,7 @@
 	    '(UNSIGNED-BYTE 8)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+      (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5)))
    (MULTIPLE-VALUE-LIST
@@ -102,7 +102,7 @@
 	    '(SIGNED-BYTE 16)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+      (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 189 44) (116 140 163) (161 98 215)))
    (MULTIPLE-VALUE-LIST
@@ -111,7 +111,7 @@
 	    '(UNSIGNED-BYTE 16)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+      (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5)))
    (MULTIPLE-VALUE-LIST
@@ -120,7 +120,7 @@
 	    '(SIGNED-BYTE 32)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+      (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 189 44) (116 140 163) (161 98 215)))
    (MULTIPLE-VALUE-LIST
@@ -129,7 +129,7 @@
 	    '(UNSIGNED-BYTE 32)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+      (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5)))
@@ -139,7 +139,7 @@
 	    '(SIGNED-BYTE 64)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))
+      (GRID:COPY-TO (SWAP-COLUMNS M1 1 2)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((67 189 44) (116 140 163) (161 98 215)))
@@ -149,5 +149,5 @@
 	    '(UNSIGNED-BYTE 64)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SWAP-COLUMNS M1 1 2))))))
+      (GRID:COPY-TO (SWAP-COLUMNS M1 1 2))))))
 
diff --git a/tests/swap-elements.lisp b/tests/swap-elements.lisp
index 7602d5e1..1a1fa95d 100644
--- a/tests/swap-elements.lisp
+++ b/tests/swap-elements.lisp
@@ -29,7 +29,7 @@
 	    :INITIAL-CONTENTS
 	    '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
       (SWAP-ELEMENTS V1 2 5)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(-34.5d0 8.24d0 -6.15d0 -8.93d0 34.12d0 3.29d0
@@ -40,7 +40,7 @@
 	    'DOUBLE-FLOAT :INITIAL-CONTENTS
 	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
       (SWAP-ELEMENTS V1 2 5)
-      (CL-ARRAY V1))))
+      (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)
@@ -54,7 +54,7 @@
 	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) #C(49.27 -13.49)
 	      #C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
       (SWAP-ELEMENTS V1 2 5)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0)
@@ -71,7 +71,7 @@
 	      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
 	      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)))))
       (SWAP-ELEMENTS V1 2 5)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-64 -68 -10 -91 52 71 73 -5))
    (MULTIPLE-VALUE-LIST
@@ -80,7 +80,7 @@
 	    '(SIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
       (SWAP-ELEMENTS V1 2 5)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(67 44 140 116 163 189 161 215))
    (MULTIPLE-VALUE-LIST
@@ -89,7 +89,7 @@
 	    '(UNSIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
       (SWAP-ELEMENTS V1 2 5)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-64 -68 -10 -91 52 71 73 -5))
    (MULTIPLE-VALUE-LIST
@@ -98,7 +98,7 @@
 	    '(SIGNED-BYTE 16)
 	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
       (SWAP-ELEMENTS V1 2 5)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(67 44 140 116 163 189 161 215))
    (MULTIPLE-VALUE-LIST
@@ -107,7 +107,7 @@
 	    '(UNSIGNED-BYTE 16)
 	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
       (SWAP-ELEMENTS V1 2 5)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-64 -68 -10 -91 52 71 73 -5))
    (MULTIPLE-VALUE-LIST
@@ -116,7 +116,7 @@
 	    '(SIGNED-BYTE 32)
 	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
       (SWAP-ELEMENTS V1 2 5)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(67 44 140 116 163 189 161 215))
    (MULTIPLE-VALUE-LIST
@@ -125,7 +125,7 @@
 	    '(UNSIGNED-BYTE 32)
 	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
       (SWAP-ELEMENTS V1 2 5)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-64 -68 -10 -91 52 71 73 -5))
@@ -135,7 +135,7 @@
 	    '(SIGNED-BYTE 64)
 	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
       (SWAP-ELEMENTS V1 2 5)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(67 44 140 116 163 189 161 215))
@@ -145,5 +145,5 @@
 	    '(UNSIGNED-BYTE 64)
 	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
       (SWAP-ELEMENTS V1 2 5)
-      (CL-ARRAY V1)))))
+      (GRID:COPY-TO V1)))))
 
diff --git a/tests/swap-row-column.lisp b/tests/swap-row-column.lisp
index 393d13d4..21863d94 100644
--- a/tests/swap-row-column.lisp
+++ b/tests/swap-row-column.lisp
@@ -32,7 +32,7 @@
 	    '((-34.5 8.24 3.29)
 	      (-8.93 34.12 -6.15)
 	      (49.27 -13.49 32.5)))))
-      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+      (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((3.29d0 -6.15d0 32.5d0)
@@ -46,7 +46,7 @@
 	    '((-34.5d0 8.24d0 3.29d0)
 	      (-8.93d0 34.12d0 -6.15d0)
 	      (49.27d0 -13.49d0 32.5d0)))))
-      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+      (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))
@@ -60,7 +60,7 @@
 	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
 	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
 	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
-      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+      (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((#C(34.12d0 -6.15d0) #C(-13.49d0 32.5d0) #C(-17.24d0 43.31d0))
@@ -74,7 +74,7 @@
 	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
 	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
 	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))))
-      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+      (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((71 -10 123) (-91 52 -68) (73 -5 -64)))
    (MULTIPLE-VALUE-LIST
@@ -82,7 +82,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+      (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((189 140 98) (116 163 44) (161 215 67)))
    (MULTIPLE-VALUE-LIST
@@ -90,7 +90,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+      (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((71 -10 123) (-91 52 -68) (73 -5 -64)))
    (MULTIPLE-VALUE-LIST
@@ -99,7 +99,7 @@
 	    '(SIGNED-BYTE 16)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+      (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((189 140 98) (116 163 44) (161 215 67)))
    (MULTIPLE-VALUE-LIST
@@ -108,7 +108,7 @@
 	    '(UNSIGNED-BYTE 16)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+      (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((71 -10 123) (-91 52 -68) (73 -5 -64)))
    (MULTIPLE-VALUE-LIST
@@ -116,7 +116,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 32)
 	    :INITIAL-CONTENTS '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+      (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((189 140 98) (116 163 44) (161 215 67)))
    (MULTIPLE-VALUE-LIST
@@ -125,7 +125,7 @@
 				    :INITIAL-CONTENTS
 				    '((67 44 189) (116 163 140)
 				      (161 215 98)))))
-      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+      (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((71 -10 123) (-91 52 -68) (73 -5 -64)))
@@ -134,7 +134,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 64)
 	    :INITIAL-CONTENTS '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))
+      (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((189 140 98) (116 163 44) (161 215 67)))
@@ -143,4 +143,4 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 64)
 	    :INITIAL-CONTENTS '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2))))))
+      (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2))))))
diff --git a/tests/swap-rows.lisp b/tests/swap-rows.lisp
index cb088611..b2c80c33 100644
--- a/tests/swap-rows.lisp
+++ b/tests/swap-rows.lisp
@@ -32,7 +32,7 @@
 	    '((-34.5 8.24 3.29)
 	      (-8.93 34.12 -6.15)
 	      (49.27 -13.49 32.5)))))
-      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+      (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((-8.93d0 34.12d0 -6.15d0)
@@ -46,7 +46,7 @@
 	    '((-34.5d0 8.24d0 3.29d0)
 	      (-8.93d0 34.12d0 -6.15d0)
 	      (49.27d0 -13.49d0 32.5d0)))))
-      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+      (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))
@@ -61,7 +61,7 @@
 	    '((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))
 	      (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))
 	      (#C(49.27 -13.49) #C(32.5 42.73) #C(-17.24 43.31))))))
-      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+      (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #2A((#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
@@ -75,7 +75,7 @@
 	    '((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0))
 	      (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0))
 	      (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0))))))
-      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+      (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123)))
    (MULTIPLE-VALUE-LIST
@@ -84,7 +84,7 @@
 	    '(SIGNED-BYTE 8)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+      (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((116 163 140) (67 44 189) (161 215 98)))
    (MULTIPLE-VALUE-LIST
@@ -93,7 +93,7 @@
 	    '(UNSIGNED-BYTE 8)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+      (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123)))
    (MULTIPLE-VALUE-LIST
@@ -102,7 +102,7 @@
 	    '(SIGNED-BYTE 16)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+      (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((116 163 140) (67 44 189) (161 215 98)))
    (MULTIPLE-VALUE-LIST
@@ -111,7 +111,7 @@
 	    '(UNSIGNED-BYTE 16)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+      (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123)))
    (MULTIPLE-VALUE-LIST
@@ -120,7 +120,7 @@
 	    '(SIGNED-BYTE 32)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+      (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((116 163 140) (67 44 189) (161 215 98)))
    (MULTIPLE-VALUE-LIST
@@ -129,7 +129,7 @@
 	    '(UNSIGNED-BYTE 32)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+      (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123)))
@@ -139,7 +139,7 @@
 	    '(SIGNED-BYTE 64)
 	    :INITIAL-CONTENTS
 	    '((-64 -68 71) (-91 52 -10) (73 -5 123)))))
-      (CL-ARRAY (SWAP-ROWS M1 0 1)))))
+      (GRID:COPY-TO (SWAP-ROWS M1 0 1)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #2A((116 163 140) (67 44 189) (161 215 98)))
@@ -149,5 +149,5 @@
 	    '(UNSIGNED-BYTE 64)
 	    :INITIAL-CONTENTS
 	    '((67 44 189) (116 163 140) (161 215 98)))))
-      (CL-ARRAY (SWAP-ROWS M1 0 1))))))
+      (GRID:COPY-TO (SWAP-ROWS M1 0 1))))))
 
diff --git a/tests/vector-add-scalar.lisp b/tests/vector-add-scalar.lisp
index d9516f11..0b824fb8 100644
--- a/tests/vector-add-scalar.lisp
+++ b/tests/vector-add-scalar.lisp
@@ -25,14 +25,14 @@
                          (LET ((V1
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
                                              '(-34.5 8.24 3.29))))
-                           (CL-ARRAY (ELT+ V1 18.19d0)))))
+                           (GRID:COPY-TO (ELT+ V1 18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(-16.31d0 26.43d0 21.48d0))
                         (MULTIPLE-VALUE-LIST
                          (LET ((V1
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
                                              '(-34.5d0 8.24d0 3.29d0))))
-                           (CL-ARRAY (ELT+ V1 18.19d0)))))
+                           (GRID:COPY-TO (ELT+ V1 18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-45 -49 89))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -42,7 +42,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-64 -68
                                                                      71))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT+ V1
                                                                    18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(85 62 207))
@@ -54,7 +54,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(67 44
                                                                      189))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT+ V1
                                                                    18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-45 -49 89))
@@ -66,7 +66,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-64 -68
                                                                      71))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT+ V1
                                                                    18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(85 62 207))
@@ -78,7 +78,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(67 44
                                                                      189))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT+ V1
                                                                    18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-45 -49 89))
@@ -90,7 +90,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-64 -68
                                                                      71))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT+ V1
                                                                    18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(85 62 207))
@@ -102,7 +102,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(67 44
                                                                      189))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT+ V1
                                                                    18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-45 -49 89))
@@ -114,7 +114,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-64 -68
                                                                      71))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT+ V1
                                                                    18.19d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(85 62 207))
@@ -126,7 +126,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(67 44
                                                                      189))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT+ V1
                                                                    18.19d0))))))
 
diff --git a/tests/vector-div.lisp b/tests/vector-div.lisp
index 7c944c44..0d628edd 100644
--- a/tests/vector-div.lisp
+++ b/tests/vector-div.lisp
@@ -28,7 +28,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
                                              '(-8.93 34.12 -6.15))))
-                           (CL-ARRAY (ELT/ V1 V2)))))
+                           (GRID:COPY-TO (ELT/ V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #(3.8633818589025757d0 0.2415005861664713d0
@@ -40,7 +40,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
                                              '(-8.93d0 34.12d0 -6.15d0))))
-                           (CL-ARRAY (ELT/ V1 V2)))))
+                           (GRID:COPY-TO (ELT/ V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 -1 -7))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -57,7 +57,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-91 52
                                                                      -10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT/ V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 1))
                                                           (MULTIPLE-VALUE-LIST
@@ -75,7 +75,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(116 163
                                                                      140))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT/ V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 -1 -7))
                                                           (MULTIPLE-VALUE-LIST
@@ -93,7 +93,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-91 52
                                                                      -10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT/ V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 1))
                                                           (MULTIPLE-VALUE-LIST
@@ -111,7 +111,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(116 163
                                                                      140))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT/ V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 -1 -7))
                                                           (MULTIPLE-VALUE-LIST
@@ -129,7 +129,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-91 52
                                                                      -10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT/ V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 1))
                                                           (MULTIPLE-VALUE-LIST
@@ -147,7 +147,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(116 163
                                                                      140))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT/ V1 V2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 -1 -7))
@@ -166,7 +166,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-91 52
                                                                      -10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT/ V1 V2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 1))
@@ -185,6 +185,6 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(116 163
                                                                      140))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT/ V1 V2))))))
 
diff --git a/tests/vector-mult-scalar.lisp b/tests/vector-mult-scalar.lisp
index 09e0f6ef..d8c77bb1 100644
--- a/tests/vector-mult-scalar.lisp
+++ b/tests/vector-mult-scalar.lisp
@@ -25,14 +25,14 @@
                          (LET ((V1
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
                                              '(-34.5 8.24 3.29))))
-                           (CL-ARRAY (ELT* V1 1.39d0)))))
+                           (GRID:COPY-TO (ELT* V1 1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(-47.955d0 11.4536d0 4.5731d0))
                         (MULTIPLE-VALUE-LIST
                          (LET ((V1
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
                                              '(-34.5d0 8.24d0 3.29d0))))
-                           (CL-ARRAY (ELT* V1 1.39d0)))))
+                           (GRID:COPY-TO (ELT* V1 1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-88 -94 98))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -42,7 +42,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-64 -68
                                                                      71))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT* V1
                                                                    1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(93 61 6))
@@ -54,7 +54,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(67 44
                                                                      189))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT* V1
                                                                    1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-88 -94 98))
@@ -66,7 +66,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-64 -68
                                                                      71))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT* V1
                                                                    1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(93 61 262))
@@ -78,7 +78,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(67 44
                                                                      189))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT* V1
                                                                    1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-88 -94 98))
@@ -90,7 +90,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-64 -68
                                                                      71))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT* V1
                                                                    1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(93 61 262))
@@ -102,7 +102,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(67 44
                                                                      189))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT* V1
                                                                    1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-88 -94 98))
@@ -114,7 +114,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-64 -68
                                                                      71))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT* V1
                                                                    1.39d0)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(93 61 262))
@@ -126,7 +126,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(67 44
                                                                      189))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT* V1
                                                                    1.39d0))))))
 
diff --git a/tests/vector-mult.lisp b/tests/vector-mult.lisp
index 69be2478..604d4d70 100644
--- a/tests/vector-mult.lisp
+++ b/tests/vector-mult.lisp
@@ -28,7 +28,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
                                              '(-8.93 34.12 -6.15))))
-                           (CL-ARRAY (ELT* V1 V2)))))
+                           (GRID:COPY-TO (ELT* V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(308.085d0 281.1488d0 -20.233500000000003d0))
                         (MULTIPLE-VALUE-LIST
@@ -38,7 +38,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
                                              '(-8.93d0 34.12d0 -6.15d0))))
-                           (CL-ARRAY (ELT* V1 V2)))))
+                           (GRID:COPY-TO (ELT* V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-64 48 58))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -55,7 +55,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-91 52
                                                                      -10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT* V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(92 4 92))
                                                           (MULTIPLE-VALUE-LIST
@@ -73,7 +73,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(116 163
                                                                      140))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT* V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(5824 -3536 -710))
@@ -84,7 +84,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16)
                                              :INITIAL-CONTENTS '(-91 52 -10))))
-                           (CL-ARRAY (ELT* V1 V2)))))
+                           (GRID:COPY-TO (ELT* V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(7772 7172 26460))
                         (MULTIPLE-VALUE-LIST
@@ -94,7 +94,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
                                              :INITIAL-CONTENTS '(116 163 140))))
-                           (CL-ARRAY (ELT* V1 V2)))))
+                           (GRID:COPY-TO (ELT* V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(5824 -3536 -710))
                         (MULTIPLE-VALUE-LIST
@@ -104,7 +104,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32)
                                              :INITIAL-CONTENTS '(-91 52 -10))))
-                           (CL-ARRAY (ELT* V1 V2)))))
+                           (GRID:COPY-TO (ELT* V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(7772 7172 26460))
                         (MULTIPLE-VALUE-LIST
@@ -114,7 +114,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
                                              :INITIAL-CONTENTS '(116 163 140))))
-                           (CL-ARRAY (ELT* V1 V2)))))
+                           (GRID:COPY-TO (ELT* V1 V2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(5824 -3536 -710))
@@ -125,7 +125,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64)
                                              :INITIAL-CONTENTS '(-91 52 -10))))
-                           (CL-ARRAY (ELT* V1 V2)))))
+                           (GRID:COPY-TO (ELT* V1 V2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(7772 7172 26460))
@@ -136,5 +136,5 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
                                              :INITIAL-CONTENTS '(116 163 140))))
-                           (CL-ARRAY (ELT* V1 V2))))))
+                           (GRID:COPY-TO (ELT* V1 V2))))))
 
diff --git a/tests/vector-reverse.lisp b/tests/vector-reverse.lisp
index 4576422e..7b753f8a 100644
--- a/tests/vector-reverse.lisp
+++ b/tests/vector-reverse.lisp
@@ -27,7 +27,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))))
-      (CL-ARRAY (VECTOR-REVERSE V1)))))
+      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(-13.49d0 49.27d0 -6.15d0 34.12d0 -8.93d0 3.29d0
@@ -38,7 +38,7 @@
 	    'DOUBLE-FLOAT
 	    :INITIAL-CONTENTS
 	    '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0))))
-      (CL-ARRAY (VECTOR-REVERSE V1)))))
+      (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)
@@ -52,7 +52,7 @@
 	    '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)
 	      #C(49.27 -13.49) #C(32.5 42.73)
 	      #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))))
-      (CL-ARRAY (VECTOR-REVERSE V1)))))
+      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(21.44d0 -49.08d0) #C(-16.12d0 -8.25d0)
@@ -68,7 +68,7 @@
 				      #C(34.12d0 -6.15d0) #C(49.27d0 -13.49d0)
 				      #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0)
 				      #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0)))))
-      (CL-ARRAY (VECTOR-REVERSE V1)))))
+      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-5 73 -10 52 -91 71 -68 -64))
    (MULTIPLE-VALUE-LIST
@@ -76,7 +76,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
-      (CL-ARRAY (VECTOR-REVERSE V1)))))
+      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(215 161 140 163 116 189 44 67))
    (MULTIPLE-VALUE-LIST
@@ -84,7 +84,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
-      (CL-ARRAY (VECTOR-REVERSE V1)))))
+      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-5 73 -10 52 -91 71 -68 -64))
    (MULTIPLE-VALUE-LIST
@@ -92,7 +92,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 16)
 	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
-      (CL-ARRAY (VECTOR-REVERSE V1)))))
+      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(215 161 140 163 116 189 44 67))
    (MULTIPLE-VALUE-LIST
@@ -100,7 +100,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 16)
 	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
-      (CL-ARRAY (VECTOR-REVERSE V1)))))
+      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-5 73 -10 52 -91 71 -68 -64))
    (MULTIPLE-VALUE-LIST
@@ -108,7 +108,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 32)
 	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
-      (CL-ARRAY (VECTOR-REVERSE V1)))))
+      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(215 161 140 163 116 189 44 67))
    (MULTIPLE-VALUE-LIST
@@ -116,7 +116,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 32)
 	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
-      (CL-ARRAY (VECTOR-REVERSE V1)))))
+      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(-5 73 -10 52 -91 71 -68 -64))
@@ -125,7 +125,7 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(SIGNED-BYTE 64)
 	    :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5))))
-      (CL-ARRAY (VECTOR-REVERSE V1)))))
+      (GRID:COPY-TO (VECTOR-REVERSE V1)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(215 161 140 163 116 189 44 67))
@@ -134,5 +134,5 @@
 	   (GRID:MAKE-FOREIGN-ARRAY
 	    '(UNSIGNED-BYTE 64)
 	    :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215))))
-      (CL-ARRAY (VECTOR-REVERSE V1))))))
+      (GRID:COPY-TO (VECTOR-REVERSE V1))))))
 
diff --git a/tests/vector-set-all.lisp b/tests/vector-set-all.lisp
index 5c6d0e10..9d2b3469 100644
--- a/tests/vector-set-all.lisp
+++ b/tests/vector-set-all.lisp
@@ -23,12 +23,12 @@
    (LIST #(-34.5 -34.5 -34.5))
    (MULTIPLE-VALUE-LIST
     (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3)))
-      (CL-ARRAY (SET-ALL V1 -34.5)))))
+      (GRID:COPY-TO (SET-ALL V1 -34.5)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST #(-34.5d0 -34.5d0 -34.5d0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3)))
-      (CL-ARRAY (SET-ALL V1 -34.5d0)))))
+      (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)))
@@ -36,7 +36,7 @@
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT)
 			:DIMENSIONS '3)))
-      (CL-ARRAY (SET-ALL V1 #C(-34.5 8.24))))))
+      (GRID:COPY-TO (SET-ALL V1 #C(-34.5 8.24))))))
   #+fsbv
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST
@@ -46,7 +46,7 @@
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT)
 			:DIMENSIONS '3)))
-      (CL-ARRAY (SET-ALL V1 #C(-34.5d0 8.24d0))))))
+      (GRID:COPY-TO (SET-ALL V1 #C(-34.5d0 8.24d0))))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(-64 -64 -64))
 				    (MULTIPLE-VALUE-LIST
 				     (LET ((V1
@@ -55,7 +55,7 @@
 					       8)
 					     :DIMENSIONS
 					     '3)))
-				       (CL-ARRAY
+				       (GRID:COPY-TO
 					(SET-ALL V1
 						 -64)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(67 67 67))
@@ -66,7 +66,7 @@
 					       8)
 					     :DIMENSIONS
 					     '3)))
-				       (CL-ARRAY
+				       (GRID:COPY-TO
 					(SET-ALL V1
 						 67)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(-64 -64 -64))
@@ -77,7 +77,7 @@
 					       16)
 					     :DIMENSIONS
 					     '3)))
-				       (CL-ARRAY
+				       (GRID:COPY-TO
 					(SET-ALL V1
 						 -64)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(67 67 67))
@@ -88,7 +88,7 @@
 					       16)
 					     :DIMENSIONS
 					     '3)))
-				       (CL-ARRAY
+				       (GRID:COPY-TO
 					(SET-ALL V1
 						 67)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(-64 -64 -64))
@@ -99,7 +99,7 @@
 					       32)
 					     :DIMENSIONS
 					     '3)))
-				       (CL-ARRAY
+				       (GRID:COPY-TO
 					(SET-ALL V1
 						 -64)))))
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(67 67 67))
@@ -110,7 +110,7 @@
 					       32)
 					     :DIMENSIONS
 					     '3)))
-				       (CL-ARRAY
+				       (GRID:COPY-TO
 					(SET-ALL V1
 						 67)))))
   #+int64
@@ -118,10 +118,10 @@
    (LIST #(-64 -64 -64))
    (MULTIPLE-VALUE-LIST
     (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS '3)))
-      (CL-ARRAY (SET-ALL V1 -64)))))
+      (GRID:COPY-TO (SET-ALL V1 -64)))))
   #+int64
   (LISP-UNIT:ASSERT-NUMERICAL-EQUAL
    (LIST #(67 67 67))
    (MULTIPLE-VALUE-LIST
     (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS '3)))
-      (CL-ARRAY (SET-ALL V1 67))))))
+      (GRID:COPY-TO (SET-ALL V1 67))))))
diff --git a/tests/vector-set-zero.lisp b/tests/vector-set-zero.lisp
index 7dd66828..a996afdf 100644
--- a/tests/vector-set-zero.lisp
+++ b/tests/vector-set-zero.lisp
@@ -25,14 +25,14 @@
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5 8.24 3.29))))
       (SET-ZERO V1)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0.0d0 0.0d0 0.0d0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS '(-34.5d0 8.24d0 3.29d0))))
       (SET-ZERO V1)
-      (CL-ARRAY V1))))
+      (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)))
    (MULTIPLE-VALUE-LIST
@@ -41,7 +41,7 @@
 	    '(COMPLEX SINGLE-FLOAT)
 	    :INITIAL-CONTENTS '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)))))
       (SET-ZERO V1)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     #(#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0)))
@@ -52,13 +52,13 @@
 	    :INITIAL-CONTENTS
 	    '(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) #C(34.12d0 -6.15d0)))))
       (SET-ZERO V1)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS '(-64 -68 71))))
       (SET-ZERO V1)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 0))
    (MULTIPLE-VALUE-LIST
@@ -67,40 +67,40 @@
 	    '(UNSIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '(67 44 189))))
       (SET-ZERO V1)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY
 	       '(SIGNED-BYTE 16) :INITIAL-CONTENTS '(-64 -68 71))))
       (SET-ZERO V1)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :INITIAL-CONTENTS '(67 44 189))))
       (SET-ZERO V1)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :INITIAL-CONTENTS '(-64 -68 71))))
       (SET-ZERO V1)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :INITIAL-CONTENTS '(67 44 189))))
       (SET-ZERO V1)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 0))
    (MULTIPLE-VALUE-LIST
     (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :INITIAL-CONTENTS '(-64 -68 71))))
       (SET-ZERO V1)
-      (CL-ARRAY V1))))
+      (GRID:COPY-TO V1))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST #(0 0 0))
@@ -108,5 +108,5 @@
     (LET ((V1
 	   (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :INITIAL-CONTENTS '(67 44 189))))
       (SET-ZERO V1)
-      (CL-ARRAY V1)))))
+      (GRID:COPY-TO V1)))))
 
diff --git a/tests/vector-sub.lisp b/tests/vector-sub.lisp
index a331c77e..ec1875e0 100644
--- a/tests/vector-sub.lisp
+++ b/tests/vector-sub.lisp
@@ -28,7 +28,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS
                                              '(-8.93 34.12 -6.15))))
-                           (CL-ARRAY (ELT- V1 V2)))))
+                           (GRID:COPY-TO (ELT- V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST
                          #(-25.57d0 -25.879999999999995d0 9.440000000000001d0))
@@ -39,7 +39,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS
                                              '(-8.93d0 34.12d0 -6.15d0))))
-                           (CL-ARRAY (ELT- V1 V2)))))
+                           (GRID:COPY-TO (ELT- V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -56,7 +56,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-91 52
                                                                      -10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT- V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(207 137 49))
                                                           (MULTIPLE-VALUE-LIST
@@ -74,7 +74,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(116 163
                                                                      140))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT- V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
                                                           (MULTIPLE-VALUE-LIST
@@ -92,7 +92,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-91 52
                                                                      -10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT- V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(65487 65417 49))
@@ -103,7 +103,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16)
                                              :INITIAL-CONTENTS '(116 163 140))))
-                           (CL-ARRAY (ELT- V1 V2)))))
+                           (GRID:COPY-TO (ELT- V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
                                                           (MULTIPLE-VALUE-LIST
                                                            (LET ((V1
@@ -120,7 +120,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-91 52
                                                                      -10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT- V1 V2)))))
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
                         (LIST #(4294967247 4294967177 49))
@@ -131,7 +131,7 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32)
                                              :INITIAL-CONTENTS '(116 163 140))))
-                           (CL-ARRAY (ELT- V1 V2)))))
+                           (GRID:COPY-TO (ELT- V1 V2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81))
                                                           (MULTIPLE-VALUE-LIST
@@ -149,7 +149,7 @@
                                                                    :INITIAL-CONTENTS
                                                                    '(-91 52
                                                                      -10))))
-                                                             (CL-ARRAY
+                                                             (GRID:COPY-TO
                                                               (ELT- V1 V2)))))
 		       #+int64
                        (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
@@ -161,5 +161,5 @@
                                (V2
                                 (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64)
                                              :INITIAL-CONTENTS '(116 163 140))))
-                           (CL-ARRAY (ELT- V1 V2))))))
+                           (GRID:COPY-TO (ELT- V1 V2))))))
 
diff --git a/tests/vector-swap.lisp b/tests/vector-swap.lisp
index 5d466947..0284afeb 100644
--- a/tests/vector-swap.lisp
+++ b/tests/vector-swap.lisp
@@ -31,7 +31,7 @@
 	    'SINGLE-FLOAT
 	    :INITIAL-CONTENTS '(-8.93 34.12 -6.15))))
       (SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST #(-8.93d0 34.12d0 -6.15d0)
@@ -46,7 +46,7 @@
 	    'DOUBLE-FLOAT
 	    :INITIAL-CONTENTS '(-8.93d0 34.12d0 -6.15d0))))
       (SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
@@ -64,7 +64,7 @@
 	    :INITIAL-CONTENTS
 	    '(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)))))
       (SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST
     (LIST
@@ -82,7 +82,7 @@
 	    :INITIAL-CONTENTS
 	    '(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) #C(-13.49d0 32.5d0)))))
       (SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST (LIST #(-91 52 -10) #(-64 -68 71)))
    (MULTIPLE-VALUE-LIST
@@ -95,7 +95,7 @@
 	    '(SIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '(-91 52 -10))))
       (SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST (LIST #(116 163 140) #(67 44 189)))
    (MULTIPLE-VALUE-LIST
@@ -108,7 +108,7 @@
 	    '(UNSIGNED-BYTE 8)
 	    :INITIAL-CONTENTS '(116 163 140))))
       (SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST (LIST #(-91 52 -10) #(-64 -68 71)))
    (MULTIPLE-VALUE-LIST
@@ -121,7 +121,7 @@
 	    '(SIGNED-BYTE 16)
 	    :INITIAL-CONTENTS '(-91 52 -10))))
       (SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST (LIST #(116 163 140) #(67 44 189)))
    (MULTIPLE-VALUE-LIST
@@ -134,7 +134,7 @@
 	    '(UNSIGNED-BYTE 16)
 	    :INITIAL-CONTENTS '(116 163 140))))
       (SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST (LIST #(-91 52 -10) #(-64 -68 71)))
    (MULTIPLE-VALUE-LIST
@@ -147,7 +147,7 @@
 	    '(SIGNED-BYTE 32)
 	    :INITIAL-CONTENTS '(-91 52 -10))))
       (SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST (LIST #(116 163 140) #(67 44 189)))
    (MULTIPLE-VALUE-LIST
@@ -160,7 +160,7 @@
 	    '(UNSIGNED-BYTE 32)
 	    :INITIAL-CONTENTS '(116 163 140))))
       (SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST (LIST #(-91 52 -10) #(-64 -68 71)))
@@ -174,7 +174,7 @@
 	    '(SIGNED-BYTE 64)
 	    :INITIAL-CONTENTS '(-91 52 -10))))
       (SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))
   #+int64
   (LISP-UNIT::ASSERT-NUMERICAL-EQUAL
    (LIST (LIST #(116 163 140) #(67 44 189)))
@@ -188,5 +188,5 @@
 	    '(UNSIGNED-BYTE 64)
 	    :INITIAL-CONTENTS '(116 163 140))))
       (SWAP V2 V1)
-      (LIST (CL-ARRAY V1) (CL-ARRAY V2))))))
+      (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2))))))
 
diff --git a/wavelet.lisp b/wavelet.lisp
index 332be11c..7fda318c 100644
--- a/wavelet.lisp
+++ b/wavelet.lisp
@@ -1,6 +1,6 @@
 ;; Wavelet transforms.
 ;; Liam Healy, Mon Nov 26 2007 - 20:43
-;; Time-stamp: <2010-06-30 19:57:28EDT wavelet.lisp>
+;; Time-stamp: <2010-07-07 14:24:54EDT wavelet.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -396,7 +396,7 @@
 	      0.0d0))) ;; Transform back
     (dotimes (i n) (format t "~&~a" (grid:gref vector i)))
     (wavelet-transform-inverse wavelet vector 1 workspace)
-    (cl-array vector)))
+    (grid:copy-to vector)))
 
 (defun wavelet-forward-example (&optional (cl-data *wavelet-sample*))
   "Simpler example, with only a Daubechies wavelet forward transformation."
@@ -405,4 +405,4 @@
 	 (wavelet (make-wavelet +daubechies-wavelet+ 4))
 	 (workspace (make-wavelet-workspace n)))
     (wavelet-transform-forward wavelet vector 1 workspace)
-    (cl-array vector)))
+    (grid:copy-to vector)))
-- 
GitLab