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))))
+