Commit 4bfa337d authored by Liam Healy's avatar Liam Healy

Elementwise array operations named "elt"

GSL functions that operate from one corresponding array elements and
then overwrite the first array, as well as those that operate on each
element of an array with a scalar, are now named starting with "elt",
as in "elt+"; formerely they started with "m".  This is to reinforce
the idea that they are not generally a mathematical solution to
algebraic problems, just elementwise operations.  The scalar
operations (addition, multiplication) are methods of elt+ and elt* as
well. Test results 64 bit:
SBCL: TOTAL: 1223 assertions passed, 5 failed, 0 execution errors.
CCL: TOTAL: 1228 assertions passed, 0 failed, 0 execution errors.
parent 2747131e
;; Tests of array functions
;; Liam Healy 2008-10-20 22:41:48EDT array-tests.lisp
;; Time-stamp: <2009-01-03 22:04:21EST array-tests.lisp>
;; Time-stamp: <2009-01-04 11:15:18EST array-tests.lisp>
;; $Id: $
;;; Generate each file with #'write-test-to-file, e.g.
......@@ -15,57 +15,49 @@
;;;; Bulk operations
;;;;****************************************************************************
(generate-all-array-tests
vector-set-all-m+ :no-complex
(generate-all-array-tests vector-set-all-add :no-complex
(let ((v1 (array-default 3 t))
(v2 (array-default 3)))
(set-all v1 (scalar-default))
(cl-array (m+ v1 v2))))
(cl-array (elt+ v1 v2))))
(generate-all-array-tests
matrix-set-all-m+ :no-complex
(generate-all-array-tests matrix-set-all-add :no-complex
(let ((m1 (array-default '(3 3) t))
(m2 (array-default '(3 3))))
(set-all m1 (scalar-default))
(cl-array (m+ m1 m2))))
(cl-array (elt+ m1 m2))))
(generate-all-array-tests
vector-set-zero t
(generate-all-array-tests vector-set-zero t
(let ((v1 (array-default 3)))
(set-zero v1)
(cl-array v1)))
(generate-all-array-tests
matrix-set-zero t
(generate-all-array-tests matrix-set-zero t
(let ((m1 (array-default '(3 3))))
(set-zero m1)
(cl-array m1)))
(generate-all-array-tests
vector-copy t
(generate-all-array-tests vector-copy t
(let ((v1 (array-default 3))
(v2 (array-default 3 t)))
(v2 (array-default 3 t)))
(copy v2 v1)
(cl-array v2)))
(generate-all-array-tests
matrix-copy t
(generate-all-array-tests matrix-copy t
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3) t)))
(m2 (array-default '(3 3) t)))
(copy m2 m1)
(cl-array m2)))
(generate-all-array-tests
vector-swap t
(generate-all-array-tests vector-swap t
(let ((v1 (array-default 3))
(v2 (array-default 3)))
(v2 (array-default 3)))
(swap v2 v1)
(list (cl-array v1) (cl-array v2))))
(generate-all-array-tests
matrix-swap t
(generate-all-array-tests matrix-swap t
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3))))
(m2 (array-default '(3 3))))
(swap m2 m1)
(list (cl-array m1) (cl-array m2))))
......@@ -73,61 +65,61 @@
;;;; Arithmetic operations
;;;;****************************************************************************
(generate-all-array-tests vector-m+ :no-complex
(generate-all-array-tests vector-add :no-complex
(let ((v1 (array-default 3))
(v2 (array-default 3)))
(cl-array (m+ v1 v2))))
(v2 (array-default 3)))
(cl-array (elt+ v1 v2))))
(generate-all-array-tests matrix-m+ :no-complex
(generate-all-array-tests matrix-add :no-complex
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3))))
(cl-array (m+ m1 m2))))
(m2 (array-default '(3 3))))
(cl-array (elt+ m1 m2))))
(generate-all-array-tests vector-m- :no-complex
(generate-all-array-tests vector-sub :no-complex
(let ((v1 (array-default 3))
(v2 (array-default 3)))
(cl-array (m- v1 v2))))
(v2 (array-default 3)))
(cl-array (elt- v1 v2))))
(generate-all-array-tests matrix-m- :no-complex
(generate-all-array-tests matrix-sub :no-complex
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3))))
(cl-array (m- m1 m2))))
(m2 (array-default '(3 3))))
(cl-array (elt- m1 m2))))
(generate-all-array-tests vector-mult :no-complex
(let ((v1 (array-default 3))
(v2 (array-default 3)))
(cl-array (e* v1 v2))))
(cl-array (elt* v1 v2))))
(generate-all-array-tests matrix-mult :no-complex
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3))))
(cl-array (e* m1 m2))))
(cl-array (elt* m1 m2))))
(generate-all-array-tests vector-div :no-complex
(let ((v1 (array-default 3))
(v2 (array-default 3)))
(cl-array (e/ v1 v2))))
(cl-array (elt/ v1 v2))))
(generate-all-array-tests matrix-div :no-complex
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3))))
(cl-array (e/ m1 m2))))
(cl-array (elt/ m1 m2))))
(generate-all-array-tests vector-mult-scalar :no-complex
(let ((v1 (array-default 3)))
(cl-array (m* v1 1.39d0))))
(cl-array (elt* v1 1.39d0))))
(generate-all-array-tests matrix-mult-scalar :no-complex
(let ((m1 (array-default '(3 3))))
(cl-array (m* m1 1.39d0))))
(cl-array (elt* m1 1.39d0))))
(generate-all-array-tests vector-add-scalar :no-complex
(let ((v1 (array-default 3)))
(cl-array (m+ v1 18.19d0))))
(cl-array (elt+ v1 18.19d0))))
(generate-all-array-tests matrix-add-scalar :no-complex
(let ((m1 (array-default '(3 3))))
(cl-array (m+ m1 18.19d0))))
(cl-array (elt+ m1 18.19d0))))
;;;;****************************************************************************
;;;; Maximum and minimum elements
......
;; Functions for both vectors and matrices.
;; Liam Healy 2008-04-26 20:48:44EDT both.lisp
;; Time-stamp: <2009-01-03 22:01:26EST both.lisp>
;; Time-stamp: <2009-01-04 11:30:47EST both.lisp>
;; $Id$
(in-package :gsl)
......@@ -99,15 +99,20 @@
"Set single element to the value. For debugging only; do not use.")
;;;;****************************************************************************
;;;; Arithmetic operations
;;;; Elementwise arithmetic operations overwriting an array
;;;;****************************************************************************
;;; These are overwriting elementwise arithmetic operations. Where
;;; there are two array arguments, the operation acts on both arrays
;;; on corresponding elements. The result is placed in the first
;;; array, overwriting the original contents.
;;; Errors in GSL:
;;; 1) complex operations in older versions of GSL
;;; https://savannah.gnu.org/bugs/index.php?22478
;;; Fixed in 1.12, can change the :no-complex spec.
(defmfun m+ ((a both) (b both))
(defmfun elt+ ((a both) (b both))
("gsl_" :category :type "_add")
(((mpointer a) :pointer) ((mpointer b) :pointer))
:definition :generic
......@@ -119,7 +124,7 @@
"Add the elements of b to the elements of vector a
The two must have the same dimensions.")
(defmfun m+ ((a both) (x float))
(defmfun elt+ ((a both) (x float))
("gsl_" :category :type "_add_constant")
(((mpointer a) :pointer) (x :double))
:definition :methods
......@@ -130,10 +135,10 @@
:documentation ; FDL
"Add the scalar double-float x to all the elements of array a.")
(defmethod m+ ((x float) (a marray))
(m+ a x))
(defmethod elt+ ((x float) (a marray))
(elt+ a x))
(defmfun m- ((a both) (b both))
(defmfun elt- ((a both) (b both))
("gsl_" :category :type "_sub")
(((mpointer a) :pointer) ((mpointer b) :pointer))
:definition :generic
......@@ -145,7 +150,7 @@
"Subtract the elements of b from the elements of a.
The two must have the same dimensions.")
(defmfun e* ((a vector) (b vector))
(defmfun elt* ((a vector) (b vector))
("gsl_" :category :type "_mul")
(((mpointer a) :pointer) ((mpointer b) :pointer))
:definition :generic
......@@ -157,7 +162,7 @@
"Multiply the elements of a by the elements of b.
The two must have the same dimensions.")
(defmfun e* ((a matrix) (b matrix))
(defmfun elt* ((a matrix) (b matrix))
("gsl_" :category :type "_mul_elements")
(((mpointer a) :pointer) ((mpointer b) :pointer))
:definition :methods
......@@ -166,7 +171,7 @@
:outputs (a)
:return (a))
(defmfun e/ ((a vector) (b vector))
(defmfun elt/ ((a vector) (b vector))
("gsl_" :category :type "_div")
(((mpointer a) :pointer) ((mpointer b) :pointer))
:definition :generic
......@@ -178,7 +183,7 @@
"Divide the elements of a by the elements of b.
The two must have the same dimensions.")
(defmfun e/ ((a matrix) (b matrix))
(defmfun elt/ ((a matrix) (b matrix))
("gsl_" :category :type "_div_elements")
(((mpointer a) :pointer) ((mpointer b) :pointer))
:definition :methods
......@@ -187,10 +192,10 @@
:outputs (a)
:return (a))
(defmfun m* ((a both) (x float))
(defmfun elt* ((a both) (x float))
("gsl_" :category :type "_scale")
(((mpointer a) :pointer) (x :double))
:definition :generic
:definition :methods
:element-types :no-complex
:inputs (a)
:outputs (a)
......@@ -198,8 +203,8 @@
:documentation ; FDL
"Multiply the elements of a by the scalar double-float factor x.")
(defmethod m* ((x float) (a marray))
(m* a x))
(defmethod elt* ((x float) (a marray))
(elt* a x))
;;;;****************************************************************************
;;;; Maximum and minimum elements
......
......@@ -196,7 +196,7 @@ T
<p>
Some examples are not yet present, or are too complicated for, the
function <code>#'examples</code>. In this case, you need to look in
the relevant source file; there is either a separate file of
the relevant source file; they are in either a separate file of
examples, or at the end of the file of definitions.
It is advisable to look at the examples first for calculations that
require more complex setup (generally, the later chapters in the GSL
......@@ -206,9 +206,9 @@ T
<p>
GSLL has many functions that work on vectors (one-dimensional arrays)
and matrices (two-dimensional arrays). GSLL supports all array
element types that are supported by CFFI, the CL implementation, and
GSL. This list is available in the
variable <code>*array-element-types*</code>. On platforms that
element types that are supported by CFFI, the CL implementation,
GSL, and the platform. This list is available in the
variable <code>*array-element-types*</code>. On implementations that
support it (currently only SBCL), the contents are directly available
to the GSL functions without copying between the Lisp area and the C
area of memory.</p>
......@@ -224,7 +224,7 @@ area of memory.</p>
by a list of lists of number, each of the same length, a matrix is
created.
<p>
Classes of vectors and matrices are names by appending the element
Classes of vectors and matrices are named by appending the element
type as hypenated words to "vector" or "matrix". The following table
shows the classes available on a 64-bit platform:
<center>
......@@ -316,7 +316,7 @@ version should still be considered alpha.
<!-- Created: Feb 25 2005 -->
<!-- hhmts start -->
<small>
Time-stamp: <2009-01-01 22:34:36EST index.html>
Time-stamp: <2009-01-03 22:40:07EST index.html>
</small>
<!-- hhmts end -->
</div>
......
;; Definition of GSLL system
;; Liam Healy
;; Time-stamp: <2008-12-31 21:53:55EST gsll-tests.asd>
;; Time-stamp: <2009-01-04 11:26:56EST gsll-tests.asd>
;; $Id$
(asdf:defsystem "gsll-tests"
......@@ -96,14 +96,14 @@
(:file "matrix-min-index")
(:file "matrix-minmax-index")
(:file "matrix-minmax")
(:file "matrix-m-")
(:file "matrix-m+")
(:file "matrix-sub")
(:file "matrix-add")
(:file "matrix-mult")
(:file "matrix-product-hermitian")
(:file "matrix-product")
(:file "matrix-product-symmetric")
(:file "matrix-product-triangular")
(:file "matrix-set-all-m+")
(:file "matrix-set-all-add")
(:file "matrix-set-zero")
(:file "matrix-standard-deviation")
(:file "matrix-standard-deviation-with-fixed-mean")
......@@ -164,11 +164,11 @@
(:file "vector-min-index")
(:file "vector-minmax-index")
(:file "vector-minmax")
(:file "vector-m-")
(:file "vector-m+")
(:file "vector-sub")
(:file "vector-add")
(:file "vector-mult")
(:file "vector-reverse")
(:file "vector-set-all-m+")
(:file "vector-set-all-add")
(:file "vector-set-zero")
(:file "vector-standard-deviation")
(:file "vector-standard-deviation-with-fixed-mean")
......
;; Histogram operations
;; Liam Healy, Mon Jan 1 2007 - 16:47
;; Time-stamp: <2008-12-26 14:47:49EST operations.lisp>
;; Time-stamp: <2009-01-04 11:15:17EST operations.lisp>
;; $Id$
(in-package :gsl)
......@@ -24,7 +24,7 @@
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun m+ ((histogram1 histogram) (histogram2 histogram))
(defmfun elt+ ((histogram1 histogram) (histogram2 histogram))
"gsl_histogram_add"
(((mpointer histogram1) :pointer) ((mpointer histogram2) :pointer))
:definition :method
......@@ -36,7 +36,7 @@
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun m+ ((histogram1 histogram2d) (histogram2 histogram2d))
(defmfun elt+ ((histogram1 histogram2d) (histogram2 histogram2d))
"gsl_histogram2d_add"
(((mpointer histogram1) :pointer) ((mpointer histogram2) :pointer))
:definition :method
......@@ -48,7 +48,7 @@
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun m- ((histogram1 histogram) (histogram2 histogram))
(defmfun elt- ((histogram1 histogram) (histogram2 histogram))
"gsl_histogram_sub"
(((mpointer histogram1) :pointer) ((mpointer histogram2) :pointer))
:definition :method
......@@ -59,7 +59,7 @@
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun m- ((histogram1 histogram2d) (histogram2 histogram2d))
(defmfun elt- ((histogram1 histogram2d) (histogram2 histogram2d))
"gsl_histogram2d_sub"
(((mpointer histogram1) :pointer) ((mpointer histogram2) :pointer))
:definition :method
......@@ -70,7 +70,7 @@
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun m* ((histogram1 histogram) (histogram2 histogram))
(defmfun elt* ((histogram1 histogram) (histogram2 histogram))
"gsl_histogram_mul"
(((mpointer histogram1) :pointer) ((mpointer histogram2) :pointer))
:definition :method
......@@ -82,7 +82,7 @@
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun m* ((histogram1 histogram2d) (histogram2 histogram2d))
(defmfun elt* ((histogram1 histogram2d) (histogram2 histogram2d))
"gsl_histogram2d_mul"
(((mpointer histogram1) :pointer) ((mpointer histogram2) :pointer))
:definition :method
......@@ -94,7 +94,7 @@
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun m/ ((histogram1 histogram) (histogram2 histogram))
(defmfun elt/ ((histogram1 histogram) (histogram2 histogram))
"gsl_histogram_div"
(((mpointer histogram1) :pointer) ((mpointer histogram2) :pointer))
:definition :method
......@@ -106,7 +106,7 @@
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun m/ ((histogram1 histogram2d) (histogram2 histogram2d))
(defmfun elt/ ((histogram1 histogram2d) (histogram2 histogram2d))
"gsl_histogram2d_div"
(((mpointer histogram1) :pointer) ((mpointer histogram2) :pointer))
:definition :method
......@@ -118,7 +118,7 @@
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun scale ((histogram histogram) scale)
(defmfun elt* ((histogram histogram) scale)
"gsl_histogram_scale"
(((mpointer histogram) :pointer) (scale :double))
:definition :method
......@@ -128,7 +128,7 @@
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun scale ((histogram histogram2d) scale)
(defmfun elt* ((histogram histogram2d) scale)
"gsl_histogram2d_scale"
(((mpointer histogram) :pointer) (scale :double))
:definition :method
......
;; Make tests from examples.
;; Liam Healy 2008-09-07 21:00:48EDT generate-tests.lisp
;; Time-stamp: <2008-12-26 17:54:49EST generate-tests.lisp>
;; Time-stamp: <2009-01-04 11:00:11EST generate-tests.lisp>
;; $Id: $
;;; Througout the GSLL interface definition files are #'save-test
......@@ -9,7 +9,7 @@
;;; the calling the function with a particular name to get the
;;; examples, e.g.
;;; (examples)
;;; (examples 'matrix-m+)
;;; (examples 'matrix-add)
;;; To do all the tests,
;;; (lisp-unit:run-tests)
......@@ -19,7 +19,7 @@
;;; shouldn't be changed very often. Rarely, it may be necessary to
;;; generate such a file. In this case, #'write-test-to-file recreates
;;; the file, e.g.
;;; (write-test-to-file 'matrix-m+ "test/")
;;; (write-test-to-file 'matrix-add "test/")
(in-package :gsl)
......
......@@ -14,7 +14,7 @@
'((-34.5 8.24 3.29)
(-8.93 34.12 -6.15)
(49.27 -13.49 32.5)))))
(CL-ARRAY (M+ M1 18.19d0)))))
(CL-ARRAY (ELT+ M1 18.19d0)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST
#2A((-16.31d0 26.43d0 21.48d0)
......@@ -27,7 +27,7 @@
'((-34.5d0 8.24d0 3.29d0)
(-8.93d0 34.12d0 -6.15d0)
(49.27d0 -13.49d0 32.5d0)))))
(CL-ARRAY (M+ M1 18.19d0)))))
(CL-ARRAY (ELT+ M1 18.19d0)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((-45 -49 89) (-72 70 8) (91 13 -115)))
(MULTIPLE-VALUE-LIST
......@@ -35,7 +35,7 @@
(MAKE-MARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
'((-64 -68 71) (-91 52 -10)
(73 -5 123)))))
(CL-ARRAY (M+ M1 18.19d0)))))
(CL-ARRAY (ELT+ M1 18.19d0)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((85 62 207) (134 181 158) (179 233 116)))
(MULTIPLE-VALUE-LIST
......@@ -44,7 +44,7 @@
:INITIAL-CONTENTS
'((67 44 189) (116 163 140)
(161 215 98)))))
(CL-ARRAY (M+ M1 18.19d0)))))
(CL-ARRAY (ELT+ M1 18.19d0)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((-45 -49 89) (-72 70 8) (91 13 141)))
(MULTIPLE-VALUE-LIST
......@@ -53,7 +53,7 @@
:INITIAL-CONTENTS
'((-64 -68 71) (-91 52 -10)
(73 -5 123)))))
(CL-ARRAY (M+ M1 18.19d0)))))
(CL-ARRAY (ELT+ M1 18.19d0)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((85 62 207) (134 181 158) (179 233 116)))
(MULTIPLE-VALUE-LIST
......@@ -62,7 +62,7 @@
:INITIAL-CONTENTS
'((67 44 189) (116 163 140)
(161 215 98)))))
(CL-ARRAY (M+ M1 18.19d0)))))
(CL-ARRAY (ELT+ M1 18.19d0)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((-45 -49 89) (-72 70 8) (91 13 141)))
(MULTIPLE-VALUE-LIST
......@@ -71,7 +71,7 @@
:INITIAL-CONTENTS
'((-64 -68 71) (-91 52 -10)
(73 -5 123)))))
(CL-ARRAY (M+ M1 18.19d0)))))
(CL-ARRAY (ELT+ M1 18.19d0)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((85 62 207) (134 181 158) (179 233 116)))
(MULTIPLE-VALUE-LIST
......@@ -80,7 +80,7 @@
:INITIAL-CONTENTS
'((67 44 189) (116 163 140)
(161 215 98)))))
(CL-ARRAY (M+ M1 18.19d0)))))
(CL-ARRAY (ELT+ M1 18.19d0)))))
#+int64
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((-45 -49 89) (-72 70 8) (91 13 141)))
......@@ -90,7 +90,7 @@
:INITIAL-CONTENTS
'((-64 -68 71) (-91 52 -10)
(73 -5 123)))))
(CL-ARRAY (M+ M1 18.19d0)))))
(CL-ARRAY (ELT+ M1 18.19d0)))))
#+int64
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((85 62 207) (134 181 158) (179 233 116)))
......@@ -100,5 +100,5 @@
:INITIAL-CONTENTS
'((67 44 189) (116 163 140)
(161 215 98)))))
(CL-ARRAY (M+ M1 18.19d0))))))
(CL-ARRAY (ELT+ M1 18.19d0))))))
;; Regression test MATRIX-M+ for GSLL, automatically generated
;; Regression test MATRIX-ADD for GSLL, automatically generated
(in-package :gsl)
(LISP-UNIT:DEFINE-TEST MATRIX-M+
(LISP-UNIT:DEFINE-TEST MATRIX-ADD
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST
#2A((8.23 -9.0 46.600002)
......@@ -19,7 +19,7 @@
'((42.73 -17.24 43.31)
(-16.12 -8.25 21.44)
(-49.08 -39.66 -49.46)))))
(CL-ARRAY (M+ M1 M2)))))
(CL-ARRAY (ELT+ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST
#2A((8.229999999999997d0 -8.999999999999998d0 46.6d0)
......@@ -37,7 +37,7 @@
'((42.73d0 -17.24d0 43.31d0)
(-16.12d0 -8.25d0 21.44d0)
(-49.08d0 -39.66d0 -49.46d0)))))
(CL-ARRAY (M+ M1 M2)))))
(CL-ARRAY (ELT+ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 -65)))
(MULTIPLE-VALUE-LIST
......@@ -49,7 +49,7 @@
(MAKE-MARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
'((32 28 30) (37 -73 -8)
(-15 -22 68)))))
(CL-ARRAY (M+ M1 M2)))))
(CL-ARRAY (ELT+ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((95 54 208) (144 85 101) (197 68 64)))
(MULTIPLE-VALUE-LIST
......@@ -63,7 +63,7 @@
:INITIAL-CONTENTS
'((28 10 19) (28 178 217)
(36 109 222)))))
(CL-ARRAY (M+ M1 M2)))))
(CL-ARRAY (ELT+ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191)))
(MULTIPLE-VALUE-LIST
......@@ -77,7 +77,7 @@
:INITIAL-CONTENTS
'((32 28 30) (37 -73 -8)
(-15 -22 68)))))
(CL-ARRAY (M+ M1 M2)))))
(CL-ARRAY (ELT+ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((95 54 208) (144 341 357) (197 324 320)))
(MULTIPLE-VALUE-LIST
......@@ -91,7 +91,7 @@
:INITIAL-CONTENTS
'((28 10 19) (28 178 217)
(36 109 222)))))
(CL-ARRAY (M+ M1 M2)))))
(CL-ARRAY (ELT+ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191)))
(MULTIPLE-VALUE-LIST
......@@ -105,7 +105,7 @@
:INITIAL-CONTENTS
'((32 28 30) (37 -73 -8)
(-15 -22 68)))))
(CL-ARRAY (M+ M1 M2)))))
(CL-ARRAY (ELT+ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((95 54 208) (144 341 357) (197 324 320)))
(MULTIPLE-VALUE-LIST
......@@ -119,7 +119,7 @@
:INITIAL-CONTENTS
'((28 10 19) (28 178 217)
(36 109 222)))))
(CL-ARRAY (M+ M1 M2)))))
(CL-ARRAY (ELT+ M1 M2)))))
#+int64
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191)))
......@@ -134,7 +134,7 @@
:INITIAL-CONTENTS
'((32 28 30) (37 -73 -8)
(-15 -22 68)))))
(CL-ARRAY (M+ M1 M2)))))
(CL-ARRAY (ELT+ M1 M2)))))
#+int64
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((95 54 208) (144 341 357) (197 324 320)))
......@@ -149,5 +149,5 @@
:INITIAL-CONTENTS
'((28 10 19) (28 178 217)
(36 109 222)))))
(CL-ARRAY (M+ M1 M2))))))
(CL-ARRAY (ELT+ M1 M2))))))
......@@ -19,7 +19,7 @@
'((42.73 -17.24 43.31)
(-16.12 -8.25 21.44)
(-49.08 -39.66 -49.46)))))
(CL-ARRAY (E/ M1 M2)))))
(CL-ARRAY (ELT/ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST
#2A((-0.8073952726421718d0 -0.4779582366589328d0
......@@ -39,7 +39,7 @@
'((42.73d0 -17.24d0 43.31d0)
(-16.12d0 -8.25d0 21.44d0)
(-49.08d0 -39.66d0 -49.46d0)))))
(CL-ARRAY (E/ M1 M2)))))
(CL-ARRAY (ELT/ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1)))
(MULTIPLE-VALUE-LIST
......@@ -51,7 +51,7 @@
(MAKE-MARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS
'((32 28 30) (37 -73 -8)
(-15 -22 68)))))
(CL-ARRAY (E/ M1 M2)))))
(CL-ARRAY (ELT/ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((2 4 9) (4 0 0) (4 1 0)))
(MULTIPLE-VALUE-LIST
......@@ -65,7 +65,7 @@
:INITIAL-CONTENTS
'((28 10 19) (28 178 217)
(36 109 222)))))
(CL-ARRAY (E/ M1 M2)))))
(CL-ARRAY (ELT/ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1)))
(MULTIPLE-VALUE-LIST
......@@ -79,7 +79,7 @@
:INITIAL-CONTENTS
'((32 28 30) (37 -73 -8)
(-15 -22 68)))))
(CL-ARRAY (E/ M1 M2)))))
(CL-ARRAY (ELT/ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((2 4 9) (4 0 0) (4 1 0)))
(MULTIPLE-VALUE-LIST
......@@ -93,7 +93,7 @@
:INITIAL-CONTENTS
'((28 10 19) (28 178 217)
(36 109 222)))))
(CL-ARRAY (E/ M1 M2)))))
(CL-ARRAY (ELT/ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1)))
(MULTIPLE-VALUE-LIST
......@@ -107,7 +107,7 @@
:INITIAL-CONTENTS
'((32 28 30) (37 -73 -8)
(-15 -22 68)))))
(CL-ARRAY (E/ M1 M2)))))
(CL-ARRAY (ELT/ M1 M2)))))
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((2 4 9) (4 0 0) (4 1 0)))
(MULTIPLE-VALUE-LIST
......@@ -121,7 +121,7 @@
:INITIAL-CONTENTS
'((28 10 19) (28 178 217)
(36 109 222)))))
(CL-ARRAY (E/ M1 M2)))))
(CL-ARRAY (ELT/ M1 M2)))))
#+int64
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1)))
......@@ -136,7 +136,7 @@
:INITIAL-CONTENTS
'((32 28 30) (37 -73 -8)
(-15 -22 68)))))
(CL-ARRAY (E/ M1 M2)))))
(CL-ARRAY (ELT/ M1 M2)))))
#+int64
(LISP-UNIT::ASSERT-NUMERICAL-EQUAL
(LIST #2A((2 4 9) (4 0 0) (4 1 0)))
......@@ -151,5 +151,5 @@
:INITIAL-CONTENTS
'((28 10 19) (28 178 217)
(36 109 222)))))
(CL-ARRAY (E/ M1 M2))))))