diff --git a/data/array-tests.lisp b/data/array-tests.lisp index 63e25139ad46a3dc3e52cdaf06d6f0369b95aa52..94846a50fc9558c06d59690c8cc0ddaef775b79c 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: <2008-12-26 12:23:58EST array-tests.lisp> +;; Time-stamp: <2008-12-31 21:40:17EST array-tests.lisp> ;; $Id: $ ;;; Generate each file with #'write-test-to-file, e.g. @@ -141,7 +141,6 @@ (let ((m1 (array-default '(3 3)))) (mmax m1))) -#| Temporarily commented out twos-complement answer for SIGNED-BYTE-8 and SIGNED-BYTE-16 (generate-all-array-tests vector-min :no-complex (let ((v1 (array-default 3))) (mmin v1))) @@ -149,7 +148,6 @@ (generate-all-array-tests matrix-min :no-complex (let ((m1 (array-default '(3 3)))) (mmin m1))) -|# (generate-all-array-tests vector-minmax :no-complex (let ((v1 (array-default 3))) diff --git a/data/combination.lisp b/data/combination.lisp index cdc915f7e57ff5800c91a53c7de8539fc81c1ee5..17e5ee41a98010f6ee93714d792ea5a040f91fad 100644 --- a/data/combination.lisp +++ b/data/combination.lisp @@ -1,6 +1,6 @@ ;; Combinations ;; Liam Healy, Sun Mar 26 2006 - 11:51 -;; Time-stamp: <2008-12-28 16:36:24EST combination.lisp> +;; Time-stamp: <2008-12-31 21:10:06EST combination.lisp> ;; $Id$ (in-package :gsl) @@ -12,8 +12,8 @@ (defclass combination (mobject foreign-array) ((element-type :initform - #+sizet-64 '(unsigned-byte 64) - #+sizet-32 '(unsigned-byte 32) + #+int64 '(unsigned-byte 64) + #+int32 '(unsigned-byte 32) :reader element-type :allocation :class) (choice-of :initarg :choice-of :reader choice-of :type (integer 0) :documentation "Maximum possible value; n in the (n k) notation.")) diff --git a/data/permutation.lisp b/data/permutation.lisp index 7099d58d2a6f6cb4b1e8e77d957d44c4c24c365c..8cfed933fd9dfffd5590a9684ce7a3ac4afd59df 100644 --- a/data/permutation.lisp +++ b/data/permutation.lisp @@ -1,6 +1,6 @@ ;; Permutations ;; Liam Healy, Sun Mar 26 2006 - 11:51 -;; Time-stamp: <2008-12-28 16:40:35EST permutation.lisp> +;; Time-stamp: <2008-12-31 21:10:05EST permutation.lisp> ;; $Id$ (in-package :gsl) @@ -12,8 +12,8 @@ (defclass permutation (mobject foreign-array) ((element-type :initform - #+sizet-64 '(unsigned-byte 64) - #+sizet-32 '(unsigned-byte 32) + #+int64 '(unsigned-byte 64) + #+int32 '(unsigned-byte 32) :reader element-type :allocation :class)) (:documentation "GSL permutations.")) diff --git a/floating-point/ieee-modes.lisp b/floating-point/ieee-modes.lisp index a7f80a0fc6412e41c12a01a08665eaeae1fbb795..654247761f700a9b81f9cec4339273edc143a746 100644 --- a/floating-point/ieee-modes.lisp +++ b/floating-point/ieee-modes.lisp @@ -1,6 +1,6 @@ ;; IEEE 754 Modes and masks ;; Liam Healy 2008-01-29 21:35:50EST ieee-modes.lisp -;; Time-stamp: <2008-12-28 20:59:16EST ieee-modes.lisp> +;; Time-stamp: <2008-12-31 18:36:26EST ieee-modes.lisp> ;; $Id$ (in-package :gsl) @@ -30,6 +30,3 @@ ((cffi:foreign-enum-value 'ieee-mask exception-mask) :int)) :documentation "Set the IEEE 754 precision, rounding mode, and exception mask.") - -#+clisp -(setf sys::*inhibit-floating-point-underflow* t) diff --git a/gsll-tests.asd b/gsll-tests.asd index d4fbc5909f9418bb5c3933c6cfbba39e3af7b8e6..8a6f75b638d0ad54f316552348f1308c154f3a09 100644 --- a/gsll-tests.asd +++ b/gsll-tests.asd @@ -1,6 +1,6 @@ ;; Definition of GSLL system ;; Liam Healy -;; Time-stamp: <2008-11-16 13:29:58EST gsll-tests.asd> +;; Time-stamp: <2008-12-31 21:53:55EST gsll-tests.asd> ;; $Id$ (asdf:defsystem "gsll-tests" @@ -92,6 +92,7 @@ (:file "matrix-max-index") (:file "matrix-max") (:file "matrix-mean") + (:file "matrix-min") (:file "matrix-min-index") (:file "matrix-minmax-index") (:file "matrix-minmax") @@ -159,6 +160,7 @@ (:file "vector-max-index") (:file "vector-max") (:file "vector-mean") + (:file "vector-min") (:file "vector-min-index") (:file "vector-minmax-index") (:file "vector-minmax") diff --git a/gsll.asd b/gsll.asd index 4dfd81f7098f215d04db1f28e05b7abd31908b8b..64163579c62bf05c6b8a2889afdff3205f990855 100644 --- a/gsll.asd +++ b/gsll.asd @@ -1,6 +1,6 @@ ;; Definition of GSLL system ;; Liam Healy -;; Time-stamp: <2008-12-29 13:35:30EST gsll.asd> +;; Time-stamp: <2008-12-31 21:10:22EST gsll.asd> ;; $Id$ (asdf:defsystem "gsll" @@ -16,7 +16,8 @@ ((:file "init") (:file "conditions" :depends-on (init)) (:file "mobject" :depends-on (init)) - (:file "element-types" :depends-on (init)) + (:file "types" :depends-on (init)) + (:file "element-types" :depends-on (init types)) (:file "number-conversion" :depends-on (init)) (:file "interface" :depends-on (init conditions element-types number-conversion)) diff --git a/init/conditions.lisp b/init/conditions.lisp index 0cf14fbdd393df184ff752c08f11d9e6b6e7fa00..54ecd51ae74d6b9f149a3a5d6c055b36b268ad1c 100644 --- a/init/conditions.lisp +++ b/init/conditions.lisp @@ -1,6 +1,6 @@ ;; GSL errors ;; Liam Healy Sat Mar 4 2006 - 18:33 -;; Time-stamp: <2008-12-27 16:42:45EST conditions.lisp> +;; Time-stamp: <2008-12-31 18:32:09EST conditions.lisp> ;; $Id$ (in-package :gsl) @@ -38,7 +38,8 @@ (defmacro define-gsl-condition (keyword number text &rest superclasses) `(progn - (define-condition ,keyword (gsl-condition ,@superclasses) + (define-condition + ,keyword ,(or superclasses '(gsl-condition)) ((error-number :initform ,number :reader error-number :allocation :class) (error-text :initform ,text :reader error-text :allocation :class)) (:documentation @@ -64,7 +65,7 @@ (define-gsl-condition exceeded-maximum-iterations 11 "Exceeded max number of iterations") (define-gsl-condition gsl-division-by-zero - 12 "Tried to divide by zero" division-by-zero) + 12 "Tried to divide by zero" gsl-condition division-by-zero) (define-gsl-condition invalid-tolerance 13 "User specified an invalid tolerance") (define-gsl-condition failure-to-reach-tolerance 14 "Failed to reach the specified tolerance") @@ -93,6 +94,7 @@ 30 "Cannot reach the specified tolerance in X") (define-gsl-condition failure-to-reach-tolerance-g 31 "Cannot reach the specified tolerance in gradient") +;; not a subclass of gsl-condition (define-gsl-condition gsl-eof 32 "End of file" end-of-file) ;;; It is possible to return +positive-infinity+ ;;; by defining a handler for 'overflow. diff --git a/init/element-types.lisp b/init/element-types.lisp index 4650b9b779c51746010fd0606e590cc57a2fbfb5..5122ae9d28fb11ce02cdca19cd3ce98c840e2169 100644 --- a/init/element-types.lisp +++ b/init/element-types.lisp @@ -1,6 +1,6 @@ ;; Mapping of element type names ;; Liam Healy 2008-04-13 11:22:46EDT element-types.lisp -;; Time-stamp: <2008-11-11 21:34:47EST element-types.lisp> +;; Time-stamp: <2008-12-31 21:10:07EST element-types.lisp> ;; $Id$ ;;; The different element type forms: @@ -39,9 +39,9 @@ :short :unsigned-short :int :unsigned-int :long :unsigned-long - #-cffi-features:no-long-long + #+int64 :long-long - #-cffi-features:no-long-long + #+int64 :unsigned-long-long) ;; http://common-lisp.net/project/cffi/manual/html_node/Built_002dIn-Types.html "List of integer types supported by CFFI, from the CFFI docs.") @@ -313,21 +313,3 @@ (:doubles *double-types*) (t element-types))) -;;;;**************************************************************************** -;;;; Types for CFFI (will eventually be in CFFI) -;;;;**************************************************************************** - -(defvar *sizet-type* nil - "The CL type for size_t.") - -(case - (cffi:foreign-type-size :long) - (8 - (push :sizet-64 *features*) - (setf *sizet-type* '(unsigned-byte 64)) - (cffi:defctype sizet :uint64)) - (4 - (push :sizet-32 *features*) - (setf *sizet-type* '(unsigned-byte 32)) - (cffi:defctype sizet :uint32)) - (t (error "Size of :long unrecognized"))) diff --git a/init/types.lisp b/init/types.lisp new file mode 100644 index 0000000000000000000000000000000000000000..e1d41fe3ef23726223143109b9286176fb07d25a --- /dev/null +++ b/init/types.lisp @@ -0,0 +1,27 @@ +;; Permissible types +;; Liam Healy 2008-12-31 21:06:34EST types.lisp +;; Time-stamp: <2008-12-31 21:52:33EST types.lisp> +;; $Id: $ + +(in-package :gsl) + +;;;;**************************************************************************** +;;;; Types for CFFI (will eventually be in CFFI) +;;;;**************************************************************************** + +(defvar *sizet-type* nil + "The CL type for size_t.") + +(case + (cffi:foreign-type-size :long) + (8 + (push :int64 *features*) + (setf *sizet-type* '(unsigned-byte 64)) + (cffi:defctype sizet :uint64)) + (4 + (push :int32 *features*) + (setf *sizet-type* '(unsigned-byte 32)) + (cffi:defctype sizet :uint32)) + (t (error "Size of :long unrecognized"))) + +;; cffi-features:no-long-long doesn't work for me, but ought to be checked? diff --git a/mathematical.lisp b/mathematical.lisp index 264331e8ba7b3173851b5269342b704e725887c6..bbfb2a7066fa278b484eb9af5fbc19d163e72d2d 100644 --- a/mathematical.lisp +++ b/mathematical.lisp @@ -1,6 +1,6 @@ ;; Mathematical functions ;; Liam Healy, Wed Mar 8 2006 - 22:09 -;; Time-stamp: <2008-10-25 19:09:09EDT mathematical.lisp> +;; Time-stamp: <2008-12-31 18:44:26EST mathematical.lisp> ;; $Id$ (in-package :gsl) @@ -14,6 +14,8 @@ ;;; Maximum and Minimum functions ;;; Does CL need the small integer powers? +#+clisp (setf sys::*inhibit-floating-point-underflow* t) + ;;;;**************************************************************************** ;;; Infinities and Not-a-number ;;;;**************************************************************************** diff --git a/tests/column.lisp b/tests/column.lisp index cea707af1171deefabbc0ca32696c9b71c85585e..5ad05e2d5526b23feaa9b5e3ad84fa32b7617b26 100644 --- a/tests/column.lisp +++ b/tests/column.lisp @@ -189,6 +189,7 @@ (CL-ARRAY (COLUMN COL M1 1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5)) (MULTIPLE-VALUE-LIST (LET ((M1 @@ -211,6 +212,7 @@ (CL-ARRAY (COLUMN COL M1 1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215)) (MULTIPLE-VALUE-LIST (LET ((M1 diff --git a/tests/matrix-add-scalar.lisp b/tests/matrix-add-scalar.lisp index 2faa18436de9f48640490d033d2773c21aaab633..64a5fc01a21b6de26d5942a4ece256b4e9236910 100644 --- a/tests/matrix-add-scalar.lisp +++ b/tests/matrix-add-scalar.lisp @@ -81,6 +81,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (CL-ARRAY (M+C M1 18.19d0))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-45 -49 89) (-72 70 8) (91 13 141))) (MULTIPLE-VALUE-LIST @@ -90,6 +91,7 @@ '((-64 -68 71) (-91 52 -10) (73 -5 123))))) (CL-ARRAY (M+C M1 18.19d0))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((85 62 207) (134 181 158) (179 233 116))) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-copy.lisp b/tests/matrix-copy.lisp index d9ac3bd666c9c020a2511f0a3ccd3ce97d3bda67..5dbee57cb77c5d2c57438985458b12d4b6bead87 100644 --- a/tests/matrix-copy.lisp +++ b/tests/matrix-copy.lisp @@ -154,6 +154,7 @@ '(3 3)))) (COPY M2 M1) (CL-ARRAY M2)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-64 -68 71) (-91 52 -10) (73 -5 123))) (MULTIPLE-VALUE-LIST @@ -167,6 +168,7 @@ '(3 3)))) (COPY M2 M1) (CL-ARRAY M2)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((67 44 189) (116 163 140) (161 215 98))) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-div.lisp b/tests/matrix-div.lisp index 7bde9bb194085cb50cded5702b1ed96489f2b457..e3b7fe9bbc11d9c27d47fb2030070e63ec7b49f7 100644 --- a/tests/matrix-div.lisp +++ b/tests/matrix-div.lisp @@ -122,6 +122,7 @@ '((28 10 19) (28 178 217) (36 109 222))))) (CL-ARRAY (M/ M1 M2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) (MULTIPLE-VALUE-LIST @@ -136,6 +137,7 @@ '((32 28 30) (37 -73 -8) (-15 -22 68))))) (CL-ARRAY (M/ M1 M2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((2 4 9) (4 0 0) (4 1 0))) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-m+.lisp b/tests/matrix-m+.lisp index b582e2e4f79da92d68f04dc0b9d14ebaaf4dd495..7095f7590cd703c7f97b4731bbf6f88b47a9c303 100644 --- a/tests/matrix-m+.lisp +++ b/tests/matrix-m+.lisp @@ -120,6 +120,7 @@ '((28 10 19) (28 178 217) (36 109 222))))) (CL-ARRAY (M+ M1 M2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191))) (MULTIPLE-VALUE-LIST @@ -134,6 +135,7 @@ '((32 28 30) (37 -73 -8) (-15 -22 68))))) (CL-ARRAY (M+ M1 M2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((95 54 208) (144 341 357) (197 324 320))) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-m-.lisp b/tests/matrix-m-.lisp index ddd4e08e3e60086313f371a4652c73e5673672c4..93d94f482450f4b675865f2dbf6db3a661fb6b2f 100644 --- a/tests/matrix-m-.lisp +++ b/tests/matrix-m-.lisp @@ -126,6 +126,7 @@ '((28 10 19) (28 178 217) (36 109 222))))) (CL-ARRAY (M- M1 M2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) (MULTIPLE-VALUE-LIST @@ -140,6 +141,7 @@ '((32 28 30) (37 -73 -8) (-15 -22 68))))) (CL-ARRAY (M- M1 M2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((39 34 170) diff --git a/tests/matrix-max-index.lisp b/tests/matrix-max-index.lisp index 8b6e1ce7827b67e86a6b54531794814840550bc6..143af3737df0f9fd12daa7f4763336f114c66a39 100644 --- a/tests/matrix-max-index.lisp +++ b/tests/matrix-max-index.lisp @@ -119,6 +119,7 @@ (161 215 98))))) (MAX-INDEX M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) (MULTIPLE-VALUE-LIST (LET ((M1 @@ -133,6 +134,7 @@ (73 -5 123))))) (MAX-INDEX M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) (MULTIPLE-VALUE-LIST (LET ((M1 diff --git a/tests/matrix-max.lisp b/tests/matrix-max.lisp index 3d0377a6b6d93d0feee0b333b92412551dd1d1c8..93504dc4682506fd84727b01d3e579ed4eaa4f0f 100644 --- a/tests/matrix-max.lisp +++ b/tests/matrix-max.lisp @@ -119,6 +119,7 @@ (161 215 98))))) (MMAX M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) (MULTIPLE-VALUE-LIST (LET ((M1 @@ -133,6 +134,7 @@ (73 -5 123))))) (MMAX M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) (MULTIPLE-VALUE-LIST (LET ((M1 diff --git a/tests/matrix-mean.lisp b/tests/matrix-mean.lisp index c460c00bfc5ff8e594e16d7eea339813f44e5e2b..d6a320fc8d933ba493dbe007be0bb9d64c216794 100644 --- a/tests/matrix-mean.lisp +++ b/tests/matrix-mean.lisp @@ -97,6 +97,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (MEAN M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) (MULTIPLE-VALUE-LIST (LET ((M1 @@ -111,6 +112,7 @@ (73 -5 123))))) (MEAN M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 132.55555555555554d0) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-min-index.lisp b/tests/matrix-min-index.lisp index 87923e4c2a6aa2581d85fbc26544a032d10ec27c..c66bb4d0750738400bd0dc581d5fbc055fd4b7d9 100644 --- a/tests/matrix-min-index.lisp +++ b/tests/matrix-min-index.lisp @@ -119,6 +119,7 @@ (161 215 98))))) (MIN-INDEX M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) (MULTIPLE-VALUE-LIST (LET ((M1 @@ -133,6 +134,7 @@ (73 -5 123))))) (MIN-INDEX M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) (MULTIPLE-VALUE-LIST (LET ((M1 diff --git a/tests/matrix-min.lisp b/tests/matrix-min.lisp new file mode 100644 index 0000000000000000000000000000000000000000..05281e9117f37fa8a3fe73e3cd2c3d9bb44e9643 --- /dev/null +++ b/tests/matrix-min.lisp @@ -0,0 +1,152 @@ +;; Regression test MATRIX-MIN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-MIN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (MAKE-MARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5 + 8.24 + 3.29) + (-8.93 + 34.12 + -6.15) + (49.27 + -13.49 + 32.5))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (MAKE-MARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '((-34.5d0 + 8.24d0 + 3.29d0) + (-8.93d0 + 34.12d0 + -6.15d0) + (49.27d0 + -13.49d0 + 32.5d0))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (MAKE-MARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (MAKE-MARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (MAKE-MARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (MAKE-MARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (MAKE-MARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (MAKE-MARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MMIN M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (MAKE-MARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MMIN M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (MAKE-MARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MMIN M1))))) + diff --git a/tests/matrix-minmax-index.lisp b/tests/matrix-minmax-index.lisp index 18b169736a1ceef305c6bb2fedba4da2c03ae446..db9ea914733e7cc0049dc2d3d58ae302970fd2d5 100644 --- a/tests/matrix-minmax-index.lisp +++ b/tests/matrix-minmax-index.lisp @@ -127,6 +127,7 @@ 98))))) (MINMAX-INDEX M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) (MULTIPLE-VALUE-LIST (LET ((M1 @@ -142,6 +143,7 @@ 123))))) (MINMAX-INDEX M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) (MULTIPLE-VALUE-LIST (LET ((M1 diff --git a/tests/matrix-minmax.lisp b/tests/matrix-minmax.lisp index 9981dc424fc31e3a4b2c718ca05a863f03d3e727..577ee660d38e83916e9f946f398de28484a97866 100644 --- a/tests/matrix-minmax.lisp +++ b/tests/matrix-minmax.lisp @@ -112,6 +112,7 @@ (161 215 98))))) (MINMAX M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) (MULTIPLE-VALUE-LIST (LET ((M1 @@ -126,6 +127,7 @@ (73 -5 123))))) (MINMAX M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) (MULTIPLE-VALUE-LIST (LET ((M1 diff --git a/tests/matrix-mult-scalar.lisp b/tests/matrix-mult-scalar.lisp index ae897a9f2fe5e1dfce8a73dee0c64b98827e0660..a1ac216714c3d95c9de8f530ff795fb986d8076e 100644 --- a/tests/matrix-mult-scalar.lisp +++ b/tests/matrix-mult-scalar.lisp @@ -80,6 +80,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (CL-ARRAY (M*C M1 1.39d0))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-88 -94 98) (-126 72 -13) (101 -6 170))) (MULTIPLE-VALUE-LIST @@ -89,6 +90,7 @@ '((-64 -68 71) (-91 52 -10) (73 -5 123))))) (CL-ARRAY (M*C M1 1.39d0))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((93 61 262) (161 226 194) (223 298 136))) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-mult.lisp b/tests/matrix-mult.lisp index 2ba53be3611107e8f6770abe4a0718ba787cb3b3..36dfccc7aa11f4f853bc1864a708284f5d3a188d 100644 --- a/tests/matrix-mult.lisp +++ b/tests/matrix-mult.lisp @@ -132,6 +132,7 @@ '((28 10 19) (28 178 217) (36 109 222))))) (CL-ARRAY (M* M1 M2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-2048 -1904 2130) @@ -149,6 +150,7 @@ '((32 28 30) (37 -73 -8) (-15 -22 68))))) (CL-ARRAY (M* M1 M2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((1876 440 3591) diff --git a/tests/matrix-set-all-m+.lisp b/tests/matrix-set-all-m+.lisp index a15b49074d49160a82b8ef79d91ccfa0ee63d18e..a9d9335d82d152573a02f7fbdf41c2144ef28ba3 100644 --- a/tests/matrix-set-all-m+.lisp +++ b/tests/matrix-set-all-m+.lisp @@ -111,6 +111,7 @@ (161 215 98))))) (SET-ALL M1 28) (CL-ARRAY (M+ M1 M2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-32 -36 103) (-59 84 22) (105 27 155))) (MULTIPLE-VALUE-LIST @@ -124,6 +125,7 @@ (73 -5 123))))) (SET-ALL M1 32) (CL-ARRAY (M+ M1 M2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((95 72 217) (144 191 168) (189 243 126))) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-set-zero.lisp b/tests/matrix-set-zero.lisp index d26658f46786b2fb4a7e31f7d62a8b285c097bce..6f8a9436b8725c08b87b4ffda4a3cffed11f7f98 100644 --- a/tests/matrix-set-zero.lisp +++ b/tests/matrix-set-zero.lisp @@ -120,6 +120,7 @@ (161 215 98))))) (SET-ZERO M1) (CL-ARRAY M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((0 0 0) (0 0 0) (0 0 0))) (MULTIPLE-VALUE-LIST @@ -130,6 +131,7 @@ (73 -5 123))))) (SET-ZERO M1) (CL-ARRAY M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((0 0 0) (0 0 0) (0 0 0))) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-standard-deviation-with-fixed-mean.lisp b/tests/matrix-standard-deviation-with-fixed-mean.lisp index 7e58a2798a7738dff106e94096a152d94a5e20ae..f62634e086e29e982cabf4040116a0fe55bf4b34 100644 --- a/tests/matrix-standard-deviation-with-fixed-mean.lisp +++ b/tests/matrix-standard-deviation-with-fixed-mean.lisp @@ -74,6 +74,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 70.39570693980959d0) (MULTIPLE-VALUE-LIST @@ -83,6 +84,7 @@ '((-64 -68 71) (-91 52 -10) (73 -5 123))))) (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 53.10599696437538d0) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-standard-deviation-with-mean.lisp b/tests/matrix-standard-deviation-with-mean.lisp index ccc0649b315a8b4a6120318d2cb93da418eae5cb..6c75d75042a2aab791f3831f3c41f2a67737a913 100644 --- a/tests/matrix-standard-deviation-with-mean.lisp +++ b/tests/matrix-standard-deviation-with-mean.lisp @@ -74,6 +74,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (STANDARD-DEVIATION M1 (MEAN M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 74.66592261534039d0) (MULTIPLE-VALUE-LIST @@ -83,6 +84,7 @@ '((-64 -68 71) (-91 52 -10) (73 -5 123))))) (STANDARD-DEVIATION M1 (MEAN M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 56.32741586277306d0) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-standard-deviation.lisp b/tests/matrix-standard-deviation.lisp index b487bc58e9f71a3012db5c2276d3d6d1f26d9338..5b9953cdab72fb654202cbf28dd7550c66514e2b 100644 --- a/tests/matrix-standard-deviation.lisp +++ b/tests/matrix-standard-deviation.lisp @@ -74,6 +74,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (STANDARD-DEVIATION M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 74.66592261534039d0) (MULTIPLE-VALUE-LIST @@ -83,6 +84,7 @@ '((-64 -68 71) (-91 52 -10) (73 -5 123))))) (STANDARD-DEVIATION M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 56.32741586277306d0) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-swap.lisp b/tests/matrix-swap.lisp index 58f8c590153d31387021d9830ab2f98e063ded79..90a79cc53f75e7e02483858454660cffd14f5fdd 100644 --- a/tests/matrix-swap.lisp +++ b/tests/matrix-swap.lisp @@ -217,6 +217,7 @@ (36 109 222))))) (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68)) @@ -234,6 +235,7 @@ (-15 -22 68))))) (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST #2A((28 10 19) (28 178 217) (36 109 222)) diff --git a/tests/matrix-transpose-copy.lisp b/tests/matrix-transpose-copy.lisp index 9112f395179266589b95765805a6fb9dbce00603..250bb7441ce3314f26d18cbb710b0977c179372d 100644 --- a/tests/matrix-transpose-copy.lisp +++ b/tests/matrix-transpose-copy.lisp @@ -144,6 +144,7 @@ (MAKE-MARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS '(3 3)))) (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123))) (MULTIPLE-VALUE-LIST @@ -156,6 +157,7 @@ (MAKE-MARRAY '(SIGNED-BYTE 64) :DIMENSIONS '(3 3)))) (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((67 116 161) (44 163 215) (189 140 98))) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-transpose.lisp b/tests/matrix-transpose.lisp index 67d16a5ab0400b57b8ad5c802c7af2d8be261992..5c5ffae7d0e82dab30169c19a9d1a13c28de0b67 100644 --- a/tests/matrix-transpose.lisp +++ b/tests/matrix-transpose.lisp @@ -116,6 +116,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123))) (MULTIPLE-VALUE-LIST @@ -125,6 +126,7 @@ '((-64 -68 71) (-91 52 -10) (73 -5 123))))) (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((67 116 161) (44 163 215) (189 140 98))) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-variance-with-fixed-mean.lisp b/tests/matrix-variance-with-fixed-mean.lisp index bdcb0d8f853adee76068f6c845e559eec323a1d5..739f120724ed1b3275be3fce39f69cc67458885c 100644 --- a/tests/matrix-variance-with-fixed-mean.lisp +++ b/tests/matrix-variance-with-fixed-mean.lisp @@ -74,6 +74,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 4955.555555555556d0) (MULTIPLE-VALUE-LIST @@ -83,6 +84,7 @@ '((-64 -68 71) (-91 52 -10) (73 -5 123))))) (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2820.246913580247d0) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-variance-with-mean.lisp b/tests/matrix-variance-with-mean.lisp index 53fc2b7fd81586c499f8e2e52e99c5914ae37fa1..ac9ba80e3caf4ddcf700756e46c40538ff258535 100644 --- a/tests/matrix-variance-with-mean.lisp +++ b/tests/matrix-variance-with-mean.lisp @@ -96,6 +96,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (VARIANCE M1 (MEAN M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) (MULTIPLE-VALUE-LIST (LET ((M1 @@ -112,6 +113,7 @@ (VARIANCE M1 (MEAN M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3172.777777777778d0) (MULTIPLE-VALUE-LIST diff --git a/tests/matrix-variance.lisp b/tests/matrix-variance.lisp index 895922eca03db65aa5716e5fe4dbbfc42c3a4add..261d434087145c4f3abbc69be2ab41dca4fe5961 100644 --- a/tests/matrix-variance.lisp +++ b/tests/matrix-variance.lisp @@ -90,6 +90,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (VARIANCE M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) (MULTIPLE-VALUE-LIST (LET ((M1 @@ -104,6 +105,7 @@ (73 -5 123))))) (VARIANCE M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3172.777777777778d0) (MULTIPLE-VALUE-LIST diff --git a/tests/row.lisp b/tests/row.lisp index 2d59c6ac45b59e024e4ce5e9e3eb4849c8a776c5..8d84aa0951b84f138ab31506b9aff892f60e81a9 100644 --- a/tests/row.lisp +++ b/tests/row.lisp @@ -190,6 +190,7 @@ (CL-ARRAY (ROW ROW M1 1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 52 -10)) (MULTIPLE-VALUE-LIST (LET ((M1 @@ -212,6 +213,7 @@ (CL-ARRAY (ROW ROW M1 1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(116 163 140)) (MULTIPLE-VALUE-LIST (LET ((M1 diff --git a/tests/set-basis.lisp b/tests/set-basis.lisp index 8c96e54f43339677558c3145130d6eeac6f12327..ba26a56ac619b1bd812846e4a65b164ae58c9a9c 100644 --- a/tests/set-basis.lisp +++ b/tests/set-basis.lisp @@ -106,6 +106,7 @@ '(67 44 189 116 163 140 161 215)))) (SET-BASIS V1 2) (CL-ARRAY V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 1 0 0 0 0 0)) (MULTIPLE-VALUE-LIST @@ -115,6 +116,7 @@ '(-64 -68 71 -91 52 -10 73 -5)))) (SET-BASIS V1 2) (CL-ARRAY V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 1 0 0 0 0 0)) (MULTIPLE-VALUE-LIST diff --git a/tests/set-identity.lisp b/tests/set-identity.lisp index 1bc870845b0223be0a7287beeb74377e33b8615d..9dd692c8f8c6f34bb4e9aa921f0e8dbd041c93dc 100644 --- a/tests/set-identity.lisp +++ b/tests/set-identity.lisp @@ -110,6 +110,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (CL-ARRAY (SET-IDENTITY M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((1 0 0) (0 1 0) (0 0 1))) (MULTIPLE-VALUE-LIST @@ -119,6 +120,7 @@ '((-64 -68 71) (-91 52 -10) (73 -5 123))))) (CL-ARRAY (SET-IDENTITY M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((1 0 0) (0 1 0) (0 0 1))) (MULTIPLE-VALUE-LIST diff --git a/tests/setf-column.lisp b/tests/setf-column.lisp index 927ae38ed8229c99be13ca2379c4b7e2d441aee2..3afbee695b7e08bb5c7fce048b59862d2e1f264c 100644 --- a/tests/setf-column.lisp +++ b/tests/setf-column.lisp @@ -160,6 +160,7 @@ :INITIAL-CONTENTS '(28 10 19)))) (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30))) (MULTIPLE-VALUE-LIST @@ -173,6 +174,7 @@ :INITIAL-CONTENTS '(32 28 30)))) (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((67 44 28) (116 163 10) (161 215 19))) (MULTIPLE-VALUE-LIST diff --git a/tests/setf-row.lisp b/tests/setf-row.lisp index d303d8df7c0cef77417873995ba010673739b3d7..d325a4e6a4246cef8c69f44f8beec53d93c18a11 100644 --- a/tests/setf-row.lisp +++ b/tests/setf-row.lisp @@ -160,6 +160,7 @@ :INITIAL-CONTENTS '(28 10 19)))) (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30))) (MULTIPLE-VALUE-LIST @@ -173,6 +174,7 @@ :INITIAL-CONTENTS '(32 28 30)))) (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((67 44 189) (116 163 140) (28 10 19))) (MULTIPLE-VALUE-LIST diff --git a/tests/sort-matrix-largest.lisp b/tests/sort-matrix-largest.lisp index 4c4d93219bc24296663ac730b033e56efbc4e928..d00151d9a46bac382ade0e2f1f96644d4a77c1cd 100644 --- a/tests/sort-matrix-largest.lisp +++ b/tests/sort-matrix-largest.lisp @@ -97,6 +97,7 @@ (MAKE-MARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS '(2 3)))) (CL-ARRAY (SORT-LARGEST M2 M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((123 73 71) (52 -5 -10))) (MULTIPLE-VALUE-LIST @@ -109,6 +110,7 @@ (MAKE-MARRAY '(SIGNED-BYTE 64) :DIMENSIONS '(2 3)))) (CL-ARRAY (SORT-LARGEST M2 M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((215 189 163) (161 140 116))) (MULTIPLE-VALUE-LIST diff --git a/tests/sort-matrix-smallest.lisp b/tests/sort-matrix-smallest.lisp index 91c393273b73bdb79b6be98bdb69fbe21bcbdc07..e174e301123ba7985ad45a7f6ebc1fa0b1b435d3 100644 --- a/tests/sort-matrix-smallest.lisp +++ b/tests/sort-matrix-smallest.lisp @@ -98,6 +98,7 @@ (MAKE-MARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS '(2 3)))) (CL-ARRAY (SORT-SMALLEST M2 M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-91 -68 -64) (-10 -5 52))) (MULTIPLE-VALUE-LIST @@ -110,6 +111,7 @@ (MAKE-MARRAY '(SIGNED-BYTE 64) :DIMENSIONS '(2 3)))) (CL-ARRAY (SORT-SMALLEST M2 M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((44 67 98) (116 140 161))) (MULTIPLE-VALUE-LIST diff --git a/tests/sort-matrix.lisp b/tests/sort-matrix.lisp index 046fc2cb32e50af6cc0c882b20894a47339a3106..5b2efdcf364ecc393c3cb0fce147ea8a57367291 100644 --- a/tests/sort-matrix.lisp +++ b/tests/sort-matrix.lisp @@ -80,6 +80,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (CL-ARRAY (MSORT M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) (MULTIPLE-VALUE-LIST @@ -89,6 +90,7 @@ '((-64 -68 71) (-91 52 -10) (73 -5 123))))) (CL-ARRAY (MSORT M1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((44 67 98) (116 140 161) (163 189 215))) (MULTIPLE-VALUE-LIST diff --git a/tests/sort-vector-index.lisp b/tests/sort-vector-index.lisp index 6be366261837f8e452177604e0e56e170d60a7fb..24014290aaf6de429763994a9fd7083a1bc5db74 100644 --- a/tests/sort-vector-index.lisp +++ b/tests/sort-vector-index.lisp @@ -83,6 +83,7 @@ '(67 44 189 116 163 140 161 215)))) (SORT-VECTOR-INDEX PERM V1) (CL-ARRAY PERM)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0 5 7 4 2 6)) (MULTIPLE-VALUE-LIST @@ -93,6 +94,7 @@ '(-64 -68 71 -91 52 -10 73 -5)))) (SORT-VECTOR-INDEX PERM V1) (CL-ARRAY PERM)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3 5 6 4 2 7)) (MULTIPLE-VALUE-LIST diff --git a/tests/sort-vector-largest-index.lisp b/tests/sort-vector-largest-index.lisp index 6da02c82909f70b24dcdfb2b0f37653e128d3775..ef15e98ec16b349bf43f6a576a310203484d4eb8 100644 --- a/tests/sort-vector-largest-index.lisp +++ b/tests/sort-vector-largest-index.lisp @@ -140,6 +140,7 @@ (CL-ARRAY (SORT-VECTOR-LARGEST-INDEX COMB V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) (MULTIPLE-VALUE-LIST (LET ((COMB @@ -156,6 +157,7 @@ (CL-ARRAY (SORT-VECTOR-LARGEST-INDEX COMB V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) (MULTIPLE-VALUE-LIST (LET ((COMB diff --git a/tests/sort-vector-largest.lisp b/tests/sort-vector-largest.lisp index 8cb149f6af1db3d77ffdca3bf2187117a3331d24..ad22a9f92588c81e28541c5f58dceef560a471fa 100644 --- a/tests/sort-vector-largest.lisp +++ b/tests/sort-vector-largest.lisp @@ -149,6 +149,7 @@ (CL-ARRAY (SORT-VECTOR-LARGEST V2 V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -169,6 +170,7 @@ (CL-ARRAY (SORT-VECTOR-LARGEST V2 V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/sort-vector-smallest-index.lisp b/tests/sort-vector-smallest-index.lisp index 137805d46ba693beaac9e9ead9ce02935e7e059b..bf0f377cd870067946444d19d01fe20d90d71c45 100644 --- a/tests/sort-vector-smallest-index.lisp +++ b/tests/sort-vector-smallest-index.lisp @@ -140,6 +140,7 @@ (CL-ARRAY (SORT-VECTOR-SMALLEST-INDEX COMB V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) (MULTIPLE-VALUE-LIST (LET ((COMB @@ -156,6 +157,7 @@ (CL-ARRAY (SORT-VECTOR-SMALLEST-INDEX COMB V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) (MULTIPLE-VALUE-LIST (LET ((COMB diff --git a/tests/sort-vector-smallest.lisp b/tests/sort-vector-smallest.lisp index 497e4e0d1af7ea4c1c1e968a873d415329144608..dae3dd36b333afc8f64860aa43cb9ff2a3339547 100644 --- a/tests/sort-vector-smallest.lisp +++ b/tests/sort-vector-smallest.lisp @@ -149,6 +149,7 @@ (CL-ARRAY (SORT-VECTOR-SMALLEST V2 V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -169,6 +170,7 @@ (CL-ARRAY (SORT-VECTOR-SMALLEST V2 V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/sort-vector.lisp b/tests/sort-vector.lisp index a372802549553cf4c5bc1f4e21883e6473752491..0f83e35af8250bea860abdb544020233df578a75 100644 --- a/tests/sort-vector.lisp +++ b/tests/sort-vector.lisp @@ -70,6 +70,7 @@ :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) (CL-ARRAY (SORT-VECTOR V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64 -10 -5 52 71 73)) (MULTIPLE-VALUE-LIST @@ -78,6 +79,7 @@ :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) (CL-ARRAY (SORT-VECTOR V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116 140 161 163 189 215)) (MULTIPLE-VALUE-LIST diff --git a/tests/swap-columns.lisp b/tests/swap-columns.lisp index 7e5421c0476558ad9e8795af88ebf2d43a7a80a7..1b058eed6fe5852a9c4b491db0ab9fbfcb09e38b 100644 --- a/tests/swap-columns.lisp +++ b/tests/swap-columns.lisp @@ -116,6 +116,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (CL-ARRAY (SWAP-COLUMNS M1 1 2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5))) (MULTIPLE-VALUE-LIST @@ -125,6 +126,7 @@ '((-64 -68 71) (-91 52 -10) (73 -5 123))))) (CL-ARRAY (SWAP-COLUMNS M1 1 2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((67 189 44) (116 140 163) (161 98 215))) (MULTIPLE-VALUE-LIST diff --git a/tests/swap-elements.lisp b/tests/swap-elements.lisp index 89f3396f396976a1d37acaf4e708a94ce4a507d8..70d2be0d17c04034f729dfd234f0455a505daa3d 100644 --- a/tests/swap-elements.lisp +++ b/tests/swap-elements.lisp @@ -110,6 +110,7 @@ '(67 44 189 116 163 140 161 215)))) (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-64 -68 -10 -91 52 71 73 -5)) (MULTIPLE-VALUE-LIST @@ -119,6 +120,7 @@ '(-64 -68 71 -91 52 -10 73 -5)))) (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(67 44 140 116 163 189 161 215)) (MULTIPLE-VALUE-LIST diff --git a/tests/swap-row-column.lisp b/tests/swap-row-column.lisp index 4a3efe7b31b730180508fdb64d828703a02fe41f..a80e7211f99669ee7f717ccb51822dfe52d30c15 100644 --- a/tests/swap-row-column.lisp +++ b/tests/swap-row-column.lisp @@ -115,6 +115,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((71 -10 123) (-91 52 -68) (73 -5 -64))) (MULTIPLE-VALUE-LIST @@ -124,6 +125,7 @@ '((-64 -68 71) (-91 52 -10) (73 -5 123))))) (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((189 140 98) (116 163 44) (161 215 67))) (MULTIPLE-VALUE-LIST diff --git a/tests/swap-rows.lisp b/tests/swap-rows.lisp index 9ae40c2d64048d214712fd9f80495d28221650f8..153b61fd7c3dcf1918983d8db7de8554749e5852 100644 --- a/tests/swap-rows.lisp +++ b/tests/swap-rows.lisp @@ -116,6 +116,7 @@ '((67 44 189) (116 163 140) (161 215 98))))) (CL-ARRAY (SWAP-ROWS M1 0 1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123))) (MULTIPLE-VALUE-LIST @@ -125,6 +126,7 @@ '((-64 -68 71) (-91 52 -10) (73 -5 123))))) (CL-ARRAY (SWAP-ROWS M1 0 1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((116 163 140) (67 44 189) (161 215 98))) (MULTIPLE-VALUE-LIST diff --git a/tests/vector-copy.lisp b/tests/vector-copy.lisp index 1503c4c260835c4a27f7c074b5de1bfff5d2d6fd..de9548ae9b3002fb402eae5156bd85f0f9c88d5d 100644 --- a/tests/vector-copy.lisp +++ b/tests/vector-copy.lisp @@ -151,6 +151,7 @@ '3))) (COPY V2 V1) (CL-ARRAY V2)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-64 -68 71)) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -168,6 +169,7 @@ '3))) (COPY V2 V1) (CL-ARRAY V2)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(67 44 189)) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-div.lisp b/tests/vector-div.lisp index cd9154c9c588a908e502cb84e65a4da2b6afee95..ca38df969ad2202a4cab6a788cdd1f65af3b5eca 100644 --- a/tests/vector-div.lisp +++ b/tests/vector-div.lisp @@ -133,6 +133,7 @@ 140)))) (CL-ARRAY (M/ V1 V2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 -1 -7)) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -151,6 +152,7 @@ -10)))) (CL-ARRAY (M/ V1 V2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 1)) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-m+.lisp b/tests/vector-m+.lisp index 8f4367a2fe0f0db1ef7aace1f8777af96b4e3ec6..838fa979c067c499c4e7294512191e0b219f00eb 100644 --- a/tests/vector-m+.lisp +++ b/tests/vector-m+.lisp @@ -131,6 +131,7 @@ 140)))) (CL-ARRAY (M+ V1 V2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-155 -16 61)) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -149,6 +150,7 @@ -10)))) (CL-ARRAY (M+ V1 V2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(183 207 329)) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-m-.lisp b/tests/vector-m-.lisp index daa57748a73adc1d9fed4ef73ab6344bf914aea2..f83ad685e56488ef86338f9d2907fbf2d21b97a8 100644 --- a/tests/vector-m-.lisp +++ b/tests/vector-m-.lisp @@ -116,6 +116,7 @@ (MAKE-MARRAY '(UNSIGNED-BYTE 32) :INITIAL-CONTENTS '(116 163 140)))) (CL-ARRAY (M- V1 V2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -134,6 +135,7 @@ -10)))) (CL-ARRAY (M- V1 V2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(18446744073709551567 18446744073709551497 49)) (MULTIPLE-VALUE-LIST diff --git a/tests/vector-max-index.lisp b/tests/vector-max-index.lisp index 05b980fd11a2074c908ebe1311395da64a004b98..b4f395787f8d2b22ad97652ab23877110857e50e 100644 --- a/tests/vector-max-index.lisp +++ b/tests/vector-max-index.lisp @@ -100,6 +100,7 @@ 140 161 215)))) (MAX-INDEX V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -111,6 +112,7 @@ -91 52 -10 73 -5)))) (MAX-INDEX V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-max.lisp b/tests/vector-max.lisp index 497d00f35a8279aba42e832c4cf2b7f25f56ba57..d63ea382fd67c731c77051ab8eaa9feca76f0b66 100644 --- a/tests/vector-max.lisp +++ b/tests/vector-max.lisp @@ -82,6 +82,7 @@ '(67 44 189)))) (MMAX V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -92,6 +93,7 @@ '(-64 -68 71)))) (MMAX V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-mean.lisp b/tests/vector-mean.lisp index c2fc337c1e54e239cb0ebd27d01cb1e29d7eaf3f..a56f3d327e074e4aef13d1ac4efd2067678dcc1e 100644 --- a/tests/vector-mean.lisp +++ b/tests/vector-mean.lisp @@ -95,6 +95,7 @@ 140 161 215)))) (MEAN V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -106,6 +107,7 @@ -91 52 -10 73 -5)))) (MEAN V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-min-index.lisp b/tests/vector-min-index.lisp index 505faf4d1c0768aa7f5bbaa348a6c6d600e37c03..4124b7977f0c55a47b2a18a4e323ff01c9f82a63 100644 --- a/tests/vector-min-index.lisp +++ b/tests/vector-min-index.lisp @@ -100,6 +100,7 @@ 140 161 215)))) (MIN-INDEX V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -111,6 +112,7 @@ -91 52 -10 73 -5)))) (MIN-INDEX V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-min.lisp b/tests/vector-min.lisp new file mode 100644 index 0000000000000000000000000000000000000000..62eba3b1cc1d69aa41dbeacd1bf5e56a15a6bbc3 --- /dev/null +++ b/tests/vector-min.lisp @@ -0,0 +1,107 @@ +;; Regression test VECTOR-MIN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-MIN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (MAKE-MARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '(-34.5 8.24 + 3.29)))) + (MMIN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (MAKE-MARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '(-34.5d0 + 8.24d0 + 3.29d0)))) + (MMIN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (MAKE-MARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(-64 -68 + 71)))) + (MMIN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (MAKE-MARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(67 44 + 189)))) + (MMIN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (MAKE-MARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(-64 -68 + 71)))) + (MMIN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (MAKE-MARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(67 44 + 189)))) + (MMIN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (MAKE-MARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(-64 -68 + 71)))) + (MMIN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (MAKE-MARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(67 44 + 189)))) + (MMIN V1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (MAKE-MARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(-64 -68 + 71)))) + (MMIN V1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (MAKE-MARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(67 44 + 189)))) + (MMIN V1))))) + diff --git a/tests/vector-minmax-index.lisp b/tests/vector-minmax-index.lisp index 953d4ddb8881b3745b01619b80741edfd2c1ed49..46e6249624eda4a28de675295f18a0476ced57bb 100644 --- a/tests/vector-minmax-index.lisp +++ b/tests/vector-minmax-index.lisp @@ -108,6 +108,7 @@ 215)))) (MINMAX-INDEX V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3 6) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -120,6 +121,7 @@ 73 -5)))) (MINMAX-INDEX V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 7) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-minmax.lisp b/tests/vector-minmax.lisp index e8d2bcb6efcf3f46ba2f05c87f184ff50dac87e2..6a995b08746ba357651cf9629a8f0dfcfc985e64 100644 --- a/tests/vector-minmax.lisp +++ b/tests/vector-minmax.lisp @@ -82,6 +82,7 @@ '(67 44 189)))) (MINMAX V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68 71) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -92,6 +93,7 @@ '(-64 -68 71)))) (MINMAX V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 189) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-mult.lisp b/tests/vector-mult.lisp index c3439e9424e8ace723e1fe5b033750aa2f8a87bb..5606878546ebd9b53d227fa99f1a53cb38ba8e34 100644 --- a/tests/vector-mult.lisp +++ b/tests/vector-mult.lisp @@ -99,6 +99,7 @@ (MAKE-MARRAY '(UNSIGNED-BYTE 32) :INITIAL-CONTENTS '(116 163 140)))) (CL-ARRAY (M* V1 V2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(5824 -3536 -710)) (MULTIPLE-VALUE-LIST @@ -109,6 +110,7 @@ (MAKE-MARRAY '(SIGNED-BYTE 64) :INITIAL-CONTENTS '(-91 52 -10)))) (CL-ARRAY (M* V1 V2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7772 7172 26460)) (MULTIPLE-VALUE-LIST diff --git a/tests/vector-reverse.lisp b/tests/vector-reverse.lisp index 6645d8bc04ba7ba78622fef86b93ff33e2987c86..21e7cd12ea748198919e5605a1e2e2b7cfac605e 100644 --- a/tests/vector-reverse.lisp +++ b/tests/vector-reverse.lisp @@ -100,6 +100,7 @@ :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) (CL-ARRAY (VECTOR-REVERSE V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-5 73 -10 52 -91 71 -68 -64)) (MULTIPLE-VALUE-LIST @@ -108,6 +109,7 @@ :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) (CL-ARRAY (VECTOR-REVERSE V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 161 140 163 116 189 44 67)) (MULTIPLE-VALUE-LIST diff --git a/tests/vector-set-all-m+.lisp b/tests/vector-set-all-m+.lisp index 9a33752869cd770d853a57c165766b3fd1854013..3a72a45315fc6f5c5a131c9a50bccdd807362e52 100644 --- a/tests/vector-set-all-m+.lisp +++ b/tests/vector-set-all-m+.lisp @@ -113,6 +113,7 @@ (SET-ALL V1 116) (CL-ARRAY (M+ V1 V2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-155 -159 -20)) (MULTIPLE-VALUE-LIST @@ -123,6 +124,7 @@ :INITIAL-CONTENTS '(-64 -68 71)))) (SET-ALL V1 -91) (CL-ARRAY (M+ V1 V2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(183 160 305)) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-set-zero.lisp b/tests/vector-set-zero.lisp index b52b2e7f2f64bb01417f39793a8dac2703c6eb87..4b1b33840a7c4b8be6dfb5d44fb60061f14d37d7 100644 --- a/tests/vector-set-zero.lisp +++ b/tests/vector-set-zero.lisp @@ -108,6 +108,7 @@ 189)))) (SET-ZERO V1) (CL-ARRAY V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0)) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -119,6 +120,7 @@ 71)))) (SET-ZERO V1) (CL-ARRAY V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0)) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-standard-deviation-with-fixed-mean.lisp b/tests/vector-standard-deviation-with-fixed-mean.lisp index c19139083450d5c44a0f72cea7d942708b98f728..24469c57bda2088f31e2172f7d4f2b24902f8103 100644 --- a/tests/vector-standard-deviation-with-fixed-mean.lisp +++ b/tests/vector-standard-deviation-with-fixed-mean.lisp @@ -67,6 +67,7 @@ :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 61.216317269172606d0) (MULTIPLE-VALUE-LIST @@ -75,6 +76,7 @@ :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 54.81659762334762d0) (MULTIPLE-VALUE-LIST diff --git a/tests/vector-standard-deviation-with-mean.lisp b/tests/vector-standard-deviation-with-mean.lisp index 1f7daff059de433b65ddd1afee14722fe925dd36..fe8abc818bd13d0141b6ae18e60fe274022ca8bb 100644 --- a/tests/vector-standard-deviation-with-mean.lisp +++ b/tests/vector-standard-deviation-with-mean.lisp @@ -67,6 +67,7 @@ :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) (STANDARD-DEVIATION V1 (MEAN V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 65.44299591465624d0) (MULTIPLE-VALUE-LIST @@ -75,6 +76,7 @@ :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) (STANDARD-DEVIATION V1 (MEAN V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 58.60140783291814d0) (MULTIPLE-VALUE-LIST diff --git a/tests/vector-standard-deviation.lisp b/tests/vector-standard-deviation.lisp index b4fad93e980e4624b8cce0ce6c6f343083820ba3..689b1f987458683312f5895de2b2e2293f2a686c 100644 --- a/tests/vector-standard-deviation.lisp +++ b/tests/vector-standard-deviation.lisp @@ -67,6 +67,7 @@ :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) (STANDARD-DEVIATION V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 65.44299591465624d0) (MULTIPLE-VALUE-LIST @@ -75,6 +76,7 @@ :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) (STANDARD-DEVIATION V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 58.60140783291814d0) (MULTIPLE-VALUE-LIST diff --git a/tests/vector-swap.lisp b/tests/vector-swap.lisp index 5a1949e27bfa12cfc420937b2fd0ecb87b77a031..9106fe03c3a029801e1565206a24f899cffbffaf 100644 --- a/tests/vector-swap.lisp +++ b/tests/vector-swap.lisp @@ -131,6 +131,7 @@ :INITIAL-CONTENTS '(116 163 140)))) (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST #(-91 52 -10) #(-64 -68 71))) (MULTIPLE-VALUE-LIST @@ -142,6 +143,7 @@ :INITIAL-CONTENTS '(-91 52 -10)))) (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST #(116 163 140) #(67 44 189))) (MULTIPLE-VALUE-LIST diff --git a/tests/vector-variance-with-fixed-mean.lisp b/tests/vector-variance-with-fixed-mean.lisp index 19768179de50b7f7f8c9aef309baa0e3f3d53f64..00074011ba8fb9fdbbb2f08328d0cf87c17b5bb5 100644 --- a/tests/vector-variance-with-fixed-mean.lisp +++ b/tests/vector-variance-with-fixed-mean.lisp @@ -95,6 +95,7 @@ 215)))) (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) (MULTIPLE-VALUE-LIST (LET ((V1 @@ -107,6 +108,7 @@ 73 -5)))) (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-variance-with-mean.lisp b/tests/vector-variance-with-mean.lisp index 1cd64af0d7495bc211a953547460a968bdb53362..8da952792e34e0f891e7a9d0e9028d1756e1653c 100644 --- a/tests/vector-variance-with-mean.lisp +++ b/tests/vector-variance-with-mean.lisp @@ -85,6 +85,7 @@ (VARIANCE V1 (MEAN V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 4282.785714285714d0) (MULTIPLE-VALUE-LIST @@ -93,6 +94,7 @@ :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) (VARIANCE V1 (MEAN V1))))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) (MULTIPLE-VALUE-LIST (LET ((V1 diff --git a/tests/vector-variance.lisp b/tests/vector-variance.lisp index 668bf73b3c165892df89875b365c5800b3ce3d78..0594c4c46a5dc5ca46361d81f32594215b51e2cb 100644 --- a/tests/vector-variance.lisp +++ b/tests/vector-variance.lisp @@ -79,6 +79,7 @@ 140 161 215)))) (VARIANCE V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 4282.785714285714d0) (MULTIPLE-VALUE-LIST @@ -87,6 +88,7 @@ :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) (VARIANCE V1)))) + #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) (MULTIPLE-VALUE-LIST (LET ((V1