diff --git a/gsll-tests.asd b/gsll-tests.asd new file mode 100644 index 0000000000000000000000000000000000000000..d4fbc5909f9418bb5c3933c6cfbba39e3af7b8e6 --- /dev/null +++ b/gsll-tests.asd @@ -0,0 +1,179 @@ +;; Definition of GSLL system +;; Liam Healy +;; Time-stamp: <2008-11-16 13:29:58EST gsll-tests.asd> +;; $Id$ + +(asdf:defsystem "gsll-tests" + :name "gsll-tests" + :description "Regression (unit) tests for GNU Scientific Library for Lisp." + :version "0" + :author "Liam M. Healy" + :licence "LLGPL v3, FDL" + :depends-on (gsll) + :components + ((:module test-unit + :components + ;; http://www.cs.northwestern.edu/academics/courses/325/readings/lisp-unit.html + ((:file "lisp-unit") + (:file "additional-definitions" :depends-on (lisp-unit)))) + (:module tests + :depends-on (test-unit) + :components + ((:file "absolute-deviation") + (:file "absolute-sum") + (:file "airy") + (:file "autocorrelation") + (:file "axpy") + (:file "bernoulli") + (:file "bessel") + (:file "beta") + (:file "binomial") + (:file "blas-copy") + (:file "blas-swap") + (:file "cauchy") + (:file "cdot") + (:file "chebyshev") + (:file "chi-squared") + (:file "clausen") + (:file "column") + (:file "combination") + (:file "coulomb") + (:file "coupling") + (:file "covariance") + (:file "dawson") + (:file "debye") + (:file "dilogarithm") + (:file "dirichlet") + (:file "discrete") + (:file "dot") + (:file "eigensystems") + (:file "elementary") + (:file "elliptic-functions") + (:file "elliptic-integrals") + (:file "error-functions") + (:file "euclidean-norm") + (:file "exponential-functions") + (:file "exponential-integrals") + (:file "exponential") + (:file "exponential-power") + (:file "fdist") + (:file "fermi-dirac") + (:file "flat") + (:file "gamma") + (:file "gamma-randist") + (:file "gaussian-bivariate") + (:file "gaussian") + (:file "gaussian-tail") + (:file "gegenbauer") + (:file "geometric") + (:file "givens") + (:file "gumbel1") + (:file "gumbel2") + (:file "higher-moments") + (:file "histogram") + (:file "hypergeometric") + (:file "hypergeometric-randist") + (:file "index-max") + (:file "inverse-matrix-product") + (:file "laguerre") + (:file "lambert") + (:file "landau") + (:file "laplace") + (:file "legendre") + (:file "levy") + (:file "logarithmic") + (:file "logarithm") + (:file "logistic") + (:file "lognormal") + (:file "lu") + (:file "mathematical") + (:file "matrix-copy") + (:file "matrix-div") + (:file "matrix-max-index") + (:file "matrix-max") + (:file "matrix-mean") + (:file "matrix-min-index") + (:file "matrix-minmax-index") + (:file "matrix-minmax") + (:file "matrix-m-") + (:file "matrix-m+") + (: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-zero") + (:file "matrix-standard-deviation") + (:file "matrix-standard-deviation-with-fixed-mean") + (:file "matrix-standard-deviation-with-mean") + (:file "matrix-swap") + (:file "matrix-transpose-copy") + (:file "matrix-transpose") + (:file "matrix-variance") + (:file "matrix-variance-with-fixed-mean") + (:file "matrix-variance-with-mean") + (:file "median-percentile") + (:file "monte-carlo") + (:file "multinomial") + (:file "negative-binomial") + (:file "numerical-differentiation") + (:file "numerical-integration") + (:file "pareto") + (:file "permutation") + (:file "poisson") + (:file "polynomial") + (:file "power") + (:file "psi") + (:file "quasi-random-number-generators") + (:file "random-number-generators") + (:file "rayleigh") + (:file "rayleigh-tail") + (:file "row") + (:file "scale") + (:file "set-basis") + (:file "setf-column") + (:file "setf-row") + (:file "set-identity") + (:file "shuffling-sampling") + (:file "sort-matrix-largest") + (:file "sort-matrix") + (:file "sort-matrix-smallest") + (:file "sort-vector-index") + (:file "sort-vector-largest-index") + (:file "sort-vector-largest") + (:file "sort-vector") + (:file "sort-vector-smallest-index") + (:file "sort-vector-smallest") + (:file "spherical-vector") + (:file "swap-columns") + (:file "swap-elements") + (:file "swap-row-column") + (:file "swap-rows") + (:file "synchrotron") + (:file "tdist") + (:file "transport") + (:file "trigonometry") + (:file "vector-copy") + (:file "vector-div") + (:file "vector-max-index") + (:file "vector-max") + (:file "vector-mean") + (:file "vector-min-index") + (:file "vector-minmax-index") + (:file "vector-minmax") + (:file "vector-m-") + (:file "vector-m+") + (:file "vector-mult") + (:file "vector-reverse") + (:file "vector-set-all-m+") + (:file "vector-set-zero") + (:file "vector-standard-deviation") + (:file "vector-standard-deviation-with-fixed-mean") + (:file "vector-standard-deviation-with-mean") + (:file "vector-swap") + (:file "vector-variance") + (:file "vector-variance-with-fixed-mean") + (:file "vector-variance-with-mean") + (:file "weibull") + (:file "zeta"))))) diff --git a/gsll.asd b/gsll.asd index 1eda85496ad28bf3c159cf5cb0e6e58a133b7deb..4f849cae2e8df4284766c1ec2572821f2c2a92f2 100644 --- a/gsll.asd +++ b/gsll.asd @@ -1,6 +1,6 @@ ;; Definition of GSLL system ;; Liam Healy -;; Time-stamp: <2008-11-15 13:41:12EST gsll.asd> +;; Time-stamp: <2008-11-16 12:14:14EST gsll.asd> ;; $Id$ (asdf:defsystem "gsll" @@ -22,10 +22,7 @@ :depends-on (init conditions element-types number-conversion)) (:file "defmfun" :depends-on (init element-types interface)) (:file "callback" :depends-on (init)) - ;; http://www.cs.northwestern.edu/academics/courses/325/readings/lisp-unit.html - (:file "lisp-unit") - (:file "tests" :depends-on (init lisp-unit)) - (:file "generate-tests" :depends-on (tests)))) + (:file "generate-examples" :depends-on (init)))) (:module floating-point :depends-on (init) :components diff --git a/histogram/probability-distribution.lisp b/histogram/probability-distribution.lisp index 7a1104e5ef107182422db7928c326417329f45e0..580628c16f90d45d769e2c23b994ef49dc0f1330 100644 --- a/histogram/probability-distribution.lisp +++ b/histogram/probability-distribution.lisp @@ -1,6 +1,6 @@ ;; Histogram probability distribution. ;; Liam Healy, Mon Jan 1 2007 - 17:51 -;; Time-stamp: <2008-08-17 09:37:15EDT probability-distribution.lisp> +;; Time-stamp: <2008-11-16 13:26:02EST probability-distribution.lisp> ;; $Id$ (in-package :gsl) @@ -59,7 +59,7 @@ :documentation ; FDL "Initialize the probability distribution pdf with the contents of the histogram. If any of the bins are negative then an - EDOM error is signalled because a probability distribution + input-domain error is signalled because a probability distribution cannot contain negative values.") (defmfun pdf-init-2 (pdf histogram) @@ -71,14 +71,14 @@ :documentation ; FDL "Initialize the probability distribution pdf with the contents of the histogram. If any of the bins are negative then an - EDOM error is signalled because a probability distribution + input-domain error is signalled because a probability distribution cannot contain negative values.") (export 'pdf-init) (defun pdf-init (pdf histogram) ; FDL "Initialize the probability distribution pdf with the contents of the histogram. If any of the bins are negative then an - EDOM error is signalled because a probability distribution + input-domain error is signalled because a probability distribution cannot contain negative values." (histo-1d2d pdf pdf-init (histogram))) diff --git a/histogram/updating-accessing.lisp b/histogram/updating-accessing.lisp index 7905b703fe50319a48144f884fde4d8d75fa8359..7e5405d42339b6cd06bc9b24c024cb9cf94da535 100644 --- a/histogram/updating-accessing.lisp +++ b/histogram/updating-accessing.lisp @@ -1,6 +1,6 @@ ;; Updating and accessing histogram elements. ;; Liam Healy, Mon Jan 1 2007 - 14:43 -;; Time-stamp: <2008-10-25 18:24:41EDT updating-accessing.lisp> +;; Time-stamp: <2008-11-16 13:26:01EST updating-accessing.lisp> ;; $Id$ (in-package :gsl) @@ -16,10 +16,10 @@ If x lies in the valid range of the histogram then the function returns zero to indicate success. If x is less than the lower - limit of the histogram then the function issues a warning :EDOM, and + limit of the histogram then the function issues a warning input-domain, and none of bins are modified. Similarly, if the value of x is greater than or equal to the upper limit of the histogram then the function - issues a warning :EDOM, and none of the bins are modified. The error + issues a warning input-domain, and none of the bins are modified. The error handler is not called, however, since it is often necessary to compute histograms for a small range of a larger dataset, ignoring the values outside the range of interest.") @@ -32,7 +32,7 @@ :documentation ; FDL "Return the contents of the i-th bin of the histogram. If i lies outside the valid range of indices for the - histogram then an error (:EDOM) is signalled.") + histogram then an error (input-domain) is signalled.") (defmfun range (histogram i) "gsl_histogram_get_range" @@ -47,7 +47,7 @@ the coordinate of the upper limit are excluded and fall in the neighboring higher bin, if it exists). If i lies outside the valid range of indices for - the histogram, then the error :EDOM is signalled.") + the histogram, then the error input-domain is signalled.") (defmfun max-range (histogram) "gsl_histogram_max" @@ -89,7 +89,7 @@ range, and will return the correct bin immediately in this case. If the value is found in the range of the histogram then the function returns the index. If value lies outside - the valid range of the histogram then the error :EDOM is + the valid range of the histogram then the error input-domain is signalled.") #| diff --git a/init/conditions.lisp b/init/conditions.lisp index 9e5086b61f2af3f73b2295ed3d4b130c10d4ac59..094735c96dc3180a3b0b7918f6023163d925ce92 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-08-31 22:52:09EDT conditions.lisp> +;; Time-stamp: <2008-11-16 13:26:03EST conditions.lisp> ;; $Id$ (in-package :gsl) @@ -48,7 +48,7 @@ (setf *errorno-keyword* (acons ,number ',keyword *errorno-keyword*)) (export ',keyword))) -(define-gsl-condition EDOM 1 "Input domain error") +(define-gsl-condition input-domain 1 "Input domain error") (define-gsl-condition ERANGE 2 "Output range error") (define-gsl-condition EFAULT 3 "Invalid pointer") (define-gsl-condition EINVAL 4 "Invalid argument") diff --git a/init/generate-tests.lisp b/init/generate-examples.lisp similarity index 66% rename from init/generate-tests.lisp rename to init/generate-examples.lisp index f87105a93e86a8644d45432cca6540ca1d1e294a..d69e4b4fd3eeb7f1ea614ba7949d08e15318c9b0 100644 --- a/init/generate-tests.lisp +++ b/init/generate-examples.lisp @@ -1,51 +1,20 @@ -;; Make tests and examples +;; Define examples. ;; Liam Healy 2008-09-07 21:00:48EDT generate-tests.lisp -;; Time-stamp: <2008-11-15 13:29:28EST generate-tests.lisp> +;; Time-stamp: <2008-11-16 12:13:10EST generate-examples.lisp> ;; $Id: $ -;;; Througout the GSLL interface definition files are #'save-test -;;; forms. These serve to define both examples and tests. Getting an -;;; example involves calling (examples) to get a list of names, then -;;; the calling the function with a particular name to get the -;;; examples, e.g. -;;; (examples) -;;; (examples 'matrix-m+) - -;;; To do all the tests, -;;; (lisp-unit:run-tests) - -;;; The files that define the tests are in tests/. These files are -;;; generated automatically and checked into the repository; they -;;; 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/") +;;; Define examples that can be displayed by users with the function +;;; #'examples and can be used to generate regression (unit) tests. +;;; The latter has been done in the gsll-tests system. (in-package :gsl) (export 'examples) ;;;;**************************************************************************** -;;;; Data pool +;;;; Defining examples ;;;;**************************************************************************** -(defun numerical-serialize (form) - (if (typep form 'list) - (cons 'list (mapcar #'numerical-serialize form)) - form)) - -;;; (make-test '(legendre-conicalP-half 3.5d0 10.0d0)) -(defun make-test (form) - "Make a test for lisp-unit." - (let ((vals (multiple-value-list (ignore-errors (eval form))))) - (if (typep (second vals) 'condition) - `(lisp-unit::assert-error - ',(type-of (second vals)) - ,form) - `(lisp-unit::assert-numerical-equal - ,(numerical-serialize vals) - (multiple-value-list ,form))))) - (defparameter *all-generated-tests* nil) (defmacro save-test (name &rest forms) @@ -71,52 +40,6 @@ (loop for (key value) on *all-generated-tests* by #'cddr collect key))) -(defun create-test (test-name) - "Find the saved test by name and create it, with the generated results." - (append - `(lisp-unit:define-test ,test-name) - (mapcar #'make-test (getf *all-generated-tests* test-name)))) - -(defun write-test-to-file (test path) - "Write the test to a file with the same name under path. - Use this function with caution; it will replace an existing - test file and thus the opportunity for regression test will be lost." - (let ((pathname (merge-pathnames (format nil "~(~a~).lisp" test) path)) - (*read-default-float-format* 'single-float)) - (with-open-file - (stream pathname :direction :output :if-exists :rename) - (format - stream - ";; Regression test ~a for GSLL, automatically generated~%~%" test) - (format stream "(in-package :gsl)~%~%") - (format t "Writing test ~a to file ~a~&" test pathname) - (format stream "~s~%~%" (create-test test))))) - - -;;; This is commented out because it shouldn't be run. It will -;;; regenerate all tests, so there will be no regression tests to -;;; previous versions. -#+(or) -(defun write-tests (path) - "Write all the tests to the appropriate file." - (iter - (for (key val) on *all-generated-tests* by #'cddr) - (write-test-to-file key path))) - -#| -;;; Obsolete; to put all tests in one file. -(defun write-tests-to-file (filename) - "Write all the saved tests with expected results to the file." - (with-open-file (stream filename :direction :output :if-exists :supersede) - (format stream ";; Regression tests for GSLL, automatically generated~%~%") - (format stream "(in-package :gsl)~%~%") - (loop for (test-name forms) on *all-generated-tests* by #'cddr - do - (format t "Writing test ~a to file~&" test-name) - (format stream "~s~%~%" (create-test test-name))))) - -|# - ;;;;**************************************************************************** ;;;; Data pool ;;;;**************************************************************************** diff --git a/linear-algebra/cholesky.lisp b/linear-algebra/cholesky.lisp index 9abfcafc990acead6b6d62a56b2290e9af69526d..fe0111cf7eb656e77f5bf84e4b3e69ab1d1081d4 100644 --- a/linear-algebra/cholesky.lisp +++ b/linear-algebra/cholesky.lisp @@ -1,6 +1,6 @@ ;; Cholesky Decomposition ;; Liam Healy, Wed May 3 2006 - 16:38 -;; Time-stamp: <2008-08-11 22:49:09EDT cholesky.lisp> +;; Time-stamp: <2008-11-16 13:26:42EST cholesky.lisp> ;; $Id$ (in-package :gsl) @@ -29,7 +29,7 @@ L. The upper triangular part of the input matrix contains L^T, the diagonal terms being identical for both L and L^T. If the matrix is not positive-definite then the - decomposition will fail, returning the error EDOM.") + decomposition will fail, returning the error input-domain.") (defmfun cholesky-solve (A x b) "gsl_linalg_cholesky_solve" diff --git a/numerical-differentiation.lisp b/numerical-differentiation.lisp index 2b248a9b96268f78d22644ee13118c32e5ecd289..9d36533edeaf2621d7b76de14f0c2dc43deb5d67 100644 --- a/numerical-differentiation.lisp +++ b/numerical-differentiation.lisp @@ -1,6 +1,6 @@ ;; Numerical differentiation. ;; Liam Healy Mon Nov 12 2007 - 22:07 -;; Time-stamp: <2008-10-25 12:00:36EDT numerical-differentiation.lisp> +;; Time-stamp: <2008-11-15 22:31:32EST numerical-differentiation.lisp> ;; $Id$ (in-package :gsl) @@ -122,77 +122,4 @@ (forward-derivative deriv-f6 10.0d0 1.0d-4) (backward-derivative deriv-f6 10.0d0 1.0d-4)) -(LISP-UNIT:DEFINE-TEST NUMERICAL-DIFFERENTIATION - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 2.718281828441488 4.123659913167868e-10) - (MULTIPLE-VALUE-LIST - (CENTRAL-DERIVATIVE DERIV-F1 1.0 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 2.7182817825298398 9.540320743340577e-7) - (MULTIPLE-VALUE-LIST - (FORWARD-DERIVATIVE DERIV-F1 1.0 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 2.7182818293827378 9.086969640080628e-7) - (MULTIPLE-VALUE-LIST - (BACKWARD-DERIVATIVE DERIV-F1 1.0 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.474341649024533 3.3922603135575853e-11) - (MULTIPLE-VALUE-LIST - (CENTRAL-DERIVATIVE DERIV-F2 0.1 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.47434164943235285 9.102230432046565e-8) - (MULTIPLE-VALUE-LIST - (FORWARD-DERIVATIVE DERIV-F2 0.1 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.4743416462049176 8.787851752748856e-8) - (MULTIPLE-VALUE-LIST - (BACKWARD-DERIVATIVE DERIV-F2 0.1 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 2.9941773945923913 6.730277498876722e-10) - (MULTIPLE-VALUE-LIST - (CENTRAL-DERIVATIVE DERIV-F3 0.45 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 2.994177385772526 1.6952086150997503e-6) - (MULTIPLE-VALUE-LIST - (FORWARD-DERIVATIVE DERIV-F3 0.45 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 2.9941775182635064 1.568063267060477e-6) - (MULTIPLE-VALUE-LIST - (BACKWARD-DERIVATIVE DERIV-F3 0.45 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST -0.7788007830653751 1.7227267499194736e-10) - (MULTIPLE-VALUE-LIST - (CENTRAL-DERIVATIVE DERIV-F4 0.5 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST -0.7788007884386108 2.530006603059119e-7) - (MULTIPLE-VALUE-LIST - (FORWARD-DERIVATIVE DERIV-F4 0.5 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST -0.7788007743421791 2.503617930568489e-7) - (MULTIPLE-VALUE-LIST - (BACKWARD-DERIVATIVE DERIV-F4 0.5 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.0 6.66133814775094e-20) - (MULTIPLE-VALUE-LIST - (CENTRAL-DERIVATIVE DERIV-F5 0.0 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST -2.6337311035821125e-26 1.606762230663824e-11) - (MULTIPLE-VALUE-LIST - (FORWARD-DERIVATIVE DERIV-F5 0.0 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 2.6337311035821125e-26 1.606762230663824e-11) - (MULTIPLE-VALUE-LIST - (BACKWARD-DERIVATIVE DERIV-F5 0.0 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST -0.009999999999871223 2.6645352591887814e-12) - (MULTIPLE-VALUE-LIST - (CENTRAL-DERIVATIVE DERIV-F6 10.0 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST -0.010000000266238856 4.9950606958271945e-9) - (MULTIPLE-VALUE-LIST - (FORWARD-DERIVATIVE DERIV-F6 10.0 1.e-4))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST -0.010000000076196142 4.641550044799095e-9) - (MULTIPLE-VALUE-LIST - (BACKWARD-DERIVATIVE DERIV-F6 10.0 1.e-4)))) diff --git a/random/gaussian-bivariate.lisp b/random/gaussian-bivariate.lisp index d2659731d251ccfe97357a747a35d25ab4e58ace..44cc69028b098e2c170df8a51b2986fe3bbb80c0 100644 --- a/random/gaussian-bivariate.lisp +++ b/random/gaussian-bivariate.lisp @@ -1,6 +1,6 @@ ;; Gaussian bivariate distribution ;; Liam Healy, Sat Sep 2 2006 - 16:32 -;; Time-stamp: <2008-10-25 13:30:58EDT gaussian-bivariate.lisp> +;; Time-stamp: <2008-11-15 22:36:38EST gaussian-bivariate.lisp> ;; $Id$ (in-package :gsl) @@ -40,22 +40,3 @@ (bivariate-gaussian rng 1.0d0 0.75d0 0.25d0))) (bivariate-gaussian-pdf 0.25d0 0.5d0 0.25d0 0.4d0 0.2d0)) - -(LISP-UNIT:DEFINE-TEST GAUSSIAN-BIVARIATE - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - (LIST -0.06509716124488897d0 -1.5733207749096374d0 - 0.27942740172325414d0 1.2021528358889673d0 - -0.6041530626907894d0 0.07582702719413444d0 - -0.5446229412165632d0 -0.6592026841613081d0 - -0.11029516610819164d0 0.17931840412143885d0 - 2.1025104980291696d0)) - (MULTIPLE-VALUE-LIST - (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) - (LOOP FOR I FROM 0 TO 10 COLLECT - (BIVARIATE-GAUSSIAN RNG 1.0d0 0.75d0 0.25d0))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.5548265557970462d0) - (MULTIPLE-VALUE-LIST - (BIVARIATE-GAUSSIAN-PDF 0.25d0 0.5d0 0.25d0 0.4d0 0.2d0)))) - diff --git a/random/lognormal.lisp b/random/lognormal.lisp index 3c7df8890461b1bf733f585256b63c6c5b9887bb..8752667fd1ab519d09d77fef4a88f04f77d6cfd6 100644 --- a/random/lognormal.lisp +++ b/random/lognormal.lisp @@ -1,6 +1,6 @@ ;; Lognormal distribution ;; Liam Healy, Sat Sep 30 2006 -;; Time-stamp: <2008-10-25 17:57:40EDT lognormal.lisp> +;; Time-stamp: <2008-11-15 22:37:16EST lognormal.lisp> ;; $Id$ (in-package :gsl) @@ -65,35 +65,3 @@ (lognormal-Q 1.2d0 1.0d0 2.0d0) (lognormal-Pinv 0.3413288272347352d0 1.0d0 2.0d0) (lognormal-Qinv 0.6586711727652649d0 1.0d0 2.0d0)) - -(LISP-UNIT:DEFINE-TEST LOGNORMAL - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - (LIST 2.386447068127768d0 0.11687602167359055d0 - 4.753374578796263d0 30.093393775755004d0 - 0.8119584375760986d0 3.163421055157545d0 - 0.9146206567715651d0 0.727307901065758d0 - 2.180184852178898d0 3.8908856616896017d0 - 182.18469788916977d0)) - (MULTIPLE-VALUE-LIST - (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) - (LOOP FOR I FROM 0 TO 10 COLLECT - (LOGNORMAL RNG 1.0d0 2.0d0))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.15289833965691607d0) - (MULTIPLE-VALUE-LIST - (LOGNORMAL-PDF 1.2d0 1.0d0 2.0d0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.3413288272347351d0) - (MULTIPLE-VALUE-LIST (LOGNORMAL-P 1.2d0 1.0d0 2.0d0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.6586711727652649d0) - (MULTIPLE-VALUE-LIST (LOGNORMAL-Q 1.2d0 1.0d0 2.0d0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 1.2000000000000004d0) - (MULTIPLE-VALUE-LIST - (LOGNORMAL-PINV 0.3413288272347352d0 1.0d0 2.0d0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 1.2d0) - (MULTIPLE-VALUE-LIST - (LOGNORMAL-QINV 0.6586711727652649d0 1.0d0 2.0d0)))) diff --git a/random/negative-binomial.lisp b/random/negative-binomial.lisp index 78724186944e33d62098f5af40ffe91773816278..7b7ebf499cdccbb73537637d02529fe5bdf5320c 100644 --- a/random/negative-binomial.lisp +++ b/random/negative-binomial.lisp @@ -1,6 +1,6 @@ ;; Negative binomial and Pascal distributions ;; Liam Healy, Sat Nov 25 2006 - 16:00 -;; Time-stamp: <2008-10-25 18:06:14EDT negative-binomial.lisp> +;; Time-stamp: <2008-11-15 22:37:16EST negative-binomial.lisp> ;; $Id$ (in-package :gsl) @@ -103,38 +103,3 @@ (pascal-pdf 5 0.4d0 12) (pascal-P 5 0.4d0 12) (pascal-Q 5 0.4d0 12)) - -(LISP-UNIT:DEFINE-TEST NEGATIVE-BINOMIAL - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST (LIST 15 21 19 15 8 18 23 18 33 16 10)) - (MULTIPLE-VALUE-LIST - (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) - (LOOP FOR I FROM 0 TO 10 COLLECT - (NEGATIVE-BINOMIAL RNG 0.4 12.0))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.0056984767089869) - (MULTIPLE-VALUE-LIST - (NEGATIVE-BINOMIAL-PDF 5 0.4 12.0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.010594202555514881) - (MULTIPLE-VALUE-LIST (NEGATIVE-BINOMIAL-P 5 0.4 12.0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.9894057974444851) - (MULTIPLE-VALUE-LIST (NEGATIVE-BINOMIAL-Q 5 0.4 12.0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST (LIST 15 21 19 15 8 18 23 18 33 16 10)) - (MULTIPLE-VALUE-LIST - (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) - (LOOP FOR I FROM 0 TO 10 COLLECT - (PASCAL RNG 0.4 12))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.0056984767089869) - (MULTIPLE-VALUE-LIST (PASCAL-PDF 5 0.4 12))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.010594202555514881) - (MULTIPLE-VALUE-LIST (PASCAL-P 5 0.4 12))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.9894057974444851) - (MULTIPLE-VALUE-LIST (PASCAL-Q 5 0.4 12)))) - - diff --git a/sorting.lisp b/sorting.lisp index 64324daaa079ad1ce9e8eefca363c8cd43d920dc..067bdc8f5609db9e02b7d16b1fd55b047f6f8cca 100644 --- a/sorting.lisp +++ b/sorting.lisp @@ -1,6 +1,6 @@ ;; Sorting ;; Liam Healy, Fri Apr 14 2006 - 20:20 -;; Time-stamp: <2008-11-09 13:10:16EST sorting.lisp> +;; Time-stamp: <2008-11-15 22:51:52EST sorting.lisp> ;; $Id$ (in-package :gsl) @@ -249,11 +249,11 @@ (generate-all-array-tests sort-vector :no-complex (letm ((v1 (array-default 8))) ;; or you can use msort - (sort-vector v1))) + (cl-array (sort-vector v1)))) (generate-all-array-tests sort-matrix :no-complex (letm ((m1 (array-default '(3 3)))) - (msort m1))) + (cl-array (msort m1)))) (generate-all-array-tests sort-vector-index :no-complex (letm ((perm (permutation 8)) diff --git a/special-functions/elliptic-functions.lisp b/special-functions/elliptic-functions.lisp index 9d0e2e0f26a0b7d61991a1c8927f635e5ea9b79a..4f3adfaa033e4c54650ce21633f141a080c97417 100644 --- a/special-functions/elliptic-functions.lisp +++ b/special-functions/elliptic-functions.lisp @@ -1,6 +1,6 @@ ;; Jacobian elliptic functions ;; Liam Healy, Mon Mar 20 2006 - 22:21 -;; Time-stamp: <2008-10-21 23:08:02EDT elliptic-functions.lisp> +;; Time-stamp: <2008-11-15 22:31:54EST elliptic-functions.lisp> ;; $Id$ (in-package :gsl) @@ -24,18 +24,6 @@ ;;; > (jacobian-elliptic-functions 0.61802d0 1.5d0) ;;; ;;;error - (save-test elliptic-functions (jacobian-elliptic-functions 0.2d0 0.81d0) (jacobian-elliptic-functions 0.61802d0 1.5d0)) - -(LISP-UNIT:DEFINE-TEST ELLIPTIC-FUNCTIONS - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.19762082367187703d0 0.9802785369736752d0 - 0.9840560289645665d0 0.0d0 0.0d0 0.0d0) - (MULTIPLE-VALUE-LIST - (JACOBIAN-ELLIPTIC-FUNCTIONS 0.2d0 0.81d0))) - (LISP-UNIT:ASSERT-ERROR 'GSL-CONDITION - (JACOBIAN-ELLIPTIC-FUNCTIONS - 0.61802d0 1.5d0))) - diff --git a/special-functions/exponential-integrals.lisp b/special-functions/exponential-integrals.lisp index 8ba30a613053859deb4f463b7bea12c5b0aa18be..8537daaec34671c2dce338cd799d6daf6a082aeb 100644 --- a/special-functions/exponential-integrals.lisp +++ b/special-functions/exponential-integrals.lisp @@ -1,6 +1,6 @@ ;; Exponential integrals ;; Liam Healy, Tue Mar 21 2006 - 17:37 -;; Time-stamp: <2008-10-23 22:56:59EDT exponential-integrals.lisp> +;; Time-stamp: <2008-11-16 12:07:43EST exponential-integrals.lisp> ;; $Id$ (in-package :gsl) @@ -86,10 +86,6 @@ ;;;; Examples and unit test ;;;;**************************************************************************** -;;; Macroexpanding in SLIME with slime-macroexpand-1 will produce the -;;; wrong error type for the first test. Instead, evaluate in -;;; listener with (macroexpand-1 '(make-tests ... )). - (save-test exponential-integrals (expint-E1 0.0d0) (expint-E1 1.0d0) @@ -100,31 +96,3 @@ (si 1.25d0) (ci 1.25d0) (atanint 1.25d0)) - -(LISP-UNIT:DEFINE-TEST EXPONENTIAL-INTEGRALS - (LISP-UNIT:ASSERT-ERROR 'GSL-CONDITION (EXPINT-E1 0.0d0)) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.21938393439552029d0 2.6541220085226265d-16) - (MULTIPLE-VALUE-LIST (EXPINT-E1 1.0d0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 4.954234356001891d0 7.64289440273947d-15) - (MULTIPLE-VALUE-LIST (EXPINT-EI 2.0d0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 1.363730673440693d0 4.275641706089105d-15) - (MULTIPLE-VALUE-LIST (SHI 1.25d0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 1.217317300914783d0 4.21062110717259d-15) - (MULTIPLE-VALUE-LIST (CHI 1.25d0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.8688926541262327d0 4.083149724141479d-16) - (MULTIPLE-VALUE-LIST (EXPINT-3 1.25d0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 1.1464464156732344d0 7.36847290397885d-16) - (MULTIPLE-VALUE-LIST (SI 1.25d0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 0.4343007240335524d0 1.2207688418479174d-15) - (MULTIPLE-VALUE-LIST (CI 1.25d0))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 1.103619161676528d0 6.711588415833395d-16) - (MULTIPLE-VALUE-LIST (ATANINT 1.25d0)))) - diff --git a/special-functions/power.lisp b/special-functions/power.lisp index 05253c2376bc2e5721a3ee51f4927080b3555b99..826c16318fab4b44534d3034fd7e537c67760f10 100644 --- a/special-functions/power.lisp +++ b/special-functions/power.lisp @@ -1,6 +1,6 @@ ;; Integer powers ;; Liam Healy, Sun Apr 30 2006 - 22:46 -;; Time-stamp: <2008-10-25 11:25:23EDT power.lisp> +;; Time-stamp: <2008-11-15 22:32:30EST power.lisp> ;; $Id$ (in-package :gsl) @@ -16,8 +16,3 @@ (save-test power (pow 3.5d0 5)) - -(LISP-UNIT:DEFINE-TEST POWER - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 525.21875d0 9.329759187437503d-13) - (MULTIPLE-VALUE-LIST (POW 3.5d0 5)))) diff --git a/init/tests.lisp b/test-unit/additional-definitions.lisp similarity index 100% rename from init/tests.lisp rename to test-unit/additional-definitions.lisp diff --git a/test-unit/generate-tests.lisp b/test-unit/generate-tests.lisp new file mode 100644 index 0000000000000000000000000000000000000000..9657d35b7cbed9cdef00873b9f037ebf2d32f5b7 --- /dev/null +++ b/test-unit/generate-tests.lisp @@ -0,0 +1,73 @@ +;; Make tests from examples. +;; Liam Healy 2008-09-07 21:00:48EDT generate-tests.lisp +;; Time-stamp: <2008-11-16 12:10:07EST generate-tests.lisp> +;; $Id: $ + +;;; Througout the GSLL interface definition files are #'save-test +;;; forms. These serve to define both examples and tests. Getting an +;;; example involves calling (examples) to get a list of names, then +;;; the calling the function with a particular name to get the +;;; examples, e.g. +;;; (examples) +;;; (examples 'matrix-m+) + +;;; To do all the tests, +;;; (lisp-unit:run-tests) + +;;; The files that define the tests are in tests/. These files are +;;; generated automatically and checked into the repository; they +;;; 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/") + +(in-package :gsl) + +(defun numerical-serialize (form) + (if (typep form 'list) + (cons 'list (mapcar #'numerical-serialize form)) + form)) + +;;; (make-test '(legendre-conicalP-half 3.5d0 10.0d0)) +(defun make-test (form) + "Make a test for lisp-unit." + (let ((vals (multiple-value-list (ignore-errors (eval form))))) + (if (typep (second vals) 'condition) + `(lisp-unit::assert-error + ',(type-of (second vals)) + ,form) + `(lisp-unit::assert-numerical-equal + ,(numerical-serialize vals) + (multiple-value-list ,form))))) + +(defun create-test (test-name) + "Find the saved test by name and create it, with the generated results." + (append + `(lisp-unit:define-test ,test-name) + (mapcar #'make-test (getf *all-generated-tests* test-name)))) + +(defun write-test-to-file (test path) + "Write the test to a file with the same name under path. + Use this function with caution; it will replace an existing + test file and thus the opportunity for regression test will be lost." + (let ((pathname (merge-pathnames (format nil "~(~a~).lisp" test) path)) + (*read-default-float-format* 'single-float)) + (with-open-file + (stream pathname :direction :output :if-exists :rename) + (format + stream + ";; Regression test ~a for GSLL, automatically generated~%~%" test) + (format stream "(in-package :gsl)~%~%") + (format t "Writing test ~a to file ~a~&" test pathname) + (format stream "~s~%~%" (create-test test))))) + + +;;; This is commented out because it shouldn't normally be run. It +;;; will regenerate all tests, so there will be no regression tests to +;;; previous versions. DON'T FORGET THE TRAILING SLASH ON THE PATH +#+(or) +(defun write-tests (path) + "Write all the tests to the appropriate file." + (iter:iter + (iter:for (key val) on *all-generated-tests* by #'cddr) + (write-test-to-file key path))) diff --git a/init/lisp-unit.lisp b/test-unit/lisp-unit.lisp similarity index 100% rename from init/lisp-unit.lisp rename to test-unit/lisp-unit.lisp diff --git a/tests/absolute-deviation.lisp b/tests/absolute-deviation.lisp new file mode 100644 index 0000000000000000000000000000000000000000..fc1808fad0a1bf198543afe987bc87b49f5ebbff --- /dev/null +++ b/tests/absolute-deviation.lisp @@ -0,0 +1,17 @@ +;; Regression test ABSOLUTE-DEVIATION for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST ABSOLUTE-DEVIATION + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST 6.18d0 6.647777777777779d0 6.18d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((VEC (VECTOR-DOUBLE-FLOAT (A -3.21d0 1.0d0 12.8d0))) + (WEIGHTS + (VECTOR-DOUBLE-FLOAT (A 3.0d0 1.0d0 2.0d0)))) + (LET ((MEAN (MEAN VEC))) + (LIST (ABSOLUTE-DEVIATION VEC) + (WEIGHTED-ABSOLUTE-DEVIATION VEC WEIGHTS) + (ABSOLUTE-DEVIATION VEC MEAN))))))) + diff --git a/tests/absolute-sum.lisp b/tests/absolute-sum.lisp new file mode 100644 index 0000000000000000000000000000000000000000..c2f14b1da2e40728957b1baaa43d897603cdc3b2 --- /dev/null +++ b/tests/absolute-sum.lisp @@ -0,0 +1,60 @@ +;; Regression test ABSOLUTE-SUM for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST ABSOLUTE-SUM + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 157.99) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 + 3.29 -8.93 + 34.12 -6.15 + 49.27 -13.49) + NIL))) + (ABSOLUTE-SUM + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 157.99d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 + 8.24d0 3.29d0 + -8.93d0 + 34.12d0 + -6.15d0 + 49.27d0 + -13.49d0) + NIL))) + (ABSOLUTE-SUM + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 388.65997) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 + 3.29 -8.93 + 34.12 -6.15 + 49.27 -13.49 + 32.5 42.73 + -17.24 43.31 + -16.12 -8.25 + 21.44 -49.08) + NIL))) + (ABSOLUTE-SUM + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 388.65999999999997d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0 -16.12d0 -8.25d0 21.44d0 -49.08d0) + NIL))) + (ABSOLUTE-SUM V1))))) + diff --git a/tests/airy.lisp b/tests/airy.lisp new file mode 100644 index 0000000000000000000000000000000000000000..c5afafb1bf80a2e9ce967590aa7d4fe485158677 --- /dev/null +++ b/tests/airy.lisp @@ -0,0 +1,42 @@ +;; Regression test AIRY for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST AIRY + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.01572592338047048d0 2.1573014423586447d-17) + (MULTIPLE-VALUE-LIST (AIRY-AI 2.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6.48166073846058d0 8.77836191730236d-15) + (MULTIPLE-VALUE-LIST (AIRY-BI 2.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.21932220512871203d0 5.966864198455728d-17) + (MULTIPLE-VALUE-LIST (AIRY-AI-SCALED 2.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.4647504801960925d0 1.1831869152362144d-16) + (MULTIPLE-VALUE-LIST (AIRY-BI-SCALED 2.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.02625088103590322d0 4.306971270221159d-17) + (MULTIPLE-VALUE-LIST (AIRY-AI-DERIV 2.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 9.421423317334305d0 1.5213125884867257d-14) + (MULTIPLE-VALUE-LIST (AIRY-BI-DERIV 2.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.36610893847516224d0 1.167515239400716d-16) + (MULTIPLE-VALUE-LIST (AIRY-AI-DERIV-SCALED 2.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6755384441644995d0 1.978922049880242d-16) + (MULTIPLE-VALUE-LIST (AIRY-BI-DERIV-SCALED 2.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -2.338107410459767d0 5.19164136227827d-16) + (MULTIPLE-VALUE-LIST (AIRY-ZERO-AI 1))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -1.173713222709128d0 2.606166888317336d-16) + (MULTIPLE-VALUE-LIST (AIRY-ZERO-BI 1))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -1.018792971647471d0 2.2621748288986134d-16) + (MULTIPLE-VALUE-LIST (AIRY-ZERO-AI-DERIV 1))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -2.294439682614123d0 5.094679528503672d-16) + (MULTIPLE-VALUE-LIST (AIRY-ZERO-BI-DERIV 1)))) + diff --git a/tests/autocorrelation.lisp b/tests/autocorrelation.lisp new file mode 100644 index 0000000000000000000000000000000000000000..7a8f51694f794399d588b6cc2c77f4cddce23818 --- /dev/null +++ b/tests/autocorrelation.lisp @@ -0,0 +1,16 @@ +;; Regression test AUTOCORRELATION for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST AUTOCORRELATION + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST -0.04646366834251103d0 -0.04646366834251103d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((VEC + (VECTOR-DOUBLE-FLOAT (A -3.21d0 1.0d0 12.8d0)))) + (LET ((MEAN (MEAN VEC))) + (LIST (AUTOCORRELATION VEC) + (AUTOCORRELATION VEC MEAN))))))) + diff --git a/tests/axpy.lisp b/tests/axpy.lisp new file mode 100644 index 0000000000000000000000000000000000000000..ea321238e552172794bc124b41bca7eee0ab35af --- /dev/null +++ b/tests/axpy.lisp @@ -0,0 +1,86 @@ +;; Regression test AXPY for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST AXPY + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(1400.77 -284.0684 -147.7214 397.47382 -1369.3191 + 235.659 -1932.6083 485.93335)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL)) + (V2 + (VECTOR-SINGLE-FLOAT + (A 32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 + -49.08) + NIL)) + (SCALAR -39.66)) + (CL-ARRAY (AXPY SCALAR V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(1400.77d0 -284.06839999999994d0 -147.7214d0 + 397.4738d0 -1369.3191999999997d0 235.659d0 + -1932.6082d0 485.93339999999995d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL)) + (V2 + (VECTOR-DOUBLE-FLOAT + (A 32.5d0 42.73d0 -17.24d0 43.31d0 -16.12d0 + -8.25d0 21.44d0 -49.08d0) + NIL)) + (SCALAR -39.66d0)) + (CL-ARRAY (AXPY SCALAR V1 V2))))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 + 34.12 -6.15 49.27 -13.49 + 32.5 42.73 -17.24 43.31 + -16.12 -8.25 21.44 + -49.08) + NIL)) + (V2 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A 32.5 42.73 -17.24 43.31 + -16.12 -8.25 21.44 -49.08 + -39.66 -49.46 19.68 -5.55 + -8.82 25.37 -30.58 31.67) + NIL)) + (SCALAR #C(-39.66 -49.46))) + (CL-ARRAY + (AXPY SCALAR V1 V2)))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 + -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0 + 42.73d0 -17.24d0 43.31d0 + -16.12d0 -8.25d0 21.44d0 + -49.08d0) + NIL)) + (V2 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A 32.5d0 42.73d0 -17.24d0 + 43.31d0 -16.12d0 -8.25d0 + 21.44d0 -49.08d0 -39.66d0 + -49.46d0 19.68d0 -5.55d0 + -8.82d0 25.37d0 -30.58d0 + 31.67d0) + NIL)) + (SCALAR + #C(-39.66d0 -49.46d0))) + (CL-ARRAY + (AXPY SCALAR V1 V2))))) + diff --git a/tests/bernoulli.lisp b/tests/bernoulli.lisp new file mode 100644 index 0000000000000000000000000000000000000000..ada4973a6fa5375c42299d58f257ab8e4ef81d55 --- /dev/null +++ b/tests/bernoulli.lisp @@ -0,0 +1,16 @@ +;; Regression test BERNOULLI for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST BERNOULLI + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST 0 1 1 0 1 1 0 0 0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (BERNOULLI RNG 0.5d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.5d0) + (MULTIPLE-VALUE-LIST + (BERNOULLI-PDF 0 + 0.5d0)))) + diff --git a/tests/bessel.lisp b/tests/bessel.lisp new file mode 100644 index 0000000000000000000000000000000000000000..1b4f7fa929912f6eb2e8116fb243095668ecc343 --- /dev/null +++ b/tests/bessel.lisp @@ -0,0 +1,243 @@ +;; Regression test BESSEL for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST BESSEL + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.3971498098638474d0 4.334456411751256d-16) + (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-J0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.0660433280235491d0 2.1409770694795335d-16) + (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-J1 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.3641281458520729d0 3.974061014982464d-16) + (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-JN 2 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.35283402861563773d0 0.12894324947440206d0 + 0.033995719807568436d0 0.007039629755871686d0)) + (MULTIPLE-VALUE-LIST + (LETM ((BESARR (VECTOR-DOUBLE-FLOAT 4))) + (CYLINDRICAL-BESSEL-JN-ARRAY 2.0d0 BESARR 2) + (CL-ARRAY BESARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.016940739325064968d0 1.8993556609468549d-16) + (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-Y0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.3979257105570999d0 3.1396236150465943d-16) + (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-Y1 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.18202211595348539d0 3.355735727760045d-16) + (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-YN 3 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-0.6174081041906827d0 -1.127783776840428d0 + -2.7659432263306014d0 -9.935989128481978d0)) + (MULTIPLE-VALUE-LIST + (LETM ((BESARR (VECTOR-DOUBLE-FLOAT 4))) + (CYLINDRICAL-BESSEL-YN-ARRAY 2.0d0 BESARR 2) + (CL-ARRAY BESARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 11.301921952136329d0 2.7297681442535893d-14) + (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-I0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 9.759465153704449d0 1.9210136786427457d-14) + (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-I1 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3.3372757784203446d0 8.06056628872663d-15) + (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-IN 3 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.6889484476987382d0 0.21273995923985267d0 + 0.05072856997918024d0 0.009825679323131702d0)) + (MULTIPLE-VALUE-LIST + (LETM ((BESARR (VECTOR-DOUBLE-FLOAT 4))) + (CYLINDRICAL-BESSEL-IN-ARRAY 2.0d0 BESARR 2) + (CL-ARRAY BESARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.2070019212239867d0 2.241925168997723d-16) + (MULTIPLE-VALUE-LIST + (CYLINDRICAL-BESSEL-I0-SCALED 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.1787508395024353d0 1.1370197115937822d-16) + (MULTIPLE-VALUE-LIST + (CYLINDRICAL-BESSEL-I1-SCALED 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.0611243380296663d0 9.334510342661594d-17) + (MULTIPLE-VALUE-LIST + (CYLINDRICAL-BESSEL-IN-SCALED 3 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.09323903330473338d0 0.028791222639470898d0 + 0.006865365386320685d0 0.0013297610941881578d0)) + (MULTIPLE-VALUE-LIST + (LETM ((BESARR (VECTOR-DOUBLE-FLOAT 4))) + (CYLINDRICAL-BESSEL-IN-SCALED-ARRAY 2.0d0 BESARR + 2) + (CL-ARRAY BESARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.011159676085853023d0 2.0424662435034432d-17) + (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-K0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.01248349888726843d0 1.767412161819488d-17) + (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-K1 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.017401425529487143d0 2.257461693414273d-16) + (MULTIPLE-VALUE-LIST (CYLINDRICAL-BESSEL-KN 2 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6092976692566953d0 3.0340122249326356d-16) + (MULTIPLE-VALUE-LIST + (CYLINDRICAL-BESSEL-K0-SCALED 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.681575945185671d0 3.596132979136138d-16) + (MULTIPLE-VALUE-LIST + (CYLINDRICAL-BESSEL-K1-SCALED 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.9500856418495256d0 1.1481477659153143d-14) + (MULTIPLE-VALUE-LIST + (CYLINDRICAL-BESSEL-KN-SCALED 2 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.2537597545660558d0 0.6473853909486341d0 + 2.1959159274119586d0 9.431049100596468d0)) + (MULTIPLE-VALUE-LIST + (LETM ((BESARR (VECTOR-DOUBLE-FLOAT 4))) + (CYLINDRICAL-BESSEL-KN-ARRAY 2.0d0 BESARR 2) + (CL-ARRAY BESARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.18920062382698205d0 1.6804391107692678d-16) + (MULTIPLE-VALUE-LIST (SPHERICAL-BESSEL-J0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.11611074925915747d0 2.387125482192573d-16) + (MULTIPLE-VALUE-LIST (SPHERICAL-BESSEL-J1 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.27628368577135015d0 3.680838111259856d-16) + (MULTIPLE-VALUE-LIST (SPHERICAL-BESSEL-J2 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.22924385795503022d0 7.126330661956055d-16) + (MULTIPLE-VALUE-LIST (SPHERICAL-BESSEL-JL 3 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-0.18920062382698202d0 0.11611074925915743d0 + 0.2762836857713501d0 0.22924385795503022d0)) + (MULTIPLE-VALUE-LIST + (LETM ((BESARR (VECTOR-DOUBLE-FLOAT 4))) + (SPHERICAL-BESSEL-JL-ARRAY 4.0d0 BESARR) + (CL-ARRAY BESARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-0.18920062382698208d0 0.11611074925915742d0 + 0.27628368577135015d0 0.22924385795503024d0)) + (MULTIPLE-VALUE-LIST + (LETM ((BESARR (VECTOR-DOUBLE-FLOAT 4))) + (SPHERICAL-BESSEL-JL-STEED-ARRAY 4.0d0 BESARR) + (CL-ARRAY BESARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.16341090521590299d0 1.4513803955642766d-16) + (MULTIPLE-VALUE-LIST (SPHERICAL-BESSEL-Y0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.2300533501309578d0 1.5324631572452525d-16) + (MULTIPLE-VALUE-LIST (SPHERICAL-BESSEL-Y1 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.009129107382315343d0 1.6876604955506113d-16) + (MULTIPLE-VALUE-LIST (SPHERICAL-BESSEL-Y2 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.009129107382315343d0 1.6876604955506113d-16) + (MULTIPLE-VALUE-LIST (SPHERICAL-BESSEL-YL 2 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.16341090521590299d0 0.2300533501309578d0 + 0.009129107382315343d0 -0.21864196590306362d0)) + (MULTIPLE-VALUE-LIST + (LETM ((BESARR (VECTOR-DOUBLE-FLOAT 4))) + (SPHERICAL-BESSEL-YL-ARRAY 4.0d0 BESARR) + (CL-ARRAY BESARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.12495806717151219d0 5.5492529314587895d-17) + (MULTIPLE-VALUE-LIST + (SPHERICAL-BESSEL-I0-SCALED 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.09380241603560975d0 4.165664081928078d-17) + (MULTIPLE-VALUE-LIST + (SPHERICAL-BESSEL-I1-SCALED 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.05460625514480487d0 2.425004870012731d-17) + (MULTIPLE-VALUE-LIST + (SPHERICAL-BESSEL-I2-SCALED 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.02554459710460367d0 5.842201171222646d-16) + (MULTIPLE-VALUE-LIST + (SPHERICAL-BESSEL-IL-SCALED 3 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.12495806717151212d0 0.09380241603560971d0 + 0.05460625514480483d0 0.02554459710460367d0)) + (MULTIPLE-VALUE-LIST + (LETM ((BESARR (VECTOR-DOUBLE-FLOAT 4))) + (SPHERICAL-BESSEL-IL-SCALED-ARRAY 4.0d0 BESARR) + (CL-ARRAY BESARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.39269908169872414d0 1.743934249004316d-16) + (MULTIPLE-VALUE-LIST + (SPHERICAL-BESSEL-K0-SCALED 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.4908738521234052d0 2.1799178112553949d-16) + (MULTIPLE-VALUE-LIST + (SPHERICAL-BESSEL-K1-SCALED 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.760854470791278d0 3.378872607445862d-16) + (MULTIPLE-VALUE-LIST + (SPHERICAL-BESSEL-K2-SCALED 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.02554459710460367d0 5.842201171222646d-16) + (MULTIPLE-VALUE-LIST + (SPHERICAL-BESSEL-KL-SCALED 3 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.39269908169872414d0 0.4908738521234052d0 + 0.760854470791278d0 1.4419419406125027d0)) + (MULTIPLE-VALUE-LIST + (LETM ((BESARR (VECTOR-DOUBLE-FLOAT 4))) + (SPHERICAL-BESSEL-KL-SCALED-ARRAY 4.0d0 BESARR) + (CL-ARRAY BESARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.43017147387562193d0 7.641380397338472d-16) + (MULTIPLE-VALUE-LIST (BESSEL-JNU 3.0d0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.6713967071418024d0 0.5130161365618323d0 + 0.06500818287738516d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((BESARR + (VECTOR-DOUBLE-FLOAT (A 1.0d0 2.0d0 3.0d0)))) + (SPHERICAL-JNU-ARRAY 0.5d0 BESARR) + (CL-ARRAY BESARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.1820221159534852d0 2.020851441225493d-15) + (MULTIPLE-VALUE-LIST (BESSEL-YNU 3.0d0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3.3372757784203437d0 1.1856385307923545d-14) + (MULTIPLE-VALUE-LIST (BESSEL-INU 3.0d0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.061124338029666284d0 1.3572329489101316d-16) + (MULTIPLE-VALUE-LIST (BESSEL-INU-SCALED 3.0d0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.029884924416755682d0 1.0617257976532701d-16) + (MULTIPLE-VALUE-LIST (BESSEL-KNU 3.0d0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -3.5104011258456183d0 4.776268519767339d-15) + (MULTIPLE-VALUE-LIST (BESSEL-LNKNU 3.0d0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.6316615870352025d0 5.072223134504136d-15) + (MULTIPLE-VALUE-LIST (BESSEL-KNU-SCALED 3.0d0 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 14.930917708487813d0 4.4792753125463437d-14) + (MULTIPLE-VALUE-LIST (BESSEL-ZERO-J0 5))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 16.470630050877624d0 3.2941260101755246d-13) + (MULTIPLE-VALUE-LIST (BESSEL-ZERO-J1 5))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 17.95981949498783d0 3.591963898997566d-14) + (MULTIPLE-VALUE-LIST (BESSEL-ZERO-JNU 2.0d0 5)))) + diff --git a/tests/beta.lisp b/tests/beta.lisp new file mode 100644 index 0000000000000000000000000000000000000000..8206ebe80480dfd99773191125e0206ff6dd7186 --- /dev/null +++ b/tests/beta.lisp @@ -0,0 +1,33 @@ +;; Regression test BETA for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST BETA + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.3935474359990073d0 0.7063621551518341d0 + 0.044515648447265056d0 0.09286083229785232d0 + 0.210544366728104d0 0.010114317425185686d0 + 0.4595767375719009d0 0.1515157002550483d0 + 0.1731331145031117d0 0.4270743075655188d0 + 0.3353314142479658d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (BETA-RD RNG 1.0d0 2.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.8000000000000016d0) + (MULTIPLE-VALUE-LIST (BETA-PDF 0.1d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.19000000000000017d0) + (MULTIPLE-VALUE-LIST (BETA-P 0.1d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.8099999999999998d0) + (MULTIPLE-VALUE-LIST (BETA-Q 0.1d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.09999999999999992d0) + (MULTIPLE-VALUE-LIST (BETA-PINV 0.19d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.09999999999999988d0) + (MULTIPLE-VALUE-LIST (BETA-QINV 0.81d0 1.0d0 2.0d0)))) + diff --git a/tests/binomial.lisp b/tests/binomial.lisp new file mode 100644 index 0000000000000000000000000000000000000000..ab2e83c999505e37fce5903f3b19db64513f149f --- /dev/null +++ b/tests/binomial.lisp @@ -0,0 +1,21 @@ +;; Regression test BINOMIAL for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST BINOMIAL + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST 11 3 4 8 4 5 8 6 5 6 6)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (BINOMIAL RNG 0.4d0 12))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.22703033548799986d0) + (MULTIPLE-VALUE-LIST (BINOMIAL-PDF 5 0.4d0 12))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6652085575680018d0) + (MULTIPLE-VALUE-LIST (BINOMIAL-P 5 0.4d0 12))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.33479144243199815d0) + (MULTIPLE-VALUE-LIST (BINOMIAL-Q 5 0.4d0 12)))) + diff --git a/tests/blas-copy.lisp b/tests/blas-copy.lisp new file mode 100644 index 0000000000000000000000000000000000000000..44c71b14e3564922b3e6b5bc74b4405f8f51eb52 --- /dev/null +++ b/tests/blas-copy.lisp @@ -0,0 +1,43 @@ +;; Regression test BLAS-COPY for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST BLAS-COPY + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-34.5 8.24 3.29)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SINGLE-FLOAT (A -34.5 8.24 3.29) NIL)) + (V2 (VECTOR-SINGLE-FLOAT '3 NIL))) + (BLAS-COPY V1 V2) (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-34.5d0 8.24d0 3.29d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT (A -34.5d0 8.24d0 3.29d0) + NIL)) + (V2 (VECTOR-DOUBLE-FLOAT '3 NIL))) + (BLAS-COPY V1 V2) (CL-ARRAY 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 + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15) NIL)) + (V2 (VECTOR-COMPLEX-SINGLE-FLOAT '3 NIL))) + (BLAS-COPY V1 V2) (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) + #C(34.12d0 -6.15d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + NIL)) + (V2 (VECTOR-COMPLEX-DOUBLE-FLOAT '3 NIL))) + (BLAS-COPY V1 V2) (CL-ARRAY V2))))) + diff --git a/tests/blas-swap.lisp b/tests/blas-swap.lisp new file mode 100644 index 0000000000000000000000000000000000000000..94039ba36f20760160b73dcbeff6e709b0cf86a5 --- /dev/null +++ b/tests/blas-swap.lisp @@ -0,0 +1,64 @@ +;; Regression test BLAS-SWAP for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST BLAS-SWAP + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST #(-8.93 34.12 -6.15) #(-34.5 8.24 3.29))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SINGLE-FLOAT (A -34.5 8.24 3.29) NIL)) + (V2 + (VECTOR-SINGLE-FLOAT (A -8.93 34.12 -6.15) NIL))) + (BLAS-SWAP V2 V1) + (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST #(-8.93d0 34.12d0 -6.15d0) + #(-34.5d0 8.24d0 3.29d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT (A -34.5d0 8.24d0 3.29d0) + NIL)) + (V2 + (VECTOR-DOUBLE-FLOAT (A -8.93d0 34.12d0 -6.15d0) + NIL))) + (BLAS-SWAP V2 V1) + (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST + #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)) + #(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15) NIL)) + (V2 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -8.93 34.12 -6.15 49.27 -13.49 32.5) NIL))) + (BLAS-SWAP V2 V1) + (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST + #(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) + #C(-13.49d0 32.5d0)) + #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) + #C(34.12d0 -6.15d0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + NIL)) + (V2 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + NIL))) + (BLAS-SWAP V2 V1) + (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))) + diff --git a/tests/cauchy.lisp b/tests/cauchy.lisp new file mode 100644 index 0000000000000000000000000000000000000000..ca7f5cd88b59f6da9c0efdc91831bf8310b67b03 --- /dev/null +++ b/tests/cauchy.lisp @@ -0,0 +1,35 @@ +;; Regression test CAUCHY for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST CAUCHY + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST -0.00811319915595434d0 5.617196410586812d0 + 12.292369828923075d0 -1.6741088357812182d0 + 8.909104486260928d0 211.6765861544609d0 + -1.3439049184367153d0 -10.364363282910663d0 + -79.0709314248171d0 -10.652071087998578d0 + -9.393948243493877d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (CAUCHY RNG 10.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.03183098861837907d0) + (MULTIPLE-VALUE-LIST (CAUCHY-PDF 0.0d0 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6475836176504333d0) + (MULTIPLE-VALUE-LIST (CAUCHY-P 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.35241638234956674d0) + (MULTIPLE-VALUE-LIST (CAUCHY-Q 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.9999999999999998d0) + (MULTIPLE-VALUE-LIST + (CAUCHY-PINV 0.6475836176504333d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.0000000000000002d0) + (MULTIPLE-VALUE-LIST + (CAUCHY-QINV 0.35241638234956674d0 2.0d0)))) + diff --git a/tests/cdot.lisp b/tests/cdot.lisp new file mode 100644 index 0000000000000000000000000000000000000000..8ed453ae36931b8edef9652f57ba70d9dbf577fc --- /dev/null +++ b/tests/cdot.lisp @@ -0,0 +1,41 @@ +;; Regression test CDOT for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST CDOT + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #C(-1.1684039224427728d28 0.0d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49 + 32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 + -49.08) + NIL)) + (V2 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A 32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 + -49.08 -39.66 -49.46 19.68 -5.55 -8.82 25.37 + -30.58 31.67) + NIL))) + (CDOT V1 V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #C(-6252.624d0 -6236.050300000001d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0 -16.12d0 -8.25d0 21.44d0 -49.08d0) + NIL)) + (V2 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A 32.5d0 42.73d0 -17.24d0 43.31d0 -16.12d0 + -8.25d0 21.44d0 -49.08d0 -39.66d0 -49.46d0 + 19.68d0 -5.55d0 -8.82d0 25.37d0 -30.58d0 + 31.67d0) + NIL))) + (CDOT V1 V2))))) + diff --git a/tests/chebyshev.lisp b/tests/chebyshev.lisp new file mode 100644 index 0000000000000000000000000000000000000000..6863a35822331d5f049912bd5aba94b1aa0be2d1 --- /dev/null +++ b/tests/chebyshev.lisp @@ -0,0 +1,11 @@ +;; Regression test CHEBYSHEV for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST CHEBYSHEV + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.7159209901689866d0 -1.5019966658054353d0 + 0.17239719403979925d0)) + (MULTIPLE-VALUE-LIST (CHEBYSHEV-POINT-EXAMPLE 0.55d0)))) + diff --git a/tests/chi-squared.lisp b/tests/chi-squared.lisp new file mode 100644 index 0000000000000000000000000000000000000000..0537e5faa3f22962ae05ef03db83f9c8dd8637ef --- /dev/null +++ b/tests/chi-squared.lisp @@ -0,0 +1,35 @@ +;; Regression test CHI-SQUARED for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST CHI-SQUARED + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 13.043328884186328d0 11.427227829236712d0 + 16.55811815484942d0 7.128795406995407d0 + 5.120266499239882d0 10.464572605669142d0 + 5.8126929867006405d0 8.784940866479005d0 + 7.559275305609187d0 8.35181083950897d0 + 4.140798004825149d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (CHI-SQUARED RNG 10.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.43939128946772227d0) + (MULTIPLE-VALUE-LIST (CHI-SQUARED-PDF 0.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5204998778130462d0) + (MULTIPLE-VALUE-LIST (CHI-SQUARED-P 0.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.4795001221869538d0) + (MULTIPLE-VALUE-LIST (CHI-SQUARED-Q 0.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5000000000000003d0) + (MULTIPLE-VALUE-LIST + (CHI-SQUARED-PINV 0.5204998778130463d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5000000000000003d0) + (MULTIPLE-VALUE-LIST + (CHI-SQUARED-QINV 0.4795001221869537d0 1.0d0)))) + diff --git a/tests/clausen.lisp b/tests/clausen.lisp new file mode 100644 index 0000000000000000000000000000000000000000..9d119f872df9f4fc762c1837074218db0a13de74 --- /dev/null +++ b/tests/clausen.lisp @@ -0,0 +1,9 @@ +;; Regression test CLAUSEN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST CLAUSEN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.4335982032355329d0 1.2032502825912828d-15) + (MULTIPLE-VALUE-LIST (CLAUSEN 2.5d0)))) + diff --git a/tests/column.lisp b/tests/column.lisp new file mode 100644 index 0000000000000000000000000000000000000000..0a5f8366e6b9cd9b981a1802277852c0b1896998 --- /dev/null +++ b/tests/column.lisp @@ -0,0 +1,177 @@ +;; Regression test COLUMN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST COLUMN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(8.24 34.12 -13.49)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (COL (VECTOR-SINGLE-FLOAT '3 NIL))) + (CL-ARRAY (COLUMN COL M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(8.24d0 34.12d0 -13.49d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (COL (VECTOR-DOUBLE-FLOAT '3 NIL))) + (CL-ARRAY (COLUMN COL M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL)) + (COL (VECTOR-COMPLEX-SINGLE-FLOAT '3 NIL))) + (CL-ARRAY (COLUMN COL M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(3.29d0 -8.93d0) #C(-6.15d0 49.27d0) + #C(32.5d0 42.73d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL)) + (COL (VECTOR-COMPLEX-DOUBLE-FLOAT '3 NIL))) + (CL-ARRAY (COLUMN COL M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL)) + (COL + (VECTOR-SIGNED-BYTE-8 + '3 NIL))) + (CL-ARRAY + (COLUMN COL M1 + 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL)) + (COL + (VECTOR-UNSIGNED-BYTE-8 + '3 NIL))) + (CL-ARRAY + (COLUMN COL M1 + 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL)) + (COL + (VECTOR-SIGNED-BYTE-16 + '3 NIL))) + (CL-ARRAY + (COLUMN COL M1 + 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL)) + (COL + (VECTOR-UNSIGNED-BYTE-16 + '3 NIL))) + (CL-ARRAY + (COLUMN COL M1 + 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL)) + (COL + (VECTOR-SIGNED-BYTE-32 + '3 NIL))) + (CL-ARRAY + (COLUMN COL M1 + 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL)) + (COL + (VECTOR-UNSIGNED-BYTE-32 + '3 NIL))) + (CL-ARRAY + (COLUMN COL M1 + 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL)) + (COL + (VECTOR-SIGNED-BYTE-64 + '3 NIL))) + (CL-ARRAY + (COLUMN COL M1 + 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL)) + (COL + (VECTOR-UNSIGNED-BYTE-64 + '3 NIL))) + (CL-ARRAY + (COLUMN COL M1 + 1)))))) + diff --git a/tests/combination.lisp b/tests/combination.lisp new file mode 100644 index 0000000000000000000000000000000000000000..2669dcacdae9855a0ada4e160fb7c96e69c581a8 --- /dev/null +++ b/tests/combination.lisp @@ -0,0 +1,46 @@ +;; Regression test COMBINATION for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST COMBINATION + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 4) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(4 2) T))) + (COMBINATION-RANGE + COMB)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(4 2) T))) + (COMBINATION-SIZE + COMB)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST #(0 1) #(0 2) #(0 3) #(1 2) #(1 3) #(2 3))) + (MULTIPLE-VALUE-LIST + (LETM ((COMB (COMBINATION '(4 2) T))) + (INIT-FIRST COMB) + (LOOP COLLECT (COPY-SEQ (CL-ARRAY 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 + (LETM ((COMB (COMBINATION '(4 2) T))) (INIT-LAST COMB) + (LOOP COLLECT (COPY-SEQ (CL-ARRAY COMB)) WHILE + (COMBINATION-PREVIOUS COMB))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST #() #(0) #(1) #(2) #(3) #(0 1) #(0 2) #(0 3) + #(1 2) #(1 3) #(2 3) #(0 1 2) #(0 1 3) #(0 2 3) + #(1 2 3) #(0 1 2 3))) + (MULTIPLE-VALUE-LIST + (LOOP FOR I FROM 0 TO 4 APPEND + (LETM ((COMB (COMBINATION (LIST 4 I) T))) + (INIT-FIRST COMB) + (LOOP COLLECT (COPY-SEQ (CL-ARRAY COMB)) + WHILE (COMBINATION-NEXT COMB))))))) + diff --git a/tests/coulomb.lisp b/tests/coulomb.lisp new file mode 100644 index 0000000000000000000000000000000000000000..fd238d160004e8ed2442fb9bb5896fe887b82d48 --- /dev/null +++ b/tests/coulomb.lisp @@ -0,0 +1,67 @@ +;; Regression test COULOMB for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST COULOMB + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.1641699972477976d0 1.8226531089715347d-16) + (MULTIPLE-VALUE-LIST (HYDROGENICR-1 1.0d0 2.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.07666468084146327d0 4.203054519905891d-16) + (MULTIPLE-VALUE-LIST (HYDROGENICR 3 1 1.0d0 2.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.06203505201137388d0 0.17709857491700906d0 + 3.6050175661599693d0 -5.8282618416439025d0 0.0d0 + 0.0d0 4.3793707124032857d-16 + 1.2502291640824433d-15 3.5328525523867457d-14 + 5.711592064490999d-14) + (MULTIPLE-VALUE-LIST + (COULOMB-WAVE-FG 0.0d0 1.0d0 2.0d0 0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.6617816138326813d0 0.3614128577450535d0 + 0.13267757609917497d0)) + (MULTIPLE-VALUE-LIST + (LETM ((ARR (VECTOR-DOUBLE-FLOAT 3))) + (COULOMB-WAVE-F-ARRAY 0.0d0 1.0d0 2.0d0 ARR) + (CL-ARRAY ARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.07161779967468254d0 0.1278101031568499d0 + 2.2510703464871114d0 -1.4245543587641651d0 0.0d0 + 0.0d0 8.269219937869759d-15 + 1.4757362807662922d-14 2.5991577338697564d-13 + 1.644835970887306d-13) + (MULTIPLE-VALUE-LIST + (COULOMB-WAVE-FG 1.0d0 2.0d0 2.5d0 1))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.035021584603913254d0 0.005752500614202263d0 + 7.116955601984411d-4 6.471726496134135d0 + 27.57457472159366d0 170.56037293106908d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((FARR (VECTOR-DOUBLE-FLOAT 3)) + (GARR (VECTOR-DOUBLE-FLOAT 3))) + (COULOMB-WAVE-FG-ARRAY 1.5d0 1.0d0 1.0d0 FARR GARR) + (APPEND (COERCE (CL-ARRAY FARR) 'LIST) + (COERCE (CL-ARRAY GARR) 'LIST))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.33089080691634065d0 0.18070642887252675d0 + 0.06633878804958748d0)) + (MULTIPLE-VALUE-LIST + (LETM ((ARR (VECTOR-DOUBLE-FLOAT 3))) + (COULOMB-WAVE-SPHF-ARRAY 0.0d0 1.0d0 2.0d0 ARR) + (CL-ARRAY ARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.0013809146441856027d0 2.759621819430441d-17) + (MULTIPLE-VALUE-LIST (COULOMB-CL 1.0d0 2.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.10842251310207264d0 0.05111086283184191d0 + 0.011428736368066591d0)) + (MULTIPLE-VALUE-LIST + (LETM ((CL (VECTOR-DOUBLE-FLOAT 3))) + (COULOMB-CL-ARRAY 0.0d0 1.0d0 CL) + (CL-ARRAY CL))))) + diff --git a/tests/coupling.lisp b/tests/coupling.lisp new file mode 100644 index 0000000000000000000000000000000000000000..de4b439f0f7e8e8885f9c377b89761119069cc89 --- /dev/null +++ b/tests/coupling.lisp @@ -0,0 +1,15 @@ +;; Regression test COUPLING for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST COUPLING + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.7071067811865475d0 3.14018491736755d-16) + (MULTIPLE-VALUE-LIST (COUPLING-3J 0 1 1 0 1 -1))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.408248290463863d0 5.438959822042073d-16) + (MULTIPLE-VALUE-LIST (COUPLING-6J 1 1 2 0 2 1))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.1388888888888889d0 6.638400825147663d-16) + (MULTIPLE-VALUE-LIST (COUPLING-9J 1 1 2 1 2 1 2 1 1)))) + diff --git a/tests/covariance.lisp b/tests/covariance.lisp new file mode 100644 index 0000000000000000000000000000000000000000..6f6a07e57238b101b04433164e4a94b3d527d757 --- /dev/null +++ b/tests/covariance.lisp @@ -0,0 +1,18 @@ +;; Regression test COVARIANCE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST COVARIANCE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST -0.2929999999999998d0 -0.2929999999999998d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((VEC1 + (VECTOR-DOUBLE-FLOAT (A -3.21d0 1.0d0 12.8d0))) + (VEC2 + (VECTOR-DOUBLE-FLOAT (A 1.15d0 -1.0d0 0.5d0)))) + (LET ((MEAN1 (MEAN VEC1)) (MEAN2 (MEAN VEC2))) + (LIST (COVARIANCE VEC1 VEC2) + (COVARIANCE VEC1 VEC2 MEAN1 MEAN2))))))) + diff --git a/tests/dawson.lisp b/tests/dawson.lisp new file mode 100644 index 0000000000000000000000000000000000000000..835a54354ac056fdf841e08a999af6f4130781c6 --- /dev/null +++ b/tests/dawson.lisp @@ -0,0 +1,9 @@ +;; Regression test DAWSON for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST DAWSON + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5380795069127684d0 1.424354102650492d-15) + (MULTIPLE-VALUE-LIST (DAWSON 1.0d0)))) + diff --git a/tests/debye.lisp b/tests/debye.lisp new file mode 100644 index 0000000000000000000000000000000000000000..5f3344ebe4e6902545a453c681eacfb9c664cd39 --- /dev/null +++ b/tests/debye.lisp @@ -0,0 +1,18 @@ +;; Regression test DEBYE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST DEBYE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.7775046341122482d0 4.117962028082377d-16) + (MULTIPLE-VALUE-LIST (DEBYE-1 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.7078784756278294d0 4.948781517277596d-16) + (MULTIPLE-VALUE-LIST (DEBYE-2 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6744155640778147d0 5.450931753448871d-16) + (MULTIPLE-VALUE-LIST (DEBYE-3 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.654874068886737d0 5.769372522202218d-16) + (MULTIPLE-VALUE-LIST (DEBYE-4 1.0d0)))) + diff --git a/tests/dilogarithm.lisp b/tests/dilogarithm.lisp new file mode 100644 index 0000000000000000000000000000000000000000..b9b83e6e2b74e5b04a3ad086d4b7b458a94f82c3 --- /dev/null +++ b/tests/dilogarithm.lisp @@ -0,0 +1,13 @@ +;; Regression test DILOGARITHM for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST DILOGARITHM + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.6449340668482264d0 7.304974700020789d-16) + (MULTIPLE-VALUE-LIST (DILOGARITHM 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #C(-0.20561675835602822d0 0.915965594177219d0) + #C(2.100180226255977d-15 7.618282373747058d-16)) + (MULTIPLE-VALUE-LIST (DILOGARITHM #C(0.0d0 1.0d0))))) + diff --git a/tests/dirichlet.lisp b/tests/dirichlet.lisp new file mode 100644 index 0000000000000000000000000000000000000000..e50b666d5ccc16b675b60679c505d69a4bdb251d --- /dev/null +++ b/tests/dirichlet.lisp @@ -0,0 +1,35 @@ +;; Regression test DIRICHLET for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST DIRICHLET + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.12448073544131681d0 0.19182353706734917d0 + 0.46054388544826397d0 0.22315184204307006d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0)) + (ALPHA + (VECTOR-DOUBLE-FLOAT (A 1.0d0 2.0d0 3.0d0 4.0d0))) + (THETA (VECTOR-DOUBLE-FLOAT 4))) + (DIRICHLET RNG ALPHA THETA) (CL-ARRAY THETA)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.8800000000000043d0) + (MULTIPLE-VALUE-LIST + (LETM + ((ALPHA + (VECTOR-DOUBLE-FLOAT (A 1.0d0 2.0d0 3.0d0 4.0d0))) + (THETA + (VECTOR-DOUBLE-FLOAT (A 0.1d0 0.3d0 0.4d0 0.2d0)))) + (DIRICHLET-PDF ALPHA THETA)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.057790294147856d0) + (MULTIPLE-VALUE-LIST + (LETM + ((ALPHA + (VECTOR-DOUBLE-FLOAT (A 1.0d0 2.0d0 3.0d0 4.0d0))) + (THETA + (VECTOR-DOUBLE-FLOAT (A 0.1d0 0.3d0 0.4d0 0.2d0)))) + (DIRICHLET-LOG-PDF ALPHA THETA))))) + diff --git a/tests/discrete.lisp b/tests/discrete.lisp new file mode 100644 index 0000000000000000000000000000000000000000..481f97e9401299e0fe22fad132093f5ee0a89ae0 --- /dev/null +++ b/tests/discrete.lisp @@ -0,0 +1,30 @@ +;; Regression test DISCRETE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST DISCRETE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST 1 0 1 1 0 1 1 2 1 2 2)) + (MULTIPLE-VALUE-LIST + (LETM + ((PROBABILITIES + (VECTOR-DOUBLE-FLOAT (A 0.25d0 0.5d0 0.25d0)))) + (LETM + ((TABLE (DISCRETE-RANDOM PROBABILITIES)) + (RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (DISCRETE RNG TABLE)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.5d0) + (MULTIPLE-VALUE-LIST + (LETM + ((PROBABILITIES + (VECTOR-DOUBLE-FLOAT + (A 0.25d0 0.5d0 + 0.25d0)))) + (LETM + ((TABLE + (DISCRETE-RANDOM + PROBABILITIES))) + (DISCRETE-PDF 1 + TABLE)))))) + diff --git a/tests/dot.lisp b/tests/dot.lisp new file mode 100644 index 0000000000000000000000000000000000000000..058436f057a531e56f75413a5cd94b8339edb56e --- /dev/null +++ b/tests/dot.lisp @@ -0,0 +1,74 @@ +;; Regression test DOT for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST DOT + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6.5285645) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 + 3.29 -8.93 + 34.12 -6.15 + 49.27 -13.49) + NIL)) + (V2 + (VECTOR-SINGLE-FLOAT + (A 32.5 42.73 + -17.24 43.31 + -16.12 -8.25 + 21.44 -49.08) + NIL))) + (DOT V1 V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6.528400000000033d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL)) + (V2 + (VECTOR-DOUBLE-FLOAT + (A 32.5d0 42.73d0 -17.24d0 43.31d0 -16.12d0 + -8.25d0 21.44d0 -49.08d0) + NIL))) + (DOT V1 V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #C(-8.778225633844878d26 0.0d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49 + 32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 + -49.08) + NIL)) + (V2 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A 32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 + -49.08 -39.66 -49.46 19.68 -5.55 -8.82 25.37 + -30.58 31.67) + NIL))) + (DOT V1 V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #C(625.9736000000007d0 -4310.1183d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0 -16.12d0 -8.25d0 21.44d0 -49.08d0) + NIL)) + (V2 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A 32.5d0 42.73d0 -17.24d0 43.31d0 -16.12d0 + -8.25d0 21.44d0 -49.08d0 -39.66d0 -49.46d0 + 19.68d0 -5.55d0 -8.82d0 25.37d0 -30.58d0 + 31.67d0) + NIL))) + (DOT V1 V2))))) + diff --git a/tests/eigensystems.lisp b/tests/eigensystems.lisp new file mode 100644 index 0000000000000000000000000000000000000000..e97e84fb8fc98a75fc46b27f9a50ef3e5a48f486 --- /dev/null +++ b/tests/eigensystems.lisp @@ -0,0 +1,14 @@ +;; Regression test EIGENSYSTEMS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST EIGENSYSTEMS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(13.819660112501051d0 36.180339887498945d0 40.0d0) + #2A((0.8506508083520399d0 -0.5257311121191337d0 0.0d0) + (0.5257311121191337d0 0.8506508083520399d0 0.0d0) + (0.0d0 0.0d0 1.0d0))) + (MULTIPLE-VALUE-LIST + (EIGENVALUE-EIGENVECTORS-EXAMPLE)))) + diff --git a/tests/elementary.lisp b/tests/elementary.lisp new file mode 100644 index 0000000000000000000000000000000000000000..35ba7413cec8b1d2c7e25e14b6103a0e0aeda91f --- /dev/null +++ b/tests/elementary.lisp @@ -0,0 +1,13 @@ +;; Regression test ELEMENTARY for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST ELEMENTARY + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6.0d0 2.6645352591003757d-15) + (MULTIPLE-VALUE-LIST (MULTIPLY 3.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6.0d0 0.5000000000000027d0) + (MULTIPLE-VALUE-LIST + (MULTIPLY-ERR 3.0d0 0.1d0 2.0d0 0.1d0)))) + diff --git a/tests/elliptic-functions.lisp b/tests/elliptic-functions.lisp new file mode 100644 index 0000000000000000000000000000000000000000..c18b23fbc951033efbad35040f0a1a463ec931af --- /dev/null +++ b/tests/elliptic-functions.lisp @@ -0,0 +1,15 @@ +;; Regression test ELLIPTIC-FUNCTIONS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST ELLIPTIC-FUNCTIONS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.19762082367187703d0 0.9802785369736752d0 + 0.9840560289645665d0 3.647587850116755d-318 + 1.4821969375237396d-321 2.023692885365746d-320) + (MULTIPLE-VALUE-LIST + (JACOBIAN-ELLIPTIC-FUNCTIONS 0.2d0 0.81d0))) + (LISP-UNIT:ASSERT-ERROR 'input-domain + (JACOBIAN-ELLIPTIC-FUNCTIONS + 0.61802d0 1.5d0))) + diff --git a/tests/elliptic-integrals.lisp b/tests/elliptic-integrals.lisp new file mode 100644 index 0000000000000000000000000000000000000000..c25c47e42258090696d670f3bb548fbc6392781a --- /dev/null +++ b/tests/elliptic-integrals.lisp @@ -0,0 +1,46 @@ +;; Regression test ELLIPTIC-INTEGRALS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST ELLIPTIC-INTEGRALS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.5707963267948966d0 4.598091522633788d-16) + (MULTIPLE-VALUE-LIST + (ELLIPTIC-INTEGRAL-K-COMPLETE 0.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.5707963267948966d0 3.487868498008632d-16) + (MULTIPLE-VALUE-LIST + (ELLIPTIC-INTEGRAL-E-COMPLETE 0.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.6774175382039307d0 3.008338192795582d-16) + (MULTIPLE-VALUE-LIST + (ELLIPTIC-INTEGRAL-F -0.5d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.4018194805534952d0 4.232239429377521d-16) + (MULTIPLE-VALUE-LIST + (ELLIPTIC-INTEGRAL-E -0.5d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.617791316339182d0 3.273131810338189d-16) + (MULTIPLE-VALUE-LIST + (ELLIPTIC-INTEGRAL-P -0.5d0 2.0d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.06889951441260889d0 3.059753091454848d-17) + (MULTIPLE-VALUE-LIST + (ELLIPTIC-INTEGRAL-D -0.5d0 2.0d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.8813735870195432d0 1.9570424992111216d-16) + (MULTIPLE-VALUE-LIST + (ELLIPTIC-INTEGRAL-RC 2.0d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.7992599630303281d0 1.7747136272346433d-16) + (MULTIPLE-VALUE-LIST + (ELLIPTIC-INTEGRAL-RD 2.0d0 1.0d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.8813735870195432d0 1.9570424992111216d-16) + (MULTIPLE-VALUE-LIST + (ELLIPTIC-INTEGRAL-RF 2.0d0 1.0d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5228004174989865d0 1.160850121582039d-16) + (MULTIPLE-VALUE-LIST + (ELLIPTIC-INTEGRAL-RJ 2.0d0 1.0d0 1.0d0 2.0d0)))) + diff --git a/tests/error-functions.lisp b/tests/error-functions.lisp new file mode 100644 index 0000000000000000000000000000000000000000..d43148f1c176b17bf4e02183b95aead551f02ed7 --- /dev/null +++ b/tests/error-functions.lisp @@ -0,0 +1,24 @@ +;; Regression test ERROR-FUNCTIONS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST ERROR-FUNCTIONS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.8427007929497149d0 7.789237746491556d-16) + (MULTIPLE-VALUE-LIST (ERF 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.1572992070502851d0 4.0468944536809554d-16) + (MULTIPLE-VALUE-LIST (ERFC 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -1.8496055099332485d0 3.394126565390616d-15) + (MULTIPLE-VALUE-LIST (LOG-ERFC 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.24197072451914334d0 1.611848817878303d-16) + (MULTIPLE-VALUE-LIST (ERF-Z 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.15865525393145707d0 2.832400331480832d-16) + (MULTIPLE-VALUE-LIST (ERF-Q 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.5251352761609807d0 5.532094155354489d-15) + (MULTIPLE-VALUE-LIST (HAZARD 1.0d0)))) + diff --git a/tests/euclidean-norm.lisp b/tests/euclidean-norm.lisp new file mode 100644 index 0000000000000000000000000000000000000000..24407bfbc132c334c49e85604a2be3da914d243d --- /dev/null +++ b/tests/euclidean-norm.lisp @@ -0,0 +1,55 @@ +;; Regression test EUCLIDEAN-NORM for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST EUCLIDEAN-NORM + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71.83472) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 + 3.29 -8.93 + 34.12 -6.15 + 49.27 -13.49) + NIL))) + (EUCLIDEAN-NORM + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 71.83471653734007d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL))) + (EUCLIDEAN-NORM V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 115.80907) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 + 3.29 -8.93 + 34.12 -6.15 + 49.27 -13.49 + 32.5 42.73 + -17.24 43.31 + -16.12 -8.25 + 21.44 -49.08) + NIL))) + (EUCLIDEAN-NORM + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 115.8090670025452d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0 -16.12d0 -8.25d0 21.44d0 -49.08d0) + NIL))) + (EUCLIDEAN-NORM V1))))) + diff --git a/tests/exponential-functions.lisp b/tests/exponential-functions.lisp new file mode 100644 index 0000000000000000000000000000000000000000..74c5e145d2505593d9375c281c69f52f843f2e31 --- /dev/null +++ b/tests/exponential-functions.lisp @@ -0,0 +1,38 @@ +;; Regression test EXPONENTIAL-FUNCTIONS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST EXPONENTIAL-FUNCTIONS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 20.085536923187668d0 8.91977022163267d-15) + (MULTIPLE-VALUE-LIST (GSL-EXP 3.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3.8811801942838993d0 868 3.448904081776264d-12) + (MULTIPLE-VALUE-LIST (EXP-SCALED 2000.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3.6535299896840335d44 8.355840218353793d30) + (MULTIPLE-VALUE-LIST (EXP-MULT 101.0d0 5.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.0908344123363103d0 243 5.42628544911082d-13) + (MULTIPLE-VALUE-LIST + (EXP-MULT-SCALED 555.0d0 101.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.0000500016667085d-4 4.441114150507224d-20) + (MULTIPLE-VALUE-LIST (EXPM1 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.0000500016667084d0 4.4411141505072235d-16) + (MULTIPLE-VALUE-LIST (EXPREL 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.0003334166833362d0 4.442372766015162d-16) + (MULTIPLE-VALUE-LIST (EXPREL-2 0.001d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.0002500500083344d0 2.665201526164121d-15) + (MULTIPLE-VALUE-LIST (EXPREL-N 3 0.001d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 20.085536923187668d0 0.04017108054156605d0) + (MULTIPLE-VALUE-LIST (EXP-ERR 3.0d0 0.001d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 461.9673492333164d0 0.4820528861567092d0) + (MULTIPLE-VALUE-LIST + (EXP-MULT-ERR 3.0d0 0.001d0 23.0d0 0.001d0)))) + diff --git a/tests/exponential-integrals.lisp b/tests/exponential-integrals.lisp new file mode 100644 index 0000000000000000000000000000000000000000..fe7a40afcf9d962165b2874c3f27ac74843d0349 --- /dev/null +++ b/tests/exponential-integrals.lisp @@ -0,0 +1,31 @@ +;; Regression test EXPONENTIAL-INTEGRALS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST EXPONENTIAL-INTEGRALS + (LISP-UNIT:ASSERT-ERROR 'input-domain (EXPINT-E1 0.0d0)) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.21938393439552029d0 2.6541220085226265d-16) + (MULTIPLE-VALUE-LIST (EXPINT-E1 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4.954234356001891d0 7.64289440273947d-15) + (MULTIPLE-VALUE-LIST (EXPINT-EI 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.363730673440693d0 4.275641706089105d-15) + (MULTIPLE-VALUE-LIST (SHI 1.25d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.217317300914783d0 4.21062110717259d-15) + (MULTIPLE-VALUE-LIST (CHI 1.25d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.8688926541262327d0 4.083149724141479d-16) + (MULTIPLE-VALUE-LIST (EXPINT-3 1.25d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.1464464156732344d0 7.36847290397885d-16) + (MULTIPLE-VALUE-LIST (SI 1.25d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.4343007240335524d0 1.2207688418479174d-15) + (MULTIPLE-VALUE-LIST (CI 1.25d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.103619161676528d0 6.711588415833395d-16) + (MULTIPLE-VALUE-LIST (ATANINT 1.25d0)))) + diff --git a/tests/exponential-power.lisp b/tests/exponential-power.lisp new file mode 100644 index 0000000000000000000000000000000000000000..8a180861ed249dadf71da4e340cd27bc61f7354a --- /dev/null +++ b/tests/exponential-power.lisp @@ -0,0 +1,30 @@ +;; Regression test EXPONENTIAL-POWER for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST EXPONENTIAL-POWER + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.09469475592777954d0 -0.06229680875327071d0 + 1.183985538537803d0 0.5187626019237904d0 + 0.7053564314063956d0 -0.9033303844569821d0 + -1.6947336289940842d0 -0.4803236108055401d0 + -0.027641736349912214d0 0.6318391856046153d0 + -0.012478875227423025d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (EXPONENTIAL-POWER RNG 1.0d0 2.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5641895835477557d0) + (MULTIPLE-VALUE-LIST + (EXPONENTIAL-POWER-PDF 0.0d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.9213503964748571d0) + (MULTIPLE-VALUE-LIST + (EXPONENTIAL-POWER-P 1.0d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.07864960352514248d0) + (MULTIPLE-VALUE-LIST + (EXPONENTIAL-POWER-Q 1.0d0 1.0d0 2.0d0)))) + diff --git a/tests/exponential.lisp b/tests/exponential.lisp new file mode 100644 index 0000000000000000000000000000000000000000..49090eefd0b3035ded34ff440e7f08e3f8628c10 --- /dev/null +++ b/tests/exponential.lisp @@ -0,0 +1,38 @@ +;; Regression test EXPONENTIAL for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST EXPONENTIAL + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.0025828444588394794d0 18.145581427987647d0 + 12.636598054339759d0 0.5424387252062355d0 + 14.624994234158105d0 7.236607929535993d0 + 0.4345362449683603d0 2.95303920904529d0 + 6.161052939065796d0 3.011686333539114d0 + 2.7451079819355364d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (EXPONENTIAL RNG 10.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.1d0) + (MULTIPLE-VALUE-LIST + (EXPONENTIAL-PDF + 0.0d0 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.3934693402873666d0) + (MULTIPLE-VALUE-LIST (EXPONENTIAL-P 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6065306597126334d0) + (MULTIPLE-VALUE-LIST (EXPONENTIAL-Q 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.0d0) + (MULTIPLE-VALUE-LIST + (EXPONENTIAL-PINV + 0.3934693402873666d0 + 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.0d0) + (MULTIPLE-VALUE-LIST + (EXPONENTIAL-QINV + 0.6065306597126334d0 + 2.0d0)))) + diff --git a/tests/fdist.lisp b/tests/fdist.lisp new file mode 100644 index 0000000000000000000000000000000000000000..0803ec7d66e617d9a3314bdf8cf606ad116475cb --- /dev/null +++ b/tests/fdist.lisp @@ -0,0 +1,36 @@ +;; Regression test FDIST for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST FDIST + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 18.411308904958695d0 5.120881381831058d0 + 18.104535265974707d0 0.15934280606960227d0 + 0.06272171507636773d0 2.2809441726456456d0 + 0.5259458753395939d0 1.8256109001076744d0 + 0.845346894458977d0 2.5212086970057763d0 + 0.5212415547032052d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (FDIST RNG 1.0d0 2.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.1594719884624466d0) + (MULTIPLE-VALUE-LIST (FDIST-PDF 1.2d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6123724356957948d0) + (MULTIPLE-VALUE-LIST (FDIST-P 1.2d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.3876275643042052d0) + (MULTIPLE-VALUE-LIST (FDIST-Q 1.2d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.2d0) + (MULTIPLE-VALUE-LIST + (FDIST-PINV + 0.612372435695795d0 + 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.1999999999999995d0) + (MULTIPLE-VALUE-LIST + (FDIST-QINV 0.38762756430420503d0 1.0d0 2.0d0)))) + diff --git a/tests/fermi-dirac.lisp b/tests/fermi-dirac.lisp new file mode 100644 index 0000000000000000000000000000000000000000..9684a1ffd5dfc43dbb31eed7ce01248c9683f857 --- /dev/null +++ b/tests/fermi-dirac.lisp @@ -0,0 +1,33 @@ +;; Regression test FERMI-DIRAC for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST FERMI-DIRAC + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6224593312018546d0 4.040305821324309d-16) + (MULTIPLE-VALUE-LIST (FERMI-DIRAC-M1 0.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.1368710061148999d0 1.6653345369377348d-16) + (MULTIPLE-VALUE-LIST (FERMI-DIRAC-0 0.75d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.42589430612383183d0 5.594591187346375d-16) + (MULTIPLE-VALUE-LIST (FERMI-DIRAC-1 -0.75d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.1301630162645293d0 6.04246936785309d-16) + (MULTIPLE-VALUE-LIST (FERMI-DIRAC-2 0.25d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6668.827087650077d0 2.1696654306572242d-10) + (MULTIPLE-VALUE-LIST (FERMI-DIRAC-INTEGRAL 5 12.35d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.4642945890876293d0 4.053118505064653d-15) + (MULTIPLE-VALUE-LIST (FERMI-DIRAC-M1/2 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.8237212774015843d0 2.909989668869937d-15) + (MULTIPLE-VALUE-LIST (FERMI-DIRAC-1/2 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4.165414459868321d0 3.666976569654393d-15) + (MULTIPLE-VALUE-LIST (FERMI-DIRAC-3/2 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.7014132779827524d0 8.881784197001252d-16) + (MULTIPLE-VALUE-LIST (FERMI-DIRAC-INC-0 2.0d0 0.5d0)))) + diff --git a/tests/flat.lisp b/tests/flat.lisp new file mode 100644 index 0000000000000000000000000000000000000000..f3d912b3e8c6f927ed395b6bcb3d4e5e4fb2b08e --- /dev/null +++ b/tests/flat.lisp @@ -0,0 +1,40 @@ +;; Regression test FLAT for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST FLAT + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 1.999741748906672d0 1.1629098753910512d0 + 1.2826178052928299d0 1.9472010820172727d0 + 1.2316565427463502d0 1.4849736143369228d0 + 1.9574769565369934d0 1.7443053431343287d0 + 1.540043658344075d0 1.7399529814720154d0 + 1.7599437981843948d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (FLAT RNG 1.0d0 2.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.0d0) + (MULTIPLE-VALUE-LIST + (FLAT-PDF 1.2d0 + 1.0d0 + 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.19999999999999996d0) + (MULTIPLE-VALUE-LIST (FLAT-P 1.2d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.8d0) + (MULTIPLE-VALUE-LIST + (FLAT-Q 1.2d0 1.0d0 + 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.2d0) + (MULTIPLE-VALUE-LIST + (FLAT-PINV + 0.19999999999999996d0 + 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.2d0) + (MULTIPLE-VALUE-LIST + (FLAT-QINV 0.8d0 + 1.0d0 + 2.0d0)))) + diff --git a/tests/gamma-randist.lisp b/tests/gamma-randist.lisp new file mode 100644 index 0000000000000000000000000000000000000000..598f590947fd9f548575ad297fc9a8e906fcf96f --- /dev/null +++ b/tests/gamma-randist.lisp @@ -0,0 +1,47 @@ +;; Regression test GAMMA-RANDIST for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST GAMMA-RANDIST + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 3.012983063768798d0 2.216796987787054d0 + 5.033971231985026d0 0.6152002566487763d0 + 0.1876159751197978d0 1.7884608326846099d0 + 0.30812625873110316d0 1.1328459017528132d0 + 0.7363931539298727d0 0.9843618987581162d0 + 0.06871686155296197d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (GAMMA-RD RNG 1.0d0 2.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 3.012983063768798d0 2.216796987787054d0 + 5.033971231985026d0 0.6152002566487763d0 + 0.1876159751197978d0 1.7884608326846099d0 + 0.30812625873110316d0 1.1328459017528132d0 + 0.7363931539298727d0 0.9843618987581162d0 + 0.06871686155296197d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (GAMMA-MT RNG 1.0d0 2.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.475614712250357d0) + (MULTIPLE-VALUE-LIST (GAMMA-PDF 0.1d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.04877057549928599d0) + (MULTIPLE-VALUE-LIST (GAMMA-P 0.1d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.951229424500714d0) + (MULTIPLE-VALUE-LIST (GAMMA-Q 0.1d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.10000000000000006d0) + (MULTIPLE-VALUE-LIST + (GAMMA-PINV 0.048770575499286005d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.10000000000000003d0) + (MULTIPLE-VALUE-LIST + (GAMMA-QINV 0.951229424500714d0 1.0d0 2.0d0)))) + diff --git a/tests/gamma.lisp b/tests/gamma.lisp new file mode 100644 index 0000000000000000000000000000000000000000..fafea78eabf8178f100c02a0fde779e5f5f74b07 --- /dev/null +++ b/tests/gamma.lisp @@ -0,0 +1,84 @@ +;; Regression test GAMMA for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST GAMMA (LISP-UNIT:ASSERT-ERROR 'input-domain (GAMMA -1.0d0)) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 120.0d0 2.6645352591003757d-14) + (MULTIPLE-VALUE-LIST (GAMMA 6.0d0))) + (LISP-UNIT:ASSERT-ERROR 'input-domain (LOG-GAMMA -100.0d0)) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 359.13420536957534d0 2.4544868717695813d-13) + (MULTIPLE-VALUE-LIST (LOG-GAMMA 100.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 359.13420536957534d0 1.0d0 + 2.4544868717695813d-13) + (MULTIPLE-VALUE-LIST (LOG-GAMMA-SIGN 100.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.0034780558311105d0 4.456337769159149d-16) + (MULTIPLE-VALUE-LIST (GAMMA* 24.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.984126984126984d-4 1.3216940769347103d-19) + (MULTIPLE-VALUE-LIST (1/GAMMA 8.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 8.236131750448724d0 -1.184037814936308d0 + 7.315154482555574d-15 2.2665868951123376d-14) + (MULTIPLE-VALUE-LIST + (LOG-GAMMA-COMPLEX #C(10.0d0 10.0d0)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.0011094764610389606d0 2.956239149580215d-18) + (MULTIPLE-VALUE-LIST (TAYLOR-COEFFICIENT 12 3.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4.790016d8 0.0d0) + (MULTIPLE-VALUE-LIST (FACTORIAL 12))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 46080.0d0 0.0d0) + (MULTIPLE-VALUE-LIST (DOUBLE-FACTORIAL 12))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 857.9336698258575d0 5.777158772429952d-13) + (MULTIPLE-VALUE-LIST (LOG-FACTORIAL 199))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 430.17789358084747d0 1.9103736085528287d-13) + (MULTIPLE-VALUE-LIST (LOG-DOUBLE-FACTORIAL 199))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.0d0 7.460698725481052d-14) + (MULTIPLE-VALUE-LIST (CHOOSE 8 3))) + (LISP-UNIT:ASSERT-ERROR 'input-domain (CHOOSE 3 8)) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 29.422274169864693d0 1.9338924605168215d-13) + (MULTIPLE-VALUE-LIST (LOG-CHOOSE 67 12))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 12.0d0 6.927791673660977d-14) + (MULTIPLE-VALUE-LIST (POCHAMMER 3.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 863.2319871924054d0 9.645972767118375d-13) + (MULTIPLE-VALUE-LIST (LOG-POCHAMMER 2.0d0 199.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 863.2319871924054d0 1.0d0 9.645972767118375d-13) + (MULTIPLE-VALUE-LIST + (LOG-POCHAMMER-SIGN 2.0d0 199.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 403199.88888888917d0 3.5998302729212807d-9) + (MULTIPLE-VALUE-LIST (RELATIVE-POCHAMMER 2.0d0 9.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.40600584970983766d0 9.568405127077496d-16) + (MULTIPLE-VALUE-LIST (INCOMPLETE-GAMMA 2.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5939941502901611d0 3.510166705531295d-15) + (MULTIPLE-VALUE-LIST + (COMPLEMENTARY-INCOMPLETE-GAMMA 2.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.40600584970983766d0 1.2272947381959672d-15) + (MULTIPLE-VALUE-LIST + (NONNORMALIZED-INCOMPLETE-GAMMA 2.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.1818181818181818d0 1.0189782228738177d-15) + (MULTIPLE-VALUE-LIST (BETA 5.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -1.7047480922384253d0 3.81791013808375d-15) + (MULTIPLE-VALUE-LIST (LOG-BETA 5.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6464466094067263d0 1.0335671699557843d-14) + (MULTIPLE-VALUE-LIST + (INCOMPLETE-BETA 1.0d0 1.5d0 0.5d0)))) + diff --git a/tests/gaussian-bivariate.lisp b/tests/gaussian-bivariate.lisp new file mode 100644 index 0000000000000000000000000000000000000000..b4cb48b2239353f0ddff6032b1f8ee3bf5a8efd5 --- /dev/null +++ b/tests/gaussian-bivariate.lisp @@ -0,0 +1,24 @@ +;; Regression test GAUSSIAN-BIVARIATE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST GAUSSIAN-BIVARIATE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST -0.06509716124488897d0 -1.5733207749096374d0 + 0.27942740172325414d0 1.2021528358889673d0 + -0.6041530626907894d0 0.07582702719413444d0 + -0.5446229412165632d0 -0.6592026841613081d0 + -0.11029516610819164d0 0.17931840412143885d0 + 2.1025104980291696d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (BIVARIATE-GAUSSIAN RNG 1.0d0 0.75d0 + 0.25d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5548265557970462d0) + (MULTIPLE-VALUE-LIST + (BIVARIATE-GAUSSIAN-PDF 0.25d0 0.5d0 0.25d0 0.4d0 + 0.2d0)))) + diff --git a/tests/gaussian-tail.lisp b/tests/gaussian-tail.lisp new file mode 100644 index 0000000000000000000000000000000000000000..b58435ca0edf9027f57d6d44baf0ea19d3a91fd6 --- /dev/null +++ b/tests/gaussian-tail.lisp @@ -0,0 +1,37 @@ +;; Regression test GAUSSIAN-TAIL for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST GAUSSIAN-TAIL + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 50.10837030381376d0 51.42695945309931d0 + 50.587160269982604d0 50.59875222444504d0 + 50.82830572864337d0 50.43343112125345d0 + 53.442286287287374d0 51.83761714183811d0 + 53.00107421429086d0 52.149774169929884d0 + 50.11572443504253d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (GAUSSIAN-TAIL RNG 50.0d0 10.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.18702270877331703d0) + (MULTIPLE-VALUE-LIST + (GAUSSIAN-TAIL-PDF 52.0d0 50.0d0 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 5.010837030381376d0 5.142695945309931d0 + 5.05871602699826d0 5.0598752224445045d0 + 5.082830572864337d0 5.043343112125345d0 + 5.344228628728738d0 5.183761714183811d0 + 5.300107421429086d0 5.214977416992989d0 + 5.011572443504253d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (UGAUSSIAN-TAIL RNG 5.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.8702270877331704d0) + (MULTIPLE-VALUE-LIST (UGAUSSIAN-TAIL-PDF 5.2d0 5.0d0)))) + diff --git a/tests/gaussian.lisp b/tests/gaussian.lisp new file mode 100644 index 0000000000000000000000000000000000000000..bd38467ccdf9dc1d63a0e12b556ffc58a80d834c --- /dev/null +++ b/tests/gaussian.lisp @@ -0,0 +1,47 @@ +;; Regression test GAUSSIAN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST GAUSSIAN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 1.3391860811867589d0 -0.8810099183143839d0 + 16.744084062537738d0 7.336411072925795d0 + 9.975246316020124d0 -12.775020810027664d0 + -23.967152827332075d0 -6.79280164729211d0 + -0.3909131843358723d0 8.935555455208181d0 + -0.17647794589783283d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (GAUSSIAN RNG 10.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.039894228040143274d0) + (MULTIPLE-VALUE-LIST (GAUSSIAN-PDF 0.0d0 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 7.648734260124924d0 -11.307312946196086d0 + 4.523361654215173d0 -4.5181725947577185d0 + 13.64676540828912d0 3.553650119391929d0 + -5.567035948404032d0 10.097727863788887d0 + 2.519120940798607d0 -9.024585521868676d0 + -9.463283369593537d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (GAUSSIAN-ZIGGURAT RNG 10.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.9772498680518208d0) + (MULTIPLE-VALUE-LIST (UGAUSSIAN-P 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.022750131948179212d0) + (MULTIPLE-VALUE-LIST (UGAUSSIAN-Q 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2.0d0) + (MULTIPLE-VALUE-LIST + (UGAUSSIAN-PINV + 0.9772498680518208d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2.0d0) + (MULTIPLE-VALUE-LIST + (UGAUSSIAN-QINV + 0.02275013194817921d0)))) + diff --git a/tests/gegenbauer.lisp b/tests/gegenbauer.lisp new file mode 100644 index 0000000000000000000000000000000000000000..8668be4fb03c5ed000c03d3f525d7c536d8164e2 --- /dev/null +++ b/tests/gegenbauer.lisp @@ -0,0 +1,24 @@ +;; Regression test GEGENBAUER for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST GEGENBAUER + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6.0d0 5.329070518200751d-15) + (MULTIPLE-VALUE-LIST (GEGENBAUER-1 1.0d0 3.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 35.0d0 1.5765166949677223d-14) + (MULTIPLE-VALUE-LIST (GEGENBAUER-2 1.0d0 3.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 204.0d0 9.126033262418787d-14) + (MULTIPLE-VALUE-LIST (GEGENBAUER-3 1.0d0 3.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1189.0d0 1.056044141023449d-12) + (MULTIPLE-VALUE-LIST (GEGENBAUER 4 1.0d0 3.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(1.0d0 6.0d0 35.0d0 204.0d0)) + (MULTIPLE-VALUE-LIST + (LETM ((ARR (VECTOR-DOUBLE-FLOAT 4))) + (GEGENBAUER-ARRAY 1.0d0 3.0d0 ARR) + (CL-ARRAY ARR))))) + diff --git a/tests/geometric.lisp b/tests/geometric.lisp new file mode 100644 index 0000000000000000000000000000000000000000..6e7829a85355bd64e609684d025a2dc699cf64a1 --- /dev/null +++ b/tests/geometric.lisp @@ -0,0 +1,24 @@ +;; Regression test GEOMETRIC for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST GEOMETRIC + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST 1 4 3 1 3 2 1 1 2 1 1)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (GEOMETRIC RNG 0.4d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.24d0) + (MULTIPLE-VALUE-LIST + (GEOMETRIC-PDF 2 + 0.4d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.64d0) + (MULTIPLE-VALUE-LIST + (GEOMETRIC-P 2 + 0.4d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.36d0) + (MULTIPLE-VALUE-LIST + (GEOMETRIC-Q 2 + 0.4d0)))) + diff --git a/tests/givens.lisp b/tests/givens.lisp new file mode 100644 index 0000000000000000000000000000000000000000..4c2922976f6097744126cdfd5053d67eab35f016 --- /dev/null +++ b/tests/givens.lisp @@ -0,0 +1,68 @@ +;; Regression test GIVENS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST GIVENS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST + #(-47.39726 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + #(-0.6856937 42.73 -17.24 43.31 -16.12 -8.25 21.44 + -49.08))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL)) + (V2 + (VECTOR-SINGLE-FLOAT + (A 32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 + -49.08) + NIL)) + (ANGLES + (VECTOR-SINGLE-FLOAT + (A -39.66 -49.46 19.68 -5.55 -8.82 25.37 -30.58 + 31.67) + NIL)) + (SINES (VECTOR-SINGLE-FLOAT '8 NIL)) + (COSINES (VECTOR-SINGLE-FLOAT '8 NIL))) + (LOOP FOR I BELOW 8 DO + (SETF (MAREF SINES I) (SIN (MAREF ANGLES I))) + (SETF (MAREF COSINES I) + (COS (MAREF ANGLES I)))) + (GIVENS-ROTATION V1 V2 COSINES SINES) + (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST + #(-47.39725730461627d0 8.24d0 3.29d0 -8.93d0 34.12d0 + -6.15d0 49.27d0 -13.49d0) + #(-0.6856936845760199d0 42.73d0 -17.24d0 43.31d0 + -16.12d0 -8.25d0 21.44d0 -49.08d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL)) + (V2 + (VECTOR-DOUBLE-FLOAT + (A 32.5d0 42.73d0 -17.24d0 43.31d0 -16.12d0 + -8.25d0 21.44d0 -49.08d0) + NIL)) + (ANGLES + (VECTOR-DOUBLE-FLOAT + (A -39.66d0 -49.46d0 19.68d0 -5.55d0 -8.82d0 + 25.37d0 -30.58d0 31.67d0) + NIL)) + (SINES (VECTOR-DOUBLE-FLOAT '8 NIL)) + (COSINES (VECTOR-DOUBLE-FLOAT '8 NIL))) + (LOOP FOR I BELOW 8 DO + (SETF (MAREF SINES I) (SIN (MAREF ANGLES I))) + (SETF (MAREF COSINES I) + (COS (MAREF ANGLES I)))) + (GIVENS-ROTATION V1 V2 COSINES SINES) + (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))) + diff --git a/tests/gumbel1.lisp b/tests/gumbel1.lisp new file mode 100644 index 0000000000000000000000000000000000000000..c519845ee74a187f3dfc519daecc2c04dc6b9f08 --- /dev/null +++ b/tests/gumbel1.lisp @@ -0,0 +1,35 @@ +;; Regression test GUMBEL1 for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST GUMBEL1 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 8.954596257487015d0 0.0973051899750762d0 + 0.45913506233088003d0 3.6074124224293223d0 + 0.31300027468174807d0 1.0165796949651174d0 + 3.8292081936610396d0 1.912897393181305d0 + 1.17748457894919d0 1.893232107970416d0 + 1.9859118616847695d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (GUMBEL1 RNG 1.0d0 2.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.29625708964974956d0) + (MULTIPLE-VALUE-LIST (GUMBEL1-PDF 0.1d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.1637073598773166d0) + (MULTIPLE-VALUE-LIST (GUMBEL1-P 0.1d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.8362926401226833d0) + (MULTIPLE-VALUE-LIST (GUMBEL1-Q 0.1d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.10000000000000007d0) + (MULTIPLE-VALUE-LIST + (GUMBEL1-PINV 0.1637073598773166d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.10000000000000028d0) + (MULTIPLE-VALUE-LIST + (GUMBEL1-QINV 0.8362926401226833d0 1.0d0 2.0d0)))) + diff --git a/tests/gumbel2.lisp b/tests/gumbel2.lisp new file mode 100644 index 0000000000000000000000000000000000000000..0c966fe4abbed64d46d6585af34891920540217d --- /dev/null +++ b/tests/gumbel2.lisp @@ -0,0 +1,36 @@ +;; Regression test GUMBEL2 for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST GUMBEL2 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 7743.400858519516d0 1.102196701680339d0 + 1.5827044520998628d0 36.87052393317972d0 + 1.3675219066608615d0 2.7637257945633085d0 + 46.026080060263446d0 6.772683525074477d0 + 3.2461983686562204d0 6.640797807286079d0 + 7.285687897019733d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (GUMBEL2 RNG 1.0d0 2.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.053625603682851145d0) + (MULTIPLE-VALUE-LIST (GUMBEL2-PDF 5.0d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.8187307530779818d0) + (MULTIPLE-VALUE-LIST (GUMBEL2-P 10.0d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.18126924692201815d0) + (MULTIPLE-VALUE-LIST (GUMBEL2-Q 10.0d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 9.999999999999998d0) + (MULTIPLE-VALUE-LIST + (GUMBEL2-PINV 0.8187307530779818d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 10.0d0) + (MULTIPLE-VALUE-LIST + (GUMBEL2-QINV + 0.18126924692201815d0 + 1.0d0 2.0d0)))) + diff --git a/tests/higher-moments.lisp b/tests/higher-moments.lisp new file mode 100644 index 0000000000000000000000000000000000000000..5c52ffe2ce5dfbdbf380c1280bfd912a151a45bc --- /dev/null +++ b/tests/higher-moments.lisp @@ -0,0 +1,18 @@ +;; Regression test HIGHER-MOMENTS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST HIGHER-MOMENTS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.2765118983985497d0 0.2765118983985497d0 + -2.333333333333333d0 -2.333333333333333d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((VEC + (VECTOR-DOUBLE-FLOAT (A -3.21d0 1.0d0 12.8d0)))) + (LET* ((MEAN (MEAN VEC)) + (SD (STANDARD-DEVIATION VEC MEAN))) + (LIST (SKEWNESS VEC) (SKEWNESS VEC MEAN SD) + (KURTOSIS VEC) (KURTOSIS VEC MEAN SD))))))) + diff --git a/tests/histogram.lisp b/tests/histogram.lisp new file mode 100644 index 0000000000000000000000000000000000000000..26a91f63bfaf002bf821ce4956769a8248b8feb6 --- /dev/null +++ b/tests/histogram.lisp @@ -0,0 +1,109 @@ +;; Regression test HISTOGRAM for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST HISTOGRAM + (LISP-UNIT:ASSERT-ERROR 'input-domain + (LETM ((HISTO (HISTOGRAM 10))) + (SET-RANGES-UNIFORM HISTO + 0.0d0 + 10.0d0) + (INCREMENT HISTO -2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((HISTO + (HISTOGRAM 10))) + (SET-RANGES-UNIFORM + HISTO 0.0d0 + 10.0d0) + (INCREMENT HISTO + 2.7d0) + (INCREMENT HISTO + 6.9d0 + 2.0d0) + (MAREF HISTO 1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((HISTO + (HISTOGRAM 10))) + (SET-RANGES-UNIFORM + HISTO 0.0d0 + 10.0d0) + (INCREMENT HISTO + 2.7d0) + (INCREMENT HISTO + 6.9d0 + 2.0d0) + (MAREF HISTO 2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((HISTO + (HISTOGRAM 10))) + (SET-RANGES-UNIFORM + HISTO 0.0d0 + 10.0d0) + (INCREMENT HISTO + 2.7d0) + (INCREMENT HISTO + 6.9d0 + 2.0d0) + (MAREF HISTO 6)))) + (LISP-UNIT:ASSERT-ERROR 'input-domain + (LETM ((HISTO (HISTOGRAM 10))) + (SET-RANGES-UNIFORM HISTO + 0.0d0 + 10.0d0) + (INCREMENT HISTO 2.7d0) + (INCREMENT HISTO 6.9d0 + 2.0d0) + (MAREF HISTO 16))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.0d0 10.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((HISTO + (HISTOGRAM 10))) + (SET-RANGES-UNIFORM + HISTO 0.0d0 + 10.0d0) + (INCREMENT HISTO + 2.7d0) + (INCREMENT HISTO + 6.9d0 + 2.0d0) + (VALUES + (MIN-RANGE HISTO) + (MAX-RANGE + HISTO))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 10) + (MULTIPLE-VALUE-LIST + (LETM + ((HISTO + (HISTOGRAM 10))) + (SET-RANGES-UNIFORM + HISTO 0.0d0 + 10.0d0) + (INCREMENT HISTO + 2.7d0) + (INCREMENT HISTO + 6.9d0 + 2.0d0) + (BINS HISTO)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5) + (MULTIPLE-VALUE-LIST + (LETM + ((HISTO + (HISTOGRAM 10))) + (SET-RANGES-UNIFORM + HISTO 0.0d0 + 10.0d0) + (INCREMENT HISTO + 2.7d0) + (INCREMENT HISTO + 6.9d0 + 2.0d0) + (HISTOGRAM-FIND + HISTO 5.5d0))))) + diff --git a/tests/hypergeometric-randist.lisp b/tests/hypergeometric-randist.lisp new file mode 100644 index 0000000000000000000000000000000000000000..303dea0e5c8d48f40345d3215a8ee83f38e1928b --- /dev/null +++ b/tests/hypergeometric-randist.lisp @@ -0,0 +1,21 @@ +;; Regression test HYPERGEOMETRIC-RANDIST for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST HYPERGEOMETRIC-RANDIST + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST 2 1 0 0 1 1 3 1 0 1 3)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (HYPERGEOMETRIC RNG 3 6 3))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.35714285714285693d0) + (MULTIPLE-VALUE-LIST (HYPERGEOMETRIC-PDF 0 2 6 3))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.892857142857143d0) + (MULTIPLE-VALUE-LIST (HYPERGEOMETRIC-P 1 2 6 3))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.10714285714285704d0) + (MULTIPLE-VALUE-LIST (HYPERGEOMETRIC-Q 1 2 6 3)))) + diff --git a/tests/hypergeometric.lisp b/tests/hypergeometric.lisp new file mode 100644 index 0000000000000000000000000000000000000000..3e657238c59d60d50ed6c255cc933abf76bc53be --- /dev/null +++ b/tests/hypergeometric.lisp @@ -0,0 +1,52 @@ +;; Regression test HYPERGEOMETRIC for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST HYPERGEOMETRIC + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3.7621956910836287d0 9.207469176703522d-14) + (MULTIPLE-VALUE-LIST (HYPERGEOMETRIC-0F1 0.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 5.43656365691809d0 6.0357981467508045d-15) + (MULTIPLE-VALUE-LIST (HYPERGEOMETRIC-1F1 2 1 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 5.43656365691809d0 6.0357981467508045d-15) + (MULTIPLE-VALUE-LIST + (HYPERGEOMETRIC-1F1 2.0d0 1.0d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.19269472464638984d0 2.5468520714552053d-12) + (MULTIPLE-VALUE-LIST + (HYPERGEOMETRIC-U 2.0d0 1.0d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.19269472464638984d0 2.5468520714552053d-12) + (MULTIPLE-VALUE-LIST (HYPERGEOMETRIC-U 2 1 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.19269472464638984d0 0 2.5468520714552053d-12) + (MULTIPLE-VALUE-LIST + (HYPERGEOMETRIC-U-E10 2.0d0 1.0d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.19269472464638984d0 0 2.5468520714552053d-12) + (MULTIPLE-VALUE-LIST (HYPERGEOMETRIC-U-E10 2 1 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.29739670999407d0 2.0404981793068d-15) + (MULTIPLE-VALUE-LIST + (HYPERGEOMETRIC-2F1 1.0d0 1.2d0 1.0d0 0.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6.629594934547447d0 5.761143589129193d-14) + (MULTIPLE-VALUE-LIST + (HYPERGEOMETRIC-2F1-CONJ #C(1.0d0 0.5d0) 0.5d0 + 0.6d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3.7403484052126372d0 5.884558632199498d-14) + (MULTIPLE-VALUE-LIST + (HYPERGEOMETRIC-2F1-CONJ-RENORM #C(1.0d0 0.5d0) 0.5d0 + 0.6d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.29739670999407d0 3.0607472689602005d-15) + (MULTIPLE-VALUE-LIST + (HYPERGEOMETRIC-2F1-RENORM 1.0d0 1.2d0 1.0d0 0.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.043513924125598485d0 3.81571654717325d-15) + (MULTIPLE-VALUE-LIST + (HYPERGEOMETRIC-2F0 1.0d0 2.0d0 -20.0d0)))) + diff --git a/tests/index-max.lisp b/tests/index-max.lisp new file mode 100644 index 0000000000000000000000000000000000000000..5429633c4abeb2733d889f6deaadd28b570b37ec --- /dev/null +++ b/tests/index-max.lisp @@ -0,0 +1,68 @@ +;; Regression test INDEX-MAX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST INDEX-MAX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 + 3.29 -8.93 + 34.12 -6.15 + 49.27 -13.49) + NIL))) + (INDEX-MAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 + 8.24d0 3.29d0 + -8.93d0 + 34.12d0 + -6.15d0 + 49.27d0 + -13.49d0) + NIL))) + (INDEX-MAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 4) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 + 3.29 -8.93 + 34.12 -6.15 + 49.27 -13.49 + 32.5 42.73 + -17.24 43.31 + -16.12 -8.25 + 21.44 -49.08) + NIL))) + (INDEX-MAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 4) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 + 8.24d0 3.29d0 + -8.93d0 + 34.12d0 + -6.15d0 + 49.27d0 + -13.49d0 + 32.5d0 + 42.73d0 + -17.24d0 + 43.31d0 + -16.12d0 + -8.25d0 + 21.44d0 + -49.08d0) + NIL))) + (INDEX-MAX V1))))) + diff --git a/tests/inverse-matrix-product.lisp b/tests/inverse-matrix-product.lisp new file mode 100644 index 0000000000000000000000000000000000000000..e653da12872a06a5ecb078a6cf71494f732dbde9 --- /dev/null +++ b/tests/inverse-matrix-product.lisp @@ -0,0 +1,171 @@ +;; Regression test INVERSE-MATRIX-PRODUCT for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST INVERSE-MATRIX-PRODUCT + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-30.708971 5.3737082 -25.897392) + (-14.654706 -9.08723 6.96797) + (-29.71983 -24.015656 -29.949932))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 + (MATRIX-SINGLE-FLOAT + (A (42.73 -17.24 43.31) (-16.12 -8.25 21.44) + (-49.08 -39.66 -49.46)) + NIL)) + (S1 19.68)) + (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-30.708968222785604d0 5.373707833953741d0 + -25.89739157520614d0) + (-14.654705167282895d0 -9.087229795292632d0 + 6.967969411128146d0) + (-29.71982769230769d0 -24.015655384615382d0 + -29.949932307692308d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 + (MATRIX-DOUBLE-FLOAT + (A (42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0)) + NIL)) + (S1 19.68d0)) + (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 M2 S1))))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A + (-34.5 8.24 3.29 -8.93 + 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 + -13.49 32.5) + (49.27 -13.49 32.5 42.73 + -17.24 43.31)) + NIL)) + (M2 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A + (42.73 -17.24 43.31 -16.12 + -8.25 21.44) + (-16.12 -8.25 21.44 -49.08 + -39.66 -49.46) + (-49.08 -39.66 -49.46 19.68 + -5.55 -8.82)) + NIL)) + (S1 #C(19.68 -5.55))) + (CL-ARRAY + (INVERSE-MATRIX-PRODUCT M1 M2 + S1)))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A + (-34.5d0 8.24d0 3.29d0 + -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0) + (49.27d0 -13.49d0 32.5d0 + 42.73d0 -17.24d0 43.31d0)) + NIL)) + (M2 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A + (42.73d0 -17.24d0 43.31d0 + -16.12d0 -8.25d0 21.44d0) + (-16.12d0 -8.25d0 21.44d0 + -49.08d0 -39.66d0 + -49.46d0) + (-49.08d0 -39.66d0 -49.46d0 + 19.68d0 -5.55d0 -8.82d0)) + NIL)) + (S1 #C(19.68d0 -5.55d0))) + (CL-ARRAY + (INVERSE-MATRIX-PRODUCT M1 M2 + S1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-1.1747805 -0.26507667 1.3326154)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (V1 + (VECTOR-SINGLE-FLOAT (A 42.73 -17.24 43.31) NIL)) + (S1 -16.12)) + (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-1.1747804927980594d0 -0.26507665253855167d0 + 1.3326153846153848d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (V1 + (VECTOR-DOUBLE-FLOAT (A 42.73d0 -17.24d0 43.31d0) + NIL)) + (S1 -16.12d0)) + (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(-1.1218005 0.24990065) #C(-0.7679142 -0.9143634) + #C(0.4927793 -0.0056687724))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL)) + (V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A 42.73 -17.24 43.31 -16.12 -8.25 21.44) NIL)) + (S1 #C(-16.12 -8.25))) + (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(-1.1218005239477833d0 0.2499006037347623d0) + #C(-0.7679142088967384d0 -0.9143634017568469d0) + #C(0.49277927293827817d0 -0.005668775466541512d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL)) + (V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A 42.73d0 -17.24d0 43.31d0 -16.12d0 -8.25d0 + 21.44d0) + NIL)) + (S1 #C(-16.12d0 -8.25d0))) + (CL-ARRAY (INVERSE-MATRIX-PRODUCT M1 V1 S1)))))) + diff --git a/tests/laguerre.lisp b/tests/laguerre.lisp new file mode 100644 index 0000000000000000000000000000000000000000..af05113b50fb6e93eb5f45b43be5c672b8be5c8d --- /dev/null +++ b/tests/laguerre.lisp @@ -0,0 +1,18 @@ +;; Regression test LAGUERRE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST LAGUERRE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -1.0d0 2.220446049250313d-15) + (MULTIPLE-VALUE-LIST (LAGUERRE-1 1.0d0 3.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -1.5d0 1.7985612998927536d-14) + (MULTIPLE-VALUE-LIST (LAGUERRE-2 1.0d0 3.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.5d0 6.59472476627343d-14) + (MULTIPLE-VALUE-LIST (LAGUERRE-3 1.0d0 3.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.875d0 6.793349802129357d-14) + (MULTIPLE-VALUE-LIST (LAGUERRE 4 1.0d0 3.0d0)))) + diff --git a/tests/lambert.lisp b/tests/lambert.lisp new file mode 100644 index 0000000000000000000000000000000000000000..305c33a927645929f414f635f85f816062cfc952 --- /dev/null +++ b/tests/lambert.lisp @@ -0,0 +1,12 @@ +;; Regression test LAMBERT for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST LAMBERT + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5671432904097838d0 2.518622157098455d-15) + (MULTIPLE-VALUE-LIST (LAMBERT-W0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5671432904097838d0 2.518622157098455d-15) + (MULTIPLE-VALUE-LIST (LAMBERT-WM1 1.0d0)))) + diff --git a/tests/landau.lisp b/tests/landau.lisp new file mode 100644 index 0000000000000000000000000000000000000000..175fba2f7c2cb9393565e6a2261d75518cce169a --- /dev/null +++ b/tests/landau.lisp @@ -0,0 +1,21 @@ +;; Regression test LANDAU for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST LANDAU + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 3880.037426254597d0 -0.6953200314545297d0 + -0.02354364646600932d0 21.329209630030316d0 + -0.3062224704714883d0 1.2424186669362394d0 + 26.146168479649152d0 4.337217640968217d0 + 1.6799546281085946d0 4.2475719218268395d0 + 4.681506208977819d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (LANDAU RNG))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.17331968995860203d0) + (MULTIPLE-VALUE-LIST (LANDAU-PDF 0.25d0)))) + diff --git a/tests/laplace.lisp b/tests/laplace.lisp new file mode 100644 index 0000000000000000000000000000000000000000..5643b670eee22711e99340c8f6ebb0f2ab318c10 --- /dev/null +++ b/tests/laplace.lisp @@ -0,0 +1,38 @@ +;; Regression test LAPLACE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST LAPLACE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.005166356198580803d0 -3.942577717493807d0 + -8.329510281601332d0 1.1159975704649974d0 + -6.2234038148786555d0 -35.04800398421181d0 + 0.8888158320028845d0 7.161892491969776d0 + 25.24637780914261d0 7.341651048064451d0 + 6.54142651602034d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (LAPLACE RNG 10.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.05d0) + (MULTIPLE-VALUE-LIST + (LAPLACE-PDF 0.0d0 + 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6967346701436833d0) + (MULTIPLE-VALUE-LIST (LAPLACE-P 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.3032653298563167d0) + (MULTIPLE-VALUE-LIST (LAPLACE-Q 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.0d0) + (MULTIPLE-VALUE-LIST + (LAPLACE-PINV + 0.6967346701436833d0 + 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.0d0) + (MULTIPLE-VALUE-LIST + (LAPLACE-QINV + 0.3032653298563167d0 + 2.0d0)))) + diff --git a/tests/legendre.lisp b/tests/legendre.lisp new file mode 100644 index 0000000000000000000000000000000000000000..21430e457ac7adbe6b48c71d9a7fc47d95261545 --- /dev/null +++ b/tests/legendre.lisp @@ -0,0 +1,116 @@ +;; Regression test LEGENDRE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST LEGENDRE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.3d0 0.0d0) + (MULTIPLE-VALUE-LIST + (LEGENDRE-P1 + 0.3d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.365d0 2.8199664825478977d-16) + (MULTIPLE-VALUE-LIST (LEGENDRE-P2 0.3d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.38249999999999995d0 1.9984014443252816d-16) + (MULTIPLE-VALUE-LIST (LEGENDRE-P3 0.3d0))) + (LISP-UNIT:ASSERT-ERROR 'input-domain (LEGENDRE-PL -4 0.3d0)) + (LISP-UNIT:ASSERT-ERROR 'input-domain (LEGENDRE-PL 4 3.0d0)) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.07293749999999999d0 1.0167387765047662d-16) + (MULTIPLE-VALUE-LIST (LEGENDRE-PL 4 0.3d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(1.0d0 0.5d0 -0.125d0 -0.4375d0)) + (MULTIPLE-VALUE-LIST + (LETM ((ARR (VECTOR-DOUBLE-FLOAT 4))) + (LEGENDRE-PL-ARRAY 0.5d0 ARR) (CL-ARRAY ARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.3128529498822064d0 1.3893461931245028d-16) + (MULTIPLE-VALUE-LIST (LEGENDRE-Q0 3.3d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.03241473461128108d0 1.4395033881023292d-17) + (MULTIPLE-VALUE-LIST (LEGENDRE-Q1 3.3d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.004026461384737812d0 1.788108054840004d-18) + (MULTIPLE-VALUE-LIST (LEGENDRE-QL 2 3.3d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -34.099750274012266d0 3.0286662310541114d-14) + (MULTIPLE-VALUE-LIST (LEGENDRE-PLM 4 3 0.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(2.25d0 5.625d0 4.21875d0 -4.921875d0)) + (MULTIPLE-VALUE-LIST + (LETM ((ARR (VECTOR-DOUBLE-FLOAT 4))) + (LEGENDRE-PLM-ARRAY 2 0.5d0 ARR) + (CL-ARRAY ARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-3.0d0 3.75d0 33.75d0 55.78125d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((VAL (VECTOR-DOUBLE-FLOAT 4)) + (DERIV (VECTOR-DOUBLE-FLOAT 4))) + (LEGENDRE-PLM-DERIV-ARRAY 2 0.5d0 VAL DERIV) + (CL-ARRAY DERIV)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.30366280894310793d0 3.5267592419993454d-14) + (MULTIPLE-VALUE-LIST + (LEGENDRE-SPHPLM 1200 1100 0.3d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.24892463950030283d0 0.4127948151484927d0 + 0.35120655562190445d0 0.051599351893561574d0)) + (MULTIPLE-VALUE-LIST + (LETM ((ARR (VECTOR-DOUBLE-FLOAT 4))) + (LEGENDRE-SPHPLM-ARRAY 4 0.5d0 ARR) + (CL-ARRAY ARR)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-0.6637990386674741d0 -0.2751965434323283d0 + 1.2710332489173686d0 2.648766730536161d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((VAL (VECTOR-DOUBLE-FLOAT 4)) + (DERIV (VECTOR-DOUBLE-FLOAT 4))) + (LEGENDRE-SPHPLM-DERIV-ARRAY 4 0.5d0 VAL DERIV) + (CL-ARRAY DERIV)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.1255299048878925d0 1.3395992025650077d-15) + (MULTIPLE-VALUE-LIST + (LEGENDRE-CONICALP-HALF 3.5d0 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.06274336292793128d0 2.504525777730328d-16) + (MULTIPLE-VALUE-LIST + (LEGENDRE-CONICALP-MHALF 3.5d0 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.1316366189368757d0 3.0865532615549887d-15) + (MULTIPLE-VALUE-LIST + (LEGENDRE-CONICALP-0 3.5d0 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.1740719556007628d0 4.02431272707091d-15) + (MULTIPLE-VALUE-LIST + (LEGENDRE-CONICALP-1 3.5d0 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 8.980797952969897d-4 7.157154480497032d-17) + (MULTIPLE-VALUE-LIST + (LEGENDRE-REGULAR-SPHERICAL-CONICAL 3 3.5d0 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.0023060250619859808d0 2.7345630541297113d-16) + (MULTIPLE-VALUE-LIST + (LEGENDRE-REGULAR-CYLINDRICAL-CONICAL 3 3.5d0 + 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.9200342692589382d0 1.7018240558144874d-15) + (MULTIPLE-VALUE-LIST (LEGENDRE-H3D-0 1.0d0 0.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.2169402645039212d0 1.418962379417407d-15) + (MULTIPLE-VALUE-LIST (LEGENDRE-H3D-1 1.0d0 0.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.002400616238997978d0 4.3381136468045d-17) + (MULTIPLE-VALUE-LIST (LEGENDRE-H3D 4 1.0d0 0.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.9200342692589379d0 0.21694026450392115d0 + 0.04795066048830776d0 0.010663769096144337d0)) + (MULTIPLE-VALUE-LIST + (LETM ((ARR (VECTOR-DOUBLE-FLOAT 4))) + (LEGENDRE-H3D-ARRAY 1.0d0 0.5d0 ARR) + (CL-ARRAY ARR))))) + diff --git a/tests/levy.lisp b/tests/levy.lisp new file mode 100644 index 0000000000000000000000000000000000000000..4a98d1301d6f8584589f4014d9ad5db8d17fd08f --- /dev/null +++ b/tests/levy.lisp @@ -0,0 +1,30 @@ +;; Regression test LEVY for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST LEVY + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 2.6941098332360465d0 -0.29395438644676647d0 + -1.2703401352272083d0 1.0771538640113538d0 + 0.13771218406916103d0 0.9419728438107844d0 + -0.5107134674789159d0 0.1648207853689268d0 + -0.14857899041035147d0 -1.9074885744364487d0 + -2.086195213997167d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (LEVY RNG 1.0d0 2.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 2.6941098332360465d0 -0.2939543864467665d0 + -1.2703401352272083d0 1.0771538640113538d0 + 0.13771218406916097d0 0.9419728438107844d0 + -0.510713467478916d0 0.1648207853689266d0 + -0.14857899041035158d0 -1.907488574436449d0 + -2.086195213997167d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (LEVY-SKEW RNG 1.0d0 2.0d0 1.0d0)))))) + diff --git a/tests/logarithm.lisp b/tests/logarithm.lisp new file mode 100644 index 0000000000000000000000000000000000000000..173fcf057560254092b3f7f713c75f2d333d0012 --- /dev/null +++ b/tests/logarithm.lisp @@ -0,0 +1,22 @@ +;; Regression test LOGARITHM for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST LOGARITHM + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6931471805599453d0 3.078191837246648d-16) + (MULTIPLE-VALUE-LIST (GSL-LOG 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #C(0.34657359027997264d0 0.7853981633974483d0) + #C(1.539095918623324d-16 7.69547959311662d-17)) + (MULTIPLE-VALUE-LIST (GSL-LOG #C(1.0d0 1.0d0)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6931471805599453d0 3.078191837246648d-16) + (MULTIPLE-VALUE-LIST (LOG-ABS -2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 9.999500033330834d-5 2.2203350343487824d-20) + (MULTIPLE-VALUE-LIST (LOG-1+X 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -4.999666691664667d-9 1.1101490153075193d-24) + (MULTIPLE-VALUE-LIST (LOG-1+X-M1 1.d-4)))) + diff --git a/tests/logarithmic.lisp b/tests/logarithmic.lisp new file mode 100644 index 0000000000000000000000000000000000000000..144af4a3091d9cc13f394b935fa281bb36069379 --- /dev/null +++ b/tests/logarithmic.lisp @@ -0,0 +1,15 @@ +;; Regression test LOGARITHMIC for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST LOGARITHMIC + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST 1 3 1 4 1 1 2 1 1 5 2)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (LOGARITHMIC RNG 0.9d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.15660921511769743d0) + (MULTIPLE-VALUE-LIST (LOGARITHMIC-PDF 2 0.4d0)))) + diff --git a/tests/logistic.lisp b/tests/logistic.lisp new file mode 100644 index 0000000000000000000000000000000000000000..5552c52e098a4ed5bb248c55d618a09242282e61 --- /dev/null +++ b/tests/logistic.lisp @@ -0,0 +1,35 @@ +;; Regression test LOGISTIC for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST LOGISTIC + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 82.6131993192451d0 -16.367346042668906d0 + -9.31513272043762d0 28.87020708710654d0 + -11.989809875784625d0 -0.6012364762000397d0 + 31.142555263622d0 10.684673721048895d0 + 1.6051840954024446d0 10.457241904701199d0 + 11.523714106294097d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (LOGISTIC RNG 10.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.2350037122015945d0) + (MULTIPLE-VALUE-LIST (LOGISTIC-PDF 0.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6224593312018546d0) + (MULTIPLE-VALUE-LIST (LOGISTIC-P 0.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.37754066879814546d0) + (MULTIPLE-VALUE-LIST (LOGISTIC-Q 0.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5000000000000001d0) + (MULTIPLE-VALUE-LIST + (LOGISTIC-PINV 0.6224593312018546d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.4999999999999998d0) + (MULTIPLE-VALUE-LIST + (LOGISTIC-QINV 0.37754066879814546d0 1.0d0)))) + diff --git a/tests/lognormal.lisp b/tests/lognormal.lisp new file mode 100644 index 0000000000000000000000000000000000000000..ba975537920e578f1d72907df7992d5caafe7da4 --- /dev/null +++ b/tests/lognormal.lisp @@ -0,0 +1,37 @@ +;; Regression test LOGNORMAL for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST LOGNORMAL + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 2.386447068127768d0 0.11687602167359055d0 + 4.753374578796263d0 30.093393775755004d0 + 0.8119584375760986d0 3.163421055157545d0 + 0.9146206567715651d0 0.727307901065758d0 + 2.180184852178898d0 3.8908856616896017d0 + 182.18469788916977d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (LOGNORMAL RNG 1.0d0 2.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.15289833965691607d0) + (MULTIPLE-VALUE-LIST + (LOGNORMAL-PDF 1.2d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.3413288272347351d0) + (MULTIPLE-VALUE-LIST (LOGNORMAL-P 1.2d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6586711727652649d0) + (MULTIPLE-VALUE-LIST (LOGNORMAL-Q 1.2d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.2000000000000004d0) + (MULTIPLE-VALUE-LIST + (LOGNORMAL-PINV 0.3413288272347352d0 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.2d0) + (MULTIPLE-VALUE-LIST + (LOGNORMAL-QINV + 0.6586711727652649d0 + 1.0d0 2.0d0)))) + diff --git a/tests/lu.lisp b/tests/lu.lisp new file mode 100644 index 0000000000000000000000000000000000000000..afe9a0e398b86dad273b5c1f60bf0650e6d00265 --- /dev/null +++ b/tests/lu.lisp @@ -0,0 +1,14 @@ +;; Regression test LU for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST LU + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-1.9999999999999998d0 1.0d0) + (1.4999999999999998d0 -0.49999999999999994d0))) + (MULTIPLE-VALUE-LIST + (INVERT-MATRIX + (MAKE-ARRAY* '(2 2) 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(1.0d0 2.0d0 3.0d0 4.0d0)))))) + diff --git a/tests/mathematical.lisp b/tests/mathematical.lisp new file mode 100644 index 0000000000000000000000000000000000000000..c323600cc4508ecaa6c90ad889f02f9476670a74 --- /dev/null +++ b/tests/mathematical.lisp @@ -0,0 +1,15 @@ +;; Regression test MATHEMATICAL for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATHEMATICAL + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 9.995003330835331d-4) + (MULTIPLE-VALUE-LIST (LOG+1 0.001d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.0010005001667083417d0) + (MULTIPLE-VALUE-LIST (EXP-1 0.001d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 5.0d0 2.220446049250313d-15) + (MULTIPLE-VALUE-LIST (HYPOTENUSE 3.0d0 4.0d0)))) + diff --git a/tests/matrix-add-scalar.lisp b/tests/matrix-add-scalar.lisp new file mode 100644 index 0000000000000000000000000000000000000000..bddb0420bb441c599cff1cf775586847898e384a --- /dev/null +++ b/tests/matrix-add-scalar.lisp @@ -0,0 +1,98 @@ +;; Regression test MATRIX-ADD-SCALAR for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-ADD-SCALAR + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-16.31 26.43 21.48) + (9.259999 52.309998 12.04) + (67.46 4.7000003 50.69))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (CL-ARRAY (M+C M1 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-16.31d0 26.43d0 21.48d0) + (9.260000000000002d0 52.31d0 12.040000000000001d0) + (67.46000000000001d0 4.700000000000001d0 + 50.69d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (CL-ARRAY (M+C M1 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-45 -49 89) (-72 70 8) (91 13 -115))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (M+C M1 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((85 62 207) (134 181 158) (179 233 116))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (M+C M1 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-45 -49 89) (-72 70 8) (91 13 141))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (M+C M1 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((85 62 207) (134 181 158) (179 233 116))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (M+C M1 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-45 -49 89) (-72 70 8) (91 13 141))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (M+C M1 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((85 62 207) (134 181 158) (179 233 116))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (M+C M1 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-45 -49 89) (-72 70 8) (91 13 141))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (M+C M1 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((85 62 207) (134 181 158) (179 233 116))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (M+C M1 18.19d0)))))) + diff --git a/tests/matrix-copy.lisp b/tests/matrix-copy.lisp new file mode 100644 index 0000000000000000000000000000000000000000..f358734bd12379ba1212cbcf106b316a3186b11e --- /dev/null +++ b/tests/matrix-copy.lisp @@ -0,0 +1,143 @@ +;; Regression test MATRIX-COPY for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-COPY + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5 8.24 3.29) + (-8.93 34.12 -6.15) + (49.27 -13.49 32.5))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 (MATRIX-SINGLE-FLOAT '(3 3) NIL))) + (COPY M2 M1) (CL-ARRAY M2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 (MATRIX-DOUBLE-FLOAT '(3 3) NIL))) + (COPY M2 M1) (CL-ARRAY M2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)) + (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)) + (#C(49.27 -13.49) #C(32.5 42.73) + #C(-17.24 43.31)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL)) + (M2 (MATRIX-COMPLEX-SINGLE-FLOAT '(3 3) NIL))) + (COPY M2 M1) (CL-ARRAY M2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#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)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL)) + (M2 (MATRIX-COMPLEX-DOUBLE-FLOAT '(3 3) NIL))) + (COPY M2 M1) (CL-ARRAY M2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -68 71) (-91 52 -10) (73 -5 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-8 '(3 3) NIL))) + (COPY M2 M1) (CL-ARRAY M2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 44 189) (116 163 140) (161 215 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-8 '(3 3) NIL))) + (COPY M2 M1) (CL-ARRAY M2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -68 71) (-91 52 -10) (73 -5 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-16 '(3 3) NIL))) + (COPY M2 M1) (CL-ARRAY M2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 44 189) (116 163 140) (161 215 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-16 '(3 3) NIL))) + (COPY M2 M1) (CL-ARRAY M2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -68 71) (-91 52 -10) (73 -5 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-32 '(3 3) NIL))) + (COPY M2 M1) (CL-ARRAY M2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 44 189) (116 163 140) (161 215 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-32 '(3 3) NIL))) + (COPY M2 M1) (CL-ARRAY M2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -68 71) (-91 52 -10) (73 -5 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-64 '(3 3) NIL))) + (COPY M2 M1) (CL-ARRAY M2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 44 189) (116 163 140) (161 215 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-64 '(3 3) NIL))) + (COPY M2 M1) (CL-ARRAY M2))))) + diff --git a/tests/matrix-div.lisp b/tests/matrix-div.lisp new file mode 100644 index 0000000000000000000000000000000000000000..2aca552934e8ff8032ef592fc92b322da5233d07 --- /dev/null +++ b/tests/matrix-div.lisp @@ -0,0 +1,135 @@ +;; Regression test MATRIX-DIV for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-DIV + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-0.8073953 -0.47795823 0.075963974) + (0.5539702 -4.1357574 -0.28684703) + (-1.0038712 0.3401412 -0.6570967))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 + (MATRIX-SINGLE-FLOAT + (A (42.73 -17.24 43.31) (-16.12 -8.25 21.44) + (-49.08 -39.66 -49.46)) + NIL))) + (CL-ARRAY (M/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-0.8073952726421718d0 -0.4779582366589328d0 + 0.07596398060494113d0) + (0.553970223325062d0 -4.135757575757576d0 + -0.2868470149253731d0) + (-1.0038712306438469d0 0.3401412002017146d0 + -0.6570966437525273d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 + (MATRIX-DOUBLE-FLOAT + (A (42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0)) + NIL))) + (CL-ARRAY (M/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-8 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((2 4 9) (4 0 0) (4 1 0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-8 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-16 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((2 4 9) (4 0 0) (4 1 0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-16 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-32 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((2 4 9) (4 0 0) (4 1 0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-32 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-64 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((2 4 9) (4 0 0) (4 1 0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-64 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M/ M1 M2)))))) + diff --git a/tests/matrix-m+.lisp b/tests/matrix-m+.lisp new file mode 100644 index 0000000000000000000000000000000000000000..a961188a7b654ae904d88adfdb70362aeb5e3bc0 --- /dev/null +++ b/tests/matrix-m+.lisp @@ -0,0 +1,133 @@ +;; Regression test MATRIX-M+ for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-M+ + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((8.23 -9.0 46.600002) + (-25.050001 25.869999 15.290001) + (0.18999863 -53.15 -16.96))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 + (MATRIX-SINGLE-FLOAT + (A (42.73 -17.24 43.31) (-16.12 -8.25 21.44) + (-49.08 -39.66 -49.46)) + NIL))) + (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((8.229999999999997d0 -8.999999999999998d0 46.6d0) + (-25.05d0 25.869999999999997d0 + 15.290000000000001d0) + (0.19000000000000483d0 -53.15d0 -16.96d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 + (MATRIX-DOUBLE-FLOAT + (A (42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0)) + NIL))) + (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 -65))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-8 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((95 54 208) (144 85 101) (197 68 64))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-8 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-16 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((95 54 208) (144 341 357) (197 324 320))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-16 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-32 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((95 54 208) (144 341 357) (197 324 320))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-32 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-64 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((95 54 208) (144 341 357) (197 324 320))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-64 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M+ M1 M2)))))) + diff --git a/tests/matrix-m-.lisp b/tests/matrix-m-.lisp new file mode 100644 index 0000000000000000000000000000000000000000..3c7d37b779172e31c4b1cfb073edd87953555c5c --- /dev/null +++ b/tests/matrix-m-.lisp @@ -0,0 +1,142 @@ +;; Regression test MATRIX-M- for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-M- + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-77.229996 25.48 -40.02) + (7.1900005 42.37 -27.59) + (98.350006 26.17 81.96))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 + (MATRIX-SINGLE-FLOAT + (A (42.73 -17.24 43.31) (-16.12 -8.25 21.44) + (-49.08 -39.66 -49.46)) + NIL))) + (CL-ARRAY (M- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-77.22999999999999d0 25.479999999999997d0 + -40.02d0) + (7.190000000000001d0 42.37d0 + -27.590000000000003d0) + (98.35d0 26.169999999999995d0 + 81.96000000000001d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 + (MATRIX-DOUBLE-FLOAT + (A (42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0)) + NIL))) + (CL-ARRAY (M- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-8 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((39 34 170) (88 241 179) (125 106 132))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-8 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-16 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((39 34 170) (88 65521 65459) (125 106 65412))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-16 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-32 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((39 34 170) + (88 4294967281 4294967219) + (125 106 4294967172))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-32 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-64 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((39 34 170) + (88 18446744073709551601 18446744073709551539) + (125 106 18446744073709551492))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-64 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M- M1 M2)))))) + diff --git a/tests/matrix-max-index.lisp b/tests/matrix-max-index.lisp new file mode 100644 index 0000000000000000000000000000000000000000..5689531b37eca911dc36b63ecf5ba54938c59166 --- /dev/null +++ b/tests/matrix-max-index.lisp @@ -0,0 +1,116 @@ +;; Regression test MATRIX-MAX-INDEX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-MAX-INDEX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A + (-34.5 8.24 + 3.29) + (-8.93 34.12 + -6.15) + (49.27 -13.49 + 32.5)) + NIL))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A + (-34.5d0 8.24d0 + 3.29d0) + (-8.93d0 + 34.12d0 + -6.15d0) + (49.27d0 + -13.49d0 + 32.5d0)) + NIL))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MAX-INDEX M1))))) + diff --git a/tests/matrix-max.lisp b/tests/matrix-max.lisp new file mode 100644 index 0000000000000000000000000000000000000000..9ece26121c69d2493b7cf3bb6c0bb996377ad346 --- /dev/null +++ b/tests/matrix-max.lisp @@ -0,0 +1,116 @@ +;; Regression test MATRIX-MAX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-MAX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 49.27) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A + (-34.5 8.24 + 3.29) + (-8.93 34.12 + -6.15) + (49.27 -13.49 + 32.5)) + NIL))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 49.27d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A + (-34.5d0 8.24d0 + 3.29d0) + (-8.93d0 + 34.12d0 + -6.15d0) + (49.27d0 + -13.49d0 + 32.5d0)) + NIL))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MMAX M1))))) + diff --git a/tests/matrix-mean.lisp b/tests/matrix-mean.lisp new file mode 100644 index 0000000000000000000000000000000000000000..275b47e5cc268b5a01178298a7d20379272ec1c5 --- /dev/null +++ b/tests/matrix-mean.lisp @@ -0,0 +1,104 @@ +;; Regression test MATRIX-MEAN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-MEAN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 7.149999883439806d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7.15d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A + (-34.5d0 8.24d0 + 3.29d0) + (-8.93d0 + 34.12d0 + -6.15d0) + (49.27d0 + -13.49d0 + 32.5d0)) + NIL))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 132.55555555555554d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 132.55555555555554d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 132.55555555555554d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 132.55555555555554d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (MEAN M1))))) + diff --git a/tests/matrix-min-index.lisp b/tests/matrix-min-index.lisp new file mode 100644 index 0000000000000000000000000000000000000000..6a76aa38cb721421d2b92afa3c809b88c196e786 --- /dev/null +++ b/tests/matrix-min-index.lisp @@ -0,0 +1,116 @@ +;; Regression test MATRIX-MIN-INDEX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-MIN-INDEX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A + (-34.5 8.24 + 3.29) + (-8.93 34.12 + -6.15) + (49.27 -13.49 + 32.5)) + NIL))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A + (-34.5d0 8.24d0 + 3.29d0) + (-8.93d0 + 34.12d0 + -6.15d0) + (49.27d0 + -13.49d0 + 32.5d0)) + NIL))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MIN-INDEX M1))))) + diff --git a/tests/matrix-minmax-index.lisp b/tests/matrix-minmax-index.lisp new file mode 100644 index 0000000000000000000000000000000000000000..e173f213633ebb996e0d1b2a581e7952b41d88c4 --- /dev/null +++ b/tests/matrix-minmax-index.lisp @@ -0,0 +1,126 @@ +;; Regression test MATRIX-MINMAX-INDEX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-MINMAX-INDEX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0 2 0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A + (-34.5 8.24 + 3.29) + (-8.93 34.12 + -6.15) + (49.27 -13.49 + 32.5)) + NIL))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0 2 0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A + (-34.5d0 8.24d0 + 3.29d0) + (-8.93d0 + 34.12d0 + -6.15d0) + (49.27d0 + -13.49d0 + 32.5d0)) + NIL))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MINMAX-INDEX + M1))))) + diff --git a/tests/matrix-minmax.lisp b/tests/matrix-minmax.lisp new file mode 100644 index 0000000000000000000000000000000000000000..d78789667332cbd420447ed08792386808a222d5 --- /dev/null +++ b/tests/matrix-minmax.lisp @@ -0,0 +1,111 @@ +;; Regression test MATRIX-MINMAX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-MINMAX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5 49.27) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A + (-34.5 8.24 + 3.29) + (-8.93 34.12 + -6.15) + (49.27 -13.49 + 32.5)) + NIL))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -34.5d0 49.27d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL))) + (MINMAX M1))))) + diff --git a/tests/matrix-mult-scalar.lisp b/tests/matrix-mult-scalar.lisp new file mode 100644 index 0000000000000000000000000000000000000000..7d3a3e3125604d0015b8079abb1b09e329eb85db --- /dev/null +++ b/tests/matrix-mult-scalar.lisp @@ -0,0 +1,97 @@ +;; Regression test MATRIX-MULT-SCALAR for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-MULT-SCALAR + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-47.955 11.4536 4.5731) + (-12.412701 47.4268 -8.5485) + (68.4853 -18.7511 45.175))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (CL-ARRAY (M*C M1 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-47.955d0 11.4536d0 4.5731d0) + (-12.4127d0 47.42679999999999d0 -8.5485d0) + (68.4853d0 -18.751099999999997d0 45.175d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (CL-ARRAY (M*C M1 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-88 -94 98) (-126 72 -13) (101 -6 -86))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (M*C M1 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((93 61 6) (161 226 194) (223 42 136))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (M*C M1 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-88 -94 98) (-126 72 -13) (101 -6 170))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (M*C M1 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((93 61 262) (161 226 194) (223 298 136))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (M*C M1 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-88 -94 98) (-126 72 -13) (101 -6 170))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (M*C M1 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((93 61 262) (161 226 194) (223 298 136))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (M*C M1 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-88 -94 98) (-126 72 -13) (101 -6 170))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (M*C M1 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((93 61 262) (161 226 194) (223 298 136))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (M*C M1 1.39d0)))))) + diff --git a/tests/matrix-mult.lisp b/tests/matrix-mult.lisp new file mode 100644 index 0000000000000000000000000000000000000000..b02e8723aa0cf35d405f7ea876ac983e4586f98b --- /dev/null +++ b/tests/matrix-mult.lisp @@ -0,0 +1,151 @@ +;; Regression test MATRIX-MULT for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-MULT + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-1474.1849 -142.05759 142.4899) + (143.95161 -281.49 -131.856) + (-2418.1716 535.01337 -1607.45))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 + (MATRIX-SINGLE-FLOAT + (A (42.73 -17.24 43.31) (-16.12 -8.25 21.44) + (-49.08 -39.66 -49.46)) + NIL))) + (CL-ARRAY (M* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-1474.185d0 -142.05759999999998d0 142.4899d0) + (143.9516d0 -281.48999999999995d0 + -131.85600000000002d0) + (-2418.1716d0 535.0133999999999d0 -1607.45d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 + (MATRIX-DOUBLE-FLOAT + (A (42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0)) + NIL))) + (CL-ARRAY (M* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((0 -112 82) (-39 44 80) (-71 110 -84))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-8 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((84 184 7) (176 86 172) (164 139 252))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-8 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-2048 -1904 2130) + (-3367 -3796 80) + (-1095 110 8364))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-16 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((1876 440 3591) + (3248 29014 30380) + (5796 23435 21756))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-16 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-2048 -1904 2130) + (-3367 -3796 80) + (-1095 110 8364))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-32 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((1876 440 3591) + (3248 29014 30380) + (5796 23435 21756))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-32 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-2048 -1904 2130) + (-3367 -3796 80) + (-1095 110 8364))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-64 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (CL-ARRAY (M* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((1876 440 3591) + (3248 29014 30380) + (5796 23435 21756))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-64 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (CL-ARRAY (M* M1 M2)))))) + diff --git a/tests/matrix-product-hermitian.lisp b/tests/matrix-product-hermitian.lisp new file mode 100644 index 0000000000000000000000000000000000000000..589de90df0269ee63eefc0fbb30a375da0522b67 --- /dev/null +++ b/tests/matrix-product-hermitian.lisp @@ -0,0 +1,129 @@ +;; Regression test MATRIX-PRODUCT-HERMITIAN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT-HERMITIAN + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A + (-34.5 8.24 3.29 -8.93 + 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 + -13.49 32.5) + (49.27 -13.49 32.5 42.73 + -17.24 43.31)) + NIL)) + (M2 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A + (42.73 -17.24 43.31 -16.12 + -8.25 21.44) + (-16.12 -8.25 21.44 -49.08 + -39.66 -49.46) + (-49.08 -39.66 -49.46 19.68 + -5.55 -8.82)) + NIL)) + (ANSWER + (MATRIX-COMPLEX-SINGLE-FLOAT + '(3 3) NIL)) + (S1 #C(19.68 -5.55)) + (S2 #C(-5.55 -8.82))) + (CL-ARRAY + (MATRIX-PRODUCT-HERMITIAN M1 + M2 + ANSWER + S1 + S2)))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A + (-34.5d0 8.24d0 3.29d0 + -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0) + (49.27d0 -13.49d0 32.5d0 + 42.73d0 -17.24d0 43.31d0)) + NIL)) + (M2 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A + (42.73d0 -17.24d0 43.31d0 + -16.12d0 -8.25d0 21.44d0) + (-16.12d0 -8.25d0 21.44d0 + -49.08d0 -39.66d0 + -49.46d0) + (-49.08d0 -39.66d0 -49.46d0 + 19.68d0 -5.55d0 -8.82d0)) + NIL)) + (ANSWER + (MATRIX-COMPLEX-DOUBLE-FLOAT + '(3 3) NIL)) + (S1 #C(19.68d0 -5.55d0)) + (S2 #C(-5.55d0 -8.82d0))) + (CL-ARRAY + (MATRIX-PRODUCT-HERMITIAN M1 + M2 + ANSWER + S1 + S2)))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A + (-34.5 8.24 3.29 -8.93 + 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 + -13.49 32.5) + (49.27 -13.49 32.5 42.73 + -17.24 43.31)) + NIL)) + (V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A 42.73 -17.24 43.31 -16.12 + -8.25 21.44) + NIL)) + (ANSWER + (VECTOR-COMPLEX-SINGLE-FLOAT + '3 NIL)) + (S1 #C(-16.12 -8.25)) + (S2 #C(-8.25 21.44))) + (CL-ARRAY + (MATRIX-PRODUCT-HERMITIAN M1 + V1 + ANSWER + S1 + S2)))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A + (-34.5d0 8.24d0 3.29d0 + -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0) + (49.27d0 -13.49d0 32.5d0 + 42.73d0 -17.24d0 43.31d0)) + NIL)) + (V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A 42.73d0 -17.24d0 43.31d0 + -16.12d0 -8.25d0 21.44d0) + NIL)) + (ANSWER + (VECTOR-COMPLEX-DOUBLE-FLOAT + '3 NIL)) + (S1 #C(-16.12d0 -8.25d0)) + (S2 #C(-8.25d0 21.44d0))) + (CL-ARRAY + (MATRIX-PRODUCT-HERMITIAN M1 + V1 + ANSWER + S1 + S2))))) + diff --git a/tests/matrix-product-symmetric.lisp b/tests/matrix-product-symmetric.lisp new file mode 100644 index 0000000000000000000000000000000000000000..aab18866572b2ad108dd40f8ae947bba8579690b --- /dev/null +++ b/tests/matrix-product-symmetric.lisp @@ -0,0 +1,85 @@ +;; Regression test MATRIX-PRODUCT-SYMMETRIC for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT-SYMMETRIC + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34803.824 7799.5503 -29131.375) + (2045.2012 -3535.288 27406.096) + (-26673.887 -25484.264 -31425.34))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 + (MATRIX-SINGLE-FLOAT + (A (42.73 -17.24 43.31) (-16.12 -8.25 21.44) + (-49.08 -39.66 -49.46)) + NIL)) + (ANSWER (MATRIX-SINGLE-FLOAT '(3 3) NIL)) (S1 19.68) + (S2 -5.55)) + (CL-ARRAY + (MATRIX-PRODUCT-SYMMETRIC M1 M2 ANSWER S1 S2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34803.82416d0 7799.550048d0 -29131.375104d0) + (2045.2007039999999d0 -3535.2876479999995d0 + 27406.096416d0) + (-26673.884303999996d0 -25484.263728d0 + -31425.340848d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 + (MATRIX-DOUBLE-FLOAT + (A (42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0)) + NIL)) + (ANSWER (MATRIX-DOUBLE-FLOAT '(3 3) NIL)) + (S1 19.68d0) (S2 -5.55d0)) + (CL-ARRAY + (MATRIX-PRODUCT-SYMMETRIC M1 M2 ANSWER S1 S2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(23756.895 8100.1406 -26665.428)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (V1 + (VECTOR-SINGLE-FLOAT (A 42.73 -17.24 43.31) NIL)) + (ANSWER (VECTOR-SINGLE-FLOAT '3 NIL)) (S1 -16.12) + (S2 -8.25)) + (CL-ARRAY + (MATRIX-PRODUCT-SYMMETRIC M1 V1 ANSWER S1 S2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(23756.893524d0 8100.140412d0 -26665.425124000005d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (V1 + (VECTOR-DOUBLE-FLOAT (A 42.73d0 -17.24d0 43.31d0) + NIL)) + (ANSWER (VECTOR-DOUBLE-FLOAT '3 NIL)) (S1 -16.12d0) + (S2 -8.25d0)) + (CL-ARRAY + (MATRIX-PRODUCT-SYMMETRIC M1 V1 ANSWER S1 S2)))))) + diff --git a/tests/matrix-product-triangular.lisp b/tests/matrix-product-triangular.lisp new file mode 100644 index 0000000000000000000000000000000000000000..db41e7185a5568ed1276f61b020983199b70577d --- /dev/null +++ b/tests/matrix-product-triangular.lisp @@ -0,0 +1,171 @@ +;; Regression test MATRIX-PRODUCT-TRIANGULAR for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT-TRIANGULAR + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34803.82 7799.5503 -29131.375) + (-4884.0327 -739.594 20382.809) + (-31391.57 -25366.535 -31634.615))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 + (MATRIX-SINGLE-FLOAT + (A (42.73 -17.24 43.31) (-16.12 -8.25 21.44) + (-49.08 -39.66 -49.46)) + NIL)) + (S1 19.68)) + (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34803.82416d0 7799.550047999999d0 + -29131.375104000002d0) + (-4884.032832000001d0 -739.5940799999992d0 + 20382.808224d0) + (-31391.568d0 -25366.535999999996d0 + -31634.616d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 + (MATRIX-DOUBLE-FLOAT + (A (42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0)) + NIL)) + (S1 19.68d0)) + (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1))))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A + (-34.5 8.24 3.29 -8.93 + 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 + -13.49 32.5) + (49.27 -13.49 32.5 42.73 + -17.24 43.31)) + NIL)) + (M2 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A + (42.73 -17.24 43.31 -16.12 + -8.25 21.44) + (-16.12 -8.25 21.44 -49.08 + -39.66 -49.46) + (-49.08 -39.66 -49.46 19.68 + -5.55 -8.82)) + NIL)) + (S1 #C(19.68 -5.55))) + (CL-ARRAY + (MATRIX-PRODUCT-TRIANGULAR M1 + M2 + S1)))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A + (-34.5d0 8.24d0 3.29d0 + -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0) + (49.27d0 -13.49d0 32.5d0 + 42.73d0 -17.24d0 43.31d0)) + NIL)) + (M2 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A + (42.73d0 -17.24d0 43.31d0 + -16.12d0 -8.25d0 21.44d0) + (-16.12d0 -8.25d0 21.44d0 + -49.08d0 -39.66d0 + -49.46d0) + (-49.08d0 -39.66d0 -49.46d0 + 19.68d0 -5.55d0 -8.82d0)) + NIL)) + (S1 #C(19.68d0 -5.55d0))) + (CL-ARRAY + (MATRIX-PRODUCT-TRIANGULAR M1 + M2 + S1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-1473.7527 -854.58527 1407.5751)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (V1 + (VECTOR-SINGLE-FLOAT (A 42.73 -17.24 43.31) NIL)) + (S1 -16.12)) + (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-1473.7527d0 -854.5853d0 1407.575d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (V1 + (VECTOR-DOUBLE-FLOAT (A 42.73d0 -17.24d0 43.31d0) + NIL)) + (S1 -16.12d0)) + (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(-1483.223 1289.3523) #C(-57.63159 1675.6711) + #C(-786.3365 -726.9331))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL)) + (V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A 42.73 -17.24 43.31 -16.12 -8.25 21.44) NIL)) + (S1 #C(-16.12 -8.25))) + (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(-1483.2230999999997d0 1289.3523999999998d0) + #C(-57.63160000000005d0 1675.6711000000003d0) + #C(-786.3364000000001d0 -726.9331d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL)) + (V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A 42.73d0 -17.24d0 43.31d0 -16.12d0 -8.25d0 + 21.44d0) + NIL)) + (S1 #C(-16.12d0 -8.25d0))) + (CL-ARRAY (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1)))))) + diff --git a/tests/matrix-product.lisp b/tests/matrix-product.lisp new file mode 100644 index 0000000000000000000000000000000000000000..4b1b0ac1e8da7a8bb6530ba46f58df548f77f569 --- /dev/null +++ b/tests/matrix-product.lisp @@ -0,0 +1,194 @@ +;; Regression test MATRIX-PRODUCT for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34803.824 7799.55 -29131.377) + (-12393.505 2290.2053 12771.404) + (14320.465 -39892.78 4668.254))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 + (MATRIX-SINGLE-FLOAT + (A (42.73 -17.24 43.31) (-16.12 -8.25 21.44) + (-49.08 -39.66 -49.46)) + NIL)) + (ANSWER (MATRIX-SINGLE-FLOAT '(3 3) NIL)) (S1 19.68) + (S2 -5.55)) + (CL-ARRAY (MATRIX-PRODUCT M1 M2 ANSWER S1 S2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34803.824160000004d0 7799.550047999999d0 + -29131.375104000002d0) + (-12393.505583999999d0 2290.2048959999997d0 + 12771.40488d0) + (14320.464911999996d0 -39892.782864d0 + 4668.255407999997d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 + (MATRIX-DOUBLE-FLOAT + (A (42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0)) + NIL)) + (ANSWER (MATRIX-DOUBLE-FLOAT '(3 3) NIL)) + (S1 19.68d0) (S2 -5.55d0)) + (CL-ARRAY (MATRIX-PRODUCT M1 M2 ANSWER S1 S2))))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A + (-34.5 8.24 3.29 -8.93 + 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 + -13.49 32.5) + (49.27 -13.49 32.5 42.73 + -17.24 43.31)) + NIL)) + (M2 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A + (42.73 -17.24 43.31 -16.12 + -8.25 21.44) + (-16.12 -8.25 21.44 -49.08 + -39.66 -49.46) + (-49.08 -39.66 -49.46 19.68 + -5.55 -8.82)) + NIL)) + (ANSWER + (MATRIX-COMPLEX-SINGLE-FLOAT + '(3 3) NIL)) + (S1 #C(19.68 -5.55)) + (S2 #C(-5.55 -8.82))) + (CL-ARRAY + (MATRIX-PRODUCT M1 M2 ANSWER + S1 S2)))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A + (-34.5d0 8.24d0 3.29d0 + -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0) + (49.27d0 -13.49d0 32.5d0 + 42.73d0 -17.24d0 43.31d0)) + NIL)) + (M2 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A + (42.73d0 -17.24d0 43.31d0 + -16.12d0 -8.25d0 21.44d0) + (-16.12d0 -8.25d0 21.44d0 + -49.08d0 -39.66d0 + -49.46d0) + (-49.08d0 -39.66d0 -49.46d0 + 19.68d0 -5.55d0 -8.82d0)) + NIL)) + (ANSWER + (MATRIX-COMPLEX-DOUBLE-FLOAT + '(3 3) NIL)) + (S1 #C(19.68d0 -5.55d0)) + (S2 #C(-5.55d0 -8.82d0))) + (CL-ARRAY + (MATRIX-PRODUCT M1 M2 ANSWER + S1 S2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(23756.895 19926.967 -60376.652)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (V1 + (VECTOR-SINGLE-FLOAT (A 42.73 -17.24 43.31) NIL)) + (ANSWER (VECTOR-SINGLE-FLOAT '3 NIL)) (S1 -16.12) + (S2 -8.25)) + (CL-ARRAY (MATRIX-PRODUCT M1 V1 ANSWER S1 S2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(23756.893524000003d0 19926.966904d0 + -60376.649164d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (V1 + (VECTOR-DOUBLE-FLOAT (A 42.73d0 -17.24d0 43.31d0) + NIL)) + (ANSWER (VECTOR-DOUBLE-FLOAT '3 NIL)) (S1 -16.12d0) + (S2 -8.25d0)) + (CL-ARRAY (MATRIX-PRODUCT M1 V1 ANSWER S1 S2))))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A + (-34.5 8.24 3.29 -8.93 + 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 + -13.49 32.5) + (49.27 -13.49 32.5 42.73 + -17.24 43.31)) + NIL)) + (V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A 42.73 -17.24 43.31 -16.12 + -8.25 21.44) + NIL)) + (ANSWER + (VECTOR-COMPLEX-SINGLE-FLOAT + '3 NIL)) + (S1 #C(-16.12 -8.25)) + (S2 #C(-8.25 21.44))) + (CL-ARRAY + (MATRIX-PRODUCT M1 V1 ANSWER + S1 S2)))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A + (-34.5d0 8.24d0 3.29d0 + -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0) + (49.27d0 -13.49d0 32.5d0 + 42.73d0 -17.24d0 43.31d0)) + NIL)) + (V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A 42.73d0 -17.24d0 43.31d0 + -16.12d0 -8.25d0 21.44d0) + NIL)) + (ANSWER + (VECTOR-COMPLEX-DOUBLE-FLOAT + '3 NIL)) + (S1 #C(-16.12d0 -8.25d0)) + (S2 #C(-8.25d0 21.44d0))) + (CL-ARRAY + (MATRIX-PRODUCT M1 V1 ANSWER + S1 S2))))) + diff --git a/tests/matrix-set-all-m+.lisp b/tests/matrix-set-all-m+.lisp new file mode 100644 index 0000000000000000000000000000000000000000..5f12a5fda58743cd27e7d3ad45dbb5f04b864aef --- /dev/null +++ b/tests/matrix-set-all-m+.lisp @@ -0,0 +1,108 @@ +;; Regression test MATRIX-SET-ALL-M+ for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-SET-ALL-M+ + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((8.23 50.97 46.02) + (33.8 76.85 36.579998) + (92.0 29.24 75.229996))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 (MATRIX-SINGLE-FLOAT '(3 3) NIL)) + (M2 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (SET-ALL M1 42.73) (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((8.229999999999997d0 50.97d0 46.019999999999996d0) + (33.8d0 76.85d0 36.58d0) + (92.0d0 29.239999999999995d0 + 75.22999999999999d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 (MATRIX-DOUBLE-FLOAT '(3 3) NIL)) + (M2 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (SET-ALL M1 42.73d0) (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-32 -36 103) (-59 84 22) (105 27 -101))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 (MATRIX-SIGNED-BYTE-8 '(3 3) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (SET-ALL M1 32) (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((95 72 217) (144 191 168) (189 243 126))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 (MATRIX-UNSIGNED-BYTE-8 '(3 3) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (SET-ALL M1 28) (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-32 -36 103) (-59 84 22) (105 27 155))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 (MATRIX-SIGNED-BYTE-16 '(3 3) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (SET-ALL M1 32) (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((95 72 217) (144 191 168) (189 243 126))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 (MATRIX-UNSIGNED-BYTE-16 '(3 3) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (SET-ALL M1 28) (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-32 -36 103) (-59 84 22) (105 27 155))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 (MATRIX-SIGNED-BYTE-32 '(3 3) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (SET-ALL M1 32) (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((95 72 217) (144 191 168) (189 243 126))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 (MATRIX-UNSIGNED-BYTE-32 '(3 3) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (SET-ALL M1 28) (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-32 -36 103) (-59 84 22) (105 27 155))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 (MATRIX-SIGNED-BYTE-64 '(3 3) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (SET-ALL M1 32) (CL-ARRAY (M+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((95 72 217) (144 191 168) (189 243 126))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 (MATRIX-UNSIGNED-BYTE-64 '(3 3) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (SET-ALL M1 28) (CL-ARRAY (M+ M1 M2)))))) + diff --git a/tests/matrix-set-zero.lisp b/tests/matrix-set-zero.lisp new file mode 100644 index 0000000000000000000000000000000000000000..1409c4b4e65fece2ea35a633e23b8f82f09671d9 --- /dev/null +++ b/tests/matrix-set-zero.lisp @@ -0,0 +1,125 @@ +;; Regression test MATRIX-SET-ZERO for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-SET-ZERO + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((0.0 0.0 0.0) (0.0 0.0 0.0) (0.0 0.0 0.0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (SET-ZERO M1) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((0.0d0 0.0d0 0.0d0) + (0.0d0 0.0d0 0.0d0) + (0.0d0 0.0d0 0.0d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (SET-ZERO M1) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0)) + (#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0)) + (#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL))) + (SET-ZERO M1) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0)) + (#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0)) + (#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) + #C(0.0d0 0.0d0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL))) + (SET-ZERO M1) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((0 0 0) (0 0 0) (0 0 0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (SET-ZERO M1) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((0 0 0) (0 0 0) (0 0 0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (SET-ZERO M1) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((0 0 0) (0 0 0) (0 0 0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (SET-ZERO M1) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((0 0 0) (0 0 0) (0 0 0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (SET-ZERO M1) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((0 0 0) (0 0 0) (0 0 0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (SET-ZERO M1) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((0 0 0) (0 0 0) (0 0 0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (SET-ZERO M1) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((0 0 0) (0 0 0) (0 0 0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (SET-ZERO M1) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((0 0 0) (0 0 0) (0 0 0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (SET-ZERO M1) (CL-ARRAY M1))))) + diff --git a/tests/matrix-standard-deviation-with-fixed-mean.lisp b/tests/matrix-standard-deviation-with-fixed-mean.lisp new file mode 100644 index 0000000000000000000000000000000000000000..a98ccb261ced529770d2917a4c241f6f6bfd81c8 --- /dev/null +++ b/tests/matrix-standard-deviation-with-fixed-mean.lisp @@ -0,0 +1,91 @@ +;; Regression test MATRIX-STANDARD-DEVIATION-WITH-FIXED-MEAN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-STANDARD-DEVIATION-WITH-FIXED-MEAN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 25.290257201025927d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 25.290257236950186d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 70.39570693980959d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 53.10599696437538d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 70.39570693980959d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 53.10599696437538d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 70.39570693980959d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 53.10599696437538d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 70.39570693980959d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 53.10599696437538d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))) + diff --git a/tests/matrix-standard-deviation-with-mean.lisp b/tests/matrix-standard-deviation-with-mean.lisp new file mode 100644 index 0000000000000000000000000000000000000000..6de8134674bae18ecb07dc2b8daee3e7f5dd2d55 --- /dev/null +++ b/tests/matrix-standard-deviation-with-mean.lisp @@ -0,0 +1,91 @@ +;; Regression test MATRIX-STANDARD-DEVIATION-WITH-MEAN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-STANDARD-DEVIATION-WITH-MEAN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.824368547196023d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.82436858529945d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (STANDARD-DEVIATION M1 (MEAN M1)))))) + diff --git a/tests/matrix-standard-deviation.lisp b/tests/matrix-standard-deviation.lisp new file mode 100644 index 0000000000000000000000000000000000000000..407ca52fae62bc83756e4f81847729c9615e787f --- /dev/null +++ b/tests/matrix-standard-deviation.lisp @@ -0,0 +1,91 @@ +;; Regression test MATRIX-STANDARD-DEVIATION for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-STANDARD-DEVIATION + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.824368547196023d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.82436858529945d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (STANDARD-DEVIATION M1))))) + diff --git a/tests/matrix-swap.lisp b/tests/matrix-swap.lisp new file mode 100644 index 0000000000000000000000000000000000000000..2c504107e932ff765acc08bbeba83a5e9e0d7d93 --- /dev/null +++ b/tests/matrix-swap.lisp @@ -0,0 +1,220 @@ +;; Regression test MATRIX-SWAP for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-SWAP + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST + #2A((42.73 -17.24 43.31) + (-16.12 -8.25 21.44) + (-49.08 -39.66 -49.46)) + #2A((-34.5 8.24 3.29) + (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 + (MATRIX-SINGLE-FLOAT + (A (42.73 -17.24 43.31) (-16.12 -8.25 21.44) + (-49.08 -39.66 -49.46)) + NIL))) + (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST + #2A((42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0)) + #2A((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 + (MATRIX-DOUBLE-FLOAT + (A (42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0)) + NIL))) + (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST + #2A((#C(42.73 -17.24) #C(43.31 -16.12) + #C(-8.25 21.44)) + (#C(-16.12 -8.25) #C(21.44 -49.08) + #C(-39.66 -49.46)) + (#C(-49.08 -39.66) #C(-49.46 19.68) + #C(-5.55 -8.82))) + #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)) + (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)) + (#C(49.27 -13.49) #C(32.5 42.73) + #C(-17.24 43.31))))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL)) + (M2 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (42.73 -17.24 43.31 -16.12 -8.25 21.44) + (-16.12 -8.25 21.44 -49.08 -39.66 -49.46) + (-49.08 -39.66 -49.46 19.68 -5.55 -8.82)) + NIL))) + (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST + #2A((#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) + #C(-8.25d0 21.44d0)) + (#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) + #C(-39.66d0 -49.46d0)) + (#C(-49.08d0 -39.66d0) #C(-49.46d0 19.68d0) + #C(-5.55d0 -8.82d0))) + #2A((#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))))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL)) + (M2 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A + (42.73d0 -17.24d0 43.31d0 -16.12d0 -8.25d0 + 21.44d0) + (-16.12d0 -8.25d0 21.44d0 -49.08d0 -39.66d0 + -49.46d0) + (-49.08d0 -39.66d0 -49.46d0 19.68d0 -5.55d0 + -8.82d0)) + NIL))) + (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68)) + #2A((-64 -68 71) (-91 52 -10) (73 -5 123)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-8 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST #2A((28 10 19) (28 178 217) (36 109 222)) + #2A((67 44 189) (116 163 140) (161 215 98)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-8 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68)) + #2A((-64 -68 71) (-91 52 -10) (73 -5 123)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-16 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST #2A((28 10 19) (28 178 217) (36 109 222)) + #2A((67 44 189) (116 163 140) (161 215 98)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-16 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68)) + #2A((-64 -68 71) (-91 52 -10) (73 -5 123)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-32 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST #2A((28 10 19) (28 178 217) (36 109 222)) + #2A((67 44 189) (116 163 140) (161 215 98)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-32 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68)) + #2A((-64 -68 71) (-91 52 -10) (73 -5 123)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 + (MATRIX-SIGNED-BYTE-64 + (A (32 28 30) (37 -73 -8) (-15 -22 68)) NIL))) + (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST #2A((28 10 19) (28 178 217) (36 109 222)) + #2A((67 44 189) (116 163 140) (161 215 98)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 + (MATRIX-UNSIGNED-BYTE-64 + (A (28 10 19) (28 178 217) (36 109 222)) NIL))) + (SWAP M2 M1) (LIST (CL-ARRAY M1) (CL-ARRAY M2)))))) + diff --git a/tests/matrix-transpose-copy.lisp b/tests/matrix-transpose-copy.lisp new file mode 100644 index 0000000000000000000000000000000000000000..a997bb3a3764d01bc64692a0e50794a575b66793 --- /dev/null +++ b/tests/matrix-transpose-copy.lisp @@ -0,0 +1,143 @@ +;; Regression test MATRIX-TRANSPOSE-COPY for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-TRANSPOSE-COPY + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5 -8.93 49.27) + (8.24 34.12 -13.49) + (3.29 -6.15 32.5))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 (MATRIX-SINGLE-FLOAT '(3 3) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5d0 -8.93d0 49.27d0) + (8.24d0 34.12d0 -13.49d0) + (3.29d0 -6.15d0 32.5d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 (MATRIX-DOUBLE-FLOAT '(3 3) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(-34.5 8.24) #C(-8.93 34.12) #C(49.27 -13.49)) + (#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73)) + (#C(34.12 -6.15) #C(-13.49 32.5) + #C(-17.24 43.31)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL)) + (M2 (MATRIX-COMPLEX-SINGLE-FLOAT '(3 3) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(-34.5d0 8.24d0) #C(-8.93d0 34.12d0) + #C(49.27d0 -13.49d0)) + (#C(3.29d0 -8.93d0) #C(-6.15d0 49.27d0) + #C(32.5d0 42.73d0)) + (#C(34.12d0 -6.15d0) #C(-13.49d0 32.5d0) + #C(-17.24d0 43.31d0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL)) + (M2 (MATRIX-COMPLEX-DOUBLE-FLOAT '(3 3) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-8 '(3 3) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 116 161) (44 163 215) (189 140 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-8 '(3 3) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-16 '(3 3) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 116 161) (44 163 215) (189 140 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-16 '(3 3) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-32 '(3 3) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 116 161) (44 163 215) (189 140 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-32 '(3 3) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-64 '(3 3) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 116 161) (44 163 215) (189 140 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-64 '(3 3) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE-COPY M2 M1)))))) + diff --git a/tests/matrix-transpose.lisp b/tests/matrix-transpose.lisp new file mode 100644 index 0000000000000000000000000000000000000000..44ed19e4084110dacfd598b4da200dc5683ecf74 --- /dev/null +++ b/tests/matrix-transpose.lisp @@ -0,0 +1,131 @@ +;; Regression test MATRIX-TRANSPOSE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-TRANSPOSE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5 -8.93 49.27) + (8.24 34.12 -13.49) + (3.29 -6.15 32.5))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5d0 -8.93d0 49.27d0) + (8.24d0 34.12d0 -13.49d0) + (3.29d0 -6.15d0 32.5d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(-34.5 8.24) #C(-8.93 34.12) #C(49.27 -13.49)) + (#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73)) + (#C(34.12 -6.15) #C(-13.49 32.5) + #C(-17.24 43.31)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(-34.5d0 8.24d0) #C(-8.93d0 34.12d0) + #C(49.27d0 -13.49d0)) + (#C(3.29d0 -8.93d0) #C(-6.15d0 49.27d0) + #C(32.5d0 42.73d0)) + (#C(34.12d0 -6.15d0) #C(-13.49d0 32.5d0) + #C(-17.24d0 43.31d0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 116 161) (44 163 215) (189 140 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 116 161) (44 163 215) (189 140 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 116 161) (44 163 215) (189 140 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -91 73) (-68 52 -5) (71 -10 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 116 161) (44 163 215) (189 140 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (MATRIX-TRANSPOSE M1)))))) + diff --git a/tests/matrix-variance-with-fixed-mean.lisp b/tests/matrix-variance-with-fixed-mean.lisp new file mode 100644 index 0000000000000000000000000000000000000000..f44fe03abd1ca13fdd5cfdb61d7ac22ea8adf7eb --- /dev/null +++ b/tests/matrix-variance-with-fixed-mean.lisp @@ -0,0 +1,91 @@ +;; Regression test MATRIX-VARIANCE-WITH-FIXED-MEAN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-VARIANCE-WITH-FIXED-MEAN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 639.5971092940438d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 639.5971111111112d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4955.555555555556d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2820.246913580247d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4955.555555555556d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2820.246913580247d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4955.555555555556d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2820.246913580247d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4955.555555555556d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2820.246913580247d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))) + diff --git a/tests/matrix-variance-with-mean.lisp b/tests/matrix-variance-with-mean.lisp new file mode 100644 index 0000000000000000000000000000000000000000..033780b5eeb456687b9a484e6128bed6dd94fdf5 --- /dev/null +++ b/tests/matrix-variance-with-mean.lisp @@ -0,0 +1,107 @@ +;; Regression test MATRIX-VARIANCE-WITH-MEAN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-VARIANCE-WITH-MEAN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.5467479557992d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (VARIANCE M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.5467500000001d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (VARIANCE M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (VARIANCE M1 + (MEAN + M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (VARIANCE M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (VARIANCE M1 + (MEAN + M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (VARIANCE M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (VARIANCE M1 + (MEAN + M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (VARIANCE M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (VARIANCE M1 + (MEAN + M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (VARIANCE M1 (MEAN M1)))))) + diff --git a/tests/matrix-variance.lisp b/tests/matrix-variance.lisp new file mode 100644 index 0000000000000000000000000000000000000000..3b6345d04d589c893860c878c50b658283746375 --- /dev/null +++ b/tests/matrix-variance.lisp @@ -0,0 +1,99 @@ +;; Regression test MATRIX-VARIANCE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MATRIX-VARIANCE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.5467479557992d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.5467500000001d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (VARIANCE M1))))) + diff --git a/tests/median-percentile.lisp b/tests/median-percentile.lisp new file mode 100644 index 0000000000000000000000000000000000000000..98283d76946ba3839ab3c73c867bd09ac5ad1b93 --- /dev/null +++ b/tests/median-percentile.lisp @@ -0,0 +1,26 @@ +;; Regression test MEDIAN-PERCENTILE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MEDIAN-PERCENTILE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((VEC + (VECTOR-DOUBLE-FLOAT + (A -3.21d0 1.0d0 + 12.8d0)))) + (MEDIAN VEC)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.85d0) + (MULTIPLE-VALUE-LIST + (LETM + ((VEC + (VECTOR-DOUBLE-FLOAT + (A -18.0d0 + -12.0d0 + -3.21d0 0.5d0 + 1.0d0 2.7d0 + 12.8d0)))) + (QUANTILE VEC + 0.75d0))))) + diff --git a/tests/monte-carlo.lisp b/tests/monte-carlo.lisp new file mode 100644 index 0000000000000000000000000000000000000000..e16792e3ed8b93b11b9ae5853eaed2994ab04f1b --- /dev/null +++ b/tests/monte-carlo.lisp @@ -0,0 +1,15 @@ +;; Regression test MONTE-CARLO for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MONTE-CARLO + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.4122087033540667d0 0.013435861456267064d0) + (MULTIPLE-VALUE-LIST (RANDOM-WALK-PLAIN-EXAMPLE))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.3895297058825096d0 0.0050106269732269415d0) + (MULTIPLE-VALUE-LIST (RANDOM-WALK-MISER-EXAMPLE))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.3931632739551914d0 1.4981164744582692d-4) + (MULTIPLE-VALUE-LIST (RANDOM-WALK-VEGAS-EXAMPLE)))) + diff --git a/tests/multinomial.lisp b/tests/multinomial.lisp new file mode 100644 index 0000000000000000000000000000000000000000..a1ea245211e906f93edbe9c78c4803f831967e2d --- /dev/null +++ b/tests/multinomial.lisp @@ -0,0 +1,39 @@ +;; Regression test MULTINOMIAL for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST MULTINOMIAL + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(5 0 1 2)) + (MULTIPLE-VALUE-LIST + (LETM + ((RNG + (RANDOM-NUMBER-GENERATOR + *MT19937* 0)) + (P + (VECTOR-DOUBLE-FLOAT + (A 0.1d0 0.2d0 + 0.3d0 + 0.4d0))) + (N + (VECTOR-SIGNED-BYTE-32 + 4))) + (MULTINOMIAL RNG 8 + P N) + (CL-ARRAY N)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 8.064000000000026d-5) + (MULTIPLE-VALUE-LIST + (LETM + ((P + (VECTOR-DOUBLE-FLOAT (A 0.1d0 0.2d0 0.3d0 0.4d0))) + (N (VECTOR-SIGNED-BYTE-32 (A 5 0 1 2)))) + (MULTINOMIAL-PDF P N)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -9.425515753641212d0) + (MULTIPLE-VALUE-LIST + (LETM + ((P + (VECTOR-DOUBLE-FLOAT (A 0.1d0 0.2d0 0.3d0 0.4d0))) + (N (VECTOR-SIGNED-BYTE-32 (A 5 0 1 2)))) + (MULTINOMIAL-LOG-PDF P N))))) + diff --git a/tests/negative-binomial.lisp b/tests/negative-binomial.lisp new file mode 100644 index 0000000000000000000000000000000000000000..ee060522723c419f5b4493ac3f7d66c2059f6ec9 --- /dev/null +++ b/tests/negative-binomial.lisp @@ -0,0 +1,39 @@ +;; Regression test NEGATIVE-BINOMIAL for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST NEGATIVE-BINOMIAL + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST 15 21 19 15 8 18 23 18 33 16 10)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (NEGATIVE-BINOMIAL RNG 0.4d0 12.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.0056984767089869d0) + (MULTIPLE-VALUE-LIST + (NEGATIVE-BINOMIAL-PDF 5 0.4d0 12.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.010594202555514881d0) + (MULTIPLE-VALUE-LIST + (NEGATIVE-BINOMIAL-P 5 0.4d0 12.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.9894057974444851d0) + (MULTIPLE-VALUE-LIST + (NEGATIVE-BINOMIAL-Q 5 0.4d0 12.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST 15 21 19 15 8 18 23 18 33 16 10)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (PASCAL RNG 0.4d0 12))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.0056984767089869d0) + (MULTIPLE-VALUE-LIST (PASCAL-PDF 5 0.4d0 12))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.010594202555514881d0) + (MULTIPLE-VALUE-LIST (PASCAL-P 5 0.4d0 12))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.9894057974444851d0) + (MULTIPLE-VALUE-LIST (PASCAL-Q 5 0.4d0 12)))) + diff --git a/tests/numerical-differentiation.lisp b/tests/numerical-differentiation.lisp new file mode 100644 index 0000000000000000000000000000000000000000..a002579b444580401c7594e27e26d467b3f102af --- /dev/null +++ b/tests/numerical-differentiation.lisp @@ -0,0 +1,78 @@ +;; Regression test NUMERICAL-DIFFERENTIATION for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST NUMERICAL-DIFFERENTIATION + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.718281828441488d0 4.123659913167868d-10) + (MULTIPLE-VALUE-LIST + (CENTRAL-DERIVATIVE DERIV-F1 1.0d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.7182817825298398d0 9.540320743340577d-7) + (MULTIPLE-VALUE-LIST + (FORWARD-DERIVATIVE DERIV-F1 1.0d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.7182818293827378d0 9.086969640080628d-7) + (MULTIPLE-VALUE-LIST + (BACKWARD-DERIVATIVE DERIV-F1 1.0d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.474341649024533d0 3.3922603135575853d-11) + (MULTIPLE-VALUE-LIST + (CENTRAL-DERIVATIVE DERIV-F2 0.1d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.47434164943235285d0 9.102230432046565d-8) + (MULTIPLE-VALUE-LIST + (FORWARD-DERIVATIVE DERIV-F2 0.1d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.4743416462049176d0 8.787851752748856d-8) + (MULTIPLE-VALUE-LIST + (BACKWARD-DERIVATIVE DERIV-F2 0.1d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.9941773945923913d0 6.730277498876722d-10) + (MULTIPLE-VALUE-LIST + (CENTRAL-DERIVATIVE DERIV-F3 0.45d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.994177385772526d0 1.6952086150997503d-6) + (MULTIPLE-VALUE-LIST + (FORWARD-DERIVATIVE DERIV-F3 0.45d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.9941775182635064d0 1.568063267060477d-6) + (MULTIPLE-VALUE-LIST + (BACKWARD-DERIVATIVE DERIV-F3 0.45d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.7788007830653751d0 1.7227267499194736d-10) + (MULTIPLE-VALUE-LIST + (CENTRAL-DERIVATIVE DERIV-F4 0.5d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.7788007884386108d0 2.530006603059119d-7) + (MULTIPLE-VALUE-LIST + (FORWARD-DERIVATIVE DERIV-F4 0.5d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.7788007743421791d0 2.503617930568489d-7) + (MULTIPLE-VALUE-LIST + (BACKWARD-DERIVATIVE DERIV-F4 0.5d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.0d0 6.66133814775094d-20) + (MULTIPLE-VALUE-LIST + (CENTRAL-DERIVATIVE DERIV-F5 0.0d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -2.6337311035821125d-26 1.606762230663824d-11) + (MULTIPLE-VALUE-LIST + (FORWARD-DERIVATIVE DERIV-F5 0.0d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.6337311035821125d-26 1.606762230663824d-11) + (MULTIPLE-VALUE-LIST + (BACKWARD-DERIVATIVE DERIV-F5 0.0d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.009999999999871223d0 2.6645352591887814d-12) + (MULTIPLE-VALUE-LIST + (CENTRAL-DERIVATIVE DERIV-F6 10.0d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.010000000266238856d0 4.9950606958271945d-9) + (MULTIPLE-VALUE-LIST + (FORWARD-DERIVATIVE DERIV-F6 10.0d0 1.d-4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.010000000076196142d0 4.641550044799095d-9) + (MULTIPLE-VALUE-LIST + (BACKWARD-DERIVATIVE DERIV-F6 10.0d0 1.d-4)))) + diff --git a/tests/numerical-integration.lisp b/tests/numerical-integration.lisp new file mode 100644 index 0000000000000000000000000000000000000000..1ed86047d320a0833391ab1a238b7a43428a0ab1 --- /dev/null +++ b/tests/numerical-integration.lisp @@ -0,0 +1,23 @@ +;; Regression test NUMERICAL-INTEGRATION for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST NUMERICAL-INTEGRATION + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.0d0 2.220446049250313d-14 21) + (MULTIPLE-VALUE-LIST + (INTEGRATION-QNG ONE-SINE 0.0d0 PI))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.0d0 2.220446049250313d-14) + (MULTIPLE-VALUE-LIST + (LETM ((WS (INTEGRATION-WORKSPACE 20))) + (INTEGRATION-QAG ONE-SINE 0.0d0 PI :GAUSS15 20 + WS)))) + (LISP-UNIT:ASSERT-ERROR 'EINVAL + (LETM + ((WS + (INTEGRATION-WORKSPACE 20))) + (INTEGRATION-QAG ONE-SINE 0.0d0 + PI :GAUSS15 50 + WS)))) + diff --git a/tests/pareto.lisp b/tests/pareto.lisp new file mode 100644 index 0000000000000000000000000000000000000000..bda54ad9d03152d2729529484bb055640c3bdbdb --- /dev/null +++ b/tests/pareto.lisp @@ -0,0 +1,35 @@ +;; Regression test PARETO for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST PARETO + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 2.0005166356083666d0 12.276726596218747d0 + 7.076694965937239d0 2.111484074469764d0 + 8.633470811095883d0 4.123935696449152d0 + 2.0888231161547828d0 2.6870692498025632d0 + 3.703404287965457d0 2.7028744394290123d0 + 2.631773566385122d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (PARETO RNG 1.0d0 2.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5116034405707658d0) + (MULTIPLE-VALUE-LIST (PARETO-PDF 1.5d0 1.3d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5168849835182453d0) + (MULTIPLE-VALUE-LIST (PARETO-P 3.5d0 1.3d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.4831150164817547d0) + (MULTIPLE-VALUE-LIST (PARETO-Q 3.5d0 1.3d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3.5000000000000004d0) + (MULTIPLE-VALUE-LIST + (PARETO-PINV 0.5168849835182453d0 1.3d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3.5000000000000004d0) + (MULTIPLE-VALUE-LIST + (PARETO-QINV 0.4831150164817547d0 1.3d0 2.0d0)))) + diff --git a/tests/permutation.lisp b/tests/permutation.lisp new file mode 100644 index 0000000000000000000000000000000000000000..407b2814819590ba5939826d0b3ebb78b6dd963b --- /dev/null +++ b/tests/permutation.lisp @@ -0,0 +1,127 @@ +;; Regression test PERMUTATION for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST PERMUTATION + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM-1 + (PERMUTATION 4 + T))) + (SET-IDENTITY + PERM-1) + (MAREF PERM-1 2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 1 2 3)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM-1 + (PERMUTATION 4 + T))) + (SET-IDENTITY + PERM-1) + (CL-ARRAY + PERM-1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 2 1 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM-1 + (PERMUTATION 4 + T))) + (SET-IDENTITY + PERM-1) + (CL-ARRAY + (PERMUTATION-REVERSE + PERM-1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 3 1 2)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM-1 + (PERMUTATION 4 + T)) + (PERM-2 + (PERMUTATION 4 + T))) + (SET-IDENTITY + PERM-1) + (PERMUTATION-NEXT + PERM-1) + (PERMUTATION-NEXT + PERM-1) + (PERMUTATION-NEXT + PERM-1) + (PERMUTATION-INVERSE + PERM-2 PERM-1) + (CL-ARRAY + PERM-2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 3 2 1)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM-1 + (PERMUTATION 4 + T))) + (SET-IDENTITY + PERM-1) + (SWAP-ELEMENTS + PERM-1 1 3) + (CL-ARRAY + PERM-1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(33 44 11 22)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM-1 + (PERMUTATION 4 + T)) + (INTVEC + (VECTOR-SIGNED-BYTE-32 + (A 11 22 33 + 44)))) + (SET-IDENTITY + PERM-1) + (SWAP-ELEMENTS + PERM-1 1 3) + (SWAP-ELEMENTS + PERM-1 0 2) + (PERMUTE-VECTOR + PERM-1 INTVEC) + (CL-ARRAY + INTVEC)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM-1 + (PERMUTATION 4 + T))) + (SET-IDENTITY + PERM-1) + (SWAP-ELEMENTS + PERM-1 1 3) + (INVERSIONS + PERM-1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM-1 + (PERMUTATION 4 + T))) + (SET-IDENTITY + PERM-1) + (SWAP-ELEMENTS + PERM-1 1 3) + (LINEAR-CYCLES + PERM-1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM-1 + (PERMUTATION 4 + T))) + (SET-IDENTITY + PERM-1) + (SWAP-ELEMENTS + PERM-1 1 3) + (SWAP-ELEMENTS + PERM-1 0 2) + (CANONICAL-CYCLES + PERM-1))))) + diff --git a/tests/poisson.lisp b/tests/poisson.lisp new file mode 100644 index 0000000000000000000000000000000000000000..94674b6d5e9d72bcca6540d907164e2e3458547c --- /dev/null +++ b/tests/poisson.lisp @@ -0,0 +1,21 @@ +;; Regression test POISSON for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST POISSON + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST 15 6 9 9 5 8 11 9 11 5 10)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (POISSON RNG 10.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.11259903214902009d0) + (MULTIPLE-VALUE-LIST (POISSON-PDF 8 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.3328196787507177d0) + (MULTIPLE-VALUE-LIST (POISSON-P 8 10.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6671803212492823d0) + (MULTIPLE-VALUE-LIST (POISSON-Q 8 10.0d0)))) + diff --git a/tests/polynomial.lisp b/tests/polynomial.lisp new file mode 100644 index 0000000000000000000000000000000000000000..f330ec0ae2572a473421663ba340b6c7204acfce --- /dev/null +++ b/tests/polynomial.lisp @@ -0,0 +1,66 @@ +;; Regression test POLYNOMIAL for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST POLYNOMIAL + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST 2.5d0 7.2d0 32.7d0 91.0d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((XA + (VECTOR-DOUBLE-FLOAT (A 0.0d0 1.0d0 2.0d0 3.0d0))) + (YA + (VECTOR-DOUBLE-FLOAT + (A 2.5d0 7.2d0 32.7d0 91.0d0))) + (DD (VECTOR-DOUBLE-FLOAT 4))) + (DIVIDED-DIFFERENCE DD XA YA) + (LIST + (POLYNOMIAL-EVAL-DIVIDED-DIFFERENCE DD XA 0.0d0) + (POLYNOMIAL-EVAL-DIVIDED-DIFFERENCE DD XA 1.0d0) + (POLYNOMIAL-EVAL-DIVIDED-DIFFERENCE DD XA 2.0d0) + (POLYNOMIAL-EVAL-DIVIDED-DIFFERENCE DD XA 3.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2.0d0) + (MULTIPLE-VALUE-LIST + (LETM + ((VEC + (VECTOR-DOUBLE-FLOAT + (A 1.0d0 2.0d0 + 3.0d0)))) + (POLYNOMIAL-EVAL + VEC -1.0d0)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST) (LIST)) + (MULTIPLE-VALUE-LIST + (SOLVE-QUADRATIC + 1.0d0 0.0d0 + 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.0d0 1.0d0) + (MULTIPLE-VALUE-LIST + (SOLVE-QUADRATIC + 1.0d0 -2.0d0 + 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #C(1.0d0 0.0d0) #C(1.0d0 0.0d0)) + (MULTIPLE-VALUE-LIST + (SOLVE-QUADRATIC-COMPLEX 1.0d0 -2.0d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -3.000000000000001d0 1.9999999999999996d0 + 7.000000000000001d0) + (MULTIPLE-VALUE-LIST + (SOLVE-CUBIC -6.0d0 -13.0d0 42.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #C(-5.551115123125783d-17 -0.9999999999999999d0) + #C(-5.551115123125783d-17 0.9999999999999999d0) + #C(1.0d0 0.0d0)) + (MULTIPLE-VALUE-LIST + (SOLVE-CUBIC-COMPLEX -1.0d0 1.0d0 -1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #C(-0.8090169943749477d0 0.5877852522924734d0) + #C(-0.8090169943749477d0 -0.5877852522924734d0) + #C(0.3090169943749475d0 0.951056516295153d0) + #C(0.3090169943749475d0 -0.951056516295153d0) + #C(0.9999999999999999d0 0.0d0)) + (MULTIPLE-VALUE-LIST + (POLYNOMIAL-SOLVE + (A DOUBLE-FLOAT -1.0d0 0.0d0 0.0d0 0.0d0 0.0d0 + 1.0d0))))) + diff --git a/tests/power.lisp b/tests/power.lisp new file mode 100644 index 0000000000000000000000000000000000000000..f7f5121f141590d37c712aaa439a72b33afab57e --- /dev/null +++ b/tests/power.lisp @@ -0,0 +1,9 @@ +;; Regression test POWER for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST POWER + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 525.21875d0 9.329759187437503d-13) + (MULTIPLE-VALUE-LIST (POW 3.5d0 5)))) + diff --git a/tests/psi.lisp b/tests/psi.lisp new file mode 100644 index 0000000000000000000000000000000000000000..78901ac89f675955006e04b9171d49d59dece01b --- /dev/null +++ b/tests/psi.lisp @@ -0,0 +1,24 @@ +;; Regression test PSI for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST PSI + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.2561176684318005d0 2.789141514262906d-16) + (MULTIPLE-VALUE-LIST (PSI 4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.2561176684318005d0 2.846229783626858d-16) + (MULTIPLE-VALUE-LIST (PSI 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.7145915153739806d0 1.925418559790263d-14) + (MULTIPLE-VALUE-LIST (PSI-1+IY 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.2838229557371153d0 6.302135607530242d-17) + (MULTIPLE-VALUE-LIST (PSI-1 4))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.28382295573711525d0 1.764597970108467d-15) + (MULTIPLE-VALUE-LIST (PSI-1 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.0800397322451145d0 5.222647053360405d-16) + (MULTIPLE-VALUE-LIST (PSI-N 2 4.0d0)))) + diff --git a/tests/quasi-random-number-generators.lisp b/tests/quasi-random-number-generators.lisp new file mode 100644 index 0000000000000000000000000000000000000000..0fc47dd361ca18d73a248b0c77d1536e960c3805 --- /dev/null +++ b/tests/quasi-random-number-generators.lisp @@ -0,0 +1,16 @@ +;; Regression test QUASI-RANDOM-NUMBER-GENERATORS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST QUASI-RANDOM-NUMBER-GENERATORS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.5d0 0.5d0 0.75d0 0.25d0 0.25d0 0.75d0 0.375d0 + 0.375d0 0.875d0 0.875d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((GEN (QUASI-RANDOM-NUMBER-GENERATOR 2 *SOBOL*)) + (VEC (VECTOR-DOUBLE-FLOAT 2))) + (LOOP REPEAT 5 DO (QRNG-GET GEN VEC) APPEND + (COERCE (CL-ARRAY VEC) 'LIST)))))) + diff --git a/tests/random-number-generators.lisp b/tests/random-number-generators.lisp new file mode 100644 index 0000000000000000000000000000000000000000..02f78bdb9d77bcc60b12c23cf52a97be0c0f459c --- /dev/null +++ b/tests/random-number-generators.lisp @@ -0,0 +1,25 @@ +;; Regression test RANDOM-NUMBER-GENERATORS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST RANDOM-NUMBER-GENERATORS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 999 162 282 947 231 484 957 744 540 739 759)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (UNIFORM-FIXNUM RNG 1000))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.11177622997750353d0 0.9591667949963206d0 + 0.8415268011584537d0 0.9254037136795947d0 + 0.27540698474059205d0 0.7093040573919677d0 + 0.5541333041871588d0 0.8806957769583426d0 + 0.597139396982798d0 0.7518741133398722d0 + 0.9311084621265104d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *CMRG* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (UNIFORM RNG)))))) + diff --git a/tests/rayleigh-tail.lisp b/tests/rayleigh-tail.lisp new file mode 100644 index 0000000000000000000000000000000000000000..30283aac98de5ba5c68416c313052b3b9b6b617c --- /dev/null +++ b/tests/rayleigh-tail.lisp @@ -0,0 +1,22 @@ +;; Regression test RAYLEIGH-TAIL for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST RAYLEIGH-TAIL + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 1.0255032370386696d0 19.0764679267351d0 + 15.928966102255199d0 3.4422048899106383d0 + 17.131838333441106d0 12.071957529361999d0 + 3.112992916690818d0 7.749889301203328d0 + 11.145450138119857d0 7.825198187316554d0 + 7.476774681552917d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (RAYLEIGH-TAIL RNG 1.0d0 10.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.10224317624874313d0) + (MULTIPLE-VALUE-LIST + (RAYLEIGH-TAIL-PDF 0.25d0 -2.0d0 2.0d0)))) + diff --git a/tests/rayleigh.lisp b/tests/rayleigh.lisp new file mode 100644 index 0000000000000000000000000000000000000000..c7219c820915c7205db9a36563d10dc0fa2e6751 --- /dev/null +++ b/tests/rayleigh.lisp @@ -0,0 +1,35 @@ +;; Regression test RAYLEIGH for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST RAYLEIGH + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.22728151965522753d0 19.05023959323748d0 + 15.897545756713367d0 3.2937477899992147d0 + 17.102628005168157d0 12.030467929000928d0 + 2.9480035446666624d0 7.6851014424603274d0 + 11.100498132125239d0 7.76103902005281d0 + 7.409599155063027d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (RAYLEIGH RNG 10.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.4412484512922977d0) + (MULTIPLE-VALUE-LIST (RAYLEIGH-PDF 0.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.1175030974154046d0) + (MULTIPLE-VALUE-LIST (RAYLEIGH-P 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.8824969025845955d0) + (MULTIPLE-VALUE-LIST (RAYLEIGH-Q 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.0000000000000002d0) + (MULTIPLE-VALUE-LIST + (RAYLEIGH-PINV 0.1175030974154046d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.9999999999999998d0) + (MULTIPLE-VALUE-LIST + (RAYLEIGH-QINV 0.8824969025845955d0 2.0d0)))) + diff --git a/tests/row.lisp b/tests/row.lisp new file mode 100644 index 0000000000000000000000000000000000000000..13bd20d0e127c5f2d338591223fc6a90797b9d76 --- /dev/null +++ b/tests/row.lisp @@ -0,0 +1,170 @@ +;; Regression test ROW for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST ROW + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-8.93 34.12 -6.15)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (ROW (VECTOR-SINGLE-FLOAT '3 NIL))) + (CL-ARRAY (ROW ROW M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-8.93d0 34.12d0 -6.15d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (ROW (VECTOR-DOUBLE-FLOAT '3 NIL))) + (CL-ARRAY (ROW ROW M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL)) + (ROW (VECTOR-COMPLEX-SINGLE-FLOAT '3 NIL))) + (CL-ARRAY (ROW ROW M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) + #C(-13.49d0 32.5d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL)) + (ROW (VECTOR-COMPLEX-DOUBLE-FLOAT '3 NIL))) + (CL-ARRAY (ROW ROW M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 52 -10)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL)) + (ROW + (VECTOR-SIGNED-BYTE-8 + '3 NIL))) + (CL-ARRAY + (ROW ROW M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(116 163 140)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL)) + (ROW + (VECTOR-UNSIGNED-BYTE-8 + '3 NIL))) + (CL-ARRAY + (ROW ROW M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 52 -10)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL)) + (ROW + (VECTOR-SIGNED-BYTE-16 + '3 NIL))) + (CL-ARRAY + (ROW ROW M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(116 163 140)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL)) + (ROW + (VECTOR-UNSIGNED-BYTE-16 + '3 NIL))) + (CL-ARRAY + (ROW ROW M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 52 -10)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL)) + (ROW + (VECTOR-SIGNED-BYTE-32 + '3 NIL))) + (CL-ARRAY + (ROW ROW M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(116 163 140)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL)) + (ROW + (VECTOR-UNSIGNED-BYTE-32 + '3 NIL))) + (CL-ARRAY + (ROW ROW M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 52 -10)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) + (-91 52 -10) + (73 -5 123)) + NIL)) + (ROW + (VECTOR-SIGNED-BYTE-64 + '3 NIL))) + (CL-ARRAY + (ROW ROW M1 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(116 163 140)) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) + (116 163 140) + (161 215 98)) + NIL)) + (ROW + (VECTOR-UNSIGNED-BYTE-64 + '3 NIL))) + (CL-ARRAY + (ROW ROW M1 1)))))) + diff --git a/tests/scale.lisp b/tests/scale.lisp new file mode 100644 index 0000000000000000000000000000000000000000..e8e51e5c17dec5cd8ad011de2c9f4ac824e4a6d2 --- /dev/null +++ b/tests/scale.lisp @@ -0,0 +1,91 @@ +;; Regression test SCALE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SCALE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(-1121.25 267.8) #C(106.924995 -290.225) + #C(1108.9 -199.875) #C(1601.275 -438.425) + #C(1056.25 1388.725) #C(-560.3 1407.5751) + #C(-523.9 -268.125) #C(696.8 -1595.1001))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49 + 32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 + -49.08) + NIL)) + (SCALAR 32.5)) + (CL-ARRAY (SCALE SCALAR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(-1121.25d0 267.8d0) + #C(106.925d0 -290.22499999999997d0) + #C(1108.8999999999999d0 -199.875d0) + #C(1601.275d0 -438.425d0) #C(1056.25d0 1388.725d0) + #C(-560.3d0 1407.575d0) #C(-523.9d0 -268.125d0) + #C(696.8000000000001d0 -1595.1d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0 -16.12d0 -8.25d0 21.44d0 -49.08d0) + NIL)) + (SCALAR 32.5d0)) + (CL-ARRAY (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 + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL)) + (SCALAR 32.5)) + (CL-ARRAY (SCALE SCALAR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-1121.25d0 267.8d0 106.925d0 -290.22499999999997d0 + 1108.8999999999999d0 -199.875d0 1601.275d0 + -438.425d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL)) + (SCALAR 32.5d0)) + (CL-ARRAY (SCALE SCALAR V1))))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 + 34.12 -6.15 49.27 -13.49 + 32.5 42.73 -17.24 43.31 + -16.12 -8.25 21.44 + -49.08) + NIL)) + (SCALAR #C(32.5 42.73))) + (CL-ARRAY (SCALE SCALAR V1)))) + (LISP-UNIT:ASSERT-ERROR 'SIMPLE-ERROR + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 + -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0 + 42.73d0 -17.24d0 43.31d0 + -16.12d0 -8.25d0 21.44d0 + -49.08d0) + NIL)) + (SCALAR #C(32.5d0 42.73d0))) + (CL-ARRAY (SCALE SCALAR V1))))) + diff --git a/tests/set-basis.lisp b/tests/set-basis.lisp new file mode 100644 index 0000000000000000000000000000000000000000..13a7dcda75be79e8cbeaa4bd0df577a872c41c1b --- /dev/null +++ b/tests/set-basis.lisp @@ -0,0 +1,117 @@ +;; Regression test SET-BASIS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SET-BASIS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL))) + (SET-BASIS V1 2) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(0.0d0 0.0d0 1.0d0 0.0d0 0.0d0 0.0d0 0.0d0 0.0d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL))) + (SET-BASIS V1 2) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(0.0 0.0) #C(0.0 0.0) #C(1.0 0.0) #C(0.0 0.0) + #C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49 + 32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 + -49.08) + NIL))) + (SET-BASIS V1 2) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(1.0d0 0.0d0) + #C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0) + #C(0.0d0 0.0d0) #C(0.0d0 0.0d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0 -16.12d0 -8.25d0 21.44d0 -49.08d0) + NIL))) + (SET-BASIS V1 2) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 0 1 0 0 0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (SET-BASIS V1 2) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 0 1 0 0 0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 163 140 161 215) NIL))) + (SET-BASIS V1 2) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 0 1 0 0 0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (SET-BASIS V1 2) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 0 1 0 0 0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 163 140 161 215) NIL))) + (SET-BASIS V1 2) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 0 1 0 0 0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (SET-BASIS V1 2) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 0 1 0 0 0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 163 140 161 215) NIL))) + (SET-BASIS V1 2) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 0 1 0 0 0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (SET-BASIS V1 2) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 0 1 0 0 0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 163 140 161 215) NIL))) + (SET-BASIS V1 2) (CL-ARRAY V1))))) + diff --git a/tests/set-identity.lisp b/tests/set-identity.lisp new file mode 100644 index 0000000000000000000000000000000000000000..d5911a1b15b0a979cc57aacae351bb2537007b41 --- /dev/null +++ b/tests/set-identity.lisp @@ -0,0 +1,125 @@ +;; Regression test SET-IDENTITY for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SET-IDENTITY + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((1.0 0.0 0.0) (0.0 1.0 0.0) (0.0 0.0 1.0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (CL-ARRAY (SET-IDENTITY M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((1.0d0 0.0d0 0.0d0) + (0.0d0 1.0d0 0.0d0) + (0.0d0 0.0d0 1.0d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (CL-ARRAY (SET-IDENTITY M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(1.0 0.0) #C(0.0 0.0) #C(0.0 0.0)) + (#C(0.0 0.0) #C(1.0 0.0) #C(0.0 0.0)) + (#C(0.0 0.0) #C(0.0 0.0) #C(1.0 0.0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL))) + (CL-ARRAY (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)) + (#C(0.0d0 0.0d0) #C(1.0d0 0.0d0) #C(0.0d0 0.0d0)) + (#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) + #C(1.0d0 0.0d0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL))) + (CL-ARRAY (SET-IDENTITY M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((1 0 0) (0 1 0) (0 0 1))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (SET-IDENTITY M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((1 0 0) (0 1 0) (0 0 1))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SET-IDENTITY M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((1 0 0) (0 1 0) (0 0 1))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (SET-IDENTITY M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((1 0 0) (0 1 0) (0 0 1))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SET-IDENTITY M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((1 0 0) (0 1 0) (0 0 1))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (SET-IDENTITY M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((1 0 0) (0 1 0) (0 0 1))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SET-IDENTITY M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((1 0 0) (0 1 0) (0 0 1))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (SET-IDENTITY M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((1 0 0) (0 1 0) (0 0 1))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SET-IDENTITY M1)))))) + diff --git a/tests/setf-column.lisp b/tests/setf-column.lisp new file mode 100644 index 0000000000000000000000000000000000000000..f833744016cb5437b1d8b5ff4c7059a9a3db6674 --- /dev/null +++ b/tests/setf-column.lisp @@ -0,0 +1,152 @@ +;; Regression test SETF-COLUMN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SETF-COLUMN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5 8.24 42.73) + (-8.93 34.12 -17.24) + (49.27 -13.49 43.31))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (COL + (VECTOR-SINGLE-FLOAT (A 42.73 -17.24 43.31) NIL))) + (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5d0 8.24d0 42.73d0) + (-8.93d0 34.12d0 -17.24d0) + (49.27d0 -13.49d0 43.31d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (COL + (VECTOR-DOUBLE-FLOAT (A 42.73d0 -17.24d0 43.31d0) + NIL))) + (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(42.73 -17.24)) + (#C(-8.93 34.12) #C(-6.15 49.27) #C(43.31 -16.12)) + (#C(49.27 -13.49) #C(32.5 42.73) + #C(-8.25 21.44)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL)) + (COL + (VECTOR-COMPLEX-SINGLE-FLOAT + (A 42.73 -17.24 43.31 -16.12 -8.25 21.44) NIL))) + (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) + #C(42.73d0 -17.24d0)) + (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) + #C(43.31d0 -16.12d0)) + (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) + #C(-8.25d0 21.44d0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL)) + (COL + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A 42.73d0 -17.24d0 43.31d0 -16.12d0 -8.25d0 + 21.44d0) + NIL))) + (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (COL (VECTOR-SIGNED-BYTE-8 (A 32 28 30) NIL))) + (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 44 28) (116 163 10) (161 215 19))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (COL (VECTOR-UNSIGNED-BYTE-8 (A 28 10 19) NIL))) + (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (COL (VECTOR-SIGNED-BYTE-16 (A 32 28 30) NIL))) + (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 44 28) (116 163 10) (161 215 19))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (COL (VECTOR-UNSIGNED-BYTE-16 (A 28 10 19) NIL))) + (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (COL (VECTOR-SIGNED-BYTE-32 (A 32 28 30) NIL))) + (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 44 28) (116 163 10) (161 215 19))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (COL (VECTOR-UNSIGNED-BYTE-32 (A 28 10 19) NIL))) + (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -68 32) (-91 52 28) (73 -5 30))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (COL (VECTOR-SIGNED-BYTE-64 (A 32 28 30) NIL))) + (SETF (COLUMN M1 2) COL) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 44 28) (116 163 10) (161 215 19))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (COL (VECTOR-UNSIGNED-BYTE-64 (A 28 10 19) NIL))) + (SETF (COLUMN M1 2) COL) (CL-ARRAY M1))))) + diff --git a/tests/setf-row.lisp b/tests/setf-row.lisp new file mode 100644 index 0000000000000000000000000000000000000000..725675f36435cdb0dc053bc5ce393e949a6022e3 --- /dev/null +++ b/tests/setf-row.lisp @@ -0,0 +1,152 @@ +;; Regression test SETF-ROW for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SETF-ROW + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5 8.24 3.29) + (-8.93 34.12 -6.15) + (42.73 -17.24 43.31))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (ROW + (VECTOR-SINGLE-FLOAT (A 42.73 -17.24 43.31) NIL))) + (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (42.73d0 -17.24d0 43.31d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (ROW + (VECTOR-DOUBLE-FLOAT (A 42.73d0 -17.24d0 43.31d0) + NIL))) + (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)) + (#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)) + (#C(42.73 -17.24) #C(43.31 -16.12) + #C(-8.25 21.44)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL)) + (ROW + (VECTOR-COMPLEX-SINGLE-FLOAT + (A 42.73 -17.24 43.31 -16.12 -8.25 21.44) NIL))) + (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#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(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) + #C(-8.25d0 21.44d0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL)) + (ROW + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A 42.73d0 -17.24d0 43.31d0 -16.12d0 -8.25d0 + 21.44d0) + NIL))) + (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (ROW (VECTOR-SIGNED-BYTE-8 (A 32 28 30) NIL))) + (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 44 189) (116 163 140) (28 10 19))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (ROW (VECTOR-UNSIGNED-BYTE-8 (A 28 10 19) NIL))) + (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (ROW (VECTOR-SIGNED-BYTE-16 (A 32 28 30) NIL))) + (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 44 189) (116 163 140) (28 10 19))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (ROW (VECTOR-UNSIGNED-BYTE-16 (A 28 10 19) NIL))) + (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (ROW (VECTOR-SIGNED-BYTE-32 (A 32 28 30) NIL))) + (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 44 189) (116 163 140) (28 10 19))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (ROW (VECTOR-UNSIGNED-BYTE-32 (A 28 10 19) NIL))) + (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -68 71) (-91 52 -10) (32 28 30))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (ROW (VECTOR-SIGNED-BYTE-64 (A 32 28 30) NIL))) + (SETF (ROW M1 2) ROW) (CL-ARRAY M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 44 189) (116 163 140) (28 10 19))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (ROW (VECTOR-UNSIGNED-BYTE-64 (A 28 10 19) NIL))) + (SETF (ROW M1 2) ROW) (CL-ARRAY M1))))) + diff --git a/tests/shuffling-sampling.lisp b/tests/shuffling-sampling.lisp new file mode 100644 index 0000000000000000000000000000000000000000..d4ab00926ea552fb62e29fe65a1be4a9cd2d1356 --- /dev/null +++ b/tests/shuffling-sampling.lisp @@ -0,0 +1,38 @@ +;; Regression test SHUFFLING-SAMPLING for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SHUFFLING-SAMPLING + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(4 3 6 1 5 7 2 8)) + (MULTIPLE-VALUE-LIST + (LETM + ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0)) + (V1 (VECTOR-SIGNED-BYTE-32 (A 1 2 3 4 5 6 7 8)))) + (SHUFFLE RNG V1) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(2 3 5 8)) + (MULTIPLE-VALUE-LIST + (LETM + ((RNG + (RANDOM-NUMBER-GENERATOR + *MT19937* 0)) + (V1 + (VECTOR-SIGNED-BYTE-32 + (A 1 2 3 4 5 6 7 + 8))) + (V2 + (VECTOR-SIGNED-BYTE-32 + 4))) + (CHOOSE-RANDOM RNG + V2 + V1) + (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(8 2 3 8 2 4 8 6 5 6)) + (MULTIPLE-VALUE-LIST + (LETM + ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0)) + (V1 (VECTOR-SIGNED-BYTE-32 (A 1 2 3 4 5 6 7 8))) + (V2 (VECTOR-SIGNED-BYTE-32 10))) + (SAMPLE RNG V2 V1) (CL-ARRAY V2))))) + diff --git a/tests/sort-matrix-largest.lisp b/tests/sort-matrix-largest.lisp new file mode 100644 index 0000000000000000000000000000000000000000..96004bb7308f1f4702bf76256488ab7d7ef728ef --- /dev/null +++ b/tests/sort-matrix-largest.lisp @@ -0,0 +1,102 @@ +;; Regression test SORT-MATRIX-LARGEST for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SORT-MATRIX-LARGEST + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((49.27 34.12 32.5) (8.24 3.29 -6.15))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 (MATRIX-SINGLE-FLOAT '(2 3) NIL))) + (CL-ARRAY (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((49.27d0 34.12d0 32.5d0) (8.24d0 3.29d0 -6.15d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 (MATRIX-DOUBLE-FLOAT '(2 3) NIL))) + (CL-ARRAY (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((123 73 71) (52 -5 -10))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-8 '(2 3) NIL))) + (CL-ARRAY (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((215 189 163) (161 140 116))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-8 '(2 3) NIL))) + (CL-ARRAY (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((123 73 71) (52 -5 -10))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-16 '(2 3) NIL))) + (CL-ARRAY (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((215 189 163) (161 140 116))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-16 '(2 3) NIL))) + (CL-ARRAY (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((123 73 71) (52 -5 -10))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-32 '(2 3) NIL))) + (CL-ARRAY (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((215 189 163) (161 140 116))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-32 '(2 3) NIL))) + (CL-ARRAY (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((123 73 71) (52 -5 -10))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-64 '(2 3) NIL))) + (CL-ARRAY (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((215 189 163) (161 140 116))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-64 '(2 3) NIL))) + (CL-ARRAY (SORT-LARGEST M2 M1)))))) + diff --git a/tests/sort-matrix-smallest.lisp b/tests/sort-matrix-smallest.lisp new file mode 100644 index 0000000000000000000000000000000000000000..28072225ca4fc44a204b23419f3db1656508bd99 --- /dev/null +++ b/tests/sort-matrix-smallest.lisp @@ -0,0 +1,103 @@ +;; Regression test SORT-MATRIX-SMALLEST for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SORT-MATRIX-SMALLEST + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-34.5 -13.49 -8.93) (-6.15 3.29 8.24))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL)) + (M2 (MATRIX-SINGLE-FLOAT '(2 3) NIL))) + (CL-ARRAY (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5d0 -13.49d0 -8.93d0) + (-6.15d0 3.29d0 8.24d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL)) + (M2 (MATRIX-DOUBLE-FLOAT '(2 3) NIL))) + (CL-ARRAY (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-8 '(2 3) NIL))) + (CL-ARRAY (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-8 '(2 3) NIL))) + (CL-ARRAY (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-16 '(2 3) NIL))) + (CL-ARRAY (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-16 '(2 3) NIL))) + (CL-ARRAY (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-32 '(2 3) NIL))) + (CL-ARRAY (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-32 '(2 3) NIL))) + (CL-ARRAY (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL)) + (M2 (MATRIX-SIGNED-BYTE-64 '(2 3) NIL))) + (CL-ARRAY (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL)) + (M2 (MATRIX-UNSIGNED-BYTE-64 '(2 3) NIL))) + (CL-ARRAY (SORT-SMALLEST M2 M1)))))) + diff --git a/tests/sort-matrix.lisp b/tests/sort-matrix.lisp new file mode 100644 index 0000000000000000000000000000000000000000..866dd10d978bfad3f9ce2652d9a235050972c4ac --- /dev/null +++ b/tests/sort-matrix.lisp @@ -0,0 +1,97 @@ +;; Regression test SORT-MATRIX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SORT-MATRIX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5 -13.49 -8.93) + (-6.15 3.29 8.24) + (32.5 34.12 49.27))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (CL-ARRAY (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5d0 -13.49d0 -8.93d0) + (-6.15d0 3.29d0 8.24d0) + (32.5d0 34.12d0 49.27d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (CL-ARRAY (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161) (163 189 215))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161) (163 189 215))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161) (163 189 215))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161) (163 189 215))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (MSORT M1)))))) + diff --git a/tests/sort-vector-index.lisp b/tests/sort-vector-index.lisp new file mode 100644 index 0000000000000000000000000000000000000000..95e646c8961e11b34ba7f0dc030ea01b890c54b1 --- /dev/null +++ b/tests/sort-vector-index.lisp @@ -0,0 +1,99 @@ +;; Regression test SORT-VECTOR-INDEX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SORT-VECTOR-INDEX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 7 3 5 2 1 4 6)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM (PERMUTATION 8)) + (V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL))) + (SORT-VECTOR-INDEX PERM V1) (CL-ARRAY PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 7 3 5 2 1 4 6)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM (PERMUTATION 8)) + (V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL))) + (SORT-VECTOR-INDEX PERM V1) (CL-ARRAY PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(3 1 0 5 7 4 2 6)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM (PERMUTATION 8)) + (V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (SORT-VECTOR-INDEX PERM V1) (CL-ARRAY PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(1 0 3 5 6 4 2 7)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM (PERMUTATION 8)) + (V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 163 140 161 215) NIL))) + (SORT-VECTOR-INDEX PERM V1) (CL-ARRAY PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(3 1 0 5 7 4 2 6)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM (PERMUTATION 8)) + (V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (SORT-VECTOR-INDEX PERM V1) (CL-ARRAY PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(1 0 3 5 6 4 2 7)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM (PERMUTATION 8)) + (V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 163 140 161 215) NIL))) + (SORT-VECTOR-INDEX PERM V1) (CL-ARRAY PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(3 1 0 5 7 4 2 6)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM (PERMUTATION 8)) + (V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (SORT-VECTOR-INDEX PERM V1) (CL-ARRAY PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(1 0 3 5 6 4 2 7)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM (PERMUTATION 8)) + (V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 163 140 161 215) NIL))) + (SORT-VECTOR-INDEX PERM V1) (CL-ARRAY PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(3 1 0 5 7 4 2 6)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM (PERMUTATION 8)) + (V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (SORT-VECTOR-INDEX PERM V1) (CL-ARRAY PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(1 0 3 5 6 4 2 7)) + (MULTIPLE-VALUE-LIST + (LETM + ((PERM (PERMUTATION 8)) + (V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 163 140 161 215) NIL))) + (SORT-VECTOR-INDEX PERM V1) (CL-ARRAY PERM))))) + diff --git a/tests/sort-vector-largest-index.lisp b/tests/sort-vector-largest-index.lisp new file mode 100644 index 0000000000000000000000000000000000000000..50b2218eb47a25e2ccadffecb18aa687b8fcf370 --- /dev/null +++ b/tests/sort-vector-largest-index.lisp @@ -0,0 +1,161 @@ +;; Regression test SORT-VECTOR-LARGEST-INDEX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SORT-VECTOR-LARGEST-INDEX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 4 1)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 + 3.29 -8.93 + 34.12 -6.15 + 49.27 -13.49) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 4 1)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 + 8.24d0 3.29d0 + -8.93d0 + 34.12d0 + -6.15d0 + 49.27d0 + -13.49d0) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST-INDEX + COMB V1)))))) + diff --git a/tests/sort-vector-largest.lisp b/tests/sort-vector-largest.lisp new file mode 100644 index 0000000000000000000000000000000000000000..58f9b38a8b4df71611cc2392f50ce571441c9a6e --- /dev/null +++ b/tests/sort-vector-largest.lisp @@ -0,0 +1,158 @@ +;; Regression test SORT-VECTOR-LARGEST for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SORT-VECTOR-LARGEST + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(49.27 34.12 8.24)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL)) + (V2 + (VECTOR-SINGLE-FLOAT (A 32.5 42.73 -17.24) NIL))) + (CL-ARRAY (SORT-VECTOR-LARGEST V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(49.27d0 34.12d0 8.24d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL)) + (V2 + (VECTOR-DOUBLE-FLOAT (A 32.5d0 42.73d0 -17.24d0) + NIL))) + (CL-ARRAY (SORT-VECTOR-LARGEST V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-8 + (A 123 32 28) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 + 163 140 161 + 215) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-8 + (A 98 28 10) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-16 + (A 123 32 28) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 + 163 140 161 + 215) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-16 + (A 98 28 10) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-32 + (A 123 32 28) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 + 163 140 161 + 215) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-32 + (A 98 28 10) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-64 + (A 123 32 28) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 + 163 140 161 + 215) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-64 + (A 98 28 10) + NIL))) + (CL-ARRAY + (SORT-VECTOR-LARGEST + V2 V1)))))) + diff --git a/tests/sort-vector-smallest-index.lisp b/tests/sort-vector-smallest-index.lisp new file mode 100644 index 0000000000000000000000000000000000000000..ba8aeb4312e999fe78fa4098ae53aa20bedbea3e --- /dev/null +++ b/tests/sort-vector-smallest-index.lisp @@ -0,0 +1,161 @@ +;; Regression test SORT-VECTOR-SMALLEST-INDEX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SORT-VECTOR-SMALLEST-INDEX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 7 3)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 + 3.29 -8.93 + 34.12 -6.15 + 49.27 -13.49) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 7 3)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 + 8.24d0 3.29d0 + -8.93d0 + 34.12d0 + -6.15d0 + 49.27d0 + -13.49d0) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) + (MULTIPLE-VALUE-LIST + (LETM + ((COMB + (COMBINATION + '(8 3))) + (V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST-INDEX + COMB V1)))))) + diff --git a/tests/sort-vector-smallest.lisp b/tests/sort-vector-smallest.lisp new file mode 100644 index 0000000000000000000000000000000000000000..83010991319a7f32808032341006019a27b021a7 --- /dev/null +++ b/tests/sort-vector-smallest.lisp @@ -0,0 +1,158 @@ +;; Regression test SORT-VECTOR-SMALLEST for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SORT-VECTOR-SMALLEST + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-34.5 -13.49 -8.93)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL)) + (V2 + (VECTOR-SINGLE-FLOAT (A 32.5 42.73 -17.24) NIL))) + (CL-ARRAY (SORT-VECTOR-SMALLEST V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-34.5d0 -13.49d0 -8.93d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL)) + (V2 + (VECTOR-DOUBLE-FLOAT (A 32.5d0 42.73d0 -17.24d0) + NIL))) + (CL-ARRAY (SORT-VECTOR-SMALLEST V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-8 + (A 123 32 28) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 + 163 140 161 + 215) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-8 + (A 98 28 10) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-16 + (A 123 32 28) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 + 163 140 161 + 215) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-16 + (A 98 28 10) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-32 + (A 123 32 28) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 + 163 140 161 + 215) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-32 + (A 98 28 10) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-64 + (A 123 32 28) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 + 163 140 161 + 215) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-64 + (A 98 28 10) + NIL))) + (CL-ARRAY + (SORT-VECTOR-SMALLEST + V2 V1)))))) + diff --git a/tests/sort-vector.lisp b/tests/sort-vector.lisp new file mode 100644 index 0000000000000000000000000000000000000000..5ccc9499af2343fa825585a599bde7b1d8bbd0f8 --- /dev/null +++ b/tests/sort-vector.lisp @@ -0,0 +1,92 @@ +;; Regression test SORT-VECTOR for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SORT-VECTOR + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-34.5 -13.49 -8.93 -6.15 3.29 8.24 34.12 49.27)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL))) + (CL-ARRAY (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-34.5d0 -13.49d0 -8.93d0 -6.15d0 3.29d0 8.24d0 + 34.12d0 49.27d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL))) + (CL-ARRAY (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-91 -68 -64 -10 -5 52 71 73)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (CL-ARRAY (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(44 67 116 140 161 163 189 215)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 163 140 161 215) NIL))) + (CL-ARRAY (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-91 -68 -64 -10 -5 52 71 73)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (CL-ARRAY (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(44 67 116 140 161 163 189 215)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 163 140 161 215) NIL))) + (CL-ARRAY (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-91 -68 -64 -10 -5 52 71 73)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (CL-ARRAY (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(44 67 116 140 161 163 189 215)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 163 140 161 215) NIL))) + (CL-ARRAY (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-91 -68 -64 -10 -5 52 71 73)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (CL-ARRAY (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(44 67 116 140 161 163 189 215)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 163 140 161 215) NIL))) + (CL-ARRAY (SORT-VECTOR V1)))))) + diff --git a/tests/spherical-vector.lisp b/tests/spherical-vector.lisp new file mode 100644 index 0000000000000000000000000000000000000000..1e68b3b08508e7b6f0986d2c67dcaceab270082e --- /dev/null +++ b/tests/spherical-vector.lisp @@ -0,0 +1,42 @@ +;; Regression test SPHERICAL-VECTOR for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SPHERICAL-VECTOR + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST -0.617745613497854d0 -0.7863779988047479d0 + 0.993748310886084d0 0.1116436053298841d0 + -0.9458104280982743d0 0.3247193158722761d0 + 0.45726622946182216d0 0.8893298574734622d0 + -0.46325616159849964d0 -0.8862244234622655d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 4 APPEND + (MULTIPLE-VALUE-LIST + (DIRECTION-2D RNG)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.9999986835208556d0 -0.0016226387631051197d0 + 0.5203010106077766d0 0.8539829379797504d0 + -0.2035120531038584d0 0.9790724407527016d0 + 0.9454753227485545d0 -0.3256937427607672d0 + 0.11500033916619544d0 0.9933654523848008d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 4 APPEND + (MULTIPLE-VALUE-LIST + (DIRECTION-2D-TRIG-METHOD RNG)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST -0.09129925750445994d0 0.18782185357162273d0 + 0.977950610665004d0 -0.9051182961559773d0 + -0.050683764485791594d0 -0.4221279734645046d0 + 0.13993766535985133d0 0.8385462620524484d0 + -0.526552576872909d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 2 APPEND + (MULTIPLE-VALUE-LIST + (DIRECTION-3D RNG))))))) + diff --git a/tests/swap-columns.lisp b/tests/swap-columns.lisp new file mode 100644 index 0000000000000000000000000000000000000000..be93fdbaa0935be2054cb2d521f3aab2e2986fe5 --- /dev/null +++ b/tests/swap-columns.lisp @@ -0,0 +1,131 @@ +;; Regression test SWAP-COLUMNS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SWAP-COLUMNS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5 3.29 8.24) + (-8.93 -6.15 34.12) + (49.27 32.5 -13.49))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (CL-ARRAY (SWAP-COLUMNS M1 1 2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5d0 3.29d0 8.24d0) + (-8.93d0 -6.15d0 34.12d0) + (49.27d0 32.5d0 -13.49d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (CL-ARRAY (SWAP-COLUMNS M1 1 2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(-34.5 8.24) #C(34.12 -6.15) #C(3.29 -8.93)) + (#C(-8.93 34.12) #C(-13.49 32.5) #C(-6.15 49.27)) + (#C(49.27 -13.49) #C(-17.24 43.31) + #C(32.5 42.73)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL))) + (CL-ARRAY (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)) + (#C(-8.93d0 34.12d0) #C(-13.49d0 32.5d0) + #C(-6.15d0 49.27d0)) + (#C(49.27d0 -13.49d0) #C(-17.24d0 43.31d0) + #C(32.5d0 42.73d0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL))) + (CL-ARRAY (SWAP-COLUMNS M1 1 2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (SWAP-COLUMNS M1 1 2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 189 44) (116 140 163) (161 98 215))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SWAP-COLUMNS M1 1 2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (SWAP-COLUMNS M1 1 2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 189 44) (116 140 163) (161 98 215))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SWAP-COLUMNS M1 1 2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (SWAP-COLUMNS M1 1 2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 189 44) (116 140 163) (161 98 215))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SWAP-COLUMNS M1 1 2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 71 -68) (-91 -10 52) (73 123 -5))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (SWAP-COLUMNS M1 1 2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 189 44) (116 140 163) (161 98 215))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SWAP-COLUMNS M1 1 2)))))) + diff --git a/tests/swap-elements.lisp b/tests/swap-elements.lisp new file mode 100644 index 0000000000000000000000000000000000000000..1ddc3dd531cc0eebb6c6b1fd16bab68cff4cf5aa --- /dev/null +++ b/tests/swap-elements.lisp @@ -0,0 +1,121 @@ +;; Regression test SWAP-ELEMENTS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SWAP-ELEMENTS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-34.5 8.24 -6.15 -8.93 34.12 3.29 49.27 -13.49)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL))) + (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-34.5d0 8.24d0 -6.15d0 -8.93d0 34.12d0 3.29d0 + 49.27d0 -13.49d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL))) + (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(-34.5 8.24) #C(3.29 -8.93) #C(-17.24 43.31) + #C(49.27 -13.49) #C(32.5 42.73) #C(34.12 -6.15) + #C(-16.12 -8.25) #C(21.44 -49.08))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49 + 32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 + -49.08) + NIL))) + (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) + #C(-17.24d0 43.31d0) #C(49.27d0 -13.49d0) + #C(32.5d0 42.73d0) #C(34.12d0 -6.15d0) + #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0 -16.12d0 -8.25d0 21.44d0 -49.08d0) + NIL))) + (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-64 -68 -10 -91 52 71 73 -5)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(67 44 140 116 163 189 161 215)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 163 140 161 215) NIL))) + (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-64 -68 -10 -91 52 71 73 -5)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(67 44 140 116 163 189 161 215)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 163 140 161 215) NIL))) + (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-64 -68 -10 -91 52 71 73 -5)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(67 44 140 116 163 189 161 215)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 163 140 161 215) NIL))) + (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-64 -68 -10 -91 52 71 73 -5)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(67 44 140 116 163 189 161 215)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 163 140 161 215) NIL))) + (SWAP-ELEMENTS V1 2 5) (CL-ARRAY V1))))) + diff --git a/tests/swap-row-column.lisp b/tests/swap-row-column.lisp new file mode 100644 index 0000000000000000000000000000000000000000..d17badaa2eb2d57db016aad1d9374aeb294f87e6 --- /dev/null +++ b/tests/swap-row-column.lisp @@ -0,0 +1,130 @@ +;; Regression test SWAP-ROW-COLUMN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SWAP-ROW-COLUMN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((3.29 -6.15 32.5) + (-8.93 34.12 8.24) + (49.27 -13.49 -34.5))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((3.29d0 -6.15d0 32.5d0) + (-8.93d0 34.12d0 8.24d0) + (49.27d0 -13.49d0 -34.5d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(34.12 -6.15) #C(-13.49 32.5) #C(-17.24 43.31)) + (#C(-8.93 34.12) #C(-6.15 49.27) #C(3.29 -8.93)) + (#C(49.27 -13.49) #C(32.5 42.73) #C(-34.5 8.24)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL))) + (CL-ARRAY (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)) + (#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) + #C(3.29d0 -8.93d0)) + (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) + #C(-34.5d0 8.24d0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL))) + (CL-ARRAY (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 + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (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 + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (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 + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (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 + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (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 + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (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 + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (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 + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (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 + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SWAP-ROW-COLUMN M1 0 2)))))) + diff --git a/tests/swap-rows.lisp b/tests/swap-rows.lisp new file mode 100644 index 0000000000000000000000000000000000000000..82b1ef7cb8031bd5614ef93e99624e5f6f0f2c84 --- /dev/null +++ b/tests/swap-rows.lisp @@ -0,0 +1,131 @@ +;; Regression test SWAP-ROWS for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SWAP-ROWS + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-8.93 34.12 -6.15) + (-34.5 8.24 3.29) + (49.27 -13.49 32.5))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SINGLE-FLOAT + (A (-34.5 8.24 3.29) (-8.93 34.12 -6.15) + (49.27 -13.49 32.5)) + NIL))) + (CL-ARRAY (SWAP-ROWS M1 0 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-8.93d0 34.12d0 -6.15d0) + (-34.5d0 8.24d0 3.29d0) + (49.27d0 -13.49d0 32.5d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)) + NIL))) + (CL-ARRAY (SWAP-ROWS M1 0 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)) + (#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)) + (#C(49.27 -13.49) #C(32.5 42.73) + #C(-17.24 43.31)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-SINGLE-FLOAT + (A (-34.5 8.24 3.29 -8.93 34.12 -6.15) + (-8.93 34.12 -6.15 49.27 -13.49 32.5) + (49.27 -13.49 32.5 42.73 -17.24 43.31)) + NIL))) + (CL-ARRAY (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)) + (#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) + #C(34.12d0 -6.15d0)) + (#C(49.27d0 -13.49d0) #C(32.5d0 42.73d0) + #C(-17.24d0 43.31d0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-COMPLEX-DOUBLE-FLOAT + (A (-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + (-8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + (49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0)) + NIL))) + (CL-ARRAY (SWAP-ROWS M1 0 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-8 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (SWAP-ROWS M1 0 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((116 163 140) (67 44 189) (161 215 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-8 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SWAP-ROWS M1 0 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-16 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (SWAP-ROWS M1 0 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((116 163 140) (67 44 189) (161 215 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-16 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SWAP-ROWS M1 0 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-32 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (SWAP-ROWS M1 0 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((116 163 140) (67 44 189) (161 215 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-32 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SWAP-ROWS M1 0 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 52 -10) (-64 -68 71) (73 -5 123))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-SIGNED-BYTE-64 + (A (-64 -68 71) (-91 52 -10) (73 -5 123)) NIL))) + (CL-ARRAY (SWAP-ROWS M1 0 1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((116 163 140) (67 44 189) (161 215 98))) + (MULTIPLE-VALUE-LIST + (LETM + ((M1 + (MATRIX-UNSIGNED-BYTE-64 + (A (67 44 189) (116 163 140) (161 215 98)) NIL))) + (CL-ARRAY (SWAP-ROWS M1 0 1)))))) + diff --git a/tests/synchrotron.lisp b/tests/synchrotron.lisp new file mode 100644 index 0000000000000000000000000000000000000000..763392c1268df20ba723331f5b12215fce9cf843 --- /dev/null +++ b/tests/synchrotron.lisp @@ -0,0 +1,12 @@ +;; Regression test SYNCHROTRON for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST SYNCHROTRON + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.052827396697912476d0 4.825849878208132d-14) + (MULTIPLE-VALUE-LIST (SYNCHROTRON-1 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.04692320582614684d0 6.854449168174663d-14) + (MULTIPLE-VALUE-LIST (SYNCHROTRON-2 4.0d0)))) + diff --git a/tests/tdist.lisp b/tests/tdist.lisp new file mode 100644 index 0000000000000000000000000000000000000000..d28086d1db707836a71e0f1135d7eb5c09269976 --- /dev/null +++ b/tests/tdist.lisp @@ -0,0 +1,37 @@ +;; Regression test TDIST for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST TDIST + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.14989366374481017d0 0.6794142879291215d0 + -1.615833951108472d0 -1.6008862825783456d0 + -1.7010935505767397d0 -0.04370959749808691d0 + 0.12761159276595174d0 -0.019731218255494867d0 + -0.6534666117199732d0 0.2035771324523077d0 + 1.77650300477611d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (RNG-SET RNG 0) + (LOOP FOR I FROM 0 TO 10 COLLECT + (TDIST RNG 10.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.2546479089470325d0) + (MULTIPLE-VALUE-LIST (TDIST-PDF 0.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6475836176504332d0) + (MULTIPLE-VALUE-LIST (TDIST-P 0.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.35241638234956685d0) + (MULTIPLE-VALUE-LIST (TDIST-Q 0.5d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.500000000000001d0) + (MULTIPLE-VALUE-LIST + (TDIST-PINV 0.6475836176504334d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.5d0) + (MULTIPLE-VALUE-LIST + (TDIST-QINV + 0.3524163823495667d0 + 1.0d0)))) + diff --git a/tests/transport.lisp b/tests/transport.lisp new file mode 100644 index 0000000000000000000000000000000000000000..d2b127a7bd709465eb878620d3fde5ee3350755f --- /dev/null +++ b/tests/transport.lisp @@ -0,0 +1,18 @@ +;; Regression test TRANSPORT for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST TRANSPORT + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.806666404563118d0 2.2867923780257255d-15) + (MULTIPLE-VALUE-LIST (TRANSPORT-2 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4.579217437229157d0 3.242324689309112d-15) + (MULTIPLE-VALUE-LIST (TRANSPORT-3 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 10.731932392998623d0 1.0925209116254758d-14) + (MULTIPLE-VALUE-LIST (TRANSPORT-4 4.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 29.488339015245842d0 3.204450601879883d-14) + (MULTIPLE-VALUE-LIST (TRANSPORT-5 4.0d0)))) + diff --git a/tests/trigonometry.lisp b/tests/trigonometry.lisp new file mode 100644 index 0000000000000000000000000000000000000000..eec1a8f00b98a51c5c77b327861e60fb8d76d811 --- /dev/null +++ b/tests/trigonometry.lisp @@ -0,0 +1,58 @@ +;; Regression test TRIGONOMETRY for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST TRIGONOMETRY + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.8414709848078965d0 3.736881847550928d-16) + (MULTIPLE-VALUE-LIST (GSL-SIN 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #C(1.2984575814159773d0 0.6349639147847361d0) + #C(5.766310013548447d-16 2.8198062320005596d-16)) + (MULTIPLE-VALUE-LIST (GSL-SIN #C(1.0d0 1.0d0)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.5403023058681398d0 2.3994242409314904d-16) + (MULTIPLE-VALUE-LIST (GSL-COS 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #C(0.8337300251311491d0 -0.9888977057628651d0) + #C(3.7025050808876487d-16 4.3915880077477046d-16)) + (MULTIPLE-VALUE-LIST (GSL-COS #C(1.0d0 1.0d0)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.23606797749979d0 9.930136612989092d-16) + (MULTIPLE-VALUE-LIST (HYPOTENUSE 1.0d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6366197723675814d0 3.0072729231305663d-16) + (MULTIPLE-VALUE-LIST (SINC 0.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #C(0.3683837314249251d0 0.4548202333099499d0) + #C(1.6359524021011266d-16 8.179762010505633d-17)) + (MULTIPLE-VALUE-LIST (LOG-SIN #C(1.0d0 1.0d0)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -0.6518223259470272d0 2.8946726169244526d-16) + (MULTIPLE-VALUE-LIST (LOG-SINH 0.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.12011450695827751d0 4.401938023864669d-17) + (MULTIPLE-VALUE-LIST (LOG-COSH 0.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.0806046117362795d0 1.682941969615793d0 + 8.535730329413909d-16 9.873187936033346d-16) + (MULTIPLE-VALUE-LIST + (POLAR-TO-RECTANGULAR 2.0d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.23606797749979d0 0.4636476090008061d0 + 9.930136612989092d-16 2.0590090033003876d-16) + (MULTIPLE-VALUE-LIST + (RECTANGULAR-TO-POLAR 2.0d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -1.2831853071795865d0) + (MULTIPLE-VALUE-LIST (RESTRICT-SYMMETRIC 5.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 5.283185307179586d0) + (MULTIPLE-VALUE-LIST (RESTRICT-POSITIVE -1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.479425538604203d0 0.008775825618904047d0) + (MULTIPLE-VALUE-LIST (SIN-ERR 0.5d0 0.01d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.8775825618903728d0 0.004794255386042614d0) + (MULTIPLE-VALUE-LIST (COS-ERR 0.5d0 0.01d0)))) + diff --git a/tests/vector-add-scalar.lisp b/tests/vector-add-scalar.lisp new file mode 100644 index 0000000000000000000000000000000000000000..9e83ad26a70d3c6b2b749536609ddf5b98591cf0 --- /dev/null +++ b/tests/vector-add-scalar.lisp @@ -0,0 +1,100 @@ +;; Regression test VECTOR-ADD-SCALAR for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-ADD-SCALAR + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-16.31 26.43 21.48)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SINGLE-FLOAT (A -34.5 8.24 3.29) NIL))) + (CL-ARRAY (M+C V1 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-16.31d0 26.43d0 21.48d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT (A -34.5d0 8.24d0 3.29d0) + NIL))) + (CL-ARRAY (M+C V1 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-45 -49 89)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71) + NIL))) + (CL-ARRAY + (M+C V1 + 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(85 62 207)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189) + NIL))) + (CL-ARRAY + (M+C V1 + 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-45 -49 89)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71) + NIL))) + (CL-ARRAY + (M+C V1 + 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(85 62 207)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189) + NIL))) + (CL-ARRAY + (M+C V1 + 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-45 -49 89)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71) + NIL))) + (CL-ARRAY + (M+C V1 + 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(85 62 207)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189) + NIL))) + (CL-ARRAY + (M+C V1 + 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-45 -49 89)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71) + NIL))) + (CL-ARRAY + (M+C V1 + 18.19d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(85 62 207)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189) + NIL))) + (CL-ARRAY + (M+C V1 + 18.19d0)))))) + diff --git a/tests/vector-copy.lisp b/tests/vector-copy.lisp new file mode 100644 index 0000000000000000000000000000000000000000..d74b9abd243032a161f9386719d75ab9fcb4dfc6 --- /dev/null +++ b/tests/vector-copy.lisp @@ -0,0 +1,139 @@ +;; Regression test VECTOR-COPY for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-COPY + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-34.5 8.24 3.29)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SINGLE-FLOAT (A -34.5 8.24 3.29) NIL)) + (V2 (VECTOR-SINGLE-FLOAT '3 NIL))) + (COPY V2 V1) (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-34.5d0 8.24d0 3.29d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT (A -34.5d0 8.24d0 3.29d0) + NIL)) + (V2 (VECTOR-DOUBLE-FLOAT '3 NIL))) + (COPY V2 V1) (CL-ARRAY 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 + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15) NIL)) + (V2 (VECTOR-COMPLEX-SINGLE-FLOAT '3 NIL))) + (COPY V2 V1) (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) + #C(34.12d0 -6.15d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + NIL)) + (V2 (VECTOR-COMPLEX-DOUBLE-FLOAT '3 NIL))) + (COPY V2 V1) (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-64 -68 71)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-8 + '3 NIL))) + (COPY V2 V1) + (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(67 44 189)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-8 + '3 NIL))) + (COPY V2 V1) + (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-64 -68 71)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-16 + '3 NIL))) + (COPY V2 V1) + (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(67 44 189)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-16 + '3 NIL))) + (COPY V2 V1) + (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-64 -68 71)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-32 + '3 NIL))) + (COPY V2 V1) + (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(67 44 189)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-32 + '3 NIL))) + (COPY V2 V1) + (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-64 -68 71)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-64 + '3 NIL))) + (COPY V2 V1) + (CL-ARRAY V2)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(67 44 189)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-64 + '3 NIL))) + (COPY V2 V1) + (CL-ARRAY V2))))) + diff --git a/tests/vector-div.lisp b/tests/vector-div.lisp new file mode 100644 index 0000000000000000000000000000000000000000..2ce4ceffa4495ddbe22588b3cbb4dfb7ec7a6445 --- /dev/null +++ b/tests/vector-div.lisp @@ -0,0 +1,131 @@ +;; Regression test VECTOR-DIV for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-DIV + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(3.8633816 0.24150059 -0.5349593)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SINGLE-FLOAT (A -34.5 8.24 3.29) NIL)) + (V2 + (VECTOR-SINGLE-FLOAT (A -8.93 34.12 -6.15) NIL))) + (CL-ARRAY (M/ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(3.8633818589025757d0 0.2415005861664713d0 + -0.5349593495934959d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT (A -34.5d0 8.24d0 3.29d0) + NIL)) + (V2 + (VECTOR-DOUBLE-FLOAT (A -8.93d0 34.12d0 -6.15d0) + NIL))) + (CL-ARRAY (M/ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 -1 -7)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-8 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M/ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 1)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-8 + (A 116 163 140) + NIL))) + (CL-ARRAY + (M/ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 -1 -7)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-16 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M/ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 1)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-16 + (A 116 163 140) + NIL))) + (CL-ARRAY + (M/ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 -1 -7)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-32 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M/ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 1)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-32 + (A 116 163 140) + NIL))) + (CL-ARRAY + (M/ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 -1 -7)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-64 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M/ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 1)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-64 + (A 116 163 140) + NIL))) + (CL-ARRAY + (M/ V1 V2)))))) + diff --git a/tests/vector-m+.lisp b/tests/vector-m+.lisp new file mode 100644 index 0000000000000000000000000000000000000000..ed36bd2a366f8e75d55520fbecee5fe8518aea86 --- /dev/null +++ b/tests/vector-m+.lisp @@ -0,0 +1,129 @@ +;; Regression test VECTOR-M+ for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-M+ + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-43.43 42.36 -2.8600001)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SINGLE-FLOAT (A -34.5 8.24 3.29) NIL)) + (V2 + (VECTOR-SINGLE-FLOAT (A -8.93 34.12 -6.15) NIL))) + (CL-ARRAY (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-43.43d0 42.36d0 -2.8600000000000003d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT (A -34.5d0 8.24d0 3.29d0) + NIL)) + (V2 + (VECTOR-DOUBLE-FLOAT (A -8.93d0 34.12d0 -6.15d0) + NIL))) + (CL-ARRAY (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(101 -16 61)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-8 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(183 207 73)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-8 + (A 116 163 140) + NIL))) + (CL-ARRAY + (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-155 -16 61)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-16 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(183 207 329)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-16 + (A 116 163 140) + NIL))) + (CL-ARRAY + (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-155 -16 61)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-32 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(183 207 329)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-32 + (A 116 163 140) + NIL))) + (CL-ARRAY + (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-155 -16 61)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-64 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(183 207 329)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-64 + (A 116 163 140) + NIL))) + (CL-ARRAY + (M+ V1 V2)))))) + diff --git a/tests/vector-m-.lisp b/tests/vector-m-.lisp new file mode 100644 index 0000000000000000000000000000000000000000..0aefb15148bbb69cb3c0a68b495445bb4bd44254 --- /dev/null +++ b/tests/vector-m-.lisp @@ -0,0 +1,112 @@ +;; Regression test VECTOR-M- for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-M- + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-25.57 -25.88 9.440001)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SINGLE-FLOAT (A -34.5 8.24 3.29) NIL)) + (V2 + (VECTOR-SINGLE-FLOAT (A -8.93 34.12 -6.15) NIL))) + (CL-ARRAY (M- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-25.57d0 -25.879999999999995d0 9.440000000000001d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT (A -34.5d0 8.24d0 3.29d0) + NIL)) + (V2 + (VECTOR-DOUBLE-FLOAT (A -8.93d0 34.12d0 -6.15d0) + NIL))) + (CL-ARRAY (M- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-8 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(207 137 49)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-8 + (A 116 163 140) + NIL))) + (CL-ARRAY + (M- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-16 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(65487 65417 49)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-UNSIGNED-BYTE-16 (A 67 44 189) NIL)) + (V2 (VECTOR-UNSIGNED-BYTE-16 (A 116 163 140) NIL))) + (CL-ARRAY (M- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-32 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(4294967247 4294967177 49)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-UNSIGNED-BYTE-32 (A 67 44 189) NIL)) + (V2 (VECTOR-UNSIGNED-BYTE-32 (A 116 163 140) NIL))) + (CL-ARRAY (M- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-64 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(18446744073709551567 18446744073709551497 49)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-UNSIGNED-BYTE-64 (A 67 44 189) NIL)) + (V2 (VECTOR-UNSIGNED-BYTE-64 (A 116 163 140) NIL))) + (CL-ARRAY (M- V1 V2)))))) + diff --git a/tests/vector-max-index.lisp b/tests/vector-max-index.lisp new file mode 100644 index 0000000000000000000000000000000000000000..84591ba694fee483bb521b1efe318ac80b056602 --- /dev/null +++ b/tests/vector-max-index.lisp @@ -0,0 +1,111 @@ +;; Regression test VECTOR-MAX-INDEX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-MAX-INDEX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 + 3.29 -8.93 + 34.12 -6.15 + 49.27 -13.49) + NIL))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 + 8.24d0 3.29d0 + -8.93d0 + 34.12d0 + -6.15d0 + 49.27d0 + -13.49d0) + NIL))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MAX-INDEX V1))))) + diff --git a/tests/vector-max.lisp b/tests/vector-max.lisp new file mode 100644 index 0000000000000000000000000000000000000000..591a371e5f7045c14db1e87de48f767393e1ccb5 --- /dev/null +++ b/tests/vector-max.lisp @@ -0,0 +1,89 @@ +;; Regression test VECTOR-MAX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-MAX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 8.24) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 + 3.29) + NIL))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 8.24d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 + 8.24d0 + 3.29d0) + NIL))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71) + NIL))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189) + NIL))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71) + NIL))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189) + NIL))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71) + NIL))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189) + NIL))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71) + NIL))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189) + NIL))) + (MMAX V1))))) + diff --git a/tests/vector-mean.lisp b/tests/vector-mean.lisp new file mode 100644 index 0000000000000000000000000000000000000000..3f7ae77f835be07d607f2463ae318377b2e89c5a --- /dev/null +++ b/tests/vector-mean.lisp @@ -0,0 +1,109 @@ +;; Regression test VECTOR-MEAN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-MEAN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3.9812498688697815d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3.98125d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 + 8.24d0 3.29d0 + -8.93d0 + 34.12d0 + -6.15d0 + 49.27d0 + -13.49d0) + NIL))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MEAN V1))))) + diff --git a/tests/vector-min-index.lisp b/tests/vector-min-index.lisp new file mode 100644 index 0000000000000000000000000000000000000000..712c53427659d2677f79ace1bd8686309acbdc02 --- /dev/null +++ b/tests/vector-min-index.lisp @@ -0,0 +1,111 @@ +;; Regression test VECTOR-MIN-INDEX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-MIN-INDEX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 + 3.29 -8.93 + 34.12 -6.15 + 49.27 -13.49) + NIL))) + (MIN-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 + 8.24d0 3.29d0 + -8.93d0 + 34.12d0 + -6.15d0 + 49.27d0 + -13.49d0) + NIL))) + (MIN-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MIN-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MIN-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MIN-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MIN-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MIN-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MIN-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MIN-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MIN-INDEX V1))))) + diff --git a/tests/vector-minmax-index.lisp b/tests/vector-minmax-index.lisp new file mode 100644 index 0000000000000000000000000000000000000000..6effd2a2538768ab009020e0c95ea90d9edfb0ed --- /dev/null +++ b/tests/vector-minmax-index.lisp @@ -0,0 +1,121 @@ +;; Regression test VECTOR-MINMAX-INDEX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-MINMAX-INDEX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 + 3.29 -8.93 + 34.12 -6.15 + 49.27 -13.49) + NIL))) + (MINMAX-INDEX + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 + 8.24d0 3.29d0 + -8.93d0 + 34.12d0 + -6.15d0 + 49.27d0 + -13.49d0) + NIL))) + (MINMAX-INDEX + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MINMAX-INDEX + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 7) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MINMAX-INDEX + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MINMAX-INDEX + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 7) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MINMAX-INDEX + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MINMAX-INDEX + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 7) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MINMAX-INDEX + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3 6) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (MINMAX-INDEX + V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 7) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (MINMAX-INDEX + V1))))) + diff --git a/tests/vector-minmax.lisp b/tests/vector-minmax.lisp new file mode 100644 index 0000000000000000000000000000000000000000..4311c97ca6fd109e1cc7f9435a1fd3a0b0796e07 --- /dev/null +++ b/tests/vector-minmax.lisp @@ -0,0 +1,89 @@ +;; Regression test VECTOR-MINMAX for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-MINMAX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5 8.24) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 + 3.29) + NIL))) + (MINMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0 8.24d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 + 8.24d0 + 3.29d0) + NIL))) + (MINMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68 71) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71) + NIL))) + (MINMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 189) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189) + NIL))) + (MINMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68 71) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71) + NIL))) + (MINMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 189) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189) + NIL))) + (MINMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68 71) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71) + NIL))) + (MINMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 189) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189) + NIL))) + (MINMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -68 71) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71) + NIL))) + (MINMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 189) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189) + NIL))) + (MINMAX V1))))) + diff --git a/tests/vector-mult-scalar.lisp b/tests/vector-mult-scalar.lisp new file mode 100644 index 0000000000000000000000000000000000000000..77759c60fafccfc66a003d818a0153eddf7ff7ce --- /dev/null +++ b/tests/vector-mult-scalar.lisp @@ -0,0 +1,100 @@ +;; Regression test VECTOR-MULT-SCALAR for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-MULT-SCALAR + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-47.955 11.4536 4.5731)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SINGLE-FLOAT (A -34.5 8.24 3.29) NIL))) + (CL-ARRAY (M*C V1 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-47.955d0 11.4536d0 4.5731d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT (A -34.5d0 8.24d0 3.29d0) + NIL))) + (CL-ARRAY (M*C V1 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-88 -94 98)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71) + NIL))) + (CL-ARRAY + (M*C V1 + 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(93 61 6)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189) + NIL))) + (CL-ARRAY + (M*C V1 + 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-88 -94 98)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71) + NIL))) + (CL-ARRAY + (M*C V1 + 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(93 61 262)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189) + NIL))) + (CL-ARRAY + (M*C V1 + 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-88 -94 98)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71) + NIL))) + (CL-ARRAY + (M*C V1 + 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(93 61 262)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189) + NIL))) + (CL-ARRAY + (M*C V1 + 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-88 -94 98)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71) + NIL))) + (CL-ARRAY + (M*C V1 + 1.39d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(93 61 262)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189) + NIL))) + (CL-ARRAY + (M*C V1 + 1.39d0)))))) + diff --git a/tests/vector-mult.lisp b/tests/vector-mult.lisp new file mode 100644 index 0000000000000000000000000000000000000000..2d9f34fa41364030d519ebda7548cc0ee91d85c3 --- /dev/null +++ b/tests/vector-mult.lisp @@ -0,0 +1,93 @@ +;; Regression test VECTOR-MULT for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-MULT + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(308.08502 281.14877 -20.2335)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SINGLE-FLOAT (A -34.5 8.24 3.29) NIL)) + (V2 + (VECTOR-SINGLE-FLOAT (A -8.93 34.12 -6.15) NIL))) + (CL-ARRAY (M* V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(308.085d0 281.1488d0 -20.233500000000003d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT (A -34.5d0 8.24d0 3.29d0) + NIL)) + (V2 + (VECTOR-DOUBLE-FLOAT (A -8.93d0 34.12d0 -6.15d0) + NIL))) + (CL-ARRAY (M* V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-64 48 58)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71) + NIL)) + (V2 + (VECTOR-SIGNED-BYTE-8 + (A -91 52 -10) + NIL))) + (CL-ARRAY + (M* V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(92 4 92)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189) + NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-8 + (A 116 163 140) + NIL))) + (CL-ARRAY + (M* V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(5824 -3536 -710)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SIGNED-BYTE-16 (A -64 -68 71) NIL)) + (V2 (VECTOR-SIGNED-BYTE-16 (A -91 52 -10) NIL))) + (CL-ARRAY (M* V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(7772 7172 26460)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-UNSIGNED-BYTE-16 (A 67 44 189) NIL)) + (V2 (VECTOR-UNSIGNED-BYTE-16 (A 116 163 140) NIL))) + (CL-ARRAY (M* V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(5824 -3536 -710)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SIGNED-BYTE-32 (A -64 -68 71) NIL)) + (V2 (VECTOR-SIGNED-BYTE-32 (A -91 52 -10) NIL))) + (CL-ARRAY (M* V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(7772 7172 26460)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-UNSIGNED-BYTE-32 (A 67 44 189) NIL)) + (V2 (VECTOR-UNSIGNED-BYTE-32 (A 116 163 140) NIL))) + (CL-ARRAY (M* V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(5824 -3536 -710)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SIGNED-BYTE-64 (A -64 -68 71) NIL)) + (V2 (VECTOR-SIGNED-BYTE-64 (A -91 52 -10) NIL))) + (CL-ARRAY (M* V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(7772 7172 26460)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-UNSIGNED-BYTE-64 (A 67 44 189) NIL)) + (V2 (VECTOR-UNSIGNED-BYTE-64 (A 116 163 140) NIL))) + (CL-ARRAY (M* V1 V2)))))) + diff --git a/tests/vector-reverse.lisp b/tests/vector-reverse.lisp new file mode 100644 index 0000000000000000000000000000000000000000..091181cb8ecb26923b98d36d2d36d896022caca3 --- /dev/null +++ b/tests/vector-reverse.lisp @@ -0,0 +1,121 @@ +;; Regression test VECTOR-REVERSE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-REVERSE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-13.49 49.27 -6.15 34.12 -8.93 3.29 8.24 -34.5)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL))) + (CL-ARRAY (VECTOR-REVERSE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-13.49d0 49.27d0 -6.15d0 34.12d0 -8.93d0 3.29d0 + 8.24d0 -34.5d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL))) + (CL-ARRAY (VECTOR-REVERSE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(21.44 -49.08) #C(-16.12 -8.25) #C(-17.24 43.31) + #C(32.5 42.73) #C(49.27 -13.49) #C(34.12 -6.15) + #C(3.29 -8.93) #C(-34.5 8.24))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49 + 32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 + -49.08) + NIL))) + (CL-ARRAY (VECTOR-REVERSE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(21.44d0 -49.08d0) #C(-16.12d0 -8.25d0) + #C(-17.24d0 43.31d0) #C(32.5d0 42.73d0) + #C(49.27d0 -13.49d0) #C(34.12d0 -6.15d0) + #C(3.29d0 -8.93d0) #C(-34.5d0 8.24d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 + 43.31d0 -16.12d0 -8.25d0 21.44d0 -49.08d0) + NIL))) + (CL-ARRAY (VECTOR-REVERSE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-5 73 -10 52 -91 71 -68 -64)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (CL-ARRAY (VECTOR-REVERSE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(215 161 140 163 116 189 44 67)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 163 140 161 215) NIL))) + (CL-ARRAY (VECTOR-REVERSE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-5 73 -10 52 -91 71 -68 -64)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (CL-ARRAY (VECTOR-REVERSE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(215 161 140 163 116 189 44 67)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 163 140 161 215) NIL))) + (CL-ARRAY (VECTOR-REVERSE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-5 73 -10 52 -91 71 -68 -64)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (CL-ARRAY (VECTOR-REVERSE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(215 161 140 163 116 189 44 67)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 163 140 161 215) NIL))) + (CL-ARRAY (VECTOR-REVERSE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-5 73 -10 52 -91 71 -68 -64)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (CL-ARRAY (VECTOR-REVERSE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(215 161 140 163 116 189 44 67)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 163 140 161 215) NIL))) + (CL-ARRAY (VECTOR-REVERSE V1)))))) + diff --git a/tests/vector-set-all-m+.lisp b/tests/vector-set-all-m+.lisp new file mode 100644 index 0000000000000000000000000000000000000000..7b2e7cef13d8fe498d3a20a3f54bb4f490649bc3 --- /dev/null +++ b/tests/vector-set-all-m+.lisp @@ -0,0 +1,108 @@ +;; Regression test VECTOR-SET-ALL-M+ for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-SET-ALL-M+ + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-43.43 -0.69000053 -5.6400003)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SINGLE-FLOAT '3 NIL)) + (V2 (VECTOR-SINGLE-FLOAT (A -34.5 8.24 3.29) NIL))) + (SET-ALL V1 -8.93) (CL-ARRAY (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-43.43d0 -0.6899999999999995d0 -5.64d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-DOUBLE-FLOAT '3 NIL)) + (V2 + (VECTOR-DOUBLE-FLOAT (A -34.5d0 8.24d0 3.29d0) + NIL))) + (SET-ALL V1 -8.93d0) (CL-ARRAY (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(101 97 -20)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + '3 NIL)) + (V2 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71) + NIL))) + (SET-ALL V1 -91) + (CL-ARRAY + (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(183 160 49)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + '3 NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189) + NIL))) + (SET-ALL V1 116) + (CL-ARRAY + (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-155 -159 -20)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SIGNED-BYTE-16 '3 NIL)) + (V2 (VECTOR-SIGNED-BYTE-16 (A -64 -68 71) NIL))) + (SET-ALL V1 -91) (CL-ARRAY (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(183 160 305)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + '3 NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189) + NIL))) + (SET-ALL V1 116) + (CL-ARRAY + (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-155 -159 -20)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SIGNED-BYTE-32 '3 NIL)) + (V2 (VECTOR-SIGNED-BYTE-32 (A -64 -68 71) NIL))) + (SET-ALL V1 -91) (CL-ARRAY (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(183 160 305)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + '3 NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189) + NIL))) + (SET-ALL V1 116) + (CL-ARRAY + (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-155 -159 -20)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SIGNED-BYTE-64 '3 NIL)) + (V2 (VECTOR-SIGNED-BYTE-64 (A -64 -68 71) NIL))) + (SET-ALL V1 -91) (CL-ARRAY (M+ V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(183 160 305)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + '3 NIL)) + (V2 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189) + NIL))) + (SET-ALL V1 116) + (CL-ARRAY + (M+ V1 V2)))))) + diff --git a/tests/vector-set-zero.lisp b/tests/vector-set-zero.lisp new file mode 100644 index 0000000000000000000000000000000000000000..8fba3d6b0bb64c348c16c11553d9d53c4d54458f --- /dev/null +++ b/tests/vector-set-zero.lisp @@ -0,0 +1,114 @@ +;; Regression test VECTOR-SET-ZERO for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-SET-ZERO + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0.0 0.0 0.0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 + 3.29) + NIL))) + (SET-ZERO V1) + (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0.0d0 0.0d0 0.0d0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT (A -34.5d0 8.24d0 3.29d0) + NIL))) + (SET-ZERO V1) (CL-ARRAY 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 + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15) NIL))) + (SET-ZERO V1) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(#C(0.0d0 0.0d0) #C(0.0d0 0.0d0) #C(0.0d0 0.0d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + NIL))) + (SET-ZERO V1) (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71) + NIL))) + (SET-ZERO V1) + (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189) + NIL))) + (SET-ZERO V1) + (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71) + NIL))) + (SET-ZERO V1) + (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189) + NIL))) + (SET-ZERO V1) + (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71) + NIL))) + (SET-ZERO V1) + (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189) + NIL))) + (SET-ZERO V1) + (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71) + NIL))) + (SET-ZERO V1) + (CL-ARRAY V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 0 0)) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189) + NIL))) + (SET-ZERO V1) + (CL-ARRAY V1))))) + diff --git a/tests/vector-standard-deviation-with-fixed-mean.lisp b/tests/vector-standard-deviation-with-fixed-mean.lisp new file mode 100644 index 0000000000000000000000000000000000000000..3fa537b4fed28850a66a34f4843d4beff75925bf --- /dev/null +++ b/tests/vector-standard-deviation-with-fixed-mean.lisp @@ -0,0 +1,89 @@ +;; Regression test VECTOR-STANDARD-DEVIATION-WITH-FIXED-MEAN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-STANDARD-DEVIATION-WITH-FIXED-MEAN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 25.08341998337271d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 25.08342004068624d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 61.216317269172606d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 54.81659762334762d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 163 140 161 215) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 61.216317269172606d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 54.81659762334762d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 163 140 161 215) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 61.216317269172606d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 54.81659762334762d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 163 140 161 215) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 61.216317269172606d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 54.81659762334762d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 163 140 161 215) NIL))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))) + diff --git a/tests/vector-standard-deviation-with-mean.lisp b/tests/vector-standard-deviation-with-mean.lisp new file mode 100644 index 0000000000000000000000000000000000000000..57577c6527503a46dc1f26c07e7bbaf5c02143e2 --- /dev/null +++ b/tests/vector-standard-deviation-with-mean.lisp @@ -0,0 +1,89 @@ +;; Regression test VECTOR-STANDARD-DEVIATION-WITH-MEAN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-STANDARD-DEVIATION-WITH-MEAN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.815303904668458d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.815303965939197d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 163 140 161 215) NIL))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 163 140 161 215) NIL))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 163 140 161 215) NIL))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 163 140 161 215) NIL))) + (STANDARD-DEVIATION V1 (MEAN V1)))))) + diff --git a/tests/vector-standard-deviation.lisp b/tests/vector-standard-deviation.lisp new file mode 100644 index 0000000000000000000000000000000000000000..e814c16345c5c9550082d8852c9bfad95e2c695a --- /dev/null +++ b/tests/vector-standard-deviation.lisp @@ -0,0 +1,89 @@ +;; Regression test VECTOR-STANDARD-DEVIATION for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-STANDARD-DEVIATION + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.815303904668458d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.815303965939197d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 163 140 161 215) NIL))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 163 140 161 215) NIL))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 163 140 161 215) NIL))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 163 140 161 215) NIL))) + (STANDARD-DEVIATION V1))))) + diff --git a/tests/vector-swap.lisp b/tests/vector-swap.lisp new file mode 100644 index 0000000000000000000000000000000000000000..a15263a18af531ae546eb257f2afda81fe692bb1 --- /dev/null +++ b/tests/vector-swap.lisp @@ -0,0 +1,116 @@ +;; Regression test VECTOR-SWAP for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-SWAP + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST #(-8.93 34.12 -6.15) #(-34.5 8.24 3.29))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SINGLE-FLOAT (A -34.5 8.24 3.29) NIL)) + (V2 + (VECTOR-SINGLE-FLOAT (A -8.93 34.12 -6.15) NIL))) + (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST #(-8.93d0 34.12d0 -6.15d0) + #(-34.5d0 8.24d0 3.29d0))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT (A -34.5d0 8.24d0 3.29d0) + NIL)) + (V2 + (VECTOR-DOUBLE-FLOAT (A -8.93d0 34.12d0 -6.15d0) + NIL))) + (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST + #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)) + #(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15) NIL)) + (V2 + (VECTOR-COMPLEX-SINGLE-FLOAT + (A -8.93 34.12 -6.15 49.27 -13.49 32.5) NIL))) + (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST + #(#C(-8.93d0 34.12d0) #C(-6.15d0 49.27d0) + #C(-13.49d0 32.5d0)) + #(#C(-34.5d0 8.24d0) #C(3.29d0 -8.93d0) + #C(34.12d0 -6.15d0)))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0) + NIL)) + (V2 + (VECTOR-COMPLEX-DOUBLE-FLOAT + (A -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0 + 32.5d0) + NIL))) + (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST #(-91 52 -10) #(-64 -68 71))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SIGNED-BYTE-8 (A -64 -68 71) NIL)) + (V2 (VECTOR-SIGNED-BYTE-8 (A -91 52 -10) NIL))) + (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST #(116 163 140) #(67 44 189))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-UNSIGNED-BYTE-8 (A 67 44 189) NIL)) + (V2 (VECTOR-UNSIGNED-BYTE-8 (A 116 163 140) NIL))) + (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST #(-91 52 -10) #(-64 -68 71))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SIGNED-BYTE-16 (A -64 -68 71) NIL)) + (V2 (VECTOR-SIGNED-BYTE-16 (A -91 52 -10) NIL))) + (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST #(116 163 140) #(67 44 189))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-UNSIGNED-BYTE-16 (A 67 44 189) NIL)) + (V2 (VECTOR-UNSIGNED-BYTE-16 (A 116 163 140) NIL))) + (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST #(-91 52 -10) #(-64 -68 71))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SIGNED-BYTE-32 (A -64 -68 71) NIL)) + (V2 (VECTOR-SIGNED-BYTE-32 (A -91 52 -10) NIL))) + (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST #(116 163 140) #(67 44 189))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-UNSIGNED-BYTE-32 (A 67 44 189) NIL)) + (V2 (VECTOR-UNSIGNED-BYTE-32 (A 116 163 140) NIL))) + (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST #(-91 52 -10) #(-64 -68 71))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-SIGNED-BYTE-64 (A -64 -68 71) NIL)) + (V2 (VECTOR-SIGNED-BYTE-64 (A -91 52 -10) NIL))) + (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST (LIST #(116 163 140) #(67 44 189))) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 (VECTOR-UNSIGNED-BYTE-64 (A 67 44 189) NIL)) + (V2 (VECTOR-UNSIGNED-BYTE-64 (A 116 163 140) NIL))) + (SWAP V2 V1) (LIST (CL-ARRAY V1) (CL-ARRAY V2)))))) + diff --git a/tests/vector-variance-with-fixed-mean.lisp b/tests/vector-variance-with-fixed-mean.lisp new file mode 100644 index 0000000000000000000000000000000000000000..2f0fdb2686fde2d1c64c7cd3745d7cc93ada47ce --- /dev/null +++ b/tests/vector-variance-with-fixed-mean.lisp @@ -0,0 +1,113 @@ +;; Regression test VECTOR-VARIANCE-WITH-FIXED-MEAN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-VARIANCE-WITH-FIXED-MEAN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 629.1779580622615d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL))) + (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 629.1779609375001d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL))) + (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 + -91 52 -10 73 + -5) + NIL))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1)))))) + diff --git a/tests/vector-variance-with-mean.lisp b/tests/vector-variance-with-mean.lisp new file mode 100644 index 0000000000000000000000000000000000000000..372c96cc2a2cf0205f36ce8b54d4b954844c083f --- /dev/null +++ b/tests/vector-variance-with-mean.lisp @@ -0,0 +1,105 @@ +;; Regression test VECTOR-VARIANCE-WITH-MEAN for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-VARIANCE-WITH-MEAN + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.0605234997274d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL))) + (VARIANCE V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.0605267857144d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL))) + (VARIANCE V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4282.785714285714d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (VARIANCE V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (VARIANCE V1 + (MEAN + V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4282.785714285714d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (VARIANCE V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (VARIANCE V1 + (MEAN + V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4282.785714285714d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (VARIANCE V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (VARIANCE V1 + (MEAN + V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4282.785714285714d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (VARIANCE V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (VARIANCE V1 + (MEAN + V1)))))) + diff --git a/tests/vector-variance.lisp b/tests/vector-variance.lisp new file mode 100644 index 0000000000000000000000000000000000000000..3402c7b42d333a557932f932054d99483af2a153 --- /dev/null +++ b/tests/vector-variance.lisp @@ -0,0 +1,97 @@ +;; Regression test VECTOR-VARIANCE for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST VECTOR-VARIANCE + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.0605234997274d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SINGLE-FLOAT + (A -34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49) + NIL))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.0605267857144d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-DOUBLE-FLOAT + (A -34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 + 49.27d0 -13.49d0) + NIL))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4282.785714285714d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-8 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-8 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4282.785714285714d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-16 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-16 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4282.785714285714d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-32 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-32 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4282.785714285714d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-SIGNED-BYTE-64 + (A -64 -68 71 -91 52 -10 73 -5) NIL))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) + (MULTIPLE-VALUE-LIST + (LETM + ((V1 + (VECTOR-UNSIGNED-BYTE-64 + (A 67 44 189 116 + 163 140 161 + 215) + NIL))) + (VARIANCE V1))))) + diff --git a/tests/weibull.lisp b/tests/weibull.lisp new file mode 100644 index 0000000000000000000000000000000000000000..53ec1a53bf116b054bc415c0551e8bc95244581e --- /dev/null +++ b/tests/weibull.lisp @@ -0,0 +1,36 @@ +;; Regression test WEIBULL for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST WEIBULL + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST 0.0160712303786595d0 1.347055359960668d0 + 1.1241262408795445d0 0.2329031397826649d0 + 1.209338423856536d0 0.8506825453443836d0 + 0.20845532973957762d0 0.5434187344070215d0 + 0.7849237503774361d0 0.5487883320132739d0 + 0.5239377808419179d0)) + (MULTIPLE-VALUE-LIST + (LETM ((RNG (RANDOM-NUMBER-GENERATOR *MT19937* 0))) + (LOOP FOR I FROM 0 TO 10 COLLECT + (WEIBULL RNG 1.0d0 2.0d0))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.24263174972226745d0) + (MULTIPLE-VALUE-LIST (WEIBULL-PDF 1.5d0 1.3d0 1.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.9992887742799077d0) + (MULTIPLE-VALUE-LIST (WEIBULL-P 3.5d0 1.3d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 7.112257200923508d-4) + (MULTIPLE-VALUE-LIST (WEIBULL-Q 3.5d0 1.3d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3.5000000000000164d0) + (MULTIPLE-VALUE-LIST + (WEIBULL-PINV 0.9992887742799077d0 1.3d0 2.0d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3.5d0) + (MULTIPLE-VALUE-LIST + (WEIBULL-QINV + 7.112257200923508d-4 + 1.3d0 2.0d0)))) + diff --git a/tests/zeta.lisp b/tests/zeta.lisp new file mode 100644 index 0000000000000000000000000000000000000000..1fdf3d46bbb7ec33c78a554b3ff731c913a387fc --- /dev/null +++ b/tests/zeta.lisp @@ -0,0 +1,24 @@ +;; Regression test ZETA for GSLL, automatically generated + +(in-package :gsl) + +(LISP-UNIT:DEFINE-TEST ZETA + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.6449340668482264d0 7.304974700020789d-16) + (MULTIPLE-VALUE-LIST (ZETA 2))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2.612375348685493d0 1.419471177334903d-14) + (MULTIPLE-VALUE-LIST (ZETA 1.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.6449340668482264d0 2.8640826015201633d-16) + (MULTIPLE-VALUE-LIST (ZETA-1 2))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.612375348685493d0 1.419471177334903d-14) + (MULTIPLE-VALUE-LIST (ZETA-1 1.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 1.4037797688568256d0 8.104244828616706d-15) + (MULTIPLE-VALUE-LIST (HURWITZ-ZETA 1.5d0 2.5d0))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0.7651470246254092d0 1.0661276646941275d-14) + (MULTIPLE-VALUE-LIST (ETA 1.5d0)))) +