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