diff --git a/basis-splines.lisp b/basis-splines.lisp index eddb72a329a1a28ccfc671f301ebd09f9c0f60ea..b5f3b8bad596464742c0762a58d34ca610a96121 100644 --- a/basis-splines.lisp +++ b/basis-splines.lisp @@ -1,8 +1,8 @@ ;; Basis splines. ;; Liam Healy 2008-02-18 14:43:20EST basis-splines.lisp -;; Time-stamp: <2010-06-30 19:57:28EDT basis-splines.lisp> +;; Time-stamp: <2011-05-26 12:37:29EDT basis-splines.lisp> ;; -;; Copyright 2008, 2009 Liam M. Healy +;; Copyright 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -125,18 +125,18 @@ (let* ((xi (coerce (* i (/ 15 (1- ndata))) 'double-float)) (yi (+ (* (cos xi) (exp (* -0.1d0 xi))) (sample rng :gaussian :sigma sigma)))) - (setf (grid:gref x i) xi - (grid:gref y i) yi - (grid:gref w i) (/ (expt sigma 2))))) + (setf (grid:aref x i) xi + (grid:aref y i) yi + (grid:aref w i) (/ (expt sigma 2))))) ;; Uniform breakpoints [0, 15] (uniform-knots 0.0d0 15.0d0 bw) ;; Fit matrix (dotimes (i ndata) ;; Compute B_j - (evaluate bw (grid:gref x i) :b B) + (evaluate bw (grid:aref x i) :b B) ;; Fill in row i of X (dotimes (j ncoeffs) - (setf (grid:gref Xmatrix i j) (grid:gref B j)))) + (setf (grid:aref Xmatrix i j) (grid:aref B j)))) ;; Do the fit (linear-mfit Xmatrix y c w nil cov mw) ;; Return the smoothed curve diff --git a/calculus/monte-carlo.lisp b/calculus/monte-carlo.lisp index 6bffa80318a67013dafd1109c920994a7d2502b2..fdd628e6ea7d3d345e1066da5d50b67af5d8af82 100644 --- a/calculus/monte-carlo.lisp +++ b/calculus/monte-carlo.lisp @@ -1,8 +1,8 @@ ;; Monte Carlo Integration ;; Liam Healy Sat Feb 3 2007 - 17:42 -;; Time-stamp: <2010-08-07 21:41:14EDT monte-carlo.lisp> +;; Time-stamp: <2011-01-10 17:59:20EST monte-carlo.lisp> ;; -;; Copyright 2007, 2008, 2009 Liam M. Healy +;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -51,7 +51,7 @@ (scalars t)) "gsl_monte_plain_integrate" ((callback :pointer) - ((foreign-pointer lower-limits) :pointer) ((foreign-pointer upper-limits) :pointer) + ((grid:foreign-pointer lower-limits) :pointer) ((grid:foreign-pointer upper-limits) :pointer) ((dim0 lower-limits) sizet) (number-of-samples sizet) ((mpointer generator) :pointer) ((mpointer state) :pointer) @@ -112,7 +112,7 @@ (scalars t)) "gsl_monte_miser_integrate" ((callback :pointer) - ((foreign-pointer lower-limits) :pointer) ((foreign-pointer upper-limits) :pointer) + ((grid:foreign-pointer lower-limits) :pointer) ((grid:foreign-pointer upper-limits) :pointer) ((dim0 lower-limits) sizet) (number-of-samples sizet) ((mpointer generator) :pointer) ((mpointer state) :pointer) @@ -173,7 +173,7 @@ (scalars t)) "gsl_monte_vegas_integrate" ((callback :pointer) - ((foreign-pointer lower-limits) :pointer) ((foreign-pointer upper-limits) :pointer) + ((grid:foreign-pointer lower-limits) :pointer) ((grid:foreign-pointer upper-limits) :pointer) ((dim0 lower-limits) sizet) (number-of-samples sizet) ((mpointer generator) :pointer) ((mpointer state) :pointer) diff --git a/calculus/numerical-integration.lisp b/calculus/numerical-integration.lisp index f11be59c1700f1c8bf299a540b731952224931c7..e398b2b1a2e05889d52fe42b3aaddb8b4bf3ecaf 100644 --- a/calculus/numerical-integration.lisp +++ b/calculus/numerical-integration.lisp @@ -1,8 +1,8 @@ ;; Numerical integration ;; Liam Healy, Wed Jul 5 2006 - 23:14 -;; Time-stamp: <2010-08-07 21:46:21EDT numerical-integration.lisp> +;; Time-stamp: <2011-01-10 17:59:21EST numerical-integration.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009, 2010 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -157,7 +157,7 @@ (limit 1000) (workspace (make-integration-workspace limit))) "gsl_integration_qagp" ((callback :pointer) - ((foreign-pointer points) :pointer) ((dim0 points) sizet) + ((grid:foreign-pointer points) :pointer) ((dim0 points) sizet) (absolute-error :double) (relative-error :double) (limit sizet) ((mpointer workspace) :pointer) (result (:pointer :double)) (abserr (:pointer :double))) diff --git a/data/both.lisp b/data/both.lisp index 31c23f450a53af34d39d3dc06758cc26433147ef..10ad027e3c433e3125c5b5351d4947e56b14a882 100644 --- a/data/both.lisp +++ b/data/both.lisp @@ -1,8 +1,8 @@ ;; Functions for both vectors and matrices. ;; Liam Healy 2008-04-26 20:48:44EDT both.lisp -;; Time-stamp: <2010-11-25 09:31:17EST both.lisp> +;; Time-stamp: <2011-05-26 12:37:36EDT both.lisp> ;; -;; Copyright 2008, 2009, 2010 Liam M. Healy +;; Copyright 2008, 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -35,13 +35,13 @@ :export nil :documentation "Allocate memory for the GSL struct given a block pointer.") -(defmfun alloc-from-block ((object matrix) blockptr) +(defmfun alloc-from-block ((object grid:matrix) blockptr) ("gsl_" :category :type "_alloc_from_block") ((blockptr :pointer) (0 sizet) ; offset - ((first (dimensions object)) sizet) ; number of rows - ((second (dimensions object)) sizet) ; number of columns - ((second (dimensions object)) sizet)) ; "tda" = number of columns for now + ((first (grid:dimensions object)) sizet) ; number of rows + ((second (grid:dimensions object)) sizet) ; number of columns + ((second (grid:dimensions object)) sizet)) ; "tda" = number of columns for now :definition :methods :c-return :pointer :export nil) @@ -81,7 +81,7 @@ ;;;;**************************************************************************** ;;;; Array elements; used in callbacks scalarsp=T only ;;;;**************************************************************************** -;;; Normal foreign array access is with grid:gref, but in order to +;;; Normal foreign array access is with grid:aref, but in order to ;;; avoid the overhead of instantiating a foreign-array object to ;;; access components, we use these macros which expand to gsl_*_get ;;; and gsl_*_set. @@ -113,7 +113,7 @@ `(cffi:foreign-funcall ,(actual-gsl-function-name `("gsl_" :category :type ,(if value "_set" "_get")) - (if matrixp 'matrix 'vector) + (if matrixp 'grid:matrix 'vector) element-type) :pointer ,mpointer sizet ,(first indices) @@ -192,7 +192,7 @@ :documentation ; FDL "Add the scalar complex x to all the elements of array a.") -(defmethod elt+ ((x float) (a foreign-array)) +(defmethod elt+ ((x float) (a grid:foreign-array)) (elt+ a x)) (defmfun elt- ((a both) (b both)) @@ -207,7 +207,7 @@ "Subtract the elements of b from the elements of a. The two must have the same dimensions.") -(defmethod elt- ((a foreign-array) (x float)) +(defmethod elt- ((a grid:foreign-array) (x float)) (elt+ a (- x))) (defmfun elt* ((a vector) (b vector)) @@ -222,7 +222,7 @@ "Multiply the elements of a by the elements of b. The two must have the same dimensions.") -(defmfun elt* ((a matrix) (b matrix)) +(defmfun elt* ((a grid:matrix) (b grid:matrix)) ("gsl_" :category :type "_mul_elements") (((mpointer a) :pointer) ((mpointer b) :pointer)) :definition :methods @@ -243,7 +243,7 @@ "Divide the elements of a by the elements of b. The two must have the same dimensions.") -(defmfun elt/ ((a matrix) (b matrix)) +(defmfun elt/ ((a grid:matrix) (b grid:matrix)) ("gsl_" :category :type "_div_elements") (((mpointer a) :pointer) ((mpointer b) :pointer)) :definition :methods @@ -252,7 +252,7 @@ :outputs (a) :return (a)) -(defmethod elt/ ((a foreign-array) (x number)) +(defmethod elt/ ((a grid:foreign-array) (x number)) (elt* a (/ x))) (defmfun elt* ((a both) (x float)) @@ -279,7 +279,7 @@ :documentation ; FDL "Multiply the elements of a by the scalar complex factor x.") -(defmethod elt* ((x float) (a foreign-array)) +(defmethod elt* ((x float) (a grid:foreign-array)) (elt* a x)) ;;;;**************************************************************************** @@ -329,7 +329,7 @@ "The index of the minimum value in a. When there are several equal minimum elements, then the lowest index is returned.") -(defmfun min-index ((a matrix)) +(defmfun min-index ((a grid:matrix)) ("gsl_" :category :type "_min_index") (((mpointer a) :pointer) (imin (:pointer sizet)) (jmin (:pointer sizet))) :definition :methods @@ -348,7 +348,7 @@ "The index of the maximum value in a. When there are several equal maximum elements, then the lowest index is returned.") -(defmfun max-index ((a matrix)) +(defmfun max-index ((a grid:matrix)) ("gsl_" :category :type "_max_index") (((mpointer a) :pointer) (imin (:pointer sizet)) (jmin (:pointer sizet))) :definition :methods @@ -369,7 +369,7 @@ returned. Returned indices are minimum, maximum; for matrices imin, jmin, imax, jmax.") -(defmfun minmax-index ((a matrix)) +(defmfun minmax-index ((a grid:matrix)) ("gsl_" :category :type "_minmax_index") (((mpointer a) :pointer) (imin (:pointer sizet)) (jmin (:pointer sizet)) diff --git a/data/combination.lisp b/data/combination.lisp index ae57ad5b50536346dfff795f605619d4f84054c2..06d2538c66e16a883a34cfb7021484b5afeefb49 100644 --- a/data/combination.lisp +++ b/data/combination.lisp @@ -1,8 +1,8 @@ ;; Combinations ;; Liam Healy, Sun Mar 26 2006 - 11:51 -;; Time-stamp: <2010-07-16 17:14:03EDT combination.lisp> +;; Time-stamp: <2011-01-10 18:16:28EST combination.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009, 2010 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -37,7 +37,7 @@ (setf (grid:metadata-slot object 'mpointer) mptr (cffi:foreign-slot-value mptr 'gsl-combination-c 'data) - (foreign-pointer object) + (grid:foreign-pointer object) (cffi:foreign-slot-value mptr 'gsl-combination-c 'range) range (cffi:foreign-slot-value mptr 'gsl-combination-c 'size) @@ -56,7 +56,7 @@ (make-instance 'combination :element-type '(unsigned-byte #+int64 64 #+int32 32) - :range (combination-range n) :dimensions (dimensions k)) + :range (combination-range n) :dimensions (grid:dimensions k)) (make-instance 'combination :element-type '(unsigned-byte #+int64 64 #+int32 32) diff --git a/data/foreign-array.lisp b/data/foreign-array.lisp index f5b3a543df049eff58df569e764bf622ad4f497d..8ebf9e681c340889213c6d815c982e0ef82ebe97 100644 --- a/data/foreign-array.lisp +++ b/data/foreign-array.lisp @@ -1,8 +1,8 @@ ;; A grid:foreign-array with added metadata for GSL. ;; Liam Healy 2008-04-06 21:23:41EDT -;; Time-stamp: <2010-07-13 22:53:02EDT foreign-array.lisp> +;; Time-stamp: <2011-01-12 00:34:42EST foreign-array.lisp> ;; -;; Copyright 2008, 2009, 2010 Liam M. Healy +;; Copyright 2008, 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -44,7 +44,7 @@ (setf (cffi:foreign-slot-value blockptr 'gsl-block-c 'size) (size object) (cffi:foreign-slot-value blockptr 'gsl-block-c 'data) - (foreign-pointer object) + (grid:foreign-pointer object) (grid:metadata-slot object 'block-pointer) blockptr) (let ((array-struct (alloc-from-block object blockptr))) (setf @@ -53,8 +53,8 @@ ;; from the block to the vector/matrix; we must do that manually here (cffi:foreign-slot-value array-struct - (if (typep object 'matrix) 'gsl-matrix-c 'gsl-vector-c) 'data) - (foreign-pointer object)) + (if (typep object 'grid:matrix) 'gsl-matrix-c 'gsl-vector-c) 'data) + (grid:foreign-pointer object)) (tg:finalize object (lambda () (cffi:foreign-free blockptr) @@ -82,23 +82,23 @@ (let* ((category (case category-or-rank ((vector :vector 1) 'vector) - ((matrix :matrix 2) 'matrix) + ((matrix grid:matrix :matrix 2) 'grid:matrix) (t (error "Unrecognized category ~a" category-or-rank)))) (cstruct (case category (vector 'gsl-vector-c) - (matrix 'gsl-matrix-c))) + (grid:matrix 'gsl-matrix-c))) (fa (grid:make-grid (case category (vector - `((foreign-array ,(cffi:foreign-slot-value mpointer cstruct 'size)) - ,element-type)) - (matrix - `((foreign-array - ,(cffi:foreign-slot-value mpointer cstruct 'size0) - ,(cffi:foreign-slot-value mpointer cstruct 'size1)) - ,element-type))) + `((grid:foreign-array ,(cffi:foreign-slot-value mpointer cstruct 'size)) + ,element-type)) + (grid:matrix + `((grid:foreign-array + ,(cffi:foreign-slot-value mpointer cstruct 'size0) + ,(cffi:foreign-slot-value mpointer cstruct 'size1)) + ,element-type))) :foreign-pointer (cffi:foreign-slot-value mpointer cstruct 'data) :finalizer finalize))) diff --git a/data/matrix.lisp b/data/matrix.lisp index 4ebdbcbf1c945a7fad7b79e60e2cc326ad979ffd..22df33a2171efefae0a62f92421c7a6dda3fa4d3 100644 --- a/data/matrix.lisp +++ b/data/matrix.lisp @@ -1,8 +1,8 @@ ;; Matrices ;; Liam Healy 2008-04-15 21:57:52EDT matrix.lisp -;; Time-stamp: <2010-06-29 22:10:48EDT matrix.lisp> +;; Time-stamp: <2011-01-12 00:34:45EST matrix.lisp> ;; -;; Copyright 2008, 2009 Liam M. Healy +;; Copyright 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -26,7 +26,7 @@ ;;;; Mathematical ;;;;**************************************************************************** -(defmfun set-identity ((matrix matrix)) +(defmfun set-identity ((matrix grid:matrix)) ("gsl_matrix" :type "_set_identity") (((mpointer matrix) :pointer)) :definition :generic @@ -43,8 +43,7 @@ ;;;; Copying rows and columns ;;;;**************************************************************************** -(defmfun row - ((matrix matrix) i +(defmfun row ((matrix grid:matrix) i &optional (vector (grid:make-foreign-array element-type :dimensions (dim1 matrix)))) ("gsl_matrix" :type "_get_row") (((mpointer vector) :pointer) ((mpointer matrix) :pointer) (i sizet)) @@ -57,7 +56,7 @@ into the vector. The length of the vector must be the same as the length of the row.") -(defmfun (setf row) ((vector vector) (matrix matrix) i) +(defmfun (setf row) ((vector vector) (matrix grid:matrix) i) ("gsl_matrix" :type "_set_row") (((mpointer matrix) :pointer) (i sizet) ((mpointer vector) :pointer)) :definition :generic @@ -68,8 +67,7 @@ "Copy the elements of the vector into the jth row of the matrix. The length of the vector must be the same as the length of the row.") -(defmfun column - ((matrix matrix) i +(defmfun column ((matrix grid:matrix) i &optional (vector (grid:make-foreign-array element-type :dimensions (dim0 matrix)))) ("gsl_matrix" :type "_get_col") (((mpointer vector) :pointer) ((mpointer matrix) :pointer) (i sizet)) @@ -82,7 +80,7 @@ into the vector. The length of the vector must be the same as the length of the column.") -(defmfun (setf column) ((vector vector) (matrix matrix) i) +(defmfun (setf column) ((vector vector) (matrix grid:matrix) i) ("gsl_matrix" :type "_set_col") (((mpointer matrix) :pointer) (i sizet) ((mpointer vector) :pointer)) :definition :generic @@ -97,7 +95,7 @@ ;;;; Exchanging rows and columns ;;;;**************************************************************************** -(defmfun swap-rows ((matrix matrix) i j) +(defmfun swap-rows ((matrix grid:matrix) i j) ("gsl_matrix" :type "_swap_rows") (((mpointer matrix) :pointer) (i sizet) (j sizet)) :definition :generic @@ -107,7 +105,7 @@ :documentation ; FDL "Exchange the ith and jth rows of the matrix in-place.") -(defmfun swap-columns ((matrix matrix) i j) +(defmfun swap-columns ((matrix grid:matrix) i j) ("gsl_matrix" :type "_swap_columns") (((mpointer matrix) :pointer) (i sizet) (j sizet)) :definition :generic @@ -117,7 +115,7 @@ :documentation ; FDL "Exchange the ith and jth columns of the matrix in-place.") -(defmfun swap-row-column ((matrix matrix) i j) +(defmfun swap-row-column ((matrix grid:matrix) i j) ("gsl_matrix" :type "_swap_rowcol") (((mpointer matrix) :pointer) (i sizet) (j sizet)) :definition :generic @@ -129,7 +127,7 @@ matrix in-place. The matrix must be square for this operation to be possible.") -(defmfun matrix-transpose* ((matrix matrix)) +(defmfun matrix-transpose* ((matrix grid:matrix)) ("gsl_matrix" :type "_transpose") (((mpointer matrix) :pointer)) :definition :generic @@ -142,10 +140,10 @@ operation to be possible.") (defmfun matrix-transpose - ((source matrix) + ((source grid:matrix) &optional (destination - (grid:make-foreign-array element-type :dimensions (reverse (dimensions source))))) + (grid:make-foreign-array element-type :dimensions (reverse (grid:dimensions source))))) ("gsl_matrix" :type "_transpose_memcpy") (((mpointer destination) :pointer) ((mpointer source) :pointer)) :definition :generic diff --git a/data/permutation.lisp b/data/permutation.lisp index b894b0cd4447ddef8142a16fd827e7cb7a438e12..89185942f8f95c71eaab88c13af977849fbe81ab 100644 --- a/data/permutation.lisp +++ b/data/permutation.lisp @@ -1,8 +1,8 @@ ;; Permutations ;; Liam Healy, Sun Mar 26 2006 - 11:51 -;; Time-stamp: <2010-11-13 18:44:09EST permutation.lisp> +;; Time-stamp: <2011-05-26 12:37:36EDT permutation.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009, 2010 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -38,7 +38,7 @@ (setf (grid:metadata-slot object 'mpointer) mptr (cffi:foreign-slot-value mptr 'gsl-permutation-c 'data) - (foreign-pointer object) + (grid:foreign-pointer object) (cffi:foreign-slot-value mptr 'gsl-permutation-c 'size) (first dimensions)) (tg:finalize object (lambda () (cffi:foreign-free mptr))))) @@ -53,7 +53,7 @@ (make-instance 'permutation :element-type '(unsigned-byte #+int64 64 #+int32 32) - :dimensions (if (typep n 'permutation) (dimensions n) (list n))))) + :dimensions (if (typep n 'permutation) (grid:dimensions n) (list n))))) (when initialize (if (typep n 'permutation) (error "not available yet") ; (copy perm n) @@ -339,7 +339,7 @@ (save-test permutation (let ((perm-1 (make-permutation 4 t))) - (grid:gref perm-1 2)) + (grid:aref perm-1 2)) (let ((perm-1 (make-permutation 4 t))) ;grid:contents (grid:contents perm-1)) (let ((perm-1 (make-permutation 4 t))) ;permutation-reverse diff --git a/documentation/index.html b/documentation/index.html index 8eb8da7272852f61f841b92a9bccd878d75230e1..499796d32dc297e435340092f3951958becb4fa2 100644 --- a/documentation/index.html +++ b/documentation/index.html @@ -9,6 +9,21 @@ content="text/html; charset=iso-8859-1"> <link rev="made" href="mailto:lhealy@common-lisp.net"> <link rel="stylesheet" type="text/css" href="site.css"> +<script type="text/javascript"> + + var _gaq = _gaq || []; + _gaq.push(['_setAccount', 'UA-25052371-1']); + _gaq.push(['_setDomainName', 'none']); + _gaq.push(['_setAllowLinker', true]); + _gaq.push(['_trackPageview']); + + (function() { + var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true; + ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js'; + var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s); + })(); + +</script> </head> <body> <div id="banner"> @@ -336,18 +351,9 @@ four-digit number; please attach them all to your email. <!-- Created: Feb 25 2005 --> <!-- hhmts start --> <small> -Time-stamp: <2010-10-12 17:46:29EDT index.html> +Time-stamp: <2011-08-09 22:37:23EDT index.html> </small> <!-- hhmts end --> </div> -<script type="text/javascript"> -var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www."); -document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E")); -</script> -<script type="text/javascript"> -var pageTracker = _gat._getTracker("UA-3669275-1"); -pageTracker._initData(); -pageTracker._trackPageview(); -</script> </body> </html> diff --git a/eigensystems/generalized.lisp b/eigensystems/generalized.lisp index c0a0cbbfcbbbd49123463e78df43d5a3feda8f06..466d48fc334291772a96fcaad63b5c128c117533 100644 --- a/eigensystems/generalized.lisp +++ b/eigensystems/generalized.lisp @@ -1,8 +1,8 @@ ;; Real generalized eigensystems ;; Liam Healy 2009-02-16 12:55:04EST real-generalized.lisp -;; Time-stamp: <2010-06-29 22:15:24EDT generalized.lisp> +;; Time-stamp: <2011-01-12 00:08:22EST generalized.lisp> ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -56,8 +56,7 @@ n-by-n complex generalized hermitian-definite eigensystems. The size of the workspace is O(5n).") -(defmfun eigenvalues-gensymm - ((A matrix) (B matrix) +(defmfun eigenvalues-gensymm ((A grid:matrix) (B grid:matrix) &optional (eigenvalues (grid:make-foreign-array element-type :dimensions (dim0 A))) (ws (eltcase complex (make-eigen-genherm (dim0 A)) @@ -78,11 +77,10 @@ outlined above. On output, B contains its Cholesky decomposition and A is destroyed.") -(defmfun eigenvalues-eigenvectors-gensymm - ((A matrix) (B matrix) +(defmfun eigenvalues-eigenvectors-gensymm ((A grid:matrix) (B grid:matrix) &optional (eigenvalues (grid:make-foreign-array element-type :dimensions (dim0 A))) - (eigenvectors (grid:make-foreign-array element-type :dimensions (dimensions A))) + (eigenvectors (grid:make-foreign-array element-type :dimensions (grid:dimensions A))) (ws (eltcase complex (make-eigen-hermv (dim0 A)) t (make-eigen-symmv (dim0 A))))) (double-float "gsl_eigen_gensymmv" diff --git a/eigensystems/nonsymmetric-generalized.lisp b/eigensystems/nonsymmetric-generalized.lisp index 9ec85cfed0dc049ea7e308e52066b5b2e934700c..3ee35f8242323c13e85a23c1d84838f354d02ae9 100644 --- a/eigensystems/nonsymmetric-generalized.lisp +++ b/eigensystems/nonsymmetric-generalized.lisp @@ -1,8 +1,8 @@ ;; Generalized eigensystems for nonsymmetric real matrices ;; Liam Healy 2009-02-16 14:27:20EST nonsymmetric-generalized.lisp -;; Time-stamp: <2010-06-29 22:15:24EDT nonsymmetric-generalized.lisp> +;; Time-stamp: <2011-01-10 18:19:14EST nonsymmetric-generalized.lisp> ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -63,11 +63,11 @@ (balance nil) ; unused by GSL (Q (if (eql shur-vectors t) - (grid:make-foreign-array 'double-float :dimensions (dimensions A)) + (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A)) shur-vectors)) (Z (if (eql shur-vectors t) - (grid:make-foreign-array 'double-float :dimensions (dimensions A)) + (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A)) shur-vectors))) ("gsl_eigen_gen" "gsl_eigen_gen_QZ") ((((mpointer A) :pointer) ((mpointer B) :pointer) @@ -118,18 +118,18 @@ (beta (grid:make-foreign-array 'double-float :dimensions (dim0 A))) (eigenvectors - (grid:make-foreign-array 'double-float :dimensions (dimensions A))) + (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A))) (ws (make-eigen-genv (dim0 A))) compute-shur-form-s compute-shur-form-t shur-vectors &aux (balance nil) ; unused by GSL (Q (if (eql shur-vectors t) - (grid:make-foreign-array 'double-float :dimensions (dimensions A)) + (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A)) shur-vectors)) (Z (if (eql shur-vectors t) - (grid:make-foreign-array 'double-float :dimensions (dimensions A)) + (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A)) shur-vectors))) ("gsl_eigen_genv" "gsl_eigen_genv_QZ") ((((mpointer A) :pointer) ((mpointer B) :pointer) diff --git a/eigensystems/nonsymmetric.lisp b/eigensystems/nonsymmetric.lisp index fc68668ae1e4c4075a19bf4759d4d089b7e39cca..9514709a1abc290dda6565d2989761f3b080095e 100644 --- a/eigensystems/nonsymmetric.lisp +++ b/eigensystems/nonsymmetric.lisp @@ -1,8 +1,8 @@ ;; Eigensystems for nonsymmetric real matrices ;; Liam Healy 2009-02-16 12:51:18EST nonsymmetric.lisp -;; Time-stamp: <2010-06-29 22:15:24EDT nonsymmetric.lisp> +;; Time-stamp: <2011-01-10 18:19:13EST nonsymmetric.lisp> ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -58,7 +58,7 @@ &aux (sv (if (eql shur-vectors t) - (grid:make-foreign-array 'double-float :dimensions (dimensions A)) + (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A)) shur-vectors))) ("gsl_eigen_nonsymm" "gsl_eigen_nonsymm_Z") ((((mpointer A) :pointer) @@ -119,13 +119,13 @@ (eigenvalues (grid:make-foreign-array '(complex double-float) :dimensions (dim0 A))) (eigenvectors - (grid:make-foreign-array '(complex double-float) :dimensions (dimensions A))) + (grid:make-foreign-array '(complex double-float) :dimensions (grid:dimensions A))) (ws (make-eigen-nonsymmv (dim0 A))) shur-vectors &aux (sv (if (eql shur-vectors t) - (grid:make-foreign-array 'double-float :dimensions (dimensions A)) + (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A)) shur-vectors))) ("gsl_eigen_nonsymmv" "gsl_eigen_nonsymmv_Z") ((((mpointer A) :pointer) diff --git a/eigensystems/symmetric-hermitian.lisp b/eigensystems/symmetric-hermitian.lisp index 38404d2c2272a57ec5d7778469e9033d36058c9a..01534f333262e235ce18e9cfe4fe811de1aa8f8e 100644 --- a/eigensystems/symmetric-hermitian.lisp +++ b/eigensystems/symmetric-hermitian.lisp @@ -1,8 +1,8 @@ ;; Eigenvectors and eigenvalues ;; Liam Healy, Sun May 21 2006 - 19:52 -;; Time-stamp: <2010-07-07 14:25:01EDT symmetric-hermitian.lisp> +;; Time-stamp: <2011-01-12 00:09:43EST symmetric-hermitian.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -66,8 +66,7 @@ ;;;; Eigenvalues and eigenvectors ;;;;**************************************************************************** -(defmfun eigenvalues - ((A matrix) +(defmfun eigenvalues ((A grid:matrix) &optional (eigenvalues (grid:make-foreign-array element-type :dimensions (dim0 A))) (ws (eltcase complex (make-eigen-herm (dim0 A)) @@ -91,11 +90,10 @@ referenced. The eigenvalues are stored in the vector eigenvalues and are unordered.") -(defmfun eigenvalues-eigenvectors - ((A matrix) +(defmfun eigenvalues-eigenvectors ((A grid:matrix) &optional (eigenvalues (grid:make-foreign-array element-type :dimensions (dim0 A))) - (eigenvectors (grid:make-foreign-array element-type :dimensions (dimensions A))) + (eigenvectors (grid:make-foreign-array element-type :dimensions (grid:dimensions A))) (ws (eltcase complex (make-eigen-hermv (dim0 A)) t (make-eigen-symmv (dim0 A))))) (double-float "gsl_eigen_symmv" @@ -126,7 +124,7 @@ ;;;;**************************************************************************** (defmfun sort-eigenvalues-eigenvectors - ((eigenvalues vector) (eigenvectors matrix) sort-type) + ((eigenvalues vector) (eigenvectors grid:matrix) sort-type) (double-float "gsl_eigen_symmv_sort" complex-double-float "gsl_eigen_hermv_sort") (((mpointer eigenvalues) :pointer) ((mpointer eigenvectors) :pointer) diff --git a/fast-fourier-transforms/backward.lisp b/fast-fourier-transforms/backward.lisp index 8b62af1d75d85d97a9707c518a8c994f67fa8166..a5bf3c7b4ff37353fe783d20a76e915c920535a8 100644 --- a/fast-fourier-transforms/backward.lisp +++ b/fast-fourier-transforms/backward.lisp @@ -1,8 +1,8 @@ ;; Backward FFT ;; Sumant Oemrawsingh, Sat Oct 24 2009 - 12:55 -;; Time-stamp: <2010-06-27 18:13:59EDT backward.lisp> +;; Time-stamp: <2011-01-11 23:34:19EST backward.lisp> ;; -;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy +;; Copyright 2009, 2011 Sumant Oemrawsingh, Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -33,7 +33,7 @@ (defmfun backward-fourier-transform-radix2 ((vector vector) &key (stride 1)) ("gsl_fft" :type "_radix2_backward") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) :definition :generic :element-types :complex :inputs (vector) @@ -49,7 +49,7 @@ (wavetable (make-fft-wavetable element-type (floor (size vector) stride))) (workspace (make-fft-workspace element-type (floor (size vector) stride)))) ("gsl_fft" :type "_backward") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) ((mpointer wavetable) :pointer) ((mpointer workspace) :pointer)) :definition :generic :element-types :complex @@ -69,7 +69,7 @@ (defmfun backward-fourier-transform-halfcomplex-radix2 ((vector vector) &key (stride 1)) ("gsl_fft_halfcomplex" :type "_radix2_backward") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) :definition :generic :element-types :float :inputs (vector) @@ -86,7 +86,7 @@ (wavetable (make-fft-wavetable element-type (floor (size vector) stride) t)) (workspace (make-fft-workspace element-type (floor (size vector) stride)))) ("gsl_fft_halfcomplex" :type "_backward") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) ((mpointer wavetable) :pointer) ((mpointer workspace) :pointer)) :definition :generic :element-types :float @@ -106,7 +106,7 @@ (defmfun backward-fourier-transform-dif-radix2 ((vector vector) &key (stride 1)) ("gsl_fft" :type "_radix2_dif_backward") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) :definition :generic :element-types :complex :inputs (vector) @@ -138,13 +138,13 @@ (remf pass-on-args :decimation-in-frequency) (remf pass-on-args :non-radix-2) (if (and (not non-radix-2) (power-of-2-p (floor (size vector) stride))) - (if (subtypep (element-type vector) 'real) + (if (subtypep (grid:element-type vector) 'real) (apply 'backward-fourier-transform-halfcomplex-radix2 vector pass-on-args) (if decimation-in-frequency (apply 'backward-fourier-transform-dif-radix2 vector pass-on-args) (apply 'backward-fourier-transform-radix2 vector pass-on-args))) - (if (subtypep (element-type vector) 'real) + (if (subtypep (grid:element-type vector) 'real) (apply 'backward-fourier-transform-halfcomplex-nonradix2 vector pass-on-args) (apply 'backward-fourier-transform-nonradix2 vector pass-on-args))))) diff --git a/fast-fourier-transforms/discrete.lisp b/fast-fourier-transforms/discrete.lisp index 6d85e2912d3d24730412d65a41ee5159ec24eddb..ac7b7ae4e8ea5e07acdd6b5c6ffcea209bbd323e 100644 --- a/fast-fourier-transforms/discrete.lisp +++ b/fast-fourier-transforms/discrete.lisp @@ -1,8 +1,8 @@ ;; Discrete Fourier Transforms ;; Liam Healy 2009-11-07 14:24:07EST -;; Time-stamp: <2010-06-29 22:15:25EDT discrete.lisp> +;; Time-stamp: <2011-01-10 18:16:24EST discrete.lisp> ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -29,10 +29,10 @@ (defmfun forward-discrete-fourier-transform ((vector vector) &key (stride 1) - (result (grid:make-foreign-array element-type :dimensions (dimensions vector)))) + (result (grid:make-foreign-array element-type :dimensions (grid:dimensions vector)))) ("gsl_dft" :type "_forward") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) - ((foreign-pointer result) :pointer)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) + ((grid:foreign-pointer result) :pointer)) :definition :generic :element-types :complex :inputs (vector) @@ -45,10 +45,10 @@ (defmfun backward-discrete-fourier-transform ((vector vector) &key (stride 1) - (result (grid:make-foreign-array element-type :dimensions (dimensions vector)))) + (result (grid:make-foreign-array element-type :dimensions (grid:dimensions vector)))) ("gsl_dft" :type "_backward") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) - ((foreign-pointer result) :pointer)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) + ((grid:foreign-pointer result) :pointer)) :definition :generic :element-types :complex :inputs (vector) @@ -61,10 +61,10 @@ (defmfun inverse-discrete-fourier-transform ((vector vector) &key (stride 1) - (result (grid:make-foreign-array element-type :dimensions (dimensions vector)))) + (result (grid:make-foreign-array element-type :dimensions (grid:dimensions vector)))) ("gsl_dft" :type "_inverse") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) - ((foreign-pointer result) :pointer)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) + ((grid:foreign-pointer result) :pointer)) :definition :generic :element-types :complex :inputs (vector) @@ -77,10 +77,10 @@ (defmfun discrete-fourier-transform ((vector vector) &key (stride 1) - (result (grid:make-foreign-array element-type :dimensions (dimensions vector)))) + (result (grid:make-foreign-array element-type :dimensions (grid:dimensions vector)))) ("gsl_dft" :type "_transform") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) - ((foreign-pointer result) :pointer)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) + ((grid:foreign-pointer result) :pointer)) :definition :generic :element-types :complex :inputs (vector) diff --git a/fast-fourier-transforms/example.lisp b/fast-fourier-transforms/example.lisp index a05d5d3bfccc723724e07c69572e8ea4adbd1342..8c3fd578beaecc5f1376e1d41735abfe476e9a92 100644 --- a/fast-fourier-transforms/example.lisp +++ b/fast-fourier-transforms/example.lisp @@ -1,8 +1,8 @@ ;; Example FFT: transform a pulse (using the "clean" fft interface) ;; Sumant Oemrawsingh, Sat Oct 31 2009 - 00:24 -;; Time-stamp: <2010-09-04 08:44:35EDT example.lisp> +;; Time-stamp: <2011-05-26 12:37:35EDT example.lisp> ;; -;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy +;; Copyright 2009, 2010, 2011 Sumant Oemrawsingh, Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -42,10 +42,10 @@ (assert (and (integerp dimension) (> dimension 20))) (let ((pulse (grid:make-foreign-array element-type :dimensions dimension)) (init-value (coerce 1 element-type))) - (setf (grid:gref pulse 0) init-value) + (setf (grid:aref pulse 0) init-value) (loop for i from 1 to 10 - do (setf (grid:gref pulse i) init-value - (grid:gref pulse (- dimension i)) init-value)) + do (setf (grid:aref pulse i) init-value + (grid:aref pulse (- dimension i)) init-value)) (forward-fourier-transform pulse))) (save-test @@ -82,7 +82,7 @@ (when init-offset (loop for i from 0 below size do - (setf (grid:gref vec i) + (setf (grid:aref vec i) (if (subtypep element-type 'complex) (coerce (complex (+ (* 2 i) init-offset) (+ (* 2 i) init-offset 1)) @@ -97,7 +97,7 @@ (* stride dimension) :init-offset init-offset))) (loop for i from 0 below (* stride dimension) by stride do - (setf (grid:gref vec i) + (setf (grid:aref vec i) (if (subtypep element-type 'complex) (coerce (complex (urand) (urand)) element-type) (complex (coerce (urand) element-type))))) @@ -107,31 +107,32 @@ "The real vector consisting of the real part of the complex vector." (let ((real-vector (make-and-init-vector - (grid:component-float-type (element-type complex-vector)) + (grid:component-float-type (grid:element-type complex-vector)) (size complex-vector) :init-offset init-offset))) (loop for i below (size complex-vector) by stride do - (setf (grid:gref real-vector i) - (realpart (grid:gref complex-vector i)))) + (setf (grid:aref real-vector i) + (realpart (grid:aref complex-vector i)))) real-vector)) (defun copy-with-stride (vector &key (stride 1) init-offset) "Copy a vector and initialize it." (let ((vec - (make-and-init-vector (element-type vector) - (size vector) - :init-offset init-offset))) + (make-and-init-vector + (grid:element-type vector) + (size vector) + :init-offset init-offset))) (loop for i below (size vector) by stride do - (setf (grid:gref vec i) (grid:gref vector i))) + (setf (grid:aref vec i) (grid:aref vector i))) vec)) (defun size-vector-scalar (vector &key (stride 1)) "Return the size of a vector while taking the stride into account." (coerce (floor (size vector) stride) - (if (subtypep (element-type vector) 'complex) - (element-type vector) + (if (subtypep (grid:element-type vector) 'complex) + (grid:element-type vector) 'double-float))) #+nil @@ -139,11 +140,11 @@ (elt/ vector (size-vector-scalar vector :stride stride))) (defun vector/length (vector &key (stride 1)) - (let ((element-type (element-type vector))) + (let ((element-type (grid:element-type vector))) (loop with length = (size-vector-scalar vector :stride stride) for i from 0 below (size vector) by stride do - (setf (grid:gref vector i) (coerce (/ (grid:gref vector i) length) element-type))) + (setf (grid:aref vector i) (coerce (/ (grid:aref vector i) length) element-type))) vector)) (defun test-real-fft-noise (vector &key (stride 1) non-radix-2) diff --git a/fast-fourier-transforms/extras.lisp b/fast-fourier-transforms/extras.lisp index 21d9a370fc2d3ea1c2e3cc237343fb2343c31e57..6ce7999ff39b3807790793c3fac698ececfdcc15 100644 --- a/fast-fourier-transforms/extras.lisp +++ b/fast-fourier-transforms/extras.lisp @@ -76,12 +76,12 @@ (zero-pos (if (evenp n) (- split 1) split))) ;; Positive frequencies (loop for i from zero-pos to (- n 1) - do (setf (grid:gref shifted (* i stride)) - (grid:gref vector (* (- i zero-pos) stride)))) + do (setf (grid:aref shifted (* i stride)) + (grid:aref vector (* (- i zero-pos) stride)))) ;; Negative frequencies (loop for i from (+ split 1) to (- n 1) - do (setf (grid:gref shifted (* (- i split 1) stride)) - (grid:gref vector (* i stride)))) + do (setf (grid:aref shifted (* (- i split 1) stride)) + (grid:aref vector (* i stride)))) shifted)) (export 'fft-inverse-shift) @@ -96,10 +96,10 @@ (zero-pos (if (evenp n) (- split 1) split))) ;; Positive frequencies (loop for i from zero-pos to (- n 1) - do (setf (grid:gref inv-shifted (* (- i zero-pos) stride)) - (grid:gref vector (* i stride)))) + do (setf (grid:aref inv-shifted (* (- i zero-pos) stride)) + (grid:aref vector (* i stride)))) ;; Negative frequencies (loop for i from (+ split 1) to (- n 1) - do (setf (grid:gref inv-shifted (* i stride)) - (grid:gref vector (* (- i split 1) stride)))) + do (setf (grid:aref inv-shifted (* i stride)) + (grid:aref vector (* (- i split 1) stride)))) inv-shifted)) diff --git a/fast-fourier-transforms/forward.lisp b/fast-fourier-transforms/forward.lisp index b90182609112abf4a17807293a2994c26918e738..e20508ae45624598358f92865b21515f485b9ea3 100644 --- a/fast-fourier-transforms/forward.lisp +++ b/fast-fourier-transforms/forward.lisp @@ -1,8 +1,8 @@ ;; Forward FFT. ;; Sumant Oemrawsingh, Sat Oct 31 2009 - 23:48 -;; Time-stamp: <2010-06-27 18:13:58EDT forward.lisp> +;; Time-stamp: <2011-01-10 17:59:23EST forward.lisp> ;; -;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy +;; Copyright 2009, 2011 Sumant Oemrawsingh, Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -37,7 +37,7 @@ single-float "gsl_fft_real_float_radix2_transform" complex-double-float "gsl_fft_complex_radix2_forward" complex-single-float "gsl_fft_complex_float_radix2_forward") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) :definition :generic :element-types :float-complex :inputs (vector) @@ -56,7 +56,7 @@ single-float "gsl_fft_real_float_transform" complex-double-float "gsl_fft_complex_forward" complex-single-float "gsl_fft_complex_float_forward") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) ((mpointer wavetable) :pointer) ((mpointer workspace) :pointer)) :definition :generic :element-types :float-complex @@ -75,7 +75,7 @@ (defmfun forward-fourier-transform-halfcomplex-radix2 ((vector vector) &key (stride 1)) ("gsl_fft_halfcomplex" :type "_radix2_transform") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) :definition :generic :element-types :float :inputs (vector) @@ -92,7 +92,7 @@ (wavetable (make-fft-wavetable element-type (floor (size vector) stride) t)) (workspace (make-fft-workspace element-type (floor (size vector) stride)))) ("gsl_fft_halfcomplex" :type "_transform") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) ((mpointer wavetable) :pointer) ((mpointer workspace) :pointer)) :definition :generic :element-types :float @@ -111,7 +111,7 @@ (defmfun forward-fourier-transform-dif-radix2 ((vector vector) &key (stride 1)) ("gsl_fft" :type "_radix2_dif_forward") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) :definition :generic :element-types :complex :inputs (vector) diff --git a/fast-fourier-transforms/inverse.lisp b/fast-fourier-transforms/inverse.lisp index 77545e27e3449e921c1369d917eadeba57e28456..27c89e07d441758a2ab144def96ed7408c6a8464 100644 --- a/fast-fourier-transforms/inverse.lisp +++ b/fast-fourier-transforms/inverse.lisp @@ -1,8 +1,8 @@ ;; Inverse FFT ;; Sumant Oemrawsingh, Sat Oct 24 2009 - 12:55 -;; Time-stamp: <2010-06-27 18:14:00EDT inverse.lisp> +;; Time-stamp: <2011-01-11 23:34:17EST inverse.lisp> ;; -;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy +;; Copyright 2009, 2011 Sumant Oemrawsingh, Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -33,7 +33,7 @@ (defmfun inverse-fourier-transform-radix2 ((vector vector) &key (stride 1)) ("gsl_fft" :type "_radix2_inverse") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) :definition :generic :element-types :complex :inputs (vector) @@ -49,7 +49,7 @@ (wavetable (make-fft-wavetable element-type (floor (size vector) stride))) (workspace (make-fft-workspace element-type (floor (size vector) stride)))) ("gsl_fft" :type "_inverse") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) ((mpointer wavetable) :pointer) ((mpointer workspace) :pointer)) :definition :generic :element-types :complex @@ -69,7 +69,7 @@ (defmfun inverse-fourier-transform-halfcomplex-radix2 ((vector vector) &key (stride 1)) ("gsl_fft_halfcomplex" :type "_radix2_inverse") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) :definition :generic :element-types :float :inputs (vector) @@ -86,7 +86,7 @@ (wavetable (make-fft-wavetable element-type (floor (size vector) stride) t)) (workspace (make-fft-workspace element-type (floor (size vector) stride)))) ("gsl_fft_halfcomplex" :type "_inverse") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet) ((mpointer wavetable) :pointer) ((mpointer workspace) :pointer)) :definition :generic :element-types :float @@ -106,7 +106,7 @@ (defmfun inverse-fourier-transform-dif-radix2 ((vector vector) &key (stride 1)) ("gsl_fft" :type "_radix2_dif_inverse") - (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) :definition :generic :element-types :complex :inputs (vector) @@ -138,13 +138,13 @@ (remf pass-on-args :decimation-in-frequency) (remf pass-on-args :non-radix-2) (if (and (not non-radix-2) (power-of-2-p (floor (size vector) stride))) - (if (subtypep (element-type vector) 'real) + (if (subtypep (grid:element-type vector) 'real) (apply 'inverse-fourier-transform-halfcomplex-radix2 vector pass-on-args) (if decimation-in-frequency (apply 'inverse-fourier-transform-dif-radix2 vector pass-on-args) (apply 'inverse-fourier-transform-radix2 vector pass-on-args))) - (if (subtypep (element-type vector) 'real) + (if (subtypep (grid:element-type vector) 'real) (apply 'inverse-fourier-transform-halfcomplex-nonradix2 vector pass-on-args) (apply 'inverse-fourier-transform-nonradix2 vector pass-on-args))))) diff --git a/fast-fourier-transforms/select-direction.lisp b/fast-fourier-transforms/select-direction.lisp index 115fe4e639ba962944c291d972142d3c7bd1c7c5..c505e424d8798cd64495fe4addaa13984c2ef67f 100644 --- a/fast-fourier-transforms/select-direction.lisp +++ b/fast-fourier-transforms/select-direction.lisp @@ -1,8 +1,8 @@ ;; FFT where direction is selected. ;; Sumant Oemrawsingh, Sat Oct 24 2009 - 12:55 -;; Time-stamp: <2010-06-27 18:13:58EDT select-direction.lisp> +;; Time-stamp: <2011-01-10 17:59:24EST select-direction.lisp> ;; -;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy +;; Copyright 2009, 2011 Sumant Oemrawsingh, Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -26,7 +26,7 @@ (defmfun fourier-transform-radix2 ((vector vector) direction &key (stride 1) (n (expt 2 (floor (log (size vector) 2))))) ("gsl_fft" :type "_radix2_transform") - (((foreign-pointer vector) :pointer) (stride sizet) (n sizet) (direction fft-direction)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) (n sizet) (direction fft-direction)) :definition :generic :element-types :complex :inputs (vector) @@ -40,7 +40,7 @@ (defmfun fourier-transform-dif-radix2 ((vector vector) direction &key (stride 1) (n (expt 2 (floor (log (size vector) 2))))) ("gsl_fft" :type "_radix2_dif_transform") - (((foreign-pointer vector) :pointer) (stride sizet) (n sizet) (direction fft-direction)) + (((grid:foreign-pointer vector) :pointer) (stride sizet) (n sizet) (direction fft-direction)) :definition :generic :element-types :complex :inputs (vector) diff --git a/fast-fourier-transforms/unpack.lisp b/fast-fourier-transforms/unpack.lisp index 228b4679d5d2ea4b1cc2e8a95568f25fca1fd39d..da474a8a8d7b5e35bb2aa594920a03188b3be640 100644 --- a/fast-fourier-transforms/unpack.lisp +++ b/fast-fourier-transforms/unpack.lisp @@ -1,8 +1,8 @@ ;; Unpack functions for FFT vectors. ;; Sumant Oemrawsingh, Sun Oct 25 2009 - 16:35 -;; Time-stamp: <2010-06-29 22:12:06EDT unpack.lisp> +;; Time-stamp: <2011-01-10 17:59:24EST unpack.lisp> ;; -;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy +;; Copyright 2009, 2011 Sumant Oemrawsingh, Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -34,8 +34,8 @@ t (grid:make-foreign-array '(complex double-float) :dimensions (size vector))))) ("gsl_fft_real" :type "_unpack") - (((foreign-pointer vector) :pointer) - ((foreign-pointer output) :pointer) + (((grid:foreign-pointer vector) :pointer) + ((grid:foreign-pointer output) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) :definition :generic :element-types :float @@ -58,8 +58,8 @@ t (grid:make-foreign-array '(complex double-float) :dimensions (size vector))))) ("gsl_fft_halfcomplex" :type "_radix2_unpack") - (((foreign-pointer vector) :pointer) - ((foreign-pointer output) :pointer) + (((grid:foreign-pointer vector) :pointer) + ((grid:foreign-pointer output) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) :definition :generic :element-types :float @@ -81,8 +81,8 @@ t (grid:make-foreign-array '(complex double-float) :dimensions (size vector))))) ("gsl_fft_halfcomplex" :type "_unpack") - (((foreign-pointer vector) :pointer) - ((foreign-pointer output) :pointer) + (((grid:foreign-pointer vector) :pointer) + ((grid:foreign-pointer output) :pointer) (stride sizet) ((floor (size vector) stride) sizet)) :definition :generic :element-types :float diff --git a/gsll-tests.asd b/gsll-tests.asd deleted file mode 100644 index 78b5f8dddc70db30c53fdea7f507a0acedec329d..0000000000000000000000000000000000000000 --- a/gsll-tests.asd +++ /dev/null @@ -1,218 +0,0 @@ -;; Definition of GSLL system -;; Liam Healy -;; Time-stamp: <2010-10-03 18:11:16EDT gsll-tests.asd> -;; -;; Copyright 2007, 2008, 2009 Liam M. Healy -;; Distributed under the terms of the GNU General Public License -;; -;; This program is free software: you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation, either version 3 of the License, or -;; (at your option) any later version. -;; -;; This program is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. -;; -;; You should have received a copy of the GNU General Public License -;; along with this program. If not, see <http://www.gnu.org/licenses/>. - -(eval-when (:compile-toplevel :load-toplevel :execute) - (asdf:oos 'asdf:load-op :cffi-grovel)) - -(asdf:defsystem GSLL-TESTS - :name "GSLL-tests" - :description "Regression (unit) tests for GNU Scientific Library for Lisp." - :version "0" - :author "Liam M. Healy" - :licence "GPL v3" - :depends-on (gsll foreign-array-tests lisp-unit) - :components - ((:module test-unit - :components - ((cffi-grovel:grovel-file "machine") - (:file "augment" :depends-on ("machine")))) - (:module tests - :depends-on (test-unit) - :components - ((:file "absolute-deviation") - (:file "absolute-sum") - (:file "airy") - (:file "autocorrelation") - (:file "axpy") - (:file "basis-spline") - (:file "bernoulli") - (:file "bessel") - (:file "beta") - (:file "binomial") - (:file "blas-copy") - (:file "blas-swap") - (:file "cauchy") - (:file "cdot") - (:file "chebyshev") - (:file "chi-squared") - (:file "cholesky") - (:file "clausen") - (:file "column") - (:file "combination") - (:file "coulomb") - (:file "coupling") - (:file "correlation") - (: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 "fast-fourier-transform") - (: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 "hankel") - (:file "higher-moments") - (:file "histogram") - (:file "householder") - (:file "hypergeometric") - (:file "hypergeometric-randist") - (:file "index-max") - (:file "interpolation") - (:file "inverse-matrix-product") - (:file "laguerre") - (:file "lambert") - (:file "landau") - (:file "laplace") - (:file "legendre") - (:file "levy") - (:file "linear-least-squares") - (:file "logarithmic") - (:file "logarithm") - (:file "logistic") - (:file "lognormal") - (:file "lu") - (:file "mathematical") - (:file "mathieu") - (:file "matrix-div") - (:file "matrix-max-index") - (:file "matrix-max") - (:file "matrix-mean") - (:file "matrix-min") - (:file "matrix-min-index") - (:file "matrix-minmax-index") - (:file "matrix-minmax") - (:file "matrix-sub") - (:file "matrix-add") - (:file "matrix-mult") - #+fsbv (:file "matrix-product-hermitian") - (:file "matrix-product") - (:file "matrix-product-nonsquare") - (:file "matrix-product-symmetric") - (:file "matrix-product-triangular") - (:file "matrix-set-all") - (: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 "minimization-one") - (:file "minimization-multi") - (:file "monte-carlo") - (:file "multinomial") - (:file "negative-binomial") - (:file "nonlinear-least-squares") - (:file "ntuple") - (:file "numerical-differentiation") - (:file "numerical-integration") - (:file "ode") - (:file "pareto") - (:file "permutation") - (:file "poisson") - (:file "polynomial") - (:file "power") - (:file "psi") - (:file "qr") - (:file "qrpt") - (:file "quasi-random-number-generators") - (:file "random-number-generators") - (:file "rank-1-update") - (:file "rayleigh") - (:file "rayleigh-tail") - (:file "roots-multi") - (:file "roots-one") - (:file "row") - (:file "scale") - (:file "series-acceleration") - (: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 "svd") - (:file "swap-columns") - (:file "swap-elements") - (:file "swap-row-column") - (:file "swap-rows") - (:file "synchrotron") - (:file "tdist") - (:file "transport") - (:file "trigonometry") - (:file "vector-div") - (:file "vector-max-index") - (:file "vector-max") - (:file "vector-mean") - (:file "vector-min") - (:file "vector-min-index") - (:file "vector-minmax-index") - (:file "vector-minmax") - (:file "vector-sub") - (:file "vector-add") - (:file "vector-mult") - (:file "vector-reverse") - (:file "vector-set-all") - (: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 17780b4aa1f90ff6a21e7caf2847bf88a9b0ff38..0b755a7a2da7e9b3344cf358cb0c58438379d125 100644 --- a/gsll.asd +++ b/gsll.asd @@ -1,8 +1,8 @@ ;; Definition of GSLL system ;; Liam Healy -;; Time-stamp: <2011-02-26 20:44:27EST gsll.asd> +;; Time-stamp: <2011-01-30 10:41:57EST gsll.asd> ;; -;; Copyright 2006, 2007, 2008, 2009, 2010 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -30,29 +30,7 @@ :version "0" :author "Liam M. Healy" :licence "GPL v3" - :description "An interface to the GNU Scientific Library (GSL) from Common Lisp." - :long-description - "The GNU Scientific Library for Lisp (GSLL) allows you to use the -GNU Scientific Library (GSL) from Common Lisp. This library provides -a full range of common mathematical operations useful to scientific -and engineering applications. The design of the GSLL interface is -such that access to most of the GSL library is possible in a -Lisp-natural way; the intent is that the user not be hampered by the -restrictions of the C language in which GSL has been written. GSLL -thus provides interactive use of GSL for getting quick answers, even -for someone not intending to program in Lisp. - -Topics include: roots of polynomials, special functions, vectors and -matrices, permutations, sorting, BLAS (basic linear algebra -subprograms), linear algebra, eigensystems, fast Fourier transforms, -quadrature, random numbers, quasi-random sequences, random -distributions, statistics, histograms, N-tuples, Monte Carlo -integration, simulated annealing, differential equations, -interpolation, numerical differentiation, Chebyshev approximation, -series acceleration, discrete Hankel transforms, root-finding, -minimization least-squares fitting, IEEE floating-point, discrete -wavelet transforms." - :depends-on (foreign-array grid cffi cffi-grovel trivial-garbage #+fsbv fsbv) + :depends-on (antik cffi-grovel trivial-garbage alexandria #+fsbv fsbv) :components ((:module init :components @@ -289,3 +267,199 @@ wavelet transforms." ((cffi-grovel:grovel-file "mksa") (cffi-grovel:grovel-file "cgsm") (:file export))))) + +(asdf:defsystem-connection GSLL-tests + :name "GSLL-tests" + :description "Regression (unit) tests for GNU Scientific Library for Lisp." + :version "0" + :author "Liam M. Healy" + :licence "GPL v3" + :requires (gsll lisp-unit) + :components + ((:module test-unit + :components + ((cffi-grovel:grovel-file "machine") + (:file "augment" :depends-on ("machine")))) + (:module tests + :depends-on (test-unit) + :components + ((:file "absolute-deviation") + (:file "absolute-sum") + (:file "airy") + (:file "autocorrelation") + (:file "axpy") + (:file "basis-spline") + (:file "bernoulli") + (:file "bessel") + (:file "beta") + (:file "binomial") + (:file "blas-copy") + (:file "blas-swap") + (:file "cauchy") + (:file "cdot") + (:file "chebyshev") + (:file "chi-squared") + (:file "cholesky") + (:file "clausen") + (:file "column") + (:file "combination") + (:file "coulomb") + (:file "coupling") + (:file "correlation") + (: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 "fast-fourier-transform") + (: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 "hankel") + (:file "higher-moments") + (:file "histogram") + (:file "householder") + (:file "hypergeometric") + (:file "hypergeometric-randist") + (:file "index-max") + (:file "interpolation") + (:file "inverse-matrix-product") + (:file "laguerre") + (:file "lambert") + (:file "landau") + (:file "laplace") + (:file "legendre") + (:file "levy") + (:file "linear-least-squares") + (:file "logarithmic") + (:file "logarithm") + (:file "logistic") + (:file "lognormal") + (:file "lu") + (:file "mathematical") + (:file "mathieu") + (:file "matrix-div") + (:file "matrix-max-index") + (:file "matrix-max") + (:file "matrix-mean") + (:file "matrix-min") + (:file "matrix-min-index") + (:file "matrix-minmax-index") + (:file "matrix-minmax") + (:file "matrix-sub") + (:file "matrix-add") + (:file "matrix-mult") + #+fsbv (:file "matrix-product-hermitian") + (:file "matrix-product") + (:file "matrix-product-nonsquare") + (:file "matrix-product-symmetric") + (:file "matrix-product-triangular") + (:file "matrix-set-all") + (: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 "minimization-one") + (:file "minimization-multi") + (:file "monte-carlo") + (:file "multinomial") + (:file "negative-binomial") + (:file "nonlinear-least-squares") + (:file "ntuple") + (:file "numerical-differentiation") + (:file "numerical-integration") + (:file "ode") + (:file "pareto") + (:file "permutation") + (:file "poisson") + (:file "polynomial") + (:file "power") + (:file "psi") + (:file "qr") + (:file "qrpt") + (:file "quasi-random-number-generators") + (:file "random-number-generators") + (:file "rank-1-update") + (:file "rayleigh") + (:file "rayleigh-tail") + (:file "roots-multi") + (:file "roots-one") + (:file "row") + (:file "scale") + (:file "series-acceleration") + (: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 "svd") + (:file "swap-columns") + (:file "swap-elements") + (:file "swap-row-column") + (:file "swap-rows") + (:file "synchrotron") + (:file "tdist") + (:file "transport") + (:file "trigonometry") + (:file "vector-div") + (:file "vector-max-index") + (:file "vector-max") + (:file "vector-mean") + (:file "vector-min") + (:file "vector-min-index") + (:file "vector-minmax-index") + (:file "vector-minmax") + (:file "vector-sub") + (:file "vector-add") + (:file "vector-mult") + (:file "vector-reverse") + (:file "vector-set-all") + (: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/hankel.lisp b/hankel.lisp index dbf4bb3c51b19a33f35d39ed355ff930e8038024..b89ddeb2b99dd7f879a2c2bf90e9f1ad61a84dba 100644 --- a/hankel.lisp +++ b/hankel.lisp @@ -1,8 +1,8 @@ ;; Discrete Hankel Transforms. ;; Liam Healy, Sat Dec 8 2007 - 16:50 -;; Time-stamp: <2010-07-07 14:19:28EDT hankel.lisp> +;; Time-stamp: <2011-05-26 12:37:29EDT hankel.lisp> ;; -;; Copyright 2007, 2008, 2009 Liam M. Healy +;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -39,10 +39,10 @@ (defmfun apply-hankel (hankel array-in &optional - (array-out (grid:make-foreign-array 'double-float :dimensions (dimensions array-in)))) + (array-out (grid:make-foreign-array 'double-float :dimensions (grid:dimensions array-in)))) "gsl_dht_apply" - (((mpointer hankel) :pointer) ((foreign-pointer array-in) :pointer) - ((foreign-pointer array-out) :pointer)) + (((mpointer hankel) :pointer) ((grid:foreign-pointer array-in) :pointer) + ((grid:foreign-pointer array-out) :pointer)) :inputs (array-in) :outputs (array-out) :return (array-out) @@ -81,7 +81,7 @@ (let ((hank (make-hankel 128 0.0d0 100.0d0)) (in (grid:make-foreign-array 'double-float :dimensions 128))) (loop for n from 0 below 128 - do (setf (grid:gref in n) + do (setf (grid:aref in n) (/ (1+ (expt (sample-x-hankel hank n) 2))))) (grid:copy-to (apply-hankel hank in))) ;; Integrate[ x exp(-x) J_1(a x), {x,0,Inf}] = a F(3/2, 2; 2; -a^2) @@ -89,13 +89,13 @@ (let ((hank (make-hankel 128 1.0d0 20.0d0)) (in (grid:make-foreign-array 'double-float :dimensions 128))) (loop for n from 0 below 128 - do (setf (grid:gref in n) (exp (- (sample-x-hankel hank n))))) + do (setf (grid:aref in n) (exp (- (sample-x-hankel hank n))))) (grid:copy-to (apply-hankel hank in))) ;; Integrate[ x^2 (1-x^2) J_1(a x), {x,0,1}] = 2/a^2 J_3(a) (let ((hank (make-hankel 128 1.0d0 1.0d0)) (in (grid:make-foreign-array 'double-float :dimensions 128))) (loop for n from 0 below 128 - do (setf (grid:gref in n) + do (setf (grid:aref in n) (let ((x (sample-x-hankel hank n))) (* x (- 1 (expt x 2)))))) (grid:copy-to (apply-hankel hank in)))) diff --git a/histogram/histogram.lisp b/histogram/histogram.lisp index f657f25a506fea297a6cdee83c60db8857645875..0ef039ef3caca1ac8694a75bbd20eb2e81a3a42a 100644 --- a/histogram/histogram.lisp +++ b/histogram/histogram.lisp @@ -1,8 +1,8 @@ ;; The histogram structure ;; Liam Healy, Mon Jan 1 2007 - 11:32 -;; Time-stamp: <2010-11-13 19:24:22EST histogram.lisp> +;; Time-stamp: <2011-01-10 17:59:25EST histogram.lisp> ;; -;; Copyright 2007, 2008, 2009, 2010 Liam M. Healy +;; Copyright 2007, 2008, 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -30,7 +30,7 @@ ((number-of-bins sizet)) "one-dimensional histogram, including bin boundaries and bin contents" :initialize-suffix "set_ranges" - :initialize-args (((foreign-pointer ranges) :pointer) ((dim0 ranges) sizet))) + :initialize-args (((grid:foreign-pointer ranges) :pointer) ((dim0 ranges) sizet))) (defmobject histogram2d "gsl_histogram2d" @@ -38,8 +38,8 @@ "two-dimensional histogram, including bin boundaries and bin contents." :initialize-suffix "set_ranges" :initialize-args - (((foreign-pointer x-ranges) :pointer) ((dim0 x-ranges) sizet) - ((foreign-pointer y-ranges) :pointer) ((dim0 y-ranges) sizet))) + (((grid:foreign-pointer x-ranges) :pointer) ((dim0 x-ranges) sizet) + ((grid:foreign-pointer y-ranges) :pointer) ((dim0 y-ranges) sizet))) ;;; GSL documentation does not state what the return value for the ;;; C function for reinitialization means; assumed to be error code. diff --git a/histogram/ntuple-example.dat b/histogram/ntuple-example.dat deleted file mode 100644 index be4cb5a5d29dc9072987e90d6886995088febcb2..0000000000000000000000000000000000000000 Binary files a/histogram/ntuple-example.dat and /dev/null differ diff --git a/histogram/ntuple.lisp b/histogram/ntuple.lisp index 2164ac39a5f6e2bd4069fb70081dee862143a20a..5c8a4a1a83f957805ac63116df2a3d487f478c6c 100644 --- a/histogram/ntuple.lisp +++ b/histogram/ntuple.lisp @@ -1,6 +1,6 @@ ;; N-tuples ;; Liam Healy Sat Feb 3 2007 - 12:53 -;; Time-stamp: <2010-06-30 19:57:28EDT ntuple.lisp> +;; Time-stamp: <2011-05-26 12:37:35EDT ntuple.lisp> ;; ;; Copyright 2007, 2008, 2009 Liam M. Healy ;; Distributed under the terms of the GNU General Public License @@ -235,7 +235,7 @@ (close-ntuple ntuple) ;; Check the histogram to see if it matches ntuple-example-values (dotimes (row 100 t) - (unless (= (grid:gref histo row) (aref answer row)) + (unless (= (grid:aref histo row) (aref answer row)) (return nil)))))) (save-test ntuple diff --git a/histogram/updating-accessing.lisp b/histogram/updating-accessing.lisp index 98c8297ea290ea71040d20a2f9e0bea20ae229af..ca3f81b1a942af59cf249d2070284aec74d1561c 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: <2010-11-14 17:46:45EST updating-accessing.lisp> +;; Time-stamp: <2011-05-26 12:37:35EDT updating-accessing.lisp> ;; ;; Copyright 2007, 2008, 2009 Liam M. Healy ;; Distributed under the terms of the GNU General Public License @@ -42,12 +42,12 @@ histograms for a small range of a larger dataset, ignoring the values outside the range of interest.") -(defmfun grid:gref ((histogram histogram) &rest indices) +(defmfun grid:aref ((histogram histogram) &rest indices) "gsl_histogram_get" (((mpointer histogram) :pointer) ((first indices) sizet)) :definition :method :c-return :double - :index grid:gref + :index grid:aref :documentation ; FDL "Return the contents of the i-th bin of the histogram. If i lies outside the valid range of index for the @@ -128,22 +128,22 @@ (set-ranges-uniform histo 0.0d0 10.0d0) (increment histo 2.7d0) (increment histo 6.9d0 2.0d0) - (grid:gref histo 1)) + (grid:aref histo 1)) (let ((histo (make-histogram 10))) (set-ranges-uniform histo 0.0d0 10.0d0) (increment histo 2.7d0) (increment histo 6.9d0 2.0d0) - (grid:gref histo 2)) + (grid:aref histo 2)) (let ((histo (make-histogram 10))) (set-ranges-uniform histo 0.0d0 10.0d0) (increment histo 2.7d0) (increment histo 6.9d0 2.0d0) - (grid:gref histo 6)) + (grid:aref histo 6)) (let ((histo (make-histogram 10))) (set-ranges-uniform histo 0.0d0 10.0d0) (increment histo 2.7d0) (increment histo 6.9d0 2.0d0) - (grid:gref histo 16)) + (grid:aref histo 16)) (let ((histo (make-histogram 10))) (set-ranges-uniform histo 0.0d0 10.0d0) (increment histo 2.7d0) diff --git a/init/callback-compile-defs.lisp b/init/callback-compile-defs.lisp index 4e8b5b18669339ee25c4c180b87067287e8a456e..54ef37bc40fb1735d5acadeb8a1963bdf787b45a 100644 --- a/init/callback-compile-defs.lisp +++ b/init/callback-compile-defs.lisp @@ -1,8 +1,8 @@ ;; Definitions for macro expansion ;; Liam Healy 2009-03-15 14:50:28EDT callback-compile-defs.lisp -;; Time-stamp: <2009-12-27 09:50:34EST callback-compile-defs.lisp> +;; Time-stamp: <2011-01-10 18:19:12EST callback-compile-defs.lisp> ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -40,7 +40,7 @@ `(make-cbstruct ',(parse-callback-static cbs 'callback-fnstruct) (when (dimension-names object) - (mappend 'list (dimension-names object) (dimensions object))) + (mappend 'list (dimension-names object) (grid:dimensions object))) ,@(mappend 'list (mapcar diff --git a/init/callback-included.lisp b/init/callback-included.lisp index 830f1fee7f8bb325fe12148907814282f3fd0e3b..75a80e9e3c6d628b4eb3f5c0fab417f2e3685ffc 100644 --- a/init/callback-included.lisp +++ b/init/callback-included.lisp @@ -1,8 +1,8 @@ ;; The mobject that defines callbacks ;; Liam Healy 2009-03-14 11:20:03EDT callback-included.lisp -;; Time-stamp: <2009-12-27 09:50:34EST callback-included.lisp> +;; Time-stamp: <2011-01-10 18:19:12EST callback-included.lisp> ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -43,7 +43,7 @@ :initarg :scalarsp :reader scalarsp :initform t :documentation "Whether the function expect to be passed and return scalars or arrays.") - (dimensions :initarg :dimensions :reader dimensions)) + (grid:dimensions :initarg :dimensions :reader grid:dimensions)) (:documentation "A mobject that includes a callback function or functions to GSL.")) @@ -65,7 +65,7 @@ (declare (ignore ignore)) `(defclass ,class-name ,superclasses ((dimension-names :initform nil :allocation :class) - (dimensions :initform '(1) :allocation :class) + (grid:dimensions :initform '(1) :allocation :class) (scalarsp :initform T :allocation :class)) (:documentation ,documentation))) @@ -76,7 +76,7 @@ (princ (first (functions object)) stream) (princ ", " stream)) (princ "dimensions " stream) - (princ (dimensions object) stream))) + (princ (grid:dimensions object) stream))) ;;;;**************************************************************************** ;;;; For making mobjects diff --git a/init/defmfun-array.lisp b/init/defmfun-array.lisp index 603319014986aeb2286c49efde178f8b64b1c4a5..f369b2c801c7790aeeca87a78e5d8943d24d317f 100644 --- a/init/defmfun-array.lisp +++ b/init/defmfun-array.lisp @@ -1,8 +1,8 @@ ;; Helpers for defining GSL functions on arrays ;; Liam Healy 2009-01-07 22:01:16EST defmfun-array.lisp -;; Time-stamp: <2010-07-12 12:28:57EDT defmfun-array.lisp> +;; Time-stamp: <2011-01-29 21:40:31EST defmfun-array.lisp> ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -28,7 +28,7 @@ (defn name arglist gsl-name c-arguments categories key-args) (setf categories (remove-if-not - (lambda (c) (member c '(both matrix vector))) + (lambda (c) (member c '(both grid:matrix vector))) categories)) (if (member 'both categories) (progn @@ -45,12 +45,12 @@ (optional-args-to-switch-gsl-functions arglist gsl-name)) (copy-list key-args) 'vector) (generate-methods - defn 'matrix + defn 'grid:matrix name arglist gsl-name (actual-array-c-type - 'matrix c-arguments + 'grid:matrix c-arguments (optional-args-to-switch-gsl-functions arglist gsl-name)) - (copy-list key-args) 'matrix))) + (copy-list key-args) 'grid:matrix))) ;; Generate forms for one category (generate-methods defn (first categories) @@ -149,18 +149,20 @@ base-name)))))))))) (defun actual-array-class (category element-type &optional replace-both) - "From the category ('vector, 'matrix, or 'both) and element type, + "From the category ('vector, 'grid:matrix, or 'both) and element type, find the class name." (case category (:element-type (grid:number-class element-type)) (:component-float-type - (grid:number-class (grid:component-float-type element-type))) - (otherwise - (grid:data-class-name - (if (and (eq category 'both) replace-both) - replace-both - category) - element-type)))) + (grid:number-class (grid:component-float-type element-type))) + ((vector grid:matrix both) + (grid:data-class-name + (if (and (eq category 'both) replace-both) + replace-both + category) + element-type)) + ;; an actual not-to-be-replaced class name + (otherwise category))) (defun actual-class-arglist (arglist element-type c-arguments &optional replace-both) diff --git a/init/funcallable.lisp b/init/funcallable.lisp index 3ef4e7b0e401a1a6b4eb2604ae4cb0aa68fd1737..92b99d878d727ed0be3486bf1ea6230c90d4b947 100644 --- a/init/funcallable.lisp +++ b/init/funcallable.lisp @@ -1,8 +1,8 @@ ;; Generate a lambda that calls the user function; will be called by callback. ;; Liam Healy -;; Time-stamp: <2010-11-25 09:09:40EST funcallable.lisp> +;; Time-stamp: <2011-01-10 18:19:11EST funcallable.lisp> ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -214,7 +214,7 @@ (lambda (fn fnspec) (compile nil - (make-funcallable-form fn fnspec (scalarsp object) (dimensions object)))) + (make-funcallable-form fn fnspec (scalarsp object) (grid:dimensions object)))) (functions object) (parse-callback-static (cbinfo object) 'functions)))) diff --git a/init/init.lisp b/init/init.lisp index dff9e2c6a9160a268b3cdd5d5723f12d8416468f..7cde22dcf7ef344db06fef194122335ea58f8f98 100644 --- a/init/init.lisp +++ b/init/init.lisp @@ -1,8 +1,8 @@ ;; Load GSL ;; Liam Healy Sat Mar 4 2006 - 18:53 -;; Time-stamp: <2010-08-16 23:08:13EDT init.lisp> +;; Time-stamp: <2011-01-13 09:38:45EST init.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009, 2010 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,17 +19,36 @@ ;; along with this program. If not, see <http://www.gnu.org/licenses/>. (defpackage gsll - (:nicknames :gsl) + (:nicknames :gsl) (:use :common-lisp :cffi) - (:import-from - :grid - #:cl-array #:dimensions #:element-type - #:foreign-array #:matrix #:dim0 #:dim1 #:^ - #:copy) - (:shadowing-import-from :grid #:foreign-pointer) - (:export - #:cl-array #:dimensions #:element-type #:dim0 #:dim1 - #:copy)) + (:import-from :grid #:dim0 #:dim1 #:^ #:copy) + (:export #:dim0 #:dim1 #:copy) + ;; No actual conflict due to different usage of symbols: + ;; antik:psi means "pounds per square inch" vs. function #'gsl:psi + ;; antik:knots means "nautical miles per hour" vs. function #'gsl:knots + ;; antik:acceleration refers to the time derivative of velocity vs. object 'gsl:acceleration. + ;; si units symbol-macro vs. GSLL's sine integral. + (:shadowing-import-from :antik #:psi #:knots #:acceleration #:si)) + +(setf + antik::*antik-user-shadow-symbols* + (append antik::*antik-user-shadow-symbols* + ;; Where there is a symbol conflict between GSLL and other packages, + '( + ;; take from the other package + grid:row ; GSLL alternate is equivalent + grid:column ; GSLL alternate is equivalent + iterate:sum ; GSLL histogram function, both pretty obscure + iterate:multiply ; GSLL function duplicates '* + antik:polar-to-rectangular ; GSLL's doesn't use vectors + antik:rectangular-to-polar ; GSLL's doesn't use vectors + ;; taken from GSLL + gsll::iterate ; conflict with iterate:iterate, but iterate:iter is a synonym + )) + antik::*antik-user-use-packages* + (cons '#:gsll antik::*antik-user-use-packages*)) + +(antik:make-user-package :antik-user) ; Add the new use package and shadow symbols to :antik-user (in-package :gsl) diff --git a/init/mobject.lisp b/init/mobject.lisp index 0b39a098a42c26b4bff019d29d107a508893be21..8b3836c89c3147f32f2a34fbd6a3bb61aa7eee2c 100644 --- a/init/mobject.lisp +++ b/init/mobject.lisp @@ -1,8 +1,8 @@ ;; Definition of GSL objects and ways to use them. ;; Liam Healy, Sun Dec 3 2006 - 10:21 -;; Time-stamp: <2010-11-13 18:22:18EST mobject.lisp> +;; Time-stamp: <2011-01-11 19:10:48EST mobject.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -288,9 +288,9 @@ (if (listp symbol) (mappend (lambda (s) (symbol-keyword-symbol s singular)) symbol) (if (member (singular-symbol symbol) singular) - (list (intern (symbol-name symbol) :keyword) + (list (alexandria:make-keyword symbol) `(list ,(singular-symbol symbol))) - (list (intern (symbol-name symbol) :keyword) + (list (alexandria:make-keyword symbol) symbol)))) ;;;;**************************************************************************** diff --git a/interpolation/evaluation.lisp b/interpolation/evaluation.lisp index 0c7c6c0c1002f0872e4ce631a388097cea636ba8..1546943b501b5e540bf590f2e0e216d33e984bae 100644 --- a/interpolation/evaluation.lisp +++ b/interpolation/evaluation.lisp @@ -1,8 +1,8 @@ ;; Evaluation of interpolation functions. ;; Liam Healy Sun Nov 4 2007 - 18:40 -;; Time-stamp: <2010-06-27 18:13:56EDT evaluation.lisp> +;; Time-stamp: <2011-01-10 17:59:26EST evaluation.lisp> ;; -;; Copyright 2007, 2008, 2009 Liam M. Healy +;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -27,8 +27,8 @@ &key xa ya (acceleration (make-acceleration))) "gsl_interp_eval" (((mpointer interpolation) :pointer) - ((foreign-pointer xa) :pointer) - ((foreign-pointer ya) :pointer) + ((grid:foreign-pointer xa) :pointer) + ((grid:foreign-pointer ya) :pointer) (x :double) ((mpointer acceleration) :pointer)) :definition :method @@ -51,8 +51,8 @@ &key xa ya (acceleration (make-acceleration))) "gsl_interp_eval_deriv" (((mpointer interpolation) :pointer) - ((foreign-pointer xa) :pointer) - ((foreign-pointer ya) :pointer) + ((grid:foreign-pointer xa) :pointer) + ((grid:foreign-pointer ya) :pointer) (x :double) ((mpointer acceleration) :pointer)) :definition :method @@ -70,8 +70,8 @@ ((interpolation interpolation) x &key xa ya (acceleration (make-acceleration))) "gsl_interp_eval_deriv2" (((mpointer interpolation) :pointer) - ((foreign-pointer xa) :pointer) - ((foreign-pointer ya) :pointer) + ((grid:foreign-pointer xa) :pointer) + ((grid:foreign-pointer ya) :pointer) (x :double) ((mpointer acceleration) :pointer)) :definition :method @@ -90,8 +90,8 @@ &key xa ya (acceleration (make-acceleration))) "gsl_interp_eval_integ" (((mpointer interpolation) :pointer) - ((foreign-pointer xa) :pointer) - ((foreign-pointer ya) :pointer) + ((grid:foreign-pointer xa) :pointer) + ((grid:foreign-pointer ya) :pointer) (low :double) (high :double) ((mpointer acceleration) :pointer)) :definition :method :inputs (xa ya) diff --git a/interpolation/interpolation.lisp b/interpolation/interpolation.lisp index f7845f4f8efdf5a4b2944ceb75d1c6a35d5f45af..dd5a83fe2c08b995a4e9290261dbe6df571c1d5e 100644 --- a/interpolation/interpolation.lisp +++ b/interpolation/interpolation.lisp @@ -1,8 +1,8 @@ ;; Interpolation allocation, initialization, and freeing. ;; Liam Healy, Sun Nov 4 2007 - 17:24 -;; Time-stamp: <2010-06-27 18:13:56EDT interpolation.lisp> +;; Time-stamp: <2011-01-10 17:59:26EST interpolation.lisp> ;; -;; Copyright 2007, 2008, 2009 Liam M. Healy +;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -37,7 +37,7 @@ strictly ordered; the behavior for other arrangements is not defined." :initialize-suffix "init" :initialize-args - (((foreign-pointer xa) :pointer) ((foreign-pointer ya) :pointer) ((dim0 xa) sizet)) + (((grid:foreign-pointer xa) :pointer) ((grid:foreign-pointer ya) :pointer) ((dim0 xa) sizet)) :arglists-function (lambda (set) `((type &optional xa-or-size (ya nil ,set)) @@ -51,7 +51,7 @@ "Make an interpolation object of type for size data-points." :initialize-suffix "init" :initialize-args - (((foreign-pointer xa) :pointer) ((foreign-pointer ya) :pointer) ((dim0 xa) sizet)) + (((grid:foreign-pointer xa) :pointer) ((grid:foreign-pointer ya) :pointer) ((dim0 xa) sizet)) :inputs (xa ya) :arglists-function (lambda (set) diff --git a/interpolation/lookup.lisp b/interpolation/lookup.lisp index fc329b701fbd4795aea46e5c88efe230e1545512..78b754c6c6bd84b42db90d1807196643541e142c 100644 --- a/interpolation/lookup.lisp +++ b/interpolation/lookup.lisp @@ -1,8 +1,8 @@ ;; Index lookup and acceleration ;; Liam Healy, Sun Nov 4 2007 - 18:09 -;; Time-stamp: <2009-12-27 09:52:14EST lookup.lisp> +;; Time-stamp: <2011-01-13 10:24:57EST lookup.lisp> ;; -;; Copyright 2007, 2008, 2009 Liam M. Healy +;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify diff --git a/interpolation/spline-example.lisp b/interpolation/spline-example.lisp index 1e870684efa29fc2e2d5e0165a7bf4bb80debbb5..1449b20523ba8919a08ca59485941b0d08e02fc8 100644 --- a/interpolation/spline-example.lisp +++ b/interpolation/spline-example.lisp @@ -1,6 +1,6 @@ ;; Example spline ;; Liam Healy, Sat Nov 10 2007 - 21:18 -;; Time-stamp: <2010-08-07 21:37:07EDT spline-example.lisp> +;; Time-stamp: <2011-05-26 12:37:34EDT spline-example.lisp> ;; ;; Copyright 2007, 2008, 2009 Liam M. Healy ;; Distributed under the terms of the GNU General Public License @@ -35,7 +35,7 @@ (loop for i from 0.0d0 below 10.0d0 collect (+ i (cos (expt i 2)))))) (spline (make-spline +cubic-spline-interpolation+ xarr yarr))) - (loop for xi from (grid:gref xarr 0) below (grid:gref xarr 9) by step + (loop for xi from (grid:aref xarr 0) below (grid:aref xarr 9) by step collect (list xi (evaluate spline xi))))) (defun evaluate-integral-example (&optional (intervals 4)) diff --git a/linear-algebra/blas1.lisp b/linear-algebra/blas1.lisp index 401def27e46c40e6a23e3ad11ab8e988b155c851..42660a81981cff8b38b8025b2ade77da2ed7f9e3 100644 --- a/linear-algebra/blas1.lisp +++ b/linear-algebra/blas1.lisp @@ -1,8 +1,8 @@ ;; BLAS level 1, Vector operations ;; Liam Healy, Wed Apr 26 2006 - 15:23 -;; Time-stamp: <2010-07-07 14:25:01EDT blas1.lisp> +;; Time-stamp: <2011-05-26 12:37:34EDT blas1.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -22,11 +22,11 @@ ;;; /usr/include/gsl/gsl_blas.h -(defmfun dot ((vec1 vector) (vec2 vector)) +(defmfun grid:inner ((vec1 vector) (vec2 vector)) ("gsl_blas_" :type "dot" :suffix) (((mpointer vec1) :pointer) ((mpointer vec2) :pointer) (result (:pointer :element-c-type))) - :definition :generic + :definition :methods :element-types :float-complex :inputs (vec1 vec2) :documentation ; FDL @@ -112,7 +112,7 @@ (defmfun axpy (alpha (x vector) &optional - (y (grid:make-foreign-array element-type :dimensions (dimensions x)))) + (y (grid:make-foreign-array element-type :dimensions (grid:dimensions x)))) ;; This gets an error for complex types because you can't pass a ;; struct in CFFI yet. ("gsl_blas_" :type "axpy") @@ -153,8 +153,8 @@ (defmfun givens-rotation ((x vector) (y vector) (c vector) (s vector)) ("gsl_blas_" :type "rotg") - (((foreign-pointer x) :pointer) ((foreign-pointer y) :pointer) - ((foreign-pointer c) :pointer) ((foreign-pointer s) :pointer)) + (((grid:foreign-pointer x) :pointer) ((grid:foreign-pointer y) :pointer) + ((grid:foreign-pointer c) :pointer) ((grid:foreign-pointer s) :pointer)) :definition :generic :element-types :float :inputs (x y c s) @@ -182,9 +182,9 @@ (defmfun modified-givens-rotation ((d1 vector) (d2 vector) (b1 vector) b2 (P vector)) ("gsl_blas_" :type "rotmg") - (((foreign-pointer d1) :pointer) ((foreign-pointer d2) :pointer) - ((foreign-pointer b1) :pointer) (b2 :element-c-type) - ((foreign-pointer P) :pointer)) + (((grid:foreign-pointer d1) :pointer) ((grid:foreign-pointer d2) :pointer) + ((grid:foreign-pointer b1) :pointer) (b2 :element-c-type) + ((grid:foreign-pointer P) :pointer)) :definition :generic :element-types :float :inputs (d1 d2 b1 P) @@ -210,7 +210,7 @@ (generate-all-array-tests dot :float-complex (let ((v1 (array-default 8)) (v2 (array-default 8))) - (dot v1 v2))) + (grid:inner v1 v2))) (generate-all-array-tests cdot :complex (let ((v1 (array-default 8)) @@ -264,7 +264,7 @@ (sines (array-default 8 t)) (cosines (array-default 8 t))) (loop for i below 8 do - (setf (grid:gref sines i) (sin (grid:gref angles i))) - (setf (grid:gref cosines i) (cos (grid:gref angles i)))) + (setf (grid:aref sines i) (sin (grid:aref angles i))) + (setf (grid:aref cosines i) (cos (grid:aref angles i)))) (givens-rotation v1 v2 cosines sines) (list (grid:copy-to v1) (grid:copy-to v2)))) diff --git a/linear-algebra/blas2.lisp b/linear-algebra/blas2.lisp index b2fbe8a3842bad8ebc007108fea9eb874e0bfadc..2b421480ad72894a5a6913973bb1b248aa96869b 100644 --- a/linear-algebra/blas2.lisp +++ b/linear-algebra/blas2.lisp @@ -1,8 +1,8 @@ ;; BLAS level 2, Matrix-vector operations ;; Liam Healy, Wed Apr 26 2006 - 21:08 -;; Time-stamp: <2010-07-07 14:25:00EDT blas2.lisp> +;; Time-stamp: <2011-04-23 17:15:33EDT blas2.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -41,20 +41,20 @@ ;;;;**************************************************************************** (defun matrix-product-dimensions (a b) - (if (typep b 'matrix) - (list (first (dimensions a)) - (second (dimensions b))) - (first (dimensions a)))) + (if (typep b 'grid:matrix) + (list (first (grid:dimensions a)) + (second (grid:dimensions b))) + (first (grid:dimensions a)))) (defmfun matrix-product - ((A matrix) (x vector) + ((A grid:matrix) (x vector) &optional y (alpha 1) (beta 1) (TransA :notrans) TransB &aux (yarr - (grid:make-foreign-array-or-default - y (matrix-product-dimensions A x) nil element-type 0))) + (grid:ensure-foreign-array + y (matrix-product-dimensions A x) element-type 0))) ("gsl_blas_" :type "gemv") ((transa cblas-transpose) (alpha :element-c-type) ((mpointer A) :pointer) ((mpointer x) :pointer) (beta :element-c-type) ((mpointer yarr) :pointer)) @@ -74,7 +74,7 @@ parameter TransB.") (defmfun matrix-product-triangular - ((A matrix) (x vector) + ((A grid:matrix) (x vector) &optional (alpha 1) (uplo :upper) (TransA :notrans) (diag :nonunit) (side :left)) ("gsl_blas_" :type "trmv") @@ -106,7 +106,7 @@ are taken as unity and are not referenced.") (defmfun inverse-matrix-product - ((A matrix) (x vector) + ((A grid:matrix) (x vector) &optional (alpha 1) (uplo :upper) (TransA :notrans) (diag :nonunit) (side :left)) ("gsl_blas_" :type "trsv") @@ -137,7 +137,7 @@ matrix A are taken as unity and are not referenced.") (defmfun matrix-product-symmetric - ((A matrix) (x vector) + ((A grid:matrix) (x vector) &optional y (alpha 1) (beta 1) (uplo :upper) (side :left) &aux @@ -170,7 +170,7 @@ #+fsbv (defmfun matrix-product-hermitian - ((A matrix) (x vector) + ((A grid:matrix) (x vector) &optional (y (grid:make-foreign-array element-type :dimensions (matrix-product-dimensions A x) :initial-element 0)) @@ -199,7 +199,7 @@ are used. The imaginary elements of the diagonal are automatically set to zero.") -(defmfun rank-1-update (alpha (x vector) (y vector) (A matrix)) +(defmfun rank-1-update (alpha (x vector) (y vector) (A grid:matrix)) ("gsl_blas_" :type "ger" :suffix) ((alpha :element-c-type) ((mpointer x) :pointer) ((mpointer y) :pointer) ((mpointer A) :pointer)) @@ -211,7 +211,7 @@ "The rank-1 update A = alpha x y^T + A of the matrix A.") #+fsbv -(defmfun conjugate-rank-1-update (alpha (x vector) (y vector) (A matrix)) +(defmfun conjugate-rank-1-update (alpha (x vector) (y vector) (A grid:matrix)) ("gsl_blas_" :type "gerc") ((alpha :element-c-type) ((mpointer x) :pointer) ((mpointer y) :pointer) ((mpointer A) :pointer)) @@ -223,7 +223,7 @@ "The conjugate rank-1 update A = alpha x y^H + A of the matrix A.") (defmfun symmetric-rank-1-update - ((x vector) (A matrix) + ((x vector) (A grid:matrix) &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans)) ("gsl_blas_" :type "syr") ((uplo cblas-uplo) (alpha :element-c-type) @@ -249,7 +249,7 @@ #+fsbv (defmfun hermitian-rank-1-update - ((x vector) (A matrix) + ((x vector) (A grid:matrix) &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans)) ("gsl_blas_" :type "her") ((uplo cblas-uplo) (alpha :element-c-type) @@ -276,7 +276,7 @@ elements of the diagonal are automatically set to zero.") (defmfun symmetric-rank-2-update - ((x vector) (y vector) (A matrix) + ((x vector) (y vector) (A grid:matrix) &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans)) ("gsl_blas_" :type "syr2") ((uplo cblas-uplo) (alpha :element-c-type) @@ -303,7 +303,7 @@ #+fsbv (defmfun hermitian-rank-2-update - ((x vector) (y vector) (A matrix) + ((x vector) (y vector) (A grid:matrix) &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans)) ("gsl_blas_" :type "her2") ((uplo cblas-uplo) (alpha :element-c-type) diff --git a/linear-algebra/blas3.lisp b/linear-algebra/blas3.lisp index ab51b2a892fd69cf74bfe0099dcd332d24c98fcd..933448596d23930f85d2b1eb568f74ad87e1040d 100644 --- a/linear-algebra/blas3.lisp +++ b/linear-algebra/blas3.lisp @@ -1,8 +1,8 @@ ;; BLAS level 3, Matrix-matrix operations ;; Liam Healy, Wed Apr 26 2006 - 21:08 -;; Time-stamp: <2010-07-07 14:25:00EDT blas3.lisp> +;; Time-stamp: <2011-01-12 00:49:27EST blas3.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -34,7 +34,7 @@ ;;;;**************************************************************************** (defmfun matrix-product - ((A matrix) (B matrix) + ((A grid:matrix) (B grid:matrix) &optional C (alpha 1) (beta 1) (TransA :notrans) (TransB :notrans) @@ -53,7 +53,7 @@ :outputs (Carr)) (defmfun matrix-product-symmetric - ((A matrix) (B matrix) + ((A grid:matrix) (B grid:matrix) &optional C (alpha 1) (beta 1) (uplo :upper) (side :left) &aux (Carr @@ -71,7 +71,7 @@ #+fsbv (defmfun matrix-product-hermitian - ((A matrix) (B matrix) + ((A grid:matrix) (B grid:matrix) &optional (C (grid:make-foreign-array element-type :dimensions (matrix-product-dimensions A B) :initial-element 0)) @@ -88,7 +88,7 @@ :outputs (C)) (defmfun matrix-product-triangular - ((A matrix) (B matrix) + ((A grid:matrix) (B grid:matrix) &optional (alpha 1) (uplo :upper) (TransA :notrans) (diag :nonunit) (side :left)) ("gsl_blas_" :type "trmm") @@ -101,7 +101,7 @@ :outputs (B)) (defmfun inverse-matrix-product - ((A matrix) (B matrix) + ((A grid:matrix) (B grid:matrix) &optional (alpha 1) (uplo :upper) (TransA :notrans) (diag :nonunit) (side :left)) ;; This signals an error for complex arguments because you can't pass a @@ -116,7 +116,7 @@ :outputs (B)) (defmfun symmetric-rank-1-update - ((A matrix) (C matrix) + ((A grid:matrix) (C grid:matrix) &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans)) ("gsl_blas_" :type "syrk") ((uplo cblas-uplo) (trans cblas-transpose) @@ -129,7 +129,7 @@ #+fsbv (defmfun hermitian-rank-1-update - ((A matrix) (C matrix) + ((A grid:matrix) (C grid:matrix) &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans)) ("gsl_blas_" :type "herk") ((uplo cblas-uplo) (trans cblas-transpose) @@ -141,7 +141,7 @@ :outputs (C)) (defmfun symmetric-rank-2-update - ((A matrix) (B matrix) (C matrix) + ((A grid:matrix) (B grid:matrix) (C grid:matrix) &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans)) ("gsl_blas_" :type "syr2k") ((uplo cblas-uplo) (trans cblas-transpose) @@ -155,7 +155,7 @@ #+fsbv (defmfun hermitian-rank-2-update - ((A matrix) (B matrix) (C matrix) + ((A grid:matrix) (B grid:matrix) (C grid:matrix) &optional (alpha 1) (beta 1) (uplo :upper) (trans :notrans)) ("gsl_blas_" :type "her2k") ((uplo cblas-uplo) (trans cblas-transpose) diff --git a/linear-algebra/cholesky.lisp b/linear-algebra/cholesky.lisp index f75ba50e23e5a3174f87cd4261596aa1ab9f54d9..afa6239034f7113275d41adb5d2198a435d8a368 100644 --- a/linear-algebra/cholesky.lisp +++ b/linear-algebra/cholesky.lisp @@ -1,8 +1,8 @@ ;; Cholesky Decomposition ;; Liam Healy, Wed May 3 2006 - 16:38 -;; Time-stamp: <2010-06-30 19:57:28EDT cholesky.lisp> +;; Time-stamp: <2011-05-26 12:37:33EDT cholesky.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -34,7 +34,7 @@ ;;; GSL version 1.10 introduced functions for complex matrices. -(defmfun cholesky-decomposition ((A matrix)) +(defmfun cholesky-decomposition ((A grid:matrix)) ("gsl_linalg" :complex "_cholesky_decomp") (((mpointer A) :pointer)) :definition :generic @@ -51,9 +51,9 @@ returning the error input-domain.") (defmfun cholesky-solve - ((A matrix) (b vector) &optional x-spec + ((A grid:matrix) (b vector) &optional x-spec &aux - (x (grid:make-foreign-array-or-default x-spec (dimensions b) t))) + (x (grid:ensure-foreign-array x-spec (grid:dimensions b)))) (("gsl_linalg" :complex "_cholesky_svx") ("gsl_linalg" :complex "_cholesky_solve")) ((((mpointer A) :pointer) ((mpointer b) :pointer)) @@ -98,7 +98,7 @@ (let ((decomp (cholesky-decomposition (copy matrix)))) (dotimes (row (dim0 matrix) decomp) (loop for col from (1+ row) below (dim1 matrix) do - (setf (grid:gref decomp row col) 0.0d0))) + (setf (grid:aref decomp row col) 0.0d0))) (matrix-product decomp decomp nil 1.0d0 0.0d0 :notrans :trans))) (defun test-cholesky-invert-dim (matrix) diff --git a/linear-algebra/diagonal.lisp b/linear-algebra/diagonal.lisp index cace5ac3e6b2ef4647f29c9fb9aedfc26464de4e..1eb71f2fcabe660ae62f0012c026a6852131e5a7 100644 --- a/linear-algebra/diagonal.lisp +++ b/linear-algebra/diagonal.lisp @@ -1,8 +1,8 @@ ;; Tridiagonal and Bidiagonal matrices ;; Liam Healy, Thu May 4 2006 - 15:43 -;; Time-stamp: <2010-06-30 19:57:28EDT diagonal.lisp> +;; Time-stamp: <2011-05-26 12:37:34EDT diagonal.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -35,7 +35,7 @@ ;;; A = U T U^T where U is a unitary ;;; matrix and T is a real symmetric tridiagonal matrix. -(defmfun tridiagonal-decomposition ((A matrix) tau) +(defmfun tridiagonal-decomposition ((A grid:matrix) tau) (double-float "gsl_linalg_symmtd_decomp" complex-double-float "gsl_linalg_hermtd_decomp") (((mpointer A) :pointer) ((mpointer tau) :pointer)) @@ -53,7 +53,7 @@ Q. This storage scheme is the same as used by lapack. The upper triangular part of A is not referenced.") -(defmfun tridiagonal-unpack ((A matrix) tau Q diag subdiag) +(defmfun tridiagonal-unpack ((A grid:matrix) tau Q diag subdiag) (double-float "gsl_linalg_symmtd_unpack" complex-double-float "gsl_linalg_hermtd_unpack") (((mpointer A) :pointer) ((mpointer tau) :pointer) @@ -69,7 +69,7 @@ orthogonal or unitary matrix Q, the vector of diagonal elements diag and the real vector of subdiagonal elements subdiag.") -(defmfun tridiagonal-unpack-T ((A matrix) diag subdiag) +(defmfun tridiagonal-unpack-T ((A grid:matrix) diag subdiag) (double-float "gsl_linalg_symmtd_unpack_T" complex-double-float "gsl_linalg_hermtd_unpack_T") (((mpointer A) :pointer) ((mpointer diag) :pointer) @@ -255,11 +255,11 @@ (subdiag (mvec (1- n) :initial-element 0.5d0))) (setf ;; i=0 matrix elements - (grid:gref diag 0) 1d0 - (grid:gref superdiag 0) 0d0 - (grid:gref b 0) (coerce (expt (1- n) 2) 'double-float) + (grid:aref diag 0) 1d0 + (grid:aref superdiag 0) 0d0 + (grid:aref b 0) (coerce (expt (1- n) 2) 'double-float) ;; i=n-1 matrix elements - (grid:gref diag (1- n)) 1d0 - (grid:gref subdiag (- n 2)) 0d0 - (grid:gref b (1- n)) 0d0) + (grid:aref diag (1- n)) 1d0 + (grid:aref subdiag (- n 2)) 0d0 + (grid:aref b (1- n)) 0d0) (solve-tridiagonal diag superdiag subdiag b x)))) diff --git a/linear-algebra/householder.lisp b/linear-algebra/householder.lisp index 7545f90dc8299a2d2c91be49bf1563adeadbc8be..a903e68d7191cd2e6f07678300518d720835a912 100644 --- a/linear-algebra/householder.lisp +++ b/linear-algebra/householder.lisp @@ -1,8 +1,8 @@ ;; Householder Transformations ;; Liam Healy, Wed May 10 2006 - 10:03 -;; Time-stamp: <2010-06-29 22:51:21EDT householder.lisp> +;; Time-stamp: <2011-04-23 17:14:09EDT householder.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -87,7 +87,7 @@ (defmfun householder-solve (A b &optional x-spec &aux - (x (grid:make-foreign-array-or-default x-spec (dimensions b) t))) + (x (grid:ensure-foreign-array x-spec (grid:dimensions b)))) ("gsl_linalg_HH_svx" "gsl_linalg_HH_solve") ((((mpointer A) :pointer) ((mpointer b) :pointer)) (((mpointer A) :pointer) ((mpointer b) :pointer) diff --git a/linear-algebra/lu.lisp b/linear-algebra/lu.lisp index fe24ced82be41dd5182aa22f6bbb88c9faf75319..4ece7b4c888a91afad005d7fdd8bb1586ffe3ed9 100644 --- a/linear-algebra/lu.lisp +++ b/linear-algebra/lu.lisp @@ -1,8 +1,8 @@ ;; LU decomposition ;; Liam Healy, Thu Apr 27 2006 - 12:42 -;; Time-stamp: <2010-07-07 14:24:59EDT lu.lisp> +;; Time-stamp: <2011-01-30 11:00:48EST lu.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -23,7 +23,7 @@ ;;; /usr/include/gsl/gsl_linalg.h (defmfun LU-decomposition - ((A matrix) &optional (permutation (make-permutation (dim0 A)))) + ((A grid:matrix) &optional (permutation (make-permutation (dim0 A)))) ("gsl_linalg" :complex "_LU_decomp") (((mpointer A) :pointer) ((mpointer permutation) :pointer) (signum (:pointer :int))) @@ -53,10 +53,10 @@ Algorithm 3.4.1).") (defmfun LU-solve - ((A matrix) (b vector) permutation &optional x-spec + ((A grid:matrix) (b vector) permutation &optional x-spec &aux (x (if (eq x-spec t) - (grid:make-foreign-array element-type :dimensions (dimensions b)) + (grid:make-foreign-array element-type :dimensions (grid:dimensions b)) x-spec))) (("gsl_linalg" :complex "_LU_svx") ("gsl_linalg" :complex "_LU_solve")) @@ -78,7 +78,7 @@ will be computed there. Otherwise it should be a supplied vector.") (defmfun LU-refine - ((A matrix) LU p (b vector) (x vector) + ((A grid:matrix) LU p (b vector) (x vector) &optional (residual (grid:make-foreign-array element-type :dimensions (dim0 A)))) ("gsl_linalg" :complex "_LU_refine") (((mpointer A) :pointer) ((mpointer LU) :pointer) @@ -95,7 +95,10 @@ A x = b, using the LU decomposition of A into (LU,p). The initial residual r = A x - b is also computed and stored in residual. ") -(defmfun LU-invert ((LU matrix) p inverse) +(defmfun LU-invert + ((LU grid:matrix) p + &optional (inverse + (grid:make-foreign-array element-type :dimensions (grid:dimensions LU)))) ("gsl_linalg" :complex "_LU_invert") (((mpointer LU) :pointer) ((mpointer p) :pointer) ((mpointer inverse) :pointer)) @@ -112,7 +115,7 @@ the same result more efficiently and reliably (consult any introductory textbook on numerical linear algebra for details).") - (defmfun LU-determinant ((LU matrix) signum) +(defmfun LU-determinant ((LU grid:matrix) signum) ("gsl_linalg" :complex "_LU_det") (((mpointer LU) :pointer) (signum :int)) :definition :generic @@ -124,7 +127,7 @@ decomposition, LU. The determinant is computed as the product of the diagonal elements of U and the sign of the row permutation signum.") -(defmfun LU-log-determinant ((LU matrix)) +(defmfun LU-log-determinant ((LU grid:matrix)) ("gsl_linalg" :complex "_LU_lndet") (((mpointer LU) :pointer)) :definition :generic @@ -137,7 +140,7 @@ LU. This function may be useful if the direct computation of the determinant would overflow or underflow.") -(defmfun LU-sgndet ((LU matrix) signum) +(defmfun LU-sgndet ((LU grid:matrix) signum) ("gsl_linalg" :complex "_LU_sgndet") (((mpointer LU) :pointer) (signum :int)) :definition :generic @@ -148,28 +151,6 @@ "Compute the sign or phase factor of the determinant of a matrix A, det(A)/|det(A)|, from its LU decomposition, LU.") -;;; Invert a matrix using LU -(export 'invert-matrix) -(defun invert-matrix (mat) - "Invert the matrix." - (let* ((dim (first (dimensions mat))) - (per (make-permutation dim)) - (inv (grid:make-foreign-array 'double-float :dimensions (list dim dim)))) - (LU-decomposition mat per) - (lu-invert mat per inv))) - -;;; Examples and unit test - -;;; These are direct tests of matrix inversion - -(save-test - lu - (grid:copy-to - (invert-matrix - (grid:make-foreign-array 'double-float - :dimensions '(2 2) - :initial-contents '(1.0d0 2.0d0 3.0d0 4.0d0))))) - (generate-all-array-tests lu :doubles (let ((matrix (array-default '(4 4))) (vec (array-default '4 ))) @@ -192,7 +173,7 @@ the index." (let* ((dim (dim0 matrix)) (rhs (or vector - (create-rhs-vector dim (element-type matrix))))) + (create-rhs-vector dim (grid:element-type matrix))))) (multiple-value-bind (upper permutation signum) (LU-decomposition (copy matrix)) (declare (ignore signum)) diff --git a/linear-algebra/matrix-generation.lisp b/linear-algebra/matrix-generation.lisp index 21645764859d726b5456943ddec4043a47f99330..902564b9e657505564269e965159dd85e71b2494 100644 --- a/linear-algebra/matrix-generation.lisp +++ b/linear-algebra/matrix-generation.lisp @@ -1,8 +1,8 @@ ;; Generate matrices used in tests of linear algebra functions ;; Liam Healy 2009-09-19 18:28:31EDT matrix-generation.lisp -;; Time-stamp: <2010-08-12 22:48:01EDT matrix-generation.lisp> +;; Time-stamp: <2011-01-11 23:58:19EST matrix-generation.lisp> ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -40,13 +40,13 @@ :source function :destination-specification (if dim1 - `((foreign-array ,dim0 ,dim1) ,element-type) - `((foreign-array ,dim0) ,element-type)))) + `((grid:foreign-array ,dim0 ,dim1) ,element-type) + `((grid:foreign-array ,dim0) ,element-type)))) (defun constant-matrix (constant dim0 &optional (dim1 dim0) (element-type 'double-float)) (grid:make-grid - `((foreign-array ,dim0 ,dim1) ,element-type) + `((grid:foreign-array ,dim0 ,dim1) ,element-type) :initial-element constant)) ;;;;**************************************************************************** diff --git a/linear-algebra/qr.lisp b/linear-algebra/qr.lisp index cf7e52ebea86eb662c56583f0a71ea1c88dc259d..8dc33b9380a16947eceede28bd49fdf56b40a035 100644 --- a/linear-algebra/qr.lisp +++ b/linear-algebra/qr.lisp @@ -1,8 +1,8 @@ ;; QR decomposition ;; Liam Healy 2008-02-17 11:05:20EST qr.lisp -;; Time-stamp: <2010-06-30 19:57:28EDT qr.lisp> +;; Time-stamp: <2011-05-26 12:37:33EDT qr.lisp> ;; -;; Copyright 2008, 2009 Liam M. Healy +;; Copyright 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -62,7 +62,7 @@ (defmfun QR-solve (QR tau b &optional x-spec &aux - (x (grid:make-foreign-array-or-default x-spec (dimensions b) t))) + (x (grid:ensure-foreign-array x-spec (grid:dimensions b)))) ("gsl_linalg_QR_svx" "gsl_linalg_QR_solve") ((((mpointer QR) :pointer) ((mpointer tau) :pointer) ((mpointer b) :pointer)) @@ -129,7 +129,7 @@ (defmfun QR-Rsolve (QR b &optional x-spec &aux - (x (grid:make-foreign-array-or-default x-spec (dimensions b) t))) + (x (grid:ensure-foreign-array x-spec (grid:dimensions b)))) ("gsl_linalg_QR_Rsvx" "gsl_linalg_QR_Rsolve") ((((mpointer QR) :pointer) ((mpointer b) :pointer)) (((mpointer QR) :pointer) ((mpointer b) :pointer) ((mpointer x) :pointer))) @@ -149,7 +149,7 @@ (QR tau &optional (Q (grid:make-foreign-array 'double-float :dimensions (list (dim0 QR) (dim0 QR)))) - (R (grid:make-foreign-array 'double-float :dimensions (dimensions QR)))) + (R (grid:make-foreign-array 'double-float :dimensions (grid:dimensions QR)))) "gsl_linalg_QR_unpack" (((mpointer QR) :pointer) ((mpointer tau) :pointer) ((mpointer Q) :pointer) ((mpointer R) :pointer)) @@ -189,7 +189,7 @@ (defmfun R-solve (R b &optional x-spec &aux - (x (grid:make-foreign-array-or-default x-spec (dimensions b) t))) + (x (grid:ensure-foreign-array x-spec (grid:dimensions b)))) ("gsl_linalg_R_svx" "gsl_linalg_R_solve") ((((mpointer R) :pointer) ((mpointer b) :pointer)) (((mpointer R) :pointer) ((mpointer b) :pointer) ((mpointer x) :pointer))) @@ -258,7 +258,7 @@ dim1 nil)) (qr1 (create-matrix - (lambda (i j) (+ (grid:gref matrix i j) (* (grid:gref u i) (grid:gref v j)))) + (lambda (i j) (+ (grid:aref matrix i j) (* (grid:aref u i) (grid:aref v j)))) dim0 dim1)) (qr2 (copy matrix)) (w (grid:make-foreign-array 'double-float :dimensions dim0 :initial-element 0))) diff --git a/linear-algebra/qrpt.lisp b/linear-algebra/qrpt.lisp index 6e093c4215513af0d3687eab167f84596ff7d33c..f38b300388d1e2cf901885610fcbb5367318d01f 100644 --- a/linear-algebra/qrpt.lisp +++ b/linear-algebra/qrpt.lisp @@ -1,8 +1,8 @@ ;; QR with column pivoting ;; Liam Healy, Fri Apr 28 2006 - 16:53 -;; Time-stamp: <2010-06-29 22:51:20EDT qrpt.lisp> +;; Time-stamp: <2011-04-23 17:15:46EDT qrpt.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -60,7 +60,7 @@ (A &optional (q (grid:make-foreign-array 'double-float :dimensions (list (dim0 A) (dim0 A)))) - (r (grid:make-foreign-array 'double-float :dimensions (dimensions A))) + (r (grid:make-foreign-array 'double-float :dimensions (grid:dimensions A))) (tau (grid:make-foreign-array 'double-float :dimensions (min (dim0 A) (dim1 A)))) (permutation (make-permutation (dim1 A))) (norm (grid:make-foreign-array 'double-float :dimensions (dim1 A)))) @@ -80,7 +80,7 @@ (defmfun QRPT-solve (QR tau permutation b &optional x-spec &aux - (x (grid:make-foreign-array-or-default x-spec (dimensions b) t))) + (x (grid:ensure-foreign-array x-spec (grid:dimensions b)))) ("gsl_linalg_QRPT_svx" "gsl_linalg_QRPT_solve") ((((mpointer QR) :pointer) ((mpointer tau) :pointer) ((mpointer permutation) :pointer) ((mpointer b) :pointer)) @@ -131,7 +131,7 @@ (defmfun QRPT-Rsolve (QR permutation b &optional x-spec &aux - (x (grid:make-foreign-array-or-default x-spec (dimensions b) t))) + (x (grid:ensure-foreign-array x-spec (grid:dimensions b)))) ("gsl_linalg_QRPT_Rsvx" "gsl_linalg_QRPT_Rsolve") ((((mpointer QR) :pointer) ((mpointer permutation) :pointer) ((mpointer b) :pointer)) @@ -180,7 +180,7 @@ (QR-unpack QRPT tau) (let* ((qr (matrix-product Q R)) (ans (grid:make-foreign-array - 'double-float :dimensions (dimensions qr) + 'double-float :dimensions (grid:dimensions qr) ;; It shouldn't be necessary to initialize values ;; because we are going to setf every row, ;; Sat Dec 26 2009. diff --git a/ordinary-differential-equations/evolution.lisp b/ordinary-differential-equations/evolution.lisp index eff0e004c2072d763c0bce9b119086d66ea4cc4d..e851cbbfdfb828b750bfd9a056052308e93eaf2e 100644 --- a/ordinary-differential-equations/evolution.lisp +++ b/ordinary-differential-equations/evolution.lisp @@ -1,8 +1,8 @@ ;; Evolution functions for ODE integration. ;; Liam Healy, Sun Sep 30 2007 - 14:31 -;; Time-stamp: <2010-06-27 18:13:51EDT evolution.lisp> +;; Time-stamp: <2011-01-10 18:16:19EST evolution.lisp> ;; -;; Copyright 2007, 2008, 2009 Liam M. Healy +;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,7 +21,7 @@ (in-package :gsl) (defmobject ode-evolution "gsl_odeiv_evolve" - ((dimensions sizet)) + ((grid:dimensions sizet)) "evolution for ordinary differential equations" :documentation "Make an object to advance the ODE solution." :initialize-suffix "reset" @@ -32,9 +32,9 @@ "gsl_odeiv_evolve_apply" (((mpointer evolution) :pointer) ((mpointer control) :pointer) ((mpointer stepper) :pointer) - ((callback-struct stepper) :pointer) ((foreign-pointer time) :pointer) + ((callback-struct stepper) :pointer) ((grid:foreign-pointer time) :pointer) (max-time :double) - ((foreign-pointer step-size) :pointer) ((foreign-pointer y) :pointer)) + ((grid:foreign-pointer step-size) :pointer) ((grid:foreign-pointer y) :pointer)) :inputs (time step-size y) :outputs (time step-size y) :callback-object ((stepper ode-stepper)) diff --git a/ordinary-differential-equations/ode-system.lisp b/ordinary-differential-equations/ode-system.lisp index 1a65e116d5e53aa93dfff1ce88abf7a9a7bb24fb..2da9f906c695e47eabcf2d9e3fa5a553c139aada 100644 --- a/ordinary-differential-equations/ode-system.lisp +++ b/ordinary-differential-equations/ode-system.lisp @@ -1,8 +1,8 @@ ;; ODE system setup ;; Liam Healy, Sun Apr 15 2007 - 14:19 -;; Time-stamp: <2011-04-08 09:20:01EDT ode-system.lisp> +;; Time-stamp: <2011-05-26 12:37:33EDT ode-system.lisp> ;; -;; Copyright 2007, 2008, 2009 Liam M. Healy +;; Copyright 2007, 2008, 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,16 +20,20 @@ (in-package :gsl) -(export '(with-ode-integration next-step)) +(export '(with-ode-integration)) (defmacro with-ode-integration ((function time step-size max-time dependent dimensions &key jacobian (scalarsp t) (stepper '+step-rk8pd+) (absolute-error 1.0d-6) (relative-error 0.0d0)) &body body) - "Environment for integration of ordinary differential equations." - ;; Note: the case jacobian=nil is not properly handled yet; it - ;; should put a null pointer into the struct that is passed to GSL. + "Environment for integration of ordinary differential equations when dependent variables are individually named scalars." + ;; Note: If the dependent variables are in a foreign array, it is + ;; best to call the ODE functions directly; this macro is just + ;; provided as a convenience if they are separate scalars. + ;; Note: + ;; the case jacobian=nil is not properly handled yet; it should put + ;; a null pointer into the struct that is passed to GSL. (let ((dep (make-symbol "DEP")) (ctime (make-symbol "CTIME")) (cstep (make-symbol "CSTEP"))) @@ -43,11 +47,11 @@ (,ctime (grid:make-foreign-array 'double-float :dimensions 1)) (,cstep (grid:make-foreign-array 'double-float :dimensions 1))) (symbol-macrolet - ((,time (grid:gref ,ctime 0)) - (,step-size (grid:gref ,cstep 0)) + ((,time (grid:aref ,ctime 0)) + (,step-size (grid:aref ,cstep 0)) ,@(loop for symb in dependent for i from 0 - collect `(,symb (grid:gref ,dep ,i)))) + collect `(,symb (grid:aref ,dep ,i)))) (flet ((next-step () (apply-evolution evolve ,ctime ,dep ,cstep control stepperobj ,max-time))) diff --git a/ordinary-differential-equations/stepping.lisp b/ordinary-differential-equations/stepping.lisp index b1deaa2023e35518d44ef502af8fda8aaee6a46c..6efc6754ce7a17a897607d1a55c0bc3d9c8f05a7 100644 --- a/ordinary-differential-equations/stepping.lisp +++ b/ordinary-differential-equations/stepping.lisp @@ -1,8 +1,8 @@ ;; Stepping functions for ODE systems. ;; Liam Healy, Mon Sep 24 2007 - 21:33 -;; Time-stamp: <2010-06-27 18:13:51EDT stepping.lisp> +;; Time-stamp: <2011-01-10 17:59:27EST stepping.lisp> ;; -;; Copyright 2007, 2008, 2009 Liam M. Healy +;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -106,10 +106,10 @@ values): (((mpointer stepper) :pointer) (time :double) (step-size :double) - ((foreign-pointer y) :pointer) - ((foreign-pointer yerr) :pointer) - ((foreign-pointer dydt-in) :pointer) - ((foreign-pointer dydt-out) :pointer) + ((grid:foreign-pointer y) :pointer) + ((grid:foreign-pointer yerr) :pointer) + ((grid:foreign-pointer dydt-in) :pointer) + ((grid:foreign-pointer dydt-out) :pointer) ((callback-struct stepper) :pointer)) :documentation ; FDL "Apply the stepping function stepper to the system of equations diff --git a/polynomial.lisp b/polynomial.lisp index db86ea47b60436bc75d06766e13c66ee4611c595..81065dd9462edae8b20061d7fd7dbbd8fe01669b 100644 --- a/polynomial.lisp +++ b/polynomial.lisp @@ -1,8 +1,8 @@ ;; Polynomials ;; Liam Healy, Tue Mar 21 2006 - 18:33 -;; Time-stamp: <2010-07-07 14:18:55EDT polynomial.lisp> +;; Time-stamp: <2011-01-10 17:47:56EST polynomial.lisp> ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -29,10 +29,10 @@ (defmfun evaluate ((coefficients grid:vector-double-float) (x float) &key divided-difference) ("gsl_poly_eval" "gsl_poly_dd_eval") - ((((foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet) + ((((grid:foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet) (x :double)) - (((foreign-pointer divided-difference) :pointer) - ((foreign-pointer coefficients) :pointer) + (((grid:foreign-pointer divided-difference) :pointer) + ((grid:foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet) (x :double))) :definition :method @@ -46,7 +46,7 @@ ((coefficients grid:vector-double-float) (x complex) &key) "gsl_poly_complex_eval" - (((foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet) + (((grid:foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet) (x grid:complex-double-c)) :definition :method :gsl-version (1 11) @@ -60,7 +60,7 @@ ((coefficients grid:vector-complex-double-float) (x complex) &key) "gsl_complex_poly_complex_eval" - (((foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet) + (((grid:foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet) (x grid:complex-double-c)) :definition :method :gsl-version (1 11) @@ -76,8 +76,8 @@ (defmfun divided-difference (xa ya &optional (dd (grid:make-foreign-array 'double-float :dimensions (dim0 xa)))) "gsl_poly_dd_init" - (((foreign-pointer dd) :pointer) - ((foreign-pointer xa) :pointer) ((foreign-pointer ya) :pointer) + (((grid:foreign-pointer dd) :pointer) + ((grid:foreign-pointer xa) :pointer) ((grid:foreign-pointer ya) :pointer) ((dim0 xa) sizet)) :inputs (xa ya) :outputs (dd) @@ -95,12 +95,12 @@ (coefficients (grid:make-foreign-array 'double-float :dimensions (dim0 xa))) (workspace (grid:make-foreign-array 'double-float :dimensions (dim0 xa)))) "gsl_poly_dd_taylor" - (((foreign-pointer coefficients) :pointer) + (((grid:foreign-pointer coefficients) :pointer) (xp :double) - ((foreign-pointer dd) :pointer) - ((foreign-pointer xa) :pointer) + ((grid:foreign-pointer dd) :pointer) + ((grid:foreign-pointer xa) :pointer) ((dim0 xa) sizet) - ((foreign-pointer workspace) :pointer)) + ((grid:foreign-pointer workspace) :pointer)) :inputs (dd xa) :outputs (coefficients) :documentation ; FDL @@ -177,8 +177,8 @@ :dimensions (1- (size coefficients)))) (workspace (make-polynomial-complex-workspace (size coefficients)))) "gsl_poly_complex_solve" - (((foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet) - ((mpointer workspace) :pointer) ((foreign-pointer answer) :pointer)) + (((grid:foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet) + ((mpointer workspace) :pointer) ((grid:foreign-pointer answer) :pointer)) :inputs (coefficients) :outputs (answer) :return (answer) @@ -213,8 +213,10 @@ ;; Example from GSL manual (grid:copy-to (polynomial-solve #m(-1.0d0 0.0d0 0.0d0 0.0d0 0.0d0 1.0d0))) ;; tests from gsl-1.11/poly/test.c - (evaluate #m(1 0.5 0.3) 0.5d0) - (evaluate #m(1 -1 1 -1 1 -1 1 -1 1 -1 1) 1.0d0) + (evaluate #m(1.0d0 0.5d0 0.3d0) 0.5d0) + (evaluate + #m(1.0d0 -1.0d0 1.0d0 -1.0d0 1.0d0 -1.0d0 1.0d0 -1.0d0 1.0d0 -1.0d0 1.0d0) + 1.0d0) (solve-quadratic 4.0d0 -20.0d0 26.0d0) ; no roots (solve-quadratic 4.0d0 -20.0d0 25.0d0) ; one root (solve-quadratic 4.0d0 -20.0d0 21.0d0) ; two roots @@ -242,10 +244,10 @@ (solve-cubic-complex -57.0d0 1071.0d0 -6647.0d0) (solve-cubic-complex -11.0d0 -493.0d0 +6647.0d0) (solve-cubic-complex -143.0d0 5087.0d0 -50065.0d0) - (grid:copy-to (polynomial-solve #m(-120 274 -225 85 -15 1.0))) - (grid:copy-to (polynomial-solve #m(1 0 0 0 1 0 0 0 1))) - (let* ((xa #m(0.16 0.97 1.94 2.74 3.58 3.73 4.70)) - (ya #m(0.73 1.11 1.49 1.84 2.30 2.41 3.07)) + (grid:copy-to (polynomial-solve #m(-120.0d0 274.0d0 -225.0d0 85.0d0 -15.0d0 1.0d0))) + (grid:copy-to (polynomial-solve #m(1.0d0 0.0d0 0.0d0 0.0d0 1.0d0 0.0d0 0.0d0 0.0d0 1.0d0))) + (let* ((xa #m(0.16d0 0.97d0 1.94d0 2.74d0 3.58d0 3.73d0 4.70d0)) + (ya #m(0.73d0 1.11d0 1.49d0 1.84d0 2.30d0 2.41d0 3.07d0)) (dd (divided-difference xa ya))) (list (grid:copy-to dd) diff --git a/random/dirichlet.lisp b/random/dirichlet.lisp index a8928767dd46232bdf4781d197377ddc5274ec94..e1e493d3854e137ba0e24c52468d29347e281d25 100644 --- a/random/dirichlet.lisp +++ b/random/dirichlet.lisp @@ -1,8 +1,8 @@ ;; Dirichlet distribution ;; Liam Healy, Sun Oct 29 2006 -;; Time-stamp: <2011-07-29 12:23:09EDT dirichlet.lisp> +;; Time-stamp: <2011-07-29 12:09:55EDT dirichlet.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -28,9 +28,9 @@ "gsl_ran_dirichlet" (((mpointer generator) :pointer) ((dim0 alpha) sizet) - ((foreign-pointer alpha) :pointer) + ((grid:foreign-pointer alpha) :pointer) ;; theta had better be at least as long as alpha, or they'll be trouble - ((foreign-pointer theta) :pointer)) + ((grid:foreign-pointer theta) :pointer)) :definition :method :inputs (alpha) :outputs (theta) @@ -55,9 +55,9 @@ (defmfun dirichlet-pdf (alpha theta) "gsl_ran_dirichlet_pdf" (((dim0 alpha) sizet) - ((foreign-pointer alpha) :pointer) + ((grid:foreign-pointer alpha) :pointer) ;; theta had better be at least as long as alpha, or they'll be trouble - ((foreign-pointer theta) :pointer)) + ((grid:foreign-pointer theta) :pointer)) :inputs (alpha theta) :c-return :double :documentation ; FDL @@ -68,9 +68,9 @@ (defmfun dirichlet-log-pdf (alpha theta) "gsl_ran_dirichlet_lnpdf" (((dim0 alpha) sizet) - ((foreign-pointer alpha) :pointer) + ((grid:foreign-pointer alpha) :pointer) ;; theta had better be at least as long as alpha, or they'll be trouble - ((foreign-pointer theta) :pointer)) + ((grid:foreign-pointer theta) :pointer)) :inputs (alpha theta) :c-return :double :documentation ; FDL diff --git a/random/discrete.lisp b/random/discrete.lisp index 0d8b0501126a04f00855770e5e1f816ab7430e6c..b88a550656b123eca7e595c562dd7481511870ed 100644 --- a/random/discrete.lisp +++ b/random/discrete.lisp @@ -1,8 +1,8 @@ ;; Discrete random variables ;; Liam Healy, Sat Nov 11 2006 - 21:51 -;; Time-stamp: <2010-06-27 18:14:53EDT discrete.lisp> +;; Time-stamp: <2011-01-10 17:59:28EST discrete.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -23,7 +23,7 @@ ;;; /usr/include/gsl/gsl_randist.h (defmobject discrete-random "gsl_ran_discrete" - (((dim0 probabilities) sizet) ((foreign-pointer probabilities) :pointer)) + (((dim0 probabilities) sizet) ((grid:foreign-pointer probabilities) :pointer)) "lookup table for the discrete random number generator" :allocator "gsl_ran_discrete_preproc" :allocate-inputs (probabilities) diff --git a/random/multinomial.lisp b/random/multinomial.lisp index 6d492edd34f6936518667024447c0646a82fd590..adb12dbd847caee4bb193226b034ae3dcc34cd8c 100644 --- a/random/multinomial.lisp +++ b/random/multinomial.lisp @@ -1,8 +1,8 @@ ;; Multinomial distribution ;; Liam Healy, Sat Nov 25 2006 - 16:00 -;; Time-stamp: <2010-07-07 14:24:58EDT multinomial.lisp> +;; Time-stamp: <2011-01-10 17:59:29EST multinomial.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -31,9 +31,9 @@ (((mpointer generator) :pointer) ((dim0 probabilities) sizet) (sum sizet) - ((foreign-pointer probabilities) :pointer) + ((grid:foreign-pointer probabilities) :pointer) ;; technically, n should be a uint array, but integers work - ((foreign-pointer n) :pointer)) + ((grid:foreign-pointer n) :pointer)) :definition :method :inputs (p) :outputs (n) @@ -56,7 +56,7 @@ (defmfun multinomial-pdf (p n) "gsl_ran_multinomial_pdf" - (((dim0 p) sizet) ((foreign-pointer p) :pointer) ((foreign-pointer n) :pointer)) + (((dim0 p) sizet) ((grid:foreign-pointer p) :pointer) ((grid:foreign-pointer n) :pointer)) :inputs (p n) :c-return :double :documentation ; FDL @@ -66,7 +66,7 @@ (defmfun multinomial-log-pdf (p n) "gsl_ran_multinomial_lnpdf" - (((dim0 p) sizet) ((foreign-pointer p) :pointer) ((foreign-pointer n) :pointer)) + (((dim0 p) sizet) ((grid:foreign-pointer p) :pointer) ((grid:foreign-pointer n) :pointer)) :inputs (p n) :c-return :double :documentation ; FDL diff --git a/random/quasi.lisp b/random/quasi.lisp index 605de960aa905f861ad12bfd3bd3d0a5f1885309..50059e6e52009cf77d3288f97db8f8a44ff3500a 100644 --- a/random/quasi.lisp +++ b/random/quasi.lisp @@ -1,8 +1,8 @@ ;; Quasi-random sequences in arbitrary dimensions. ;; Liam Healy, Sun Jul 16 2006 - 15:54 -;; Time-stamp: <2010-07-16 17:10:54EDT quasi.lisp> +;; Time-stamp: <2011-01-10 17:59:29EST quasi.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -36,7 +36,7 @@ (defmfun qrng-get (generator return-vector) "gsl_qrng_get" - (((mpointer generator) :pointer) ((foreign-pointer return-vector) :pointer)) + (((mpointer generator) :pointer) ((grid:foreign-pointer return-vector) :pointer)) :outputs (return-vector) :return (return-vector) :documentation ; FDL diff --git a/random/shuffling-sampling.lisp b/random/shuffling-sampling.lisp index 3e11719499ed2865a1af5059304d77e79eaab621..47756947a673f62536eb43f4d99a2e2ee0e6c802 100644 --- a/random/shuffling-sampling.lisp +++ b/random/shuffling-sampling.lisp @@ -1,8 +1,8 @@ ;; Shuffling and sampling ;; Liam Healy, Sat Dec 2 2006 - 18:40 -;; Time-stamp: <2010-07-07 14:24:58EDT shuffling-sampling.lisp> +;; Time-stamp: <2011-01-11 23:34:14EST shuffling-sampling.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -27,7 +27,7 @@ &key base) "gsl_ran_shuffle" (((mpointer generator) :pointer) - ((foreign-pointer base) :pointer) ((dim0 base) sizet) ((grid:element-size base) sizet)) + ((grid:foreign-pointer base) :pointer) ((dim0 base) sizet) ((grid:element-size base) sizet)) :definition :method :inputs (base) :outputs (base) @@ -46,12 +46,12 @@ &aux (destarr (if (integerp dest) - (grid:make-foreign-array (element-type src) :dimensions dest) + (grid:make-foreign-array (grid:element-type src) :dimensions dest) dest))) "gsl_ran_choose" (((mpointer generator) :pointer) - ((foreign-pointer destarr) :pointer) ((dim0 destarr) sizet) - ((foreign-pointer src) :pointer) ((dim0 src) sizet) ((grid:element-size src) sizet)) + ((grid:foreign-pointer destarr) :pointer) ((dim0 destarr) sizet) + ((grid:foreign-pointer src) :pointer) ((dim0 src) sizet) ((grid:element-size src) sizet)) :definition :method :inputs (src) :outputs (destarr) @@ -74,12 +74,12 @@ &aux (destarr (if (integerp dest) - (grid:make-foreign-array (element-type src) :dimensions dest) + (grid:make-foreign-array (grid:element-type src) :dimensions dest) dest))) "gsl_ran_sample" (((mpointer generator) :pointer) - ((foreign-pointer destarr) :pointer) ((dim0 destarr) sizet) - ((foreign-pointer src) :pointer) ((dim0 src) sizet) ((grid:element-size src) sizet)) + ((grid:foreign-pointer destarr) :pointer) ((dim0 destarr) sizet) + ((grid:foreign-pointer src) :pointer) ((dim0 src) sizet) ((grid:element-size src) sizet)) :definition :method :inputs (src) :outputs (destarr) diff --git a/random/spherical-vector.lisp b/random/spherical-vector.lisp index 70f70667853f15f66968159f7c8f796d05c596fd..f8bd795c6fbbf387284dbfd1e9ca4251d2c127da 100644 --- a/random/spherical-vector.lisp +++ b/random/spherical-vector.lisp @@ -1,8 +1,8 @@ ;; Spherical Vector distribution ;; Liam Healy, Sun Oct 22 2006 -;; Time-stamp: <2010-06-27 18:13:44EDT spherical-vector.lisp> +;; Time-stamp: <2011-01-10 17:59:30EST spherical-vector.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -68,7 +68,7 @@ ((generator random-number-generator) (type (eql :direction-Nd)) &key vector) "gsl_ran_dir_nd" (((mpointer generator) :pointer) ((dim0 vector) sizet) - ((foreign-pointer vector) :pointer)) + ((grid:foreign-pointer vector) :pointer)) :definition :method :c-return :void :outputs (vector) diff --git a/series-acceleration.lisp b/series-acceleration.lisp index 9497539cbc558cc1784474176e2430bbcac5f145..3d1cb8729c06c998b062def645ae7323020042c8 100644 --- a/series-acceleration.lisp +++ b/series-acceleration.lisp @@ -1,8 +1,8 @@ ;; Series acceleration. ;; Liam Healy, Wed Nov 21 2007 - 18:41 -;; Time-stamp: <2010-08-07 21:41:14EDT series-acceleration.lisp> +;; Time-stamp: <2011-05-26 12:37:29EDT series-acceleration.lisp> ;; -;; Copyright 2007, 2008, 2009 Liam M. Healy +;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -38,7 +38,7 @@ (defmfun accelerate (array levin) "gsl_sum_levin_u_accel" - (((foreign-pointer array) :pointer) ((dim0 array) sizet) ((mpointer levin) :pointer) + (((grid:foreign-pointer array) :pointer) ((dim0 array) sizet) ((mpointer levin) :pointer) (accelerated-sum (:pointer :double)) (abserr (:pointer :double))) :inputs (array) :documentation ; FDL @@ -66,7 +66,7 @@ (defmfun accelerate-truncated (array levin) "gsl_sum_levin_utrunc_accel" - (((foreign-pointer array) :pointer) ((dim0 array) sizet) ((mpointer levin) :pointer) + (((grid:foreign-pointer array) :pointer) ((dim0 array) sizet) ((mpointer levin) :pointer) (accelerated-sum (:pointer :double)) (abserr (:pointer :double))) :inputs (array) :documentation ; FDL @@ -95,8 +95,8 @@ (let ((levin (make-levin maxterms)) (array (grid:make-foreign-array 'double-float :dimensions maxterms))) (dotimes (n maxterms) - (setf (grid:gref array n) (coerce (/ (expt (1+ n) 2)) 'double-float)) - (incf sum (grid:gref array n))) + (setf (grid:aref array n) (coerce (/ (expt (1+ n) 2)) 'double-float)) + (incf sum (grid:aref array n))) (multiple-value-bind (accelerated-sum error) (accelerate array levin) (when print-explanation diff --git a/solve-minimize-fit/linear-least-squares.lisp b/solve-minimize-fit/linear-least-squares.lisp index c24a7857b4e60ef928b0bd7a65a1e2ab824490b1..a1482c80160baf91ba3ec5bf1a0ea994ed0d2a08 100644 --- a/solve-minimize-fit/linear-least-squares.lisp +++ b/solve-minimize-fit/linear-least-squares.lisp @@ -1,8 +1,8 @@ ;; Linear least squares, or linear regression ;; Liam Healy <2008-01-21 12:41:46EST linear-least-squares.lisp> -;; Time-stamp: <2010-06-30 19:57:28EDT linear-least-squares.lisp> +;; Time-stamp: <2011-05-26 12:37:31EDT linear-least-squares.lisp> ;; -;; Copyright 2008, 2009 Liam M. Healy +;; Copyright 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -36,15 +36,15 @@ (defmfun linear-fit (x y &optional weight (x-stride 1) (y-stride 1) (weight-stride 1)) ("gsl_fit_linear" "gsl_fit_wlinear") - ((((foreign-pointer x) :pointer) (x-stride sizet) - ((foreign-pointer y) :pointer) (y-stride sizet) + ((((grid:foreign-pointer x) :pointer) (x-stride sizet) + ((grid:foreign-pointer y) :pointer) (y-stride sizet) ((dim0 x) sizet) (c0 (:pointer :double)) (c1 (:pointer :double)) (cov00 (:pointer :double)) (cov01 (:pointer :double)) (cov11 (:pointer :double)) (sumsq (:pointer :double))) - (((foreign-pointer x) :pointer) (x-stride sizet) - ((foreign-pointer weight) :pointer) (weight-stride sizet) - ((foreign-pointer y) :pointer) (y-stride sizet) + (((grid:foreign-pointer x) :pointer) (x-stride sizet) + ((grid:foreign-pointer weight) :pointer) (weight-stride sizet) + ((grid:foreign-pointer y) :pointer) (y-stride sizet) ((dim0 x) sizet) (c0 (:pointer :double)) (c1 (:pointer :double)) (cov00 (:pointer :double)) (cov01 (:pointer :double)) @@ -85,14 +85,14 @@ (defmfun multiplier-fit (x y &optional weight (x-stride 1) (y-stride 1) (weight-stride 1)) ("gsl_fit_mul" "gsl_fit_wmul") - ((((foreign-pointer x) :pointer) (x-stride sizet) - ((foreign-pointer y) :pointer) (y-stride sizet) + ((((grid:foreign-pointer x) :pointer) (x-stride sizet) + ((grid:foreign-pointer y) :pointer) (y-stride sizet) ((dim0 x) sizet) (c1 (:pointer :double)) (cov11 (:pointer :double)) (sumsq (:pointer :double))) - (((foreign-pointer x) :pointer) (x-stride sizet) - ((foreign-pointer weight) :pointer) (weight-stride sizet) - ((foreign-pointer y) :pointer) (y-stride sizet) + (((grid:foreign-pointer x) :pointer) (x-stride sizet) + ((grid:foreign-pointer weight) :pointer) (weight-stride sizet) + ((grid:foreign-pointer y) :pointer) (y-stride sizet) ((dim0 x) sizet) (c1 (:pointer :double)) (cov11 (:pointer :double)) (sumsq (:pointer :double)))) @@ -284,7 +284,7 @@ (x observations coefficients &optional (residuals - (grid:make-foreign-array 'double-float :dimensions (dimensions observations)))) + (grid:make-foreign-array 'double-float :dimensions (grid:dimensions observations)))) "gsl_multifit_linear_residuals" (((mpointer x) :pointer) ((mpointer observations) :pointer) ((mpointer coefficients) :pointer) ((mpointer residuals) :pointer)) @@ -315,15 +315,15 @@ (loop for i from 0 below (dim0 x) do (format t "data: ~12,5f ~12,5f ~12,5f~&" - (grid:gref x i) - (grid:gref y i) - (/ (grid:gref w i)))) + (grid:aref x i) + (grid:aref y i) + (/ (grid:aref w i)))) (loop for i from -30 below 130 by 10 ; don't print everything for - xf = (+ (grid:gref x 0) + xf = (+ (grid:aref x 0) (* (/ i 100) - (- (grid:gref x (1- (dim0 x))) - (grid:gref x 0)))) + (- (grid:aref x (1- (dim0 x))) + (grid:aref x 0)))) do (multiple-value-bind (yf yferr) (linear-estimate xf c0 c1 cov00 cov01 cov11) @@ -353,26 +353,26 @@ (w (grid:make-foreign-array 'double-float :dimensions n))) (loop for i from 0 for row in data do - (setf (grid:gref X i 0) 1.0d0 - (grid:gref X i 1) (first row) - (grid:gref X i 2) (expt (first row) 2) - (grid:gref y i) (second row) - (grid:gref w i) (/ (expt (third row) 2)))) + (setf (grid:aref X i 0) 1.0d0 + (grid:aref X i 1) (first row) + (grid:aref X i 2) (expt (first row) 2) + (grid:aref y i) (second row) + (grid:aref w i) (/ (expt (third row) 2)))) (multiple-value-bind (parameters cov chisq) (linear-mfit X y 3 w) (when print-details (format t "Best fit: Y = ~10,8f + ~10,8f X + ~10,8f X^2~&" - (grid:gref parameters 0) (grid:gref parameters 1) (grid:gref parameters 2)) + (grid:aref parameters 0) (grid:aref parameters 1) (grid:aref parameters 2)) (format t "Covariance matrix:~&") (format t "~10,8f ~10,8f ~10,8f~&" - (grid:gref cov 0 0) (grid:gref cov 0 1) (grid:gref cov 0 2)) + (grid:aref cov 0 0) (grid:aref cov 0 1) (grid:aref cov 0 2)) (format t "~10,8f ~10,8f ~10,8f~&" - (grid:gref cov 1 0) (grid:gref cov 1 1) (grid:gref cov 1 2)) + (grid:aref cov 1 0) (grid:aref cov 1 1) (grid:aref cov 1 2)) (format t "~10,8f ~10,8f ~10,8f~&" - (grid:gref cov 2 0) (grid:gref cov 2 1) (grid:gref cov 2 2)) + (grid:aref cov 2 0) (grid:aref cov 2 1) (grid:aref cov 2 2)) (format t "Chisq = ~10,6f~&" chisq)) (values - (grid:gref parameters 0) (grid:gref parameters 1) (grid:gref parameters 2) + (grid:aref parameters 0) (grid:aref parameters 1) (grid:aref parameters 2) chisq)))) (save-test linear-least-squares diff --git a/solve-minimize-fit/minimization-multi.lisp b/solve-minimize-fit/minimization-multi.lisp index 687bf968239b937833179d9174faa535f079b432..0da173bbce9512436a5c9a0b0fee59915df7bee1 100644 --- a/solve-minimize-fit/minimization-multi.lisp +++ b/solve-minimize-fit/minimization-multi.lisp @@ -1,6 +1,6 @@ ;; Multivariate minimization. ;; Liam Healy <Tue Jan 8 2008 - 21:28> -;; Time-stamp: <2010-07-13 11:45:28EDT minimization-multi.lisp> +;; Time-stamp: <2011-05-26 12:37:32EDT minimization-multi.lisp> ;; ;; Copyright 2008, 2009 Liam M. Healy ;; Distributed under the terms of the GNU General Public License @@ -384,13 +384,13 @@ (when print-steps (let ((x (solution minimizer))) (format t "~d~6t~10,6f~18t~10,6f~28t~12,9f~40t~8,3f~&" - iter (grid:gref x 0) (grid:gref x 1) + iter (grid:aref x 0) (grid:aref x 1) (function-value minimizer) size))) finally (return (let ((x (solution minimizer))) - (values (grid:gref x 0) (grid:gref x 1) (function-value minimizer)))))))) + (values (grid:aref x 0) (grid:aref x 1) (function-value minimizer)))))))) ;;; Example using derivatives, taking a vector argument. ;;; Note that these functions are written to read mpointers to @@ -403,9 +403,9 @@ ;; An alternative access to the passed-in vector would be to ;; bind a variable to ;; (make-foreign-array-from-mpointer mpointer 'double-float :vector) - ;; and then call grid:gref on it. - (let ((x (grid:gref xy 0)) - (y (grid:gref xy 1)) + ;; and then call grid:aref on it. + (let ((x (grid:aref xy 0)) + (y (grid:aref xy 1)) (dp0 (aref *paraboloid-center* 0)) (dp1 (aref *paraboloid-center* 1))) (+ (* 10 (expt (- x dp0) 2)) @@ -413,19 +413,19 @@ 30))) (defun paraboloid-derivative (xy output) - (let ((x (grid:gref xy 0)) - (y (grid:gref xy 1)) + (let ((x (grid:aref xy 0)) + (y (grid:aref xy 1)) (dp0 (aref *paraboloid-center* 0)) (dp1 (aref *paraboloid-center* 1))) - (setf (grid:gref output 0) + (setf (grid:aref output 0) (* 20 (- x dp0)) - (grid:gref output 1) + (grid:aref output 1) (* 40 (- y dp1))))) (defun paraboloid-and-derivative (arguments-gv-pointer value-pointer derivative-gv-pointer) (prog1 - (setf (grid:gref value-pointer 0) + (setf (grid:aref value-pointer 0) (paraboloid-vector arguments-gv-pointer)) (paraboloid-derivative arguments-gv-pointer derivative-gv-pointer))) @@ -455,12 +455,12 @@ (when print-steps (let ((x (solution minimizer))) (format t "~d~6t~10,6f~18t~10,6f~28t~12,9f~&" - iter (grid:gref x 0) (grid:gref x 1) + iter (grid:aref x 0) (grid:aref x 1) (function-value minimizer)))) finally (return (let ((x (solution minimizer))) - (values (grid:gref x 0) (grid:gref x 1) (function-value minimizer))))))) + (values (grid:aref x 0) (grid:aref x 1) (function-value minimizer))))))) (defun paraboloid-derivative-scalar (x y) (let ((dp0 (aref *paraboloid-center* 0)) @@ -499,12 +499,12 @@ (when print-steps (let ((x (solution minimizer))) (format t "~d~6t~10,6f~18t~10,6f~28t~12,9f~&" - iter (grid:gref x 0) (grid:gref x 1) + iter (grid:aref x 0) (grid:aref x 1) (function-value minimizer)))) finally (return (let ((x (solution minimizer))) - (values (grid:gref x 0) (grid:gref x 1) (function-value minimizer))))))) + (values (grid:aref x 0) (grid:aref x 1) (function-value minimizer))))))) (save-test minimization-multi (multimin-example-no-derivative +simplex-nelder-mead-on2+ nil) diff --git a/solve-minimize-fit/nonlinear-least-squares.lisp b/solve-minimize-fit/nonlinear-least-squares.lisp index 7879c134525dbc311b1c25b54492f8e4d4b20094..5761538a3471961aa7180e5b8383c8c599a6f402 100644 --- a/solve-minimize-fit/nonlinear-least-squares.lisp +++ b/solve-minimize-fit/nonlinear-least-squares.lisp @@ -1,6 +1,6 @@ ;; Nonlinear least squares fitting. ;; Liam Healy, 2008-02-09 12:59:16EST nonlinear-least-squares.lisp -;; Time-stamp: <2010-06-30 19:57:28EDT nonlinear-least-squares.lisp> +;; Time-stamp: <2011-05-26 12:37:32EDT nonlinear-least-squares.lisp> ;; ;; Copyright 2008, 2009 Liam M. Healy ;; Distributed under the terms of the GNU General Public License @@ -301,7 +301,7 @@ (let ((arr (grid:make-foreign-array 'double-float :dimensions number-of-observations)) (rng (make-random-number-generator +mt19937+ 0))) (dotimes (i number-of-observations arr) - (setf (grid:gref arr i) + (setf (grid:aref arr i) (+ 1 (* 5 (exp (* -1/10 i))) (sample rng :gaussian :sigma 0.1d0))))) :sigma @@ -311,32 +311,32 @@ (defun exponential-residual (x f) "Compute the negative of the residuals with the exponential model for the nonlinear least squares example." - (let ((A (grid:gref x 0)) - (lambda (grid:gref x 1)) - (b (grid:gref x 2))) + (let ((A (grid:aref x 0)) + (lambda (grid:aref x 1)) + (b (grid:aref x 2))) (symbol-macrolet ((y (exponent-fit-data-y *nlls-example-data*)) (sigma (exponent-fit-data-sigma *nlls-example-data*))) (dotimes (i (exponent-fit-data-n *nlls-example-data*)) - (setf (grid:gref f i) + (setf (grid:aref f i) ;; the difference model - observation = - residual - (/ (- (+ (* A (exp (* (- lambda) i))) b) (grid:gref y i)) - (grid:gref sigma i))))))) + (/ (- (+ (* A (exp (* (- lambda) i))) b) (grid:aref y i)) + (grid:aref sigma i))))))) (defun exponential-residual-derivative (x jacobian) "Compute the partial derivatives of the negative of the residuals with the exponential model for the nonlinear least squares example." - (let ((A (grid:gref x 0)) - (lambda (grid:gref x 1))) + (let ((A (grid:aref x 0)) + (lambda (grid:aref x 1))) (symbol-macrolet ((sigma (exponent-fit-data-sigma *nlls-example-data*))) (dotimes (i (exponent-fit-data-n *nlls-example-data*)) (let ((e (exp (* (- lambda) i))) - (s (grid:gref sigma i))) - (setf (grid:gref jacobian i 0) (/ e s) - (grid:gref jacobian i 1) (* -1 i A (/ e s)) - (grid:gref jacobian i 2) (/ s))))))) + (s (grid:aref sigma i))) + (setf (grid:aref jacobian i 0) (/ e s) + (grid:aref jacobian i 1) (* -1 i A (/ e s)) + (grid:aref jacobian i 2) (/ s))))))) (defun exponential-residual-fdf (x f jacobian) "Compute the function and partial derivatives of the negative of the @@ -363,8 +363,8 @@ '(exponential-residual exponential-residual-derivative exponential-residual-fdf) init nil))) - (macrolet ((fitx (i) `(grid:gref (solution fit) ,i)) - (err (i) `(sqrt (grid:gref covariance ,i ,i)))) + (macrolet ((fitx (i) `(grid:aref (solution fit) ,i)) + (err (i) `(sqrt (grid:aref covariance ,i ,i)))) (when print-steps (format t "iter: ~d x = ~15,8f ~15,8f ~15,8f |f(x)|=~7,6g~&" 0 (fitx 0) (fitx 1) (fitx 2) diff --git a/solve-minimize-fit/roots-multi.lisp b/solve-minimize-fit/roots-multi.lisp index 25b70dab625a91c9c2e56ad29cf1781cf7450412..718065eef14540203448734da494d36a62048c38 100644 --- a/solve-minimize-fit/roots-multi.lisp +++ b/solve-minimize-fit/roots-multi.lisp @@ -1,8 +1,8 @@ ;;; Multivariate roots. ;;; Liam Healy 2008-01-12 12:49:08 -;;; Time-stamp: <2010-07-13 09:52:54EDT roots-multi.lisp> +;;; Time-stamp: <2011-05-26 12:37:31EDT roots-multi.lisp> ;; -;; Copyright 2008, 2009 Liam M. Healy +;; Copyright 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -54,7 +54,7 @@ `((type &optional function-or-dimension (initial nil ,set) (scalarsp t)) (:type type :dimensions - (if ,set (dimensions initial) function-or-dimension)) + (if ,set (grid:dimensions initial) function-or-dimension)) (:functions (list function-or-dimension) :initial initial :scalarsp scalarsp))) :inputs (initial)) @@ -91,7 +91,7 @@ (scalarsp t)) (:type type :dimensions - (if ,set (dimensions initial) function-or-dimension)) + (if ,set (grid:dimensions initial) function-or-dimension)) (:functions function-or-dimension :initial initial :scalarsp scalarsp))) :inputs (initial)) @@ -418,15 +418,15 @@ (when print-steps (format t "iter=~d~8tx0=~12,8g~24tx1=~12,8g~38tf0=~12,8g~52tf1=~12,8g~&" iter - (grid:gref argval 0) - (grid:gref argval 1) - (grid:gref fnval 0) - (grid:gref fnval 1))) + (grid:aref argval 0) + (grid:aref argval 1) + (grid:aref fnval 0) + (grid:aref fnval 1))) finally (return - (values (grid:gref argval 0) - (grid:gref argval 1) - (grid:gref fnval 0) - (grid:gref fnval 1)))))) + (values (grid:aref argval 0) + (grid:aref argval 1) + (grid:aref fnval 0) + (grid:aref fnval 1)))))) (defun rosenbrock-df (arg0 arg1) "The partial derivatives of the Rosenbrock functions." @@ -452,10 +452,10 @@ (when print-steps (format t "iter=~d~8tx0=~12,8g~24tx1=~12,8g~38tf0=~12,8g~52tf1=~12,8g~&" iter - (grid:gref argval 0) - (grid:gref argval 1) - (grid:gref fnval 0) - (grid:gref fnval 1))))) + (grid:aref argval 0) + (grid:aref argval 1) + (grid:aref fnval 0) + (grid:aref fnval 1))))) (let ((max-iter 1000) (solver (make-multi-dimensional-root-solver-fdf method @@ -473,10 +473,10 @@ argval (solution solver)) (print-state iter argval fnval) finally (return - (values (grid:gref argval 0) - (grid:gref argval 1) - (grid:gref fnval 0) - (grid:gref fnval 1))))))) + (values (grid:aref argval 0) + (grid:aref argval 1) + (grid:aref fnval 0) + (grid:aref fnval 1))))))) ;; To see step-by-step information as the solution progresses, make ;; the last argument T. diff --git a/solve-minimize-fit/simulated-annealing.lisp b/solve-minimize-fit/simulated-annealing.lisp index 1f1f3815df6b1364089ecc228f6b609c922af149..508d72ba057ea104c5647ab6154badb21b71f463 100644 --- a/solve-minimize-fit/simulated-annealing.lisp +++ b/solve-minimize-fit/simulated-annealing.lisp @@ -1,6 +1,6 @@ ;; Simulated Annealing ;; Liam Healy Sun Feb 11 2007 - 17:23 -;; Time-stamp: <2010-08-19 15:51:55EDT simulated-annealing.lisp> +;; Time-stamp: <2011-05-26 12:37:32EDT simulated-annealing.lisp> ;; ;; Copyright 2007, 2008, 2009 Liam M. Healy ;; Distributed under the terms of the GNU General Public License @@ -193,7 +193,7 @@ ;;; Trivial example, Sec. 24.3.1 (defun trivial-example-energy (state) - (let ((x (grid:gref state 0))) + (let ((x (grid:aref state 0))) (declare (type double-float x) (optimize (speed 3) (safety 1))) (* (exp (- (expt (1- x) 2))) (sin (* 8 x))))) @@ -205,15 +205,15 @@ ;; the dynamical environment. (ignore rng-mpointer) (special cl-generator)) - (symbol-macrolet ((x (grid:gref state 0))) + (symbol-macrolet ((x (grid:aref state 0))) (let ((rand (sample cl-generator :uniform))) (declare (type double-float rand)) (setf x (+ (the double-float x) (- (* 2.0d0 rand step-size) step-size)))))) (defun trivial-example-metric (state1 state2) (declare (optimize (speed 3) (safety 1))) - (abs (- (the double-float (grid:gref state1 0)) - (the double-float (grid:gref state2 0))))) + (abs (- (the double-float (grid:aref state1 0)) + (the double-float (grid:aref state2 0))))) (defun simulated-annealing-example () (simulated-annealing @@ -235,7 +235,7 @@ ;;; exp(-square(x-1))*sin(8*x) - exp(-square(x-1000))*0.89; (defun trivial-test-energy (state) - (let ((x (grid:gref state 0))) + (let ((x (grid:aref state 0))) (- (* (exp (- (expt (1- x) 2))) (sin (* 8 x))) (* 0.89d0 (exp (- (expt (- x 1000) 2))))))) diff --git a/sorting.lisp b/sorting.lisp index 8b196bb628ac716fe56c52ae7039e8f821602a60..6edcfc9bfcc5dd24cf662effbdd652222397e78d 100644 --- a/sorting.lisp +++ b/sorting.lisp @@ -1,8 +1,8 @@ ;; Sorting ;; Liam Healy, Fri Apr 14 2006 - 20:20 -;; Time-stamp: <2010-07-07 14:24:54EDT sorting.lisp> +;; Time-stamp: <2011-01-10 18:16:18EST sorting.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -75,7 +75,7 @@ (defmfun msort ((v both)) ("gsl_sort" :type) - (((foreign-pointer v) :pointer) (1 sizet) ((size v) sizet)) + (((grid:foreign-pointer v) :pointer) (1 sizet) ((size v) sizet)) :definition :generic :element-types :no-complex :c-return :void @@ -99,7 +99,7 @@ (defmfun sort-index ((permutation permutation) (vector vector)) ("gsl_sort" :type "_index") (((mpointer permutation) :pointer) - ((foreign-pointer vector) :pointer) + ((grid:foreign-pointer vector) :pointer) (1 sizet) ((dim0 vector) sizet)) :definition :generic :element-types :no-complex @@ -138,7 +138,7 @@ (defmfun sort-vector-smallest (dest (v vector)) ("gsl_sort_vector" :type "_smallest") - (((foreign-pointer dest) :pointer) ((dim0 dest) sizet) + (((grid:foreign-pointer dest) :pointer) ((dim0 dest) sizet) ((mpointer v) :pointer)) :definition :generic :element-types :no-complex @@ -151,8 +151,8 @@ (defmfun sort-smallest (dest (v both)) ("gsl_sort" :type "_smallest") - (((foreign-pointer dest) :pointer) ((size dest) sizet) - ((foreign-pointer v) :pointer) + (((grid:foreign-pointer dest) :pointer) ((size dest) sizet) + ((grid:foreign-pointer v) :pointer) (1 sizet) ; stride, set to 1 for now ((size v) sizet)) :definition :generic @@ -166,10 +166,10 @@ (defmfun sort-vector-smallest-index (combination (v vector)) ("gsl_sort_vector" :type "_smallest_index") - (((foreign-pointer combination) :pointer) ((size combination) sizet) + (((grid:foreign-pointer combination) :pointer) ((size combination) sizet) ((mpointer v) :pointer) (1 sizet) ; stride, set to 1 for now - ((first (dimensions combination)) sizet)) + ((first (grid:dimensions combination)) sizet)) :definition :generic :element-types :no-complex :c-return :void @@ -184,10 +184,10 @@ (defmfun sort-smallest-index (combination (v vector)) ("gsl_sort" :type "_smallest_index") - (((foreign-pointer combination) :pointer) ((size combination) sizet) - ((foreign-pointer v) :pointer) + (((grid:foreign-pointer combination) :pointer) ((size combination) sizet) + ((grid:foreign-pointer v) :pointer) (1 sizet) ; stride, set to 1 for now - ((first (dimensions combination)) sizet)) + ((first (grid:dimensions combination)) sizet)) :definition :generic :element-types :no-complex :c-return :void @@ -202,7 +202,7 @@ (defmfun sort-vector-largest (dest (v vector)) ("gsl_sort_vector" :type "_largest") - (((foreign-pointer dest) :pointer) ((dim0 dest) sizet) + (((grid:foreign-pointer dest) :pointer) ((dim0 dest) sizet) ((mpointer v) :pointer)) :definition :generic :element-types :no-complex @@ -215,8 +215,8 @@ (defmfun sort-largest (dest (v both)) ("gsl_sort" :type "_largest") - (((foreign-pointer dest) :pointer) ((size dest) sizet) - ((foreign-pointer v) :pointer) + (((grid:foreign-pointer dest) :pointer) ((size dest) sizet) + ((grid:foreign-pointer v) :pointer) (1 sizet) ; stride, set to 1 for now ((size v) sizet)) :definition :generic @@ -230,10 +230,10 @@ (defmfun sort-vector-largest-index (combination (v vector)) ("gsl_sort_vector" :type "_largest_index") - (((foreign-pointer combination) :pointer) ((size combination) sizet) + (((grid:foreign-pointer combination) :pointer) ((size combination) sizet) ((mpointer v) :pointer) (1 sizet) ; stride, set to 1 for now - ((first (dimensions combination)) sizet)) + ((first (grid:dimensions combination)) sizet)) :definition :generic :element-types :no-complex :c-return :void @@ -248,10 +248,10 @@ (defmfun sort-largest-index (combination (v vector)) ("gsl_sort" :type "_largest_index") - (((foreign-pointer combination) :pointer) ((size combination) sizet) - ((foreign-pointer v) :pointer) + (((grid:foreign-pointer combination) :pointer) ((size combination) sizet) + ((grid:foreign-pointer v) :pointer) (1 sizet) ; stride, set to 1 for now - ((first (dimensions combination)) sizet)) + ((first (grid:dimensions combination)) sizet)) :element-types :no-complex :definition :generic :c-return :void diff --git a/special-functions/bessel.lisp b/special-functions/bessel.lisp index da4735fb9a4db20782317df444a58fed9c749c32..d68eed81dff845c77c5052c2891ee1622a83791d 100644 --- a/special-functions/bessel.lisp +++ b/special-functions/bessel.lisp @@ -1,8 +1,8 @@ ;; Bessel functions ;; Liam Healy, Fri Mar 17 2006 - 18:42 -;; Time-stamp: <2010-07-07 14:24:57EDT bessel.lisp> +;; Time-stamp: <2011-01-10 17:59:32EST bessel.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -49,7 +49,7 @@ &aux (array (vdf size-or-array))) "gsl_sf_bessel_Jn_array" ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double) - ((foreign-pointer array) :pointer)) + ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "The values of the regular cylindrical Bessel functions J_n(x) @@ -65,7 +65,7 @@ (defmfun cylindrical-bessel-J-array-x (nu v &optional (mode :double)) "gsl_sf_bessel_sequence_Jnu_e" - ((nu :double) (mode sf-mode) ((dim0 v) :int) ((foreign-pointer v) :pointer)) + ((nu :double) (mode sf-mode) ((dim0 v) :int) ((grid:foreign-pointer v) :pointer)) :inputs (v) :outputs (v) :documentation ; FDL @@ -106,7 +106,7 @@ &aux (array (vdf size-or-array))) "gsl_sf_bessel_Yn_array" ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double) - ((foreign-pointer array) :pointer)) + ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "The values of the irregular cylindrical Bessel functions @@ -150,7 +150,7 @@ &aux (array (vdf size-or-array))) "gsl_sf_bessel_In_array" ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double) - ((foreign-pointer array) :pointer)) + ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "The values of the regular modified cylindrical Bessel functions @@ -188,7 +188,7 @@ &aux (array (vdf size-or-array))) "gsl_sf_bessel_In_scaled_array" ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double) - ((foreign-pointer array) :pointer)) + ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL ;; Bug in original documentation? doesn't say "modified" @@ -243,7 +243,7 @@ &aux (array (vdf size-or-array))) "gsl_sf_bessel_Kn_array" ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double) - ((foreign-pointer array) :pointer)) + ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "The values of the irregular modified cylindrical Bessel functions @@ -278,7 +278,7 @@ &aux (array (vdf size-or-array))) "gsl_sf_bessel_Kn_scaled_array" ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double) - ((foreign-pointer array) :pointer)) + ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "The values of the scaled irregular cylindrical @@ -342,7 +342,7 @@ (x &optional (size-or-array *default-sf-array-size*) &aux (array (vdf size-or-array))) "gsl_sf_bessel_jl_array" - (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer)) + (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "The values of the regular spherical Bessel @@ -354,7 +354,7 @@ (x &optional (size-or-array *default-sf-array-size*) &aux (array (vdf size-or-array))) "gsl_sf_bessel_jl_steed_array" - (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer)) + (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "Uses Steed's method to compute the values of the regular spherical @@ -395,7 +395,7 @@ (x &optional (size-or-array *default-sf-array-size*) &aux (array (vdf size-or-array))) "gsl_sf_bessel_yl_array" - (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer)) + (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "The irregular spherical Bessel functions y_l(x) for l @@ -435,7 +435,7 @@ (x &optional (size-or-array *default-sf-array-size*) &aux (array (vdf size-or-array))) "gsl_sf_bessel_il_scaled_array" - (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer)) + (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "The values of the scaled regular modified cylindrical Bessel @@ -475,7 +475,7 @@ (x &optional (size-or-array *default-sf-array-size*) &aux (array (vdf size-or-array))) "gsl_sf_bessel_kl_scaled_array" - (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer)) + (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "The values of the scaled irregular modified spherical Bessel diff --git a/special-functions/coulomb.lisp b/special-functions/coulomb.lisp index 4601633e4804aae4e6039e216231d64bdf6e88e5..11d951533cd91bdf146368d0456dd47ebed7a178 100644 --- a/special-functions/coulomb.lisp +++ b/special-functions/coulomb.lisp @@ -1,8 +1,8 @@ ;; Coulumb functions ;; Liam Healy, Sat Mar 18 2006 - 23:23 -;; Time-stamp: <2010-07-07 14:24:53EDT coulomb.lisp> +;; Time-stamp: <2011-01-10 17:59:32EST coulomb.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -70,7 +70,7 @@ &aux (fc-array (vdf size-or-array))) "gsl_sf_coulomb_wave_F_array" ((L-min :double) ((1- (dim0 fc-array)) :int) (eta :double) (x :double) - ((foreign-pointer fc-array) :pointer) (F-exponent (:pointer :double))) + ((grid:foreign-pointer fc-array) :pointer) (F-exponent (:pointer :double))) :outputs (fc-array) :return (fc-array (grid:dcref F-exponent)) :documentation ; FDL @@ -86,7 +86,7 @@ (gc-array (vdf (or gc-size-or-array (dim0 fc-array))))) "gsl_sf_coulomb_wave_FG_array" ((L-min :double) ((1- (dim0 fc-array)) :int) (eta :double) (x :double) - ((foreign-pointer fc-array) :pointer) ((foreign-pointer gc-array) :pointer) + ((grid:foreign-pointer fc-array) :pointer) ((grid:foreign-pointer gc-array) :pointer) (F-exponent (:pointer :double)) (G-exponent (:pointer :double))) :outputs (fc-array gc-array) :return (fc-array gc-array (grid:dcref F-exponent) (grid:dcref G-exponent)) @@ -108,8 +108,8 @@ (gcp-array (vdf (or gcp-size-or-array (dim0 fc-array))))) "gsl_sf_coulomb_wave_FGp_array" ((L-min :double) ((1- (dim0 fc-array)) :int) (eta :double) (x :double) - ((foreign-pointer fc-array) :pointer) ((foreign-pointer fcp-array) :pointer) - ((foreign-pointer gc-array) :pointer) ((foreign-pointer gcp-array) :pointer) + ((grid:foreign-pointer fc-array) :pointer) ((grid:foreign-pointer fcp-array) :pointer) + ((grid:foreign-pointer gc-array) :pointer) ((grid:foreign-pointer gcp-array) :pointer) (F-exponent (:pointer :double)) (G-exponent (:pointer :double))) :outputs (fc-array fcp-array gc-array gcp-array) :return @@ -128,7 +128,7 @@ &aux (fc-array (vdf size-or-array))) "gsl_sf_coulomb_wave_sphF_array" ((L-min :double) ((1- (dim0 fc-array)) :int) (eta :double) (x :double) - ((foreign-pointer fc-array) :pointer) (F-exponent (:pointer :double))) + ((grid:foreign-pointer fc-array) :pointer) (F-exponent (:pointer :double))) :outputs (fc-array) :return (fc-array (grid:dcref F-exponent)) :documentation ; FDL @@ -153,7 +153,7 @@ &aux (array (vdf size-or-array))) "gsl_sf_coulomb_CL_array" ((L-min :double) ((1- (dim0 array)) :int) (eta :double) - ((foreign-pointer array) :pointer)) + ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "The Coulomb wave function normalization constant C_L(\eta) diff --git a/special-functions/gegenbauer.lisp b/special-functions/gegenbauer.lisp index 87d83a52ecafa3fc568b26684984f8407a9dc2f3..53c7ed85d0b28a3bc8b0d755b7bc389658c622a5 100644 --- a/special-functions/gegenbauer.lisp +++ b/special-functions/gegenbauer.lisp @@ -1,8 +1,8 @@ ;; Gegenbauer polynomials ;; Liam Healy, Fri Apr 28 2006 - 20:40 -;; Time-stamp: <2010-07-07 14:24:57EDT gegenbauer.lisp> +;; Time-stamp: <2011-01-10 17:59:32EST gegenbauer.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -47,7 +47,7 @@ &aux (array (vdf size-or-array))) "gsl_sf_gegenpoly_array" (((1- (dim0 array)) :int) - (lambda :double) (x :double) ((foreign-pointer array) :pointer)) + (lambda :double) (x :double) ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "Compute an array of Gegenbauer polynomials C^{(\lambda)}_n(X)} diff --git a/special-functions/legendre.lisp b/special-functions/legendre.lisp index b19a98a104f64a016f897d4f04d45881f0d53564..37aecf370cfaad71856e190eb7e84ddfa4f14c33 100644 --- a/special-functions/legendre.lisp +++ b/special-functions/legendre.lisp @@ -1,8 +1,8 @@ ;; Legendre functions ;; Liam Healy, Sat Apr 29 2006 - 19:16 -;; Time-stamp: <2010-07-07 14:24:57EDT legendre.lisp> +;; Time-stamp: <2011-01-10 17:59:33EST legendre.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -54,7 +54,7 @@ (x &optional (size-or-array *default-sf-array-size*) &aux (array (vdf size-or-array))) "gsl_sf_legendre_Pl_array" - (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer)) + (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "Compute an array of Legendre polynomials @@ -64,7 +64,7 @@ (x &optional (size-or-array *default-sf-array-size*) &aux (array (vdf size-or-array))) "gsl_sf_legendre_Pl_deriv_array" - (((1- (dim0 array)) :int) (x :double) ((foreign-pointer array) :pointer)) + (((1- (dim0 array)) :int) (x :double) ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "Compute an array of Legendre polynomials derivatives @@ -115,7 +115,7 @@ &aux (array (vdf size-or-array))) "gsl_sf_legendre_Plm_array" (((+ (dim0 array) m -1) :int) (m :int) (x :double) - ((foreign-pointer array) :pointer)) + ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "An array of Legendre polynomials @@ -129,7 +129,7 @@ (derivatives (vdf derivatives-size-or-array))) "gsl_sf_legendre_Plm_deriv_array" (((+ (dim0 values) m -1) :int) (m :int) (x :double) - ((foreign-pointer values) :pointer) ((foreign-pointer derivatives) :pointer)) + ((grid:foreign-pointer values) :pointer) ((grid:foreign-pointer derivatives) :pointer)) :outputs (values derivatives) :documentation ; FDL "An array of Legendre polynomials @@ -150,7 +150,7 @@ &aux (array (vdf size-or-array))) "gsl_sf_legendre_sphPlm_array" (((+ (dim0 array) m -1) :int) (m :int) (x :double) - ((foreign-pointer array) :pointer)) + ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "An array of normalized associated Legendre functions @@ -164,7 +164,7 @@ (derivatives (vdf derivatives-size-or-array))) "gsl_sf_legendre_sphPlm_deriv_array" (((+ (dim0 values) m -1) :int) (m :int) (x :double) - ((foreign-pointer values) :pointer) ((foreign-pointer derivatives) :pointer)) + ((grid:foreign-pointer values) :pointer) ((grid:foreign-pointer derivatives) :pointer)) :outputs (values derivatives) :documentation ; FDL "An array of normalized associated Legendre functions @@ -270,7 +270,7 @@ &aux (array (vdf size-or-array))) "gsl_sf_legendre_H3d_array" (((1- (dim0 array)) :int) (lambda :double) (eta :double) - ((foreign-pointer array) :pointer)) + ((grid:foreign-pointer array) :pointer)) :outputs (array) :documentation ; FDL "An array of radial eigenfunctions diff --git a/special-functions/mathieu.lisp b/special-functions/mathieu.lisp index 09a7bf731f4b5f1c1b710ec03af836f7685b0612..0e3e454c44af8dba4becc407c8e714463e510607 100644 --- a/special-functions/mathieu.lisp +++ b/special-functions/mathieu.lisp @@ -1,8 +1,8 @@ ;; Mathieu functions ;; Liam Healy 2009-02-16 16:30:59EST mathieu.lisp -;; Time-stamp: <2010-08-07 21:38:53EDT mathieu.lisp> +;; Time-stamp: <2011-01-10 17:59:33EST mathieu.lisp> ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -59,7 +59,7 @@ &aux (size (vdf-size size-or-array)) (result-array (vdf size))) "gsl_sf_mathieu_a_array" ((minimum-order :int) ((+ minimum-order size -1) :int) (q :double) - ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer)) + ((mpointer workspace) :pointer) ((grid:foreign-pointer result-array) :pointer)) :gsl-version (1 9) :outputs (result-array) :return (result-array) @@ -78,7 +78,7 @@ &aux (size (vdf-size size-or-array)) (result-array (vdf size))) "gsl_sf_mathieu_b_array" ((minimum-order :int) ((+ minimum-order size -1) :int) (q :double) - ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer)) + ((mpointer workspace) :pointer) ((grid:foreign-pointer result-array) :pointer)) :gsl-version (1 9) :outputs (result-array) :return (result-array) @@ -116,7 +116,7 @@ "gsl_sf_mathieu_ce_array" ((minimum-order :int) ((+ minimum-order size -1) :int) (q :double) (x :double) - ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer)) + ((mpointer workspace) :pointer) ((grid:foreign-pointer result-array) :pointer)) :gsl-version (1 9) :outputs (result-array) :return (result-array) @@ -136,7 +136,7 @@ "gsl_sf_mathieu_se_array" ((minimum-order :int) ((+ minimum-order size -1) :int) (q :double) (x :double) - ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer)) + ((mpointer workspace) :pointer) ((grid:foreign-pointer result-array) :pointer)) :gsl-version (1 9) :outputs (result-array) :return (result-array) @@ -182,7 +182,7 @@ "gsl_sf_mathieu_Mc_array" ((j :int) (minimum-order :int) ((+ minimum-order size) :int) (q :double) (x :double) - ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer)) + ((mpointer workspace) :pointer) ((grid:foreign-pointer result-array) :pointer)) :gsl-version (1 9) :outputs (result-array) :return (result-array) @@ -202,7 +202,7 @@ "gsl_sf_mathieu_Ms_array" ((j :int) (minimum-order :int) ((+ minimum-order size) :int) (q :double) (x :double) - ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer)) + ((mpointer workspace) :pointer) ((grid:foreign-pointer result-array) :pointer)) :gsl-version (1 9) :outputs (result-array) :return (result-array) diff --git a/special-functions/psi.lisp b/special-functions/psi.lisp index deab62e145be1b3d85daabe015e243caa2eb515f..745f4c784870641be1147cc36cb3e690df069e86 100644 --- a/special-functions/psi.lisp +++ b/special-functions/psi.lisp @@ -1,8 +1,8 @@ ;; Psi (digamma) functions ;; Liam Healy, Mon May 1 2006 - 22:11 -;; Time-stamp: <2009-12-27 10:10:00EST psi.lisp> +;; Time-stamp: <2011-01-13 10:25:00EST psi.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify diff --git a/statistics/absolute-deviation.lisp b/statistics/absolute-deviation.lisp index 64f598de83f4bf7b694f325f3605e1eb30384854..01381c34385186f6555f335928e79c54f2f3354e 100644 --- a/statistics/absolute-deviation.lisp +++ b/statistics/absolute-deviation.lisp @@ -1,8 +1,8 @@ ;; Absolute deviation ;; Liam Healy, Sun Dec 31 2006 - 13:19 -;; Time-stamp: <2010-06-27 18:14:02EDT absolute-deviation.lisp> +;; Time-stamp: <2011-01-10 17:59:33EST absolute-deviation.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -26,8 +26,8 @@ (defmfun absolute-deviation ((data vector) &optional mean) (("gsl_stats" :type "_absdev") ("gsl_stats" :type "_absdev_m")) - ((((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)) - (((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet) + ((((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)) + (((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet) (mean :double))) :definition :generic :element-types :no-complex @@ -48,11 +48,11 @@ (defmfun weighted-absolute-deviation ((data vector) (weights vector) &optional mean) (("gsl_stats" :type "_wabsdev") ("gsl_stats" :type "_wabsdev_m")) - ((((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer data) :pointer) (1 :int) + ((((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)) - (((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer data) :pointer) (1 :int) + (((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet) (mean :double))) :definition :generic :element-types :float diff --git a/statistics/autocorrelation.lisp b/statistics/autocorrelation.lisp index 20d29fe261684e6ae639d9bd83ba7ffa6d2bb3d0..dc04aea517dd9839fb2f099c89de8ba6cf4e62f8 100644 --- a/statistics/autocorrelation.lisp +++ b/statistics/autocorrelation.lisp @@ -1,8 +1,8 @@ ;; Autocorrelation ;; Liam Healy, Sun Dec 31 2006 - 13:19 -;; Time-stamp: <2010-06-27 18:14:03EDT autocorrelation.lisp> +;; Time-stamp: <2011-01-10 17:59:34EST autocorrelation.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -26,8 +26,8 @@ (defmfun autocorrelation ((data vector) &optional mean) (("gsl_stats" :type "_lag1_autocorrelation") ("gsl_stats" :type "_lag1_autocorrelation_m")) - ((((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)) - (((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet) + ((((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)) + (((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet) (mean :double))) :definition :generic :element-types :no-complex diff --git a/statistics/covariance.lisp b/statistics/covariance.lisp index 6d7ce75615333ce49930c0eee73670017c72715a..c1b79f16bc4d472d9e4f2781c7f1617bb8fa9a7c 100644 --- a/statistics/covariance.lisp +++ b/statistics/covariance.lisp @@ -1,8 +1,8 @@ ;; Covariance ;; Liam Healy, Sun Dec 31 2006 - 13:19 -;; Time-stamp: <2010-06-27 18:14:03EDT covariance.lisp> +;; Time-stamp: <2011-01-10 17:59:34EST covariance.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -27,10 +27,10 @@ ((data1 vector) (data2 vector) &optional mean1 mean2) (("gsl_stats" :type "_covariance") ("gsl_stats" :type "_covariance_m")) - ((((foreign-pointer data1) :pointer) (1 :int) - ((foreign-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet)) - (((foreign-pointer data1) :pointer) (1 :int) - ((foreign-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet) + ((((grid:foreign-pointer data1) :pointer) (1 :int) + ((grid:foreign-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet)) + (((grid:foreign-pointer data1) :pointer) (1 :int) + ((grid:foreign-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet) (mean1 :double) (mean2 :double))) :definition :generic :element-types :no-complex @@ -44,8 +44,8 @@ (defmfun correlation ((data1 vector) (data2 vector)) ("gsl_stats" :type "_correlation") - (((foreign-pointer data1) :pointer) (1 :int) - ((foreign-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet)) + (((grid:foreign-pointer data1) :pointer) (1 :int) + ((grid:foreign-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet)) :definition :generic :gsl-version (1 10) :element-types :no-complex diff --git a/statistics/higher-moments.lisp b/statistics/higher-moments.lisp index 179bbc012ba3c35ec1ee431bd8c1958b981c12b5..5dcab44deefa56696aca500fbc560a043f66bd06 100644 --- a/statistics/higher-moments.lisp +++ b/statistics/higher-moments.lisp @@ -1,8 +1,8 @@ ;; Skewness and kurtosis. ;; Liam Healy, Sun Dec 31 2006 - 14:20 -;; Time-stamp: <2010-06-27 18:14:02EDT higher-moments.lisp> +;; Time-stamp: <2011-01-10 17:59:34EST higher-moments.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -25,8 +25,8 @@ (defmfun skewness ((data vector) &optional mean standard-deviation) (("gsl_stats" :type "_skew") ("gsl_stats" :type "_skew_m_sd")) - ((((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)) - (((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet) + ((((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)) + (((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet) (mean :double) (standard-deviation :double))) :definition :generic :element-types :no-complex @@ -45,8 +45,8 @@ (defmfun kurtosis ((data vector) &optional mean standard-deviation) (("gsl_stats" :type "_kurtosis") ("gsl_stats" :type "_kurtosis_m_sd")) - ((((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)) - (((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet) + ((((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)) + (((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet) (mean :double) (standard-deviation :double))) :definition :generic :element-types :no-complex @@ -63,11 +63,11 @@ ((data vector) (weights vector) &optional mean standard-deviation) (("gsl_stats" :type "_wskew") ("gsl_stats" :type "_wskew_m_sd")) - ((((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer data) :pointer) (1 :int) + ((((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)) - (((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer data) :pointer) (1 :int) + (((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet) (mean :double) (standard-deviation :double))) :definition :generic @@ -82,11 +82,11 @@ ((data vector) (weights vector) &optional mean standard-deviation) (("gsl_stats" :type "_wkurtosis") ("gsl_stats" :type "_wkurtosis_m_sd")) - ((((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer data) :pointer) (1 :int) + ((((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet)) - (((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer data) :pointer) (1 :int) + (((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet) (mean :double) (standard-deviation :double))) :definition :generic diff --git a/statistics/mean-variance.lisp b/statistics/mean-variance.lisp index 60ccf98f66b68cab93f0959bdec88f63ddbd44eb..a0d7a81e85595c2506b65141561c37ca92d82f13 100644 --- a/statistics/mean-variance.lisp +++ b/statistics/mean-variance.lisp @@ -1,8 +1,8 @@ ;; Mean, standard deviation, and variance ;; Liam Healy, Sat Dec 2 2006 - 22:15 -;; Time-stamp: <2010-06-30 19:57:28EDT mean-variance.lisp> +;; Time-stamp: <2011-05-26 12:37:30EDT mean-variance.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -29,7 +29,7 @@ (defmfun mean ((array both)) ("gsl_stats" :type "_mean") - (((foreign-pointer array) :pointer) (1 :int) ((size array) sizet)) + (((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet)) :definition :generic :element-types :no-complex :c-return :double @@ -41,8 +41,8 @@ (defmfun weighted-mean ((array both) (weights both)) ("gsl_stats" :type "_wmean") - (((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer array) :pointer) (1 :int) + (((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet)) :definition :generic :element-types :float @@ -60,8 +60,8 @@ (defmfun variance ((array both) &optional mean) (("gsl_stats" :type "_variance") ("gsl_stats" :type "_variance_m")) - ((((foreign-pointer array) :pointer) (1 :int) ((size array) sizet)) - (((foreign-pointer array) :pointer) (1 :int) + ((((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet)) + (((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet) (mean :double))) :definition :generic :element-types :no-complex @@ -82,11 +82,11 @@ (defmfun weighted-variance ((array both) (weights both) &optional mean) (("gsl_stats" :type "_wvariance") ("gsl_stats" :type "_wvariance_m")) - ((((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer array) :pointer) (1 :int) + ((((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet)) - (((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer array) :pointer) (1 :int) + (((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet) (mean :double))) :definition :generic :element-types :float @@ -108,8 +108,8 @@ (defmfun standard-deviation ((array both) &optional mean) (("gsl_stats" :type "_sd") ("gsl_stats" :type "_sd_m")) - ((((foreign-pointer array) :pointer) (1 :int) ((size array) sizet)) - (((foreign-pointer array) :pointer) (1 :int) + ((((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet)) + (((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet) (mean :double))) :definition :generic :element-types :no-complex @@ -123,11 +123,11 @@ (defmfun weighted-standard-deviation ((array both) (weights both) &optional mean) (("gsl_stats" :type "_wsd") ("gsl_stats" :type "_wsd_m")) - ((((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer array) :pointer) (1 :int) + ((((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet)) - (((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer array) :pointer) (1 :int) + (((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet) (mean :double))) :definition :generic :element-types :float @@ -144,7 +144,7 @@ (defmfun variance-with-fixed-mean ((array both) mean) ("gsl_stats" :type "_variance_with_fixed_mean") - (((foreign-pointer array) :pointer) (1 :int) + (((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet) (mean :double)) :definition :generic :element-types :no-complex @@ -160,7 +160,7 @@ (defmfun standard-deviation-with-fixed-mean ((array both) mean) ("gsl_stats" :type "_sd_with_fixed_mean") - (((foreign-pointer array) :pointer) (1 :int) + (((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet) (mean :double)) :definition :generic :element-types :no-complex @@ -178,8 +178,8 @@ (defmfun weighted-variance-with-fixed-mean ((array both) (weights both) mean) ("gsl_stats" :type "_wvariance_with_fixed_mean") - (((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer array) :pointer) (1 :int) + (((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet) (mean :double)) :definition :generic :element-types :float @@ -196,8 +196,8 @@ (defmfun weighted-standard-deviation-with-fixed-mean ((array both) (weights both) mean) ("gsl_stats" :type "_wsd_with_fixed_mean") - (((foreign-pointer weights) :pointer) (1 :int) - ((foreign-pointer array) :pointer) (1 :int) + (((grid:foreign-pointer weights) :pointer) (1 :int) + ((grid:foreign-pointer array) :pointer) (1 :int) ((size array) sizet) (mean :double)) :definition :generic :element-types :float @@ -273,8 +273,8 @@ (generate-all-array-tests weighted-mean :float (let ((v1 (array-default 8)) (v2 (array-default 8))) - (loop for i below (first (dimensions v2)) - do (setf (grid:gref v2 i) (abs (grid:gref v2 i)))) + (loop for i below (first (grid:dimensions v2)) + do (setf (grid:aref v2 i) (abs (grid:aref v2 i)))) (weighted-mean v1 v2))) |# diff --git a/statistics/median-percentile.lisp b/statistics/median-percentile.lisp index c29993dec1db1acae8dcda1f83217b084be567dd..67eb56bcca3e098690fb1a9e33baabbb541bc1a6 100644 --- a/statistics/median-percentile.lisp +++ b/statistics/median-percentile.lisp @@ -1,8 +1,8 @@ ;; Median and percentile ;; Liam Healy, Sun Dec 31 2006 - 13:19 -;; Time-stamp: <2010-06-27 18:14:04EDT median-percentile.lisp> +;; Time-stamp: <2011-01-10 17:59:35EST median-percentile.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -25,7 +25,7 @@ (defmfun median ((sorted-data vector)) ("gsl_stats" :type "_median_from_sorted_data") - (((foreign-pointer sorted-data) :pointer) (1 :int) ((dim0 sorted-data) sizet)) + (((grid:foreign-pointer sorted-data) :pointer) (1 :int) ((dim0 sorted-data) sizet)) :definition :generic :element-types :no-complex :c-return :double @@ -44,7 +44,7 @@ (defmfun quantile ((sorted-data vector) fraction) ("gsl_stats" :type "_quantile_from_sorted_data") - (((foreign-pointer sorted-data) :pointer) (1 :int) ((dim0 sorted-data) sizet) + (((grid:foreign-pointer sorted-data) :pointer) (1 :int) ((dim0 sorted-data) sizet) (fraction :double)) :definition :generic :element-types :no-complex diff --git a/test-unit/augment.lisp b/test-unit/augment.lisp index 17ac0d5888da5ccc6327f4b5e2120e5dab420d48..a6fdd3275c87181649948a8ee4e57889d0ee9e34 100644 --- a/test-unit/augment.lisp +++ b/test-unit/augment.lisp @@ -1,8 +1,8 @@ ;; Additional methods for lisp-unit ;; Liam Healy 2009-04-15 23:23:30EDT augment.lisp -;; Time-stamp: <2010-07-07 14:24:56EDT augment.lisp> +;; Time-stamp: <2011-01-10 18:19:07EST augment.lisp> ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -23,7 +23,7 @@ (defmethod lisp-unit:numerical-equal ((result1 grid:foreign-array) (result2 grid:foreign-array) &key (test #'lisp-unit:number-equal)) "Return true if the arrays are numerically equal according to :TEST." - (when (equal (dimensions result1) (dimensions result2)) + (when (equal (grid:dimensions result1) (grid:dimensions result2)) (lisp-unit:numerical-equal (grid:copy-to result1) (grid:copy-to result2) :test test))) diff --git a/tests/absolute-sum.lisp b/tests/absolute-sum.lisp index fa1d6b7079279b1217d5ed4bef21e8eb1d60abca..e77374b57edf20984dd6f035592002436b027ae2 100644 --- a/tests/absolute-sum.lisp +++ b/tests/absolute-sum.lisp @@ -1,6 +1,6 @@ ;; Regression test ABSOLUTE-SUM for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,13 +20,13 @@ (LISP-UNIT:DEFINE-TEST ABSOLUTE-SUM (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 157.99) + (LIST 157.99f0) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)))) + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) (ABSOLUTE-SUM V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 157.99d0) @@ -38,15 +38,14 @@ '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0)))) (ABSOLUTE-SUM V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 388.65997) + (LIST 388.65997f0) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX - SINGLE-FLOAT) + '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) #C(49.27 -13.49) - #C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))) + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0) + #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))) (ABSOLUTE-SUM V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 388.65999999999997d0) diff --git a/tests/axpy.lisp b/tests/axpy.lisp index 8b014436c218e2ce8d6bb6e75fef2455e9452366..5b6677b947af6f24a9d78944a49a1dd3cbf94873 100644 --- a/tests/axpy.lisp +++ b/tests/axpy.lisp @@ -1,6 +1,6 @@ ;; Regression test AXPY for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,18 +21,18 @@ (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)) + #(1400.77f0 -284.0684f0 -147.7214f0 397.47382f0 -1369.3191f0 + 235.659f0 -1932.6083f0 485.93335f0)) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))) + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))) (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 -49.08))) - (SCALAR -39.66)) + '(32.5f0 42.73f0 -17.24f0 43.31f0 -16.12f0 -8.25f0 21.44f0 -49.08f0))) + (SCALAR -39.66f0)) (grid:copy-to (AXPY SCALAR V1 V2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -59,27 +59,27 @@ #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #(#C(1808.3204 1422.3015) #C(-589.3992 234.75043) - #C(-1673.498 -1451.916) #C(-2599.8237 -1950.9608) - #C(784.81586 -3351.5815) #C(2845.531 -870.5343) - #C(222.45422 1149.8602) #C(-3308.3872 917.76044))) + #(#C(1808.3204f0 1422.3015f0) #C(-589.3992f0 234.75043f0) + #C(-1673.498f0 -1451.916f0) #C(-2599.8237f0 -1950.9608f0) + #C(784.81586f0 -3351.5815f0) #C(2845.531f0 -870.5343f0) + #C(222.45422f0 1149.8602f0) #C(-3308.3872f0 917.76044f0))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) - #C(34.12 -6.15) #C(49.27 -13.49) #C(32.5 42.73) - #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))) + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) + #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) + #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))) (V2 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25) - #C(21.44 -49.08) #C(-39.66 -49.46) - #C(19.68 -5.55) #C(-8.82 25.37) - #C(-30.58 31.67)))) - (SCALAR #C(-39.66 -49.46))) + '(#C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) + #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0) + #C(19.68f0 -5.55f0) #C(-8.82f0 25.37f0) + #C(-30.58f0 31.67f0)))) + (SCALAR #C(-39.66f0 -49.46f0))) (GRID:COPY-TO (AXPY SCALAR V1 V2))))) #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/blas-copy.lisp b/tests/blas-copy.lisp index bd0502b55de62325e59e9820ffc8794745b532ad..f2ad285dc7372a988d27e3961b5a6f10b3bad809 100644 --- a/tests/blas-copy.lisp +++ b/tests/blas-copy.lisp @@ -1,6 +1,6 @@ ;; Regression test BLAS-COPY for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,11 +20,11 @@ (LISP-UNIT:DEFINE-TEST BLAS-COPY (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(-34.5 8.24 3.29)) + (LIST #(-34.5f0 8.24f0 3.29f0)) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5 8.24 3.29))) + 'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0))) (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3))) (BLAS-COPY V1 V2) (GRID:COPY-TO V2)))) @@ -38,13 +38,13 @@ (BLAS-COPY V1 V2) (GRID:COPY-TO V2)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))) + (LIST #(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)))) + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)))) (V2 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3))) diff --git a/tests/blas-swap.lisp b/tests/blas-swap.lisp index 405442e1c64cd114ca0407ec15ad7961b5c63a3b..2cf69132db4b88f283ec1e6b56f0708e9af4598e 100644 --- a/tests/blas-swap.lisp +++ b/tests/blas-swap.lisp @@ -1,6 +1,6 @@ ;; Regression test BLAS-SWAP for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,16 +20,16 @@ (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))) + (LIST (LIST #(-8.93f0 34.12f0 -6.15f0) #(-34.5f0 8.24f0 3.29f0))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29))) + '(-34.5f0 8.24f0 3.29f0))) (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-8.93 34.12 -6.15)))) + '(-8.93f0 34.12f0 -6.15f0)))) (BLAS-SWAP V2 V1) (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL @@ -50,19 +50,19 @@ (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)))) + #(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + #(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)))) + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)))) (V2 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))))) + '(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))))) (BLAS-SWAP V2 V1) (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/cdot.lisp b/tests/cdot.lisp index 59db2a942de63cd4c263afd22307d665240ed647..42af8212efcc600d58c4fc4376a3eaee1594021a 100644 --- a/tests/cdot.lisp +++ b/tests/cdot.lisp @@ -1,6 +1,6 @@ ;; Regression test CDOT for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,22 +20,22 @@ (LISP-UNIT:DEFINE-TEST CDOT (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #C(-6252.624 -6236.0503)) + (LIST #C(-6252.624f0 -6236.0503f0)) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) - #C(49.27 -13.49) #C(32.5 42.73) - #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))) + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0) + #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) + #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))) (V2 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25) - #C(21.44 -49.08) #C(-39.66 -49.46) - #C(19.68 -5.55) #C(-8.82 25.37) #C(-30.58 31.67))))) + '(#C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) + #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0) + #C(19.68f0 -5.55f0) #C(-8.82f0 25.37f0) #C(-30.58f0 31.67f0))))) (CDOT V1 V2)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #C(-6252.624d0 -6236.050300000001d0)) diff --git a/tests/column.lisp b/tests/column.lisp index fac955d630173ec70a0bea04ef5d31296f5eec05..d25e69c842aba1d493e860bcd526a776eb47a087 100644 --- a/tests/column.lisp +++ b/tests/column.lisp @@ -1,6 +1,6 @@ ;; Regression test COLUMN for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,175 +19,175 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST COLUMN - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(8.24 34.12 -13.49)) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) - (COL (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3))) - (GRID:COPY-TO (COLUMN M1 1 COL))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(8.24f0 34.12f0 -13.49f0)) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) + (COL (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3))) + (GRID:COPY-TO (COLUMN M1 1 COL))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(8.24d0 34.12d0 -13.49d0)) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0)))) - (COL (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3))) - (GRID:COPY-TO (COLUMN M1 1 COL))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (COL (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '3))) + (GRID:COPY-TO (COLUMN M1 1 COL))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(#C(3.29 -8.93) #C(-6.15 49.27) #C(32.5 42.73))) + (LIST #(#C(3.29f0 -8.93f0) #C(-6.15f0 49.27f0) #C(32.5f0 42.73f0))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS - '((#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))))) - (COL - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3))) - (GRID:COPY-TO (COLUMN M1 1 COL))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX SINGLE-FLOAT) + :INITIAL-CONTENTS + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) + (COL + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3))) + (GRID:COPY-TO (COLUMN M1 1 COL))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(#C(3.29d0 -8.93d0) #C(-6.15d0 49.27d0) #C(32.5d0 42.73d0))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX DOUBLE-FLOAT) - :INITIAL-CONTENTS - '((#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))))) - (COL - (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT) :DIMENSIONS '3))) - (GRID:COPY-TO (COLUMN M1 1 COL))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX DOUBLE-FLOAT) + :INITIAL-CONTENTS + '((#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))))) + (COL + (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT) :DIMENSIONS '3))) + (GRID:COPY-TO (COLUMN M1 1 COL))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5)) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE 8) - :INITIAL-CONTENTS - '((-64 -68 71) - (-91 52 -10) - (73 -5 123)))) - (COL - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE 8) - :DIMENSIONS '3))) - (GRID:COPY-TO (COLUMN M1 1 COL))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 8) + :INITIAL-CONTENTS + '((-64 -68 71) + (-91 52 -10) + (73 -5 123)))) + (COL + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 8) + :DIMENSIONS '3))) + (GRID:COPY-TO (COLUMN M1 1 COL))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215)) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) - (116 163 140) - (161 215 98)))) - (COL - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE 8) - :DIMENSIONS '3))) - (GRID:COPY-TO (COLUMN M1 1 COL))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) + (116 163 140) + (161 215 98)))) + (COL + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 8) + :DIMENSIONS '3))) + (GRID:COPY-TO (COLUMN M1 1 COL))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5)) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) - (-91 52 -10) - (73 -5 123)))) - (COL - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE 16) :DIMENSIONS '3))) - (GRID:COPY-TO (COLUMN M1 1 COL))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) + (-91 52 -10) + (73 -5 123)))) + (COL + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 16) :DIMENSIONS '3))) + (GRID:COPY-TO (COLUMN M1 1 COL))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215)) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) - (116 163 140) - (161 215 98)))) - (COL - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE 16) - :DIMENSIONS '3))) - (GRID:COPY-TO (COLUMN M1 1 COL))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) + (116 163 140) + (161 215 98)))) + (COL + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 16) + :DIMENSIONS '3))) + (GRID:COPY-TO (COLUMN M1 1 COL))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5)) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) - (-91 52 -10) - (73 -5 123)))) - (COL - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE 32) :DIMENSIONS '3))) - (GRID:COPY-TO (COLUMN M1 1 COL))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) + (-91 52 -10) + (73 -5 123)))) + (COL + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 32) :DIMENSIONS '3))) + (GRID:COPY-TO (COLUMN M1 1 COL))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215)) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) - (116 163 140) - (161 215 98)))) - (COL - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE 32) :DIMENSIONS '3))) - (GRID:COPY-TO (COLUMN M1 1 COL))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) + (116 163 140) + (161 215 98)))) + (COL + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 32) :DIMENSIONS '3))) + (GRID:COPY-TO (COLUMN M1 1 COL))))) #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-68 52 -5)) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) - (-91 52 -10) - (73 -5 123)))) - (COL - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE 64) - :DIMENSIONS '3))) - (GRID:COPY-TO (COLUMN M1 1 COL))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) + (-91 52 -10) + (73 -5 123)))) + (COL + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 64) + :DIMENSIONS '3))) + (GRID:COPY-TO (COLUMN M1 1 COL))))) #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 163 215)) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) - (116 163 140) - (161 215 98)))) - (COL - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE 64) - :DIMENSIONS '3))) - (GRID:COPY-TO (COLUMN M1 1 COL)))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) + (116 163 140) + (161 215 98)))) + (COL + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 64) + :DIMENSIONS '3))) + (GRID:COPY-TO (COLUMN M1 1 COL)))))) diff --git a/tests/correlation.lisp b/tests/correlation.lisp index b05deb8870c95029d84a30b50812e783a43c12c1..1d66fd399c90c85e88d1d9edb47c1bc4a188591c 100644 --- a/tests/correlation.lisp +++ b/tests/correlation.lisp @@ -1,6 +1,6 @@ ;; Regression test CORRELATION for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -24,10 +24,10 @@ (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29))) + '(-34.5f0 8.24f0 3.29f0))) (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-8.93 34.12 -6.15)))) + '(-8.93f0 34.12f0 -6.15f0)))) (CORRELATION V1 V2)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.6345226817840662d0) diff --git a/tests/covariance.lisp b/tests/covariance.lisp index 16b5f83d2123eddb2157ca0c28bdd011471d2c8a..b64c07f18c5f6d8c414ebc0c437dce205e5c5f95 100644 --- a/tests/covariance.lisp +++ b/tests/covariance.lisp @@ -1,6 +1,6 @@ ;; Regression test COVARIANCE for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -24,10 +24,10 @@ (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29))) + '(-34.5f0 8.24f0 3.29f0))) (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-8.93 34.12 -6.15)))) + '(-8.93f0 34.12f0 -6.15f0)))) (LET ((MEAN1 (MEAN V1)) (MEAN2 (MEAN V2))) (COVARIANCE V1 V2 MEAN1 MEAN2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/dot.lisp b/tests/dot.lisp index 6375c5541e4af028a7005e296ab3378e2b7e4a37..80b7873154d3bc0b8b5faf846da9addfa57db3cf 100644 --- a/tests/dot.lisp +++ b/tests/dot.lisp @@ -1,6 +1,6 @@ ;; Regression test DOT for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,19 +20,19 @@ (LISP-UNIT:DEFINE-TEST DOT (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 6.5285645) + (LIST 6.5285645f0) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))) + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))) (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(32.5 42.73 -17.24 43.31 -16.12 -8.25 21.44 -49.08)))) - (DOT V1 V2)))) + '(32.5f0 42.73f0 -17.24f0 43.31f0 -16.12f0 -8.25f0 21.44f0 -49.08f0)))) + (GRID:INNER V1 V2)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6.528400000000033d0) (MULTIPLE-VALUE-LIST @@ -48,25 +48,25 @@ '(32.5d0 42.73d0 -17.24d0 43.31d0 -16.12d0 -8.25d0 21.44d0 -49.08d0)))) - (DOT V1 V2)))) + (GRID:INNER V1 V2)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #C(625.9737 -4310.1177)) + (LIST #C(625.9737f0 -4310.1177f0)) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) - #C(49.27 -13.49) #C(32.5 42.73) - #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))) + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0) + #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) + #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))) (V2 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25) - #C(21.44 -49.08) #C(-39.66 -49.46) - #C(19.68 -5.55) #C(-8.82 25.37) #C(-30.58 31.67))))) - (DOT V1 V2)))) + '(#C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) + #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0) + #C(19.68f0 -5.55f0) #C(-8.82f0 25.37f0) #C(-30.58f0 31.67f0))))) + (GRID:INNER V1 V2)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #C(625.9736000000007d0 -4310.1183d0)) (MULTIPLE-VALUE-LIST @@ -87,4 +87,4 @@ #C(-39.66d0 -49.46d0) #C(19.68d0 -5.55d0) #C(-8.82d0 25.37d0) #C(-30.58d0 31.67d0))))) - (DOT V1 V2))))) + (GRID:INNER V1 V2))))) diff --git a/tests/euclidean-norm.lisp b/tests/euclidean-norm.lisp index fcee147a020c60a5684d1d8c1d526e88b866152d..818d862dab50ba692d47425ab16604b747c23c67 100644 --- a/tests/euclidean-norm.lisp +++ b/tests/euclidean-norm.lisp @@ -1,6 +1,6 @@ ;; Regression test EUCLIDEAN-NORM for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,13 +20,13 @@ (LISP-UNIT:DEFINE-TEST EUCLIDEAN-NORM (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 71.83472) + (LIST 71.83472f0) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)))) + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) (EUCLIDEAN-NORM V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71.83471653734007d0) @@ -37,16 +37,16 @@ '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0)))) (EUCLIDEAN-NORM V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 115.80907) + (LIST 115.80907f0) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) - #C(34.12 -6.15) #C(49.27 -13.49) - #C(32.5 42.73) #C(-17.24 43.31) - #C(-16.12 -8.25) #C(21.44 -49.08))))) + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) + #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0) + #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) + #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))) (EUCLIDEAN-NORM V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 115.8090670025452d0) @@ -60,4 +60,3 @@ #C(32.5d0 42.73d0) #C(-17.24d0 43.31d0) #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0))))) (EUCLIDEAN-NORM V1))))) - diff --git a/tests/fast-fourier-transform.lisp b/tests/fast-fourier-transform.lisp index dac5cda25708d500cfc06727e4576a1520da12f2..f6c7c34ffd5b0c42315affab14c41d717c913399 100644 --- a/tests/fast-fourier-transform.lisp +++ b/tests/fast-fourier-transform.lisp @@ -1,8 +1,8 @@ ;; Fast fourier transform tests ;; Liam Healy 2010-08-14 11:58:26EDT fast-fourier-transform.lisp -;; Time-stamp: <2010-09-04 17:07:32EDT fast-fourier-transform.lisp> +;; Time-stamp: <2011-05-26 12:37:30EDT fast-fourier-transform.lisp> ;; -;; Copyright 2010 Liam M. Healy +;; Copyright 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -27,11 +27,11 @@ "Make a grid that is all of the original array except that the stride points are excluded." (grid:make-foreign-array - (element-type array) + (grid:element-type array) :initial-contents (loop for i from 0 below (grid:total-size array) unless (zerop (mod i stride)) - collect (grid:gref* array i)))) + collect (grid:aref* array i)))) (defun fft-complex-off-stride-check (vector stride offset) (loop with size = (size vector) @@ -40,7 +40,7 @@ unless (lisp-unit:numerical-equal (complex (+ offset (* 2 i)) (+ offset (* 2 i) 1)) - (grid:gref vector i)) + (grid:aref vector i)) return nil finally (return t))) diff --git a/tests/givens.lisp b/tests/givens.lisp index 5c90408d0fd76f048ca0b8f2a00a7e31b78ce28c..6f051969d792f54cce05d0bd1ff880e3bba4972e 100644 --- a/tests/givens.lisp +++ b/tests/givens.lisp @@ -1,6 +1,6 @@ ;; Regression test GIVENS for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,66 +19,69 @@ (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 - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 - -6.15 49.27 -13.49))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(32.5 42.73 -17.24 43.31 -16.12 - -8.25 21.44 -49.08))) - (ANGLES - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-39.66 -49.46 19.68 -5.55 -8.82 - 25.37 -30.58 31.67))) - (SINES - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8)) - (COSINES - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8))) - (LOOP FOR I BELOW 8 DO - (SETF (GRID:GREF SINES I) (SIN (GRID:GREF ANGLES I))) - (SETF (GRID:GREF COSINES I) - (COS (GRID:GREF ANGLES I)))) - (GIVENS-ROTATION V1 V2 COSINES SINES) - (LIST (GRID:COPY-TO V1) (GRID:COPY-TO 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 - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0 -8.93d0 - 34.12d0 -6.15d0 49.27d0 - -13.49d0))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(32.5d0 42.73d0 -17.24d0 43.31d0 - -16.12d0 -8.25d0 21.44d0 - -49.08d0))) - (ANGLES - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-39.66d0 -49.46d0 19.68d0 - -5.55d0 -8.82d0 25.37d0 -30.58d0 - 31.67d0))) - (SINES - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8)) - (COSINES - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8))) - (LOOP FOR I BELOW 8 DO - (SETF (GRID:GREF SINES I) (SIN (GRID:GREF ANGLES I))) - (SETF (GRID:GREF COSINES I) - (COS (GRID:GREF ANGLES I)))) - (GIVENS-ROTATION V1 V2 COSINES SINES) - (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + (LIST + #(-47.39726f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0) + #(-0.6856937f0 42.73f0 -17.24f0 43.31f0 -16.12f0 -8.25f0 21.44f0 + -49.08f0))) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '(32.5f0 42.73f0 -17.24f0 43.31f0 -16.12f0 -8.25f0 21.44f0 -49.08f0))) + (ANGLES + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '(-39.66f0 -49.46f0 19.68f0 -5.55f0 -8.82f0 25.37f0 -30.58f0 31.67f0))) + (SINES + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8)) + (COSINES + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '8))) + (LOOP FOR I BELOW 8 DO + (SETF (GRID:AREF SINES I) (SIN (GRID:AREF ANGLES I))) + (SETF (GRID:AREF COSINES I) + (COS (GRID:AREF ANGLES I)))) + (GIVENS-ROTATION V1 V2 COSINES SINES) + (LIST (GRID:COPY-TO V1) (GRID:COPY-TO 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 + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 + 34.12d0 -6.15d0 49.27d0 + -13.49d0))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(32.5d0 42.73d0 -17.24d0 43.31d0 + -16.12d0 -8.25d0 21.44d0 + -49.08d0))) + (ANGLES + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(-39.66d0 -49.46d0 19.68d0 + -5.55d0 -8.82d0 25.37d0 -30.58d0 + 31.67d0))) + (SINES + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8)) + (COSINES + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '8))) + (LOOP FOR I BELOW 8 DO + (SETF (GRID:AREF SINES I) (SIN (GRID:AREF ANGLES I))) + (SETF (GRID:AREF COSINES I) + (COS (GRID:AREF ANGLES I)))) + (GIVENS-ROTATION V1 V2 COSINES SINES) + (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2)))))) diff --git a/tests/hankel.lisp b/tests/hankel.lisp index 92dba83c2623962bfdc7c74d27c2ce73a74d0e4c..461013ff9c8d893ed8b59bc9f65c331334ae9983 100644 --- a/tests/hankel.lisp +++ b/tests/hankel.lisp @@ -114,7 +114,7 @@ (LET ((HANK (MAKE-HANKEL 128 0.0d0 100.0d0)) (IN (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 128))) (LOOP FOR N FROM 0 BELOW 128 DO - (SETF (GRID:GREF IN N) + (SETF (GRID:AREF IN N) (/ (1+ (EXPT (SAMPLE-X-HANKEL HANK N) @@ -190,7 +190,7 @@ (LET ((HANK (MAKE-HANKEL 128 1.0d0 20.0d0)) (IN (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 128))) (LOOP FOR N FROM 0 BELOW 128 DO - (SETF (GRID:GREF IN N) + (SETF (GRID:AREF IN N) (EXP (- (SAMPLE-X-HANKEL HANK N))))) (grid:COPY-to (APPLY-HANKEL HANK IN))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL @@ -263,7 +263,7 @@ (LET ((HANK (MAKE-HANKEL 128 1.0d0 1.0d0)) (IN (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS 128))) (LOOP FOR N FROM 0 BELOW 128 DO - (SETF (GRID:GREF IN N) + (SETF (GRID:AREF IN N) (LET ((X (SAMPLE-X-HANKEL HANK N))) (* X (- 1 (EXPT X 2)))))) (grid:COPY-to (APPLY-HANKEL HANK IN)))))) diff --git a/tests/histogram.lisp b/tests/histogram.lisp index d832eb4e9ecfe1771116095dc94a365c3bc55114..d37108b1954cb5cc561f3753ff30f841d3268c85 100644 --- a/tests/histogram.lisp +++ b/tests/histogram.lisp @@ -39,7 +39,7 @@ (INCREMENT HISTO 6.9d0 2.0d0) - (GRID:GREF HISTO 1)))) + (GRID:AREF HISTO 1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1.0d0) (MULTIPLE-VALUE-LIST (LET ((HISTO @@ -53,7 +53,7 @@ (INCREMENT HISTO 6.9d0 2.0d0) - (GRID:GREF HISTO 2)))) + (GRID:AREF HISTO 2)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2.0d0) (MULTIPLE-VALUE-LIST (LET ((HISTO @@ -67,7 +67,7 @@ (INCREMENT HISTO 6.9d0 2.0d0) - (GRID:GREF HISTO 6)))) + (GRID:AREF HISTO 6)))) (LISP-UNIT:ASSERT-ERROR 'INPUT-DOMAIN (LET ((HISTO (MAKE-HISTOGRAM 10))) @@ -76,7 +76,7 @@ 10.0d0) (INCREMENT HISTO 2.7d0) (INCREMENT HISTO 6.9d0 2.0d0) - (GRID:GREF HISTO 16))) + (GRID:AREF HISTO 16))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0.0d0 10.0d0) (MULTIPLE-VALUE-LIST (LET ((HISTO diff --git a/tests/index-max.lisp b/tests/index-max.lisp index 0752044424bfa9c51ca1c44dd9cec75660620056..0dff9495d5a1680649f9d9c5f29d36b655d14c2e 100644 --- a/tests/index-max.lisp +++ b/tests/index-max.lisp @@ -1,6 +1,6 @@ ;; Regression test INDEX-MAX for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,49 +19,48 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST INDEX-MAX + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (INDEX-MAX V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)))) - (INDEX-MAX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 6) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0)))) - (INDEX-MAX V1)))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0)))) + (INDEX-MAX V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 4) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) - #C(49.27 -13.49) #C(32.5 42.73) - #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))) - (INDEX-MAX V1)))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX SINGLE-FLOAT) + :INITIAL-CONTENTS + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0) + #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) + #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))) + (INDEX-MAX V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 4) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX DOUBLE-FLOAT) - :INITIAL-CONTENTS - '(#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) - #C(-16.12d0 -8.25d0) - #C(21.44d0 -49.08d0))))) - (INDEX-MAX V1))))) - + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX DOUBLE-FLOAT) + :INITIAL-CONTENTS + '(#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) + #C(-16.12d0 -8.25d0) + #C(21.44d0 -49.08d0))))) + (INDEX-MAX V1))))) diff --git a/tests/inverse-matrix-product.lisp b/tests/inverse-matrix-product.lisp index 0730e9713a8ad77ecd4f0b32b9b6bd27210e4b1a..a5c7fb102b2451a267bb001778f7a467486ae680 100644 --- a/tests/inverse-matrix-product.lisp +++ b/tests/inverse-matrix-product.lisp @@ -1,6 +1,6 @@ ;; Regression test INVERSE-MATRIX-PRODUCT for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,23 +21,23 @@ (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))) + #2A((-30.708971f0 5.3737082f0 -25.897392f0) + (-14.654706f0 -9.08723f0 6.96797f0) + (-29.71983f0 -24.015656f0 -29.949932f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) (M2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((42.73 -17.24 43.31) - (-16.12 -8.25 21.44) - (-49.08 -39.66 -49.46)))) - (S1 19.68)) + '((42.73f0 -17.24f0 43.31f0) + (-16.12f0 -8.25f0 21.44f0) + (-49.08f0 -39.66f0 -49.46f0)))) + (S1 19.68f0)) (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -65,28 +65,28 @@ #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(-28.191956 35.052914) #C(-13.378113 28.736774) - #C(5.4411864 -3.0717967)) - (#C(5.1555862 -11.330741) #C(-33.49236 -12.241006) - #C(-10.527424 20.3357)) - (#C(-0.71776515 27.669863) #C(20.046593 11.972884) - #C(-1.5907472 4.2853727)))) + #2A((#C(-28.191956f0 35.052914f0) #C(-13.378113f0 28.736774f0) + #C(5.4411864f0 -3.0717967f0)) + (#C(5.1555862f0 -11.330741f0) #C(-33.49236f0 -12.241006f0) + #C(-10.527424f0 20.3357f0)) + (#C(-0.71776515f0 27.669863f0) #C(20.046593f0 11.972884f0) + #C(-1.5907472f0 4.2853727f0)))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) (M2 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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))))) - (S1 #C(19.68 -5.55))) + '((#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)) + (#C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)) + (#C(-49.08f0 -39.66f0) #C(-49.46f0 19.68f0) #C(-5.55f0 -8.82f0))))) + (S1 #C(19.68f0 -5.55f0))) (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1))))) #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL @@ -118,19 +118,19 @@ (S1 #C(19.68d0 -5.55d0))) (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 M2 S1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(-1.1747805 -0.26507667 1.3326154)) + (LIST #(-1.1747805f0 -0.26507667f0 1.3326154f0)) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) (V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(42.73 -17.24 43.31))) - (S1 -16.12)) + '(42.73f0 -17.24f0 43.31f0))) + (S1 -16.12f0)) (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 V1 S1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -150,22 +150,22 @@ (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 V1 S1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #(#C(-1.1218005 0.24990065) #C(-0.7679142 -0.9143634) - #C(0.4927793 -0.0056687724))) + #(#C(-1.1218005f0 0.24990065f0) #C(-0.7679142f0 -0.9143634f0) + #C(0.4927793f0 -0.0056687724f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) (V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44)))) - (S1 #C(-16.12 -8.25))) + '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)))) + (S1 #C(-16.12f0 -8.25f0))) (GRID:COPY-TO (INVERSE-MATRIX-PRODUCT M1 V1 S1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST diff --git a/tests/lu.lisp b/tests/lu.lisp index 2fd3573c78065b3c40cd4993f06f87fcdd32f400..cedc999a82a068f93603c4be15d1ed4ed01e2812 100644 --- a/tests/lu.lisp +++ b/tests/lu.lisp @@ -1,7 +1,7 @@ ;; Regression test LU for GSLL, automatically generated ;; with some manual changes to the results ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,7 +20,7 @@ (in-package :gsl) -;;; Answers (except for invert-matrix)inserted from linalg/test.c +;;; Answers inserted from linalg/test.c ;;; GSL has #define GSL_DBL_EPSILON 2.2204460492503131e-16 ;;; which is 2x what double-float-epsilon is. (LISP-UNIT:DEFINE-TEST LU @@ -129,14 +129,4 @@ (MATRIX-PRODUCT-TRIANGULAR MATRIX (MATRIX-PRODUCT-TRIANGULAR MATRIX X 1 :UPPER :NOTRANS :NONUNIT) - 1 :LOWER :NOTRANS :UNIT)))))))) - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST - #2A((-1.9999999999999998d0 1.0d0) - (1.4999999999999998d0 -0.49999999999999994d0))) - (MULTIPLE-VALUE-LIST - (GRID:COPY-TO - (INVERT-MATRIX - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 2) - :INITIAL-CONTENTS - '((1.0d0 2.0d0) (3.0d0 4.0d0)))))))) + 1 :LOWER :NOTRANS :UNIT))))))))) diff --git a/tests/matrix-add.lisp b/tests/matrix-add.lisp index 9bf89281739d5a1935d38149aef66eafabfe2f48..51c633c2d5f2a74cdf1a944c89ffb546f5aebe64 100644 --- a/tests/matrix-add.lisp +++ b/tests/matrix-add.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-ADD for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,151 +19,151 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-ADD - (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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((42.73 -17.24 43.31) - (-16.12 -8.25 21.44) - (-49.08 -39.66 -49.46))))) - (GRID:COPY-TO (ELT+ 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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((42.73d0 -17.24d0 43.31d0) - (-16.12d0 -8.25d0 21.44d0) - (-49.08d0 -39.66d0 -49.46d0))))) - (GRID:COPY-TO (ELT+ M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 -65))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT+ M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((95 54 208) (144 85 101) (197 68 64))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT+ M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT+ M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((95 54 208) (144 341 357) (197 324 320))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT+ M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT+ M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((95 54 208) (144 341 357) (197 324 320))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT+ M1 M2))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT+ M1 M2))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((95 54 208) (144 341 357) (197 324 320))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT+ M1 M2)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((8.23f0 -9.0f0 46.600002f0) + (-25.050001f0 25.869999f0 15.290001f0) + (0.18999863f0 -53.15f0 -16.96f0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '((42.73f0 -17.24f0 43.31f0) + (-16.12f0 -8.25f0 21.44f0) + (-49.08f0 -39.66f0 -49.46f0))))) + (GRID:COPY-TO (ELT+ 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 + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0))))) + (GRID:COPY-TO (ELT+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 -65))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((95 54 208) (144 85 101) (197 68 64))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((95 54 208) (144 341 357) (197 324 320))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT+ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((95 54 208) (144 341 357) (197 324 320))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT+ M1 M2))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-32 -40 101) (-54 -21 -18) (58 -27 191))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT+ M1 M2))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((95 54 208) (144 341 357) (197 324 320))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT+ M1 M2)))))) diff --git a/tests/matrix-div.lisp b/tests/matrix-div.lisp index 5f7cd88ae2d07529fddd7af37ef26af8805d6709..f9ea4614867615d0f79ea3a2294aa6506e3c59ec 100644 --- a/tests/matrix-div.lisp +++ b/tests/matrix-div.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-DIV for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,153 +19,153 @@ (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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((42.73 -17.24 43.31) - (-16.12 -8.25 21.44) - (-49.08 -39.66 -49.46))))) - (GRID:COPY-TO (ELT/ 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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((42.73d0 -17.24d0 43.31d0) - (-16.12d0 -8.25d0 21.44d0) - (-49.08d0 -39.66d0 -49.46d0))))) - (GRID:COPY-TO (ELT/ M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT/ M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((2 4 9) (4 0 0) (4 1 0))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT/ M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT/ M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((2 4 9) (4 0 0) (4 1 0))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT/ M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT/ M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((2 4 9) (4 0 0) (4 1 0))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT/ M1 M2))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT/ M1 M2))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((2 4 9) (4 0 0) (4 1 0))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT/ M1 M2)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-0.8073953f0 -0.47795823f0 0.075963974f0) + (0.5539702f0 -4.1357574f0 -0.28684703f0) + (-1.0038712f0 0.3401412f0 -0.6570967f0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '((42.73f0 -17.24f0 43.31f0) + (-16.12f0 -8.25f0 21.44f0) + (-49.08f0 -39.66f0 -49.46f0))))) + (GRID:COPY-TO (ELT/ 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 + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0))))) + (GRID:COPY-TO (ELT/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((2 4 9) (4 0 0) (4 1 0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((2 4 9) (4 0 0) (4 1 0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT/ M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((2 4 9) (4 0 0) (4 1 0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT/ M1 M2))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-2 -2 2) (-2 0 1) (-4 0 1))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT/ M1 M2))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((2 4 9) (4 0 0) (4 1 0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT/ M1 M2)))))) diff --git a/tests/matrix-max-index.lisp b/tests/matrix-max-index.lisp index 56584303f6d505dae72507acde90073643c3a837..da899628ac263aacadd61e182af27bba0e219023 100644 --- a/tests/matrix-max-index.lisp +++ b/tests/matrix-max-index.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-MAX-INDEX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,150 +19,140 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-MAX-INDEX - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS - '((-34.5 - 8.24 - 3.29) - (-8.93 - 34.12 - -6.15) - (49.27 - -13.49 - 32.5))))) - (MAX-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '((-34.5d0 - 8.24d0 - 3.29d0) - (-8.93d0 - 34.12d0 - -6.15d0) - (49.27d0 - -13.49d0 - 32.5d0))))) - (MAX-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MAX-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MAX-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MAX-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MAX-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MAX-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MAX-INDEX M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MAX-INDEX M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MAX-INDEX M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2 0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2 0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MAX-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MAX-INDEX M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 2) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MAX-INDEX M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 2 1) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MAX-INDEX M1))))) diff --git a/tests/matrix-max.lisp b/tests/matrix-max.lisp index 30e64b5dc6e6d8b71409d10ec63ea7de2e0dd3e8..8ae559f9c419890b26563dc5bb3f918281ec4603 100644 --- a/tests/matrix-max.lisp +++ b/tests/matrix-max.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-MAX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,150 +19,140 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-MAX - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 49.27) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS - '((-34.5 - 8.24 - 3.29) - (-8.93 - 34.12 - -6.15) - (49.27 - -13.49 - 32.5))))) - (MMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 49.27d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '((-34.5d0 - 8.24d0 - 3.29d0) - (-8.93d0 - 34.12d0 - -6.15d0) - (49.27d0 - -13.49d0 - 32.5d0))))) - (MMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MMAX M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MMAX M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MMAX M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 49.27f0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 49.27d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MMAX M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 123) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MMAX M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 215) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MMAX M1))))) diff --git a/tests/matrix-mean.lisp b/tests/matrix-mean.lisp index 481ca69878ed37e2b634572101e9eff31d60b85f..be183897625d19b73f7691522ac2e58cd1942b48 100644 --- a/tests/matrix-mean.lisp +++ b/tests/matrix-mean.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-MEAN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,123 +19,123 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-MEAN - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 7.149999883439806d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) - (MEAN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7.15d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '((-34.5d0 - 8.24d0 - 3.29d0) - (-8.93d0 - 34.12d0 - -6.15d0) - (49.27d0 - -13.49d0 - 32.5d0))))) - (MEAN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MEAN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 132.55555555555554d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (MEAN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MEAN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 132.55555555555554d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (MEAN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MEAN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 132.55555555555554d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (MEAN M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MEAN M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 132.55555555555554d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 7.149999883439806d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7.15d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '((-34.5d0 + 8.24d0 + 3.29d0) + (-8.93d0 + 34.12d0 + -6.15d0) + (49.27d0 + -13.49d0 + 32.5d0))))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 132.55555555555554d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 132.55555555555554d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MEAN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 132.55555555555554d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (MEAN M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 9.0d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MEAN M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 132.55555555555554d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (MEAN M1))))) diff --git a/tests/matrix-min-index.lisp b/tests/matrix-min-index.lisp index 28caea195bc96f5ce85ee89f458908354a79e810..882876e51683124854090e5a805fe6450b8039ce 100644 --- a/tests/matrix-min-index.lisp +++ b/tests/matrix-min-index.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-MIN-INDEX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,150 +19,140 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-MIN-INDEX - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS - '((-34.5 - 8.24 - 3.29) - (-8.93 - 34.12 - -6.15) - (49.27 - -13.49 - 32.5))))) - (MIN-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '((-34.5d0 - 8.24d0 - 3.29d0) - (-8.93d0 - 34.12d0 - -6.15d0) - (49.27d0 - -13.49d0 - 32.5d0))))) - (MIN-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MIN-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MIN-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MIN-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MIN-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MIN-INDEX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MIN-INDEX M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MIN-INDEX M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MIN-INDEX M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0 0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0 0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MIN-INDEX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MIN-INDEX M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MIN-INDEX M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MIN-INDEX M1))))) diff --git a/tests/matrix-min.lisp b/tests/matrix-min.lisp index e0fd59f895790e10f3b09bf1cda0ce1f7ee0ad06..4c7f7734251773dc56b84027da6abbf2c544dbd9 100644 --- a/tests/matrix-min.lisp +++ b/tests/matrix-min.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-MIN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,150 +19,140 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-MIN - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS - '((-34.5 - 8.24 - 3.29) - (-8.93 - 34.12 - -6.15) - (49.27 - -13.49 - 32.5))))) - (MMIN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '((-34.5d0 - 8.24d0 - 3.29d0) - (-8.93d0 - 34.12d0 - -6.15d0) - (49.27d0 - -13.49d0 - 32.5d0))))) - (MMIN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MMIN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MMIN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MMIN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MMIN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MMIN M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MMIN M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MMIN M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MMIN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -34.5f0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -34.5d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MMIN M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MMIN M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MMIN M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MMIN M1))))) diff --git a/tests/matrix-minmax-index.lisp b/tests/matrix-minmax-index.lisp index 960d408ce14de5ecfbee69a5833af51a37a89c55..8cc4626609e103ae1b24e66ea40e8ed74e1f1b02 100644 --- a/tests/matrix-minmax-index.lisp +++ b/tests/matrix-minmax-index.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-MINMAX-INDEX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,160 +19,155 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-MINMAX-INDEX - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0 2 0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS - '((-34.5 - 8.24 - 3.29) - (-8.93 - 34.12 - -6.15) - (49.27 - -13.49 - 32.5))))) - (MINMAX-INDEX - M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0 2 0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '((-34.5d0 - 8.24d0 - 3.29d0) - (-8.93d0 - 34.12d0 - -6.15d0) - (49.27d0 - -13.49d0 - 32.5d0))))) - (MINMAX-INDEX - M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MINMAX-INDEX - M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MINMAX-INDEX - M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MINMAX-INDEX - M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MINMAX-INDEX - M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MINMAX-INDEX - M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MINMAX-INDEX - M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MINMAX-INDEX - M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MINMAX-INDEX - M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 0 0 2 0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 0 2 0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '((-34.5d0 + 8.24d0 + 3.29d0) + (-8.93d0 + 34.12d0 + -6.15d0) + (49.27d0 + -13.49d0 + 32.5d0))))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MINMAX-INDEX + M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MINMAX-INDEX + M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 1 0 2 2) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MINMAX-INDEX + M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 1 2 1) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MINMAX-INDEX + M1))))) diff --git a/tests/matrix-minmax.lisp b/tests/matrix-minmax.lisp index 6e23b21c953a5188a620d1da3cfceb1e694e07e6..d6959d0092d6c63d477bf45b666a97427d6f6c5f 100644 --- a/tests/matrix-minmax.lisp +++ b/tests/matrix-minmax.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-MINMAX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,143 +19,140 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-MINMAX - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5 49.27) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS - '((-34.5 - 8.24 - 3.29) - (-8.93 - 34.12 - -6.15) - (49.27 - -13.49 - 32.5))))) - (MINMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST -34.5d0 49.27d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0))))) - (MINMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MINMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MINMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MINMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MINMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MINMAX M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MINMAX M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (MINMAX M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((67 44 - 189) - (116 163 - 140) - (161 215 - 98))))) - (MINMAX M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -34.5f0 49.27f0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -34.5d0 49.27d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MINMAX M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MINMAX M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -91 123) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (MINMAX M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 44 215) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((67 44 + 189) + (116 163 + 140) + (161 215 + 98))))) + (MINMAX M1))))) diff --git a/tests/matrix-mult.lisp b/tests/matrix-mult.lisp index 2778d32a5dd6783ed4db3dd45ee97f20ea56a36b..d38672fe01d0d6f4a58f599b2c5f8eba71af0ba6 100644 --- a/tests/matrix-mult.lisp +++ b/tests/matrix-mult.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-MULT for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,169 +19,171 @@ (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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((42.73 -17.24 43.31) - (-16.12 -8.25 21.44) - (-49.08 -39.66 -49.46))))) - (GRID:COPY-TO (ELT* 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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((42.73d0 -17.24d0 43.31d0) - (-16.12d0 -8.25d0 21.44d0) - (-49.08d0 -39.66d0 -49.46d0))))) - (GRID:COPY-TO (ELT* M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((0 -112 82) (-39 44 80) (-71 110 -84))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT* M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((84 184 7) (176 86 172) (164 139 252))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT* M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((-2048 -1904 2130) - (-3367 -3796 80) - (-1095 110 8364))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT* M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((1876 440 3591) - (3248 29014 30380) - (5796 23435 21756))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT* M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((-2048 -1904 2130) - (-3367 -3796 80) - (-1095 110 8364))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT* M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((1876 440 3591) - (3248 29014 30380) - (5796 23435 21756))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT* M1 M2))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((-2048 -1904 2130) - (-3367 -3796 80) - (-1095 110 8364))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT* M1 M2))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((1876 440 3591) - (3248 29014 30380) - (5796 23435 21756))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT* M1 M2)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-1474.1849f0 -142.05759f0 142.4899f0) + (143.95161f0 -281.49f0 -131.856f0) + (-2418.1716f0 535.01337f0 -1607.45f0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT :INITIAL-CONTENTS + '((42.73f0 -17.24f0 43.31f0) + (-16.12f0 -8.25f0 21.44f0) + (-49.08f0 -39.66f0 -49.46f0))))) + (GRID:COPY-TO (ELT* 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 + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0))))) + (GRID:COPY-TO (ELT* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((0 -112 82) (-39 44 80) (-71 110 -84))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((84 184 7) (176 86 172) (164 139 252))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-2048 -1904 2130) + (-3367 -3796 80) + (-1095 110 8364))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((1876 440 3591) + (3248 29014 30380) + (5796 23435 21756))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-2048 -1904 2130) + (-3367 -3796 80) + (-1095 110 8364))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT* M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((1876 440 3591) + (3248 29014 30380) + (5796 23435 21756))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT* M1 M2))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-2048 -1904 2130) + (-3367 -3796 80) + (-1095 110 8364))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT* M1 M2))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((1876 440 3591) + (3248 29014 30380) + (5796 23435 21756))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT* M1 M2)))))) diff --git a/tests/matrix-product-nonsquare.lisp b/tests/matrix-product-nonsquare.lisp index 451928f1b14e5a1b0bc051f07a28472b0b43a56c..d8a28910fe7c35ed5d07a5338f2a768184a7e974 100644 --- a/tests/matrix-product-nonsquare.lisp +++ b/tests/matrix-product-nonsquare.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-PRODUCT-NONSQUARE for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,18 +20,18 @@ (LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT-NONSQUARE (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-1488.7347 959.9901) (774.94495 1312.0566))) + (LIST #2A((-1488.7347f0 959.9901f0) (774.94495f0 1312.0566f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15)))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0)))) (M2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((49.27 -13.49) (32.5 42.73) - (-17.24 43.31))))) + '((49.27f0 -13.49f0) (32.5f0 42.73f0) + (-17.24f0 43.31f0))))) (GRID:COPY-TO (MATRIX-PRODUCT M1 M2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -53,24 +53,24 @@ #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(-1422.0259 2305.5098) - #C(-1744.0583 -1092.294)) - (#C(-3459.892 1995.4918) - #C(-3290.4465 -801.0577)))) + #2A((#C(-1422.0259f0 2305.5098f0) + #C(-1744.0583f0 -1092.294f0)) + (#C(-3459.892f0 1995.4918f0) + #C(-3290.4465f0 -801.0577f0)))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))))) (M2 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#C(49.27 -13.49) #C(32.5 42.73)) - (#C(32.5 42.73) #C(-17.24 43.31)) - (#C(-17.24 43.31) #C(-16.12 -8.25)))))) + '((#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0)) + (#C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)) + (#C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0)))))) (GRID:COPY-TO (MATRIX-PRODUCT M1 M2))))) #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/matrix-product-symmetric.lisp b/tests/matrix-product-symmetric.lisp index bab6003626a9d729e4e72150e295eb4714ece2a8..92c9560ff515ebfbc684e37b7d1a689f790bd84a 100644 --- a/tests/matrix-product-symmetric.lisp +++ b/tests/matrix-product-symmetric.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-PRODUCT-SYMMETRIC for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,95 +19,95 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT-SYMMETRIC - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((74519.41 -16747.695 61311.69) - (-3264.9219 6201.1797 -56698.92) - (57711.813 52563.74 65404.063))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((42.73 -17.24 43.31) - (-16.12 -8.25 21.44) - (-49.08 -39.66 -49.46)))) - (M3 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((19.68 -5.55 -8.82) - (25.37 -30.58 31.67) - (29.36 -33.24 -27.03)))) - (S1 -41.67) - (S2 42.0)) - (GRID:COPY-TO - (MATRIX-PRODUCT-SYMMETRIC M1 M2 M3 S1 S2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((74519.41329d0 -16747.696062d0 - 61311.694176000005d0) - (-3264.923076000001d0 6201.180462000002d0 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((74519.41f0 -16747.695f0 61311.69f0) + (-3264.9219f0 6201.1797f0 -56698.92f0) + (57711.813f0 52563.74f0 65404.063f0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '((42.73f0 -17.24f0 43.31f0) + (-16.12f0 -8.25f0 21.44f0) + (-49.08f0 -39.66f0 -49.46f0)))) + (M3 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '((19.68f0 -5.55f0 -8.82f0) + (25.37f0 -30.58f0 31.67f0) + (29.36f0 -33.24f0 -27.03f0)))) + (S1 -41.67f0) + (S2 42.0f0)) + (GRID:COPY-TO + (MATRIX-PRODUCT-SYMMETRIC M1 M2 M3 S1 S2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((74519.41329d0 -16747.696062d0 + 61311.694176000005d0) + (-3264.923076000001d0 6201.180462000002d0 -56698.92695400001d0) - (57711.81710100001d0 52563.740607d0 - 65404.066887d0))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((42.73d0 -17.24d0 43.31d0) - (-16.12d0 -8.25d0 21.44d0) - (-49.08d0 -39.66d0 -49.46d0)))) - (M3 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((19.68d0 -5.55d0 -8.82d0) - (25.37d0 -30.58d0 31.67d0) - (29.36d0 -33.24d0 -27.03d0)))) - (S1 -41.67d0) - (S2 42.0d0)) - (GRID:COPY-TO - (MATRIX-PRODUCT-SYMMETRIC M1 M2 M3 S1 S2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(72971.1 24989.41 -82037.61)) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) - (V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(42.73 -17.24 43.31))) - (V3 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-16.12 -8.25 21.44))) - (S1 -49.08) - (S2 -39.66)) - (GRID:COPY-TO - (MATRIX-PRODUCT-SYMMETRIC M1 V1 V3 S1 S2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #(72971.10171599999d0 24989.409107999996d0 - -82037.597316d0)) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0)))) - (V1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(42.73d0 -17.24d0 43.31d0))) - (V3 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-16.12d0 -8.25d0 21.44d0))) - (S1 -49.08d0) - (S2 -39.66d0)) - (GRID:COPY-TO - (MATRIX-PRODUCT-SYMMETRIC M1 V1 V3 S1 S2)))))) + (57711.81710100001d0 52563.740607d0 + 65404.066887d0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0)))) + (M3 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((19.68d0 -5.55d0 -8.82d0) + (25.37d0 -30.58d0 31.67d0) + (29.36d0 -33.24d0 -27.03d0)))) + (S1 -41.67d0) + (S2 42.0d0)) + (GRID:COPY-TO + (MATRIX-PRODUCT-SYMMETRIC M1 M2 M3 S1 S2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(72971.1f0 24989.41f0 -82037.61f0)) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) + (V1 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '(42.73f0 -17.24f0 43.31f0))) + (V3 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '(-16.12f0 -8.25f0 21.44f0))) + (S1 -49.08f0) + (S2 -39.66f0)) + (GRID:COPY-TO + (MATRIX-PRODUCT-SYMMETRIC M1 V1 V3 S1 S2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(72971.10171599999d0 24989.409107999996d0 + -82037.597316d0)) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (V1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(42.73d0 -17.24d0 43.31d0))) + (V3 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(-16.12d0 -8.25d0 21.44d0))) + (S1 -49.08d0) + (S2 -39.66d0)) + (GRID:COPY-TO + (MATRIX-PRODUCT-SYMMETRIC M1 V1 V3 S1 S2)))))) diff --git a/tests/matrix-product-triangular.lisp b/tests/matrix-product-triangular.lisp index 8b6131ead4861dcd73794cf64e19ce3f5fdcd7ea..db48373800a5301f10f9d3a53f04cbadc321d53e 100644 --- a/tests/matrix-product-triangular.lisp +++ b/tests/matrix-product-triangular.lisp @@ -21,23 +21,23 @@ (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))) + #2A((-34803.82f0 7799.5503f0 -29131.375f0) + (-4884.0327f0 -739.594f0 20382.809f0) + (-31391.57f0 -25366.535f0 -31634.615f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) (M2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((42.73 -17.24 43.31) - (-16.12 -8.25 21.44) - (-49.08 -39.66 -49.46)))) - (S1 19.68)) + '((42.73f0 -17.24f0 43.31f0) + (-16.12f0 -8.25f0 21.44f0) + (-49.08f0 -39.66f0 -49.46f0)))) + (S1 19.68f0)) (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -62,25 +62,25 @@ #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(-66397.9 18986.908) #C(-56335.145 48514.305) #C(-18830.469 -13449.601)) - (#C(38337.09 -49128.918) #C(42681.344 -22972.445) #C(50375.406 -50562.54)) - (#C(42453.223 -42606.086) #C(-13764.868 -48835.813) #C(8910.526 -4389.117)))) + #2A((#C(-66397.9f0 18986.908f0) #C(-56335.145f0 48514.305f0) #C(-18830.469f0 -13449.601f0)) + (#C(38337.09f0 -49128.918f0) #C(42681.344f0 -22972.445f0) #C(50375.406f0 -50562.54f0)) + (#C(42453.223f0 -42606.086f0) #C(-13764.868f0 -48835.813f0) #C(8910.526f0 -4389.117f0)))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) (M2 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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))))) - (S1 #C(19.68 -5.55))) + '((#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)) + (#C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)) + (#C(-49.08f0 -39.66f0) #C(-49.46f0 19.68f0) #C(-5.55f0 -8.82f0))))) + (S1 #C(19.68f0 -5.55f0))) (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1))))) #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL @@ -112,19 +112,19 @@ (S1 #C(19.68d0 -5.55d0))) (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 M2 S1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(-1473.7527 -854.58527 1407.5751)) + (LIST #(-1473.7527f0 -854.58527f0 1407.5751f0)) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) (V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(42.73 -17.24 43.31))) - (S1 -16.12)) + '(42.73f0 -17.24f0 43.31f0))) + (S1 -16.12f0)) (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-1473.7527d0 -854.5853d0 1407.575d0)) @@ -144,22 +144,22 @@ #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #(#C(-1483.223 1289.3523) #C(-57.63159 1675.6711) - #C(-786.3365 -726.9331))) + #(#C(-1483.223f0 1289.3523f0) #C(-57.63159f0 1675.6711f0) + #C(-786.3365f0 -726.9331f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) (V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44)))) - (S1 #C(-16.12 -8.25))) + '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)))) + (S1 #C(-16.12f0 -8.25f0))) (GRID:COPY-TO (MATRIX-PRODUCT-TRIANGULAR M1 V1 S1))))) #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/matrix-product.lisp b/tests/matrix-product.lisp index 9f09852f3c1c64626d1a761c6ee9d8cdaed1344d..3dde525ff22793294160406fe288273b43dd7d15 100644 --- a/tests/matrix-product.lisp +++ b/tests/matrix-product.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-PRODUCT for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,92 +21,92 @@ (LISP-UNIT:DEFINE-TEST MATRIX-PRODUCT (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((74519.41 -16747.695 61311.69) - (27307.273 -6133.5903 -25711.75) - (-29088.719 83072.016 -11019.719))) + #2A((74519.41f0 -16747.695f0 61311.69f0) + (27307.273f0 -6133.5903f0 -25711.75f0) + (-29088.719f0 83072.016f0 -11019.719f0))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT :INITIAL-CONTENTS - '((42.73 -17.24 43.31) - (-16.12 -8.25 21.44) - (-49.08 -39.66 -49.46)))) - (M3 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT :INITIAL-CONTENTS - '((19.68 -5.55 -8.82) - (25.37 -30.58 31.67) - (29.36 -33.24 -27.03)))) - (S1 -41.67) - (S2 42.0)) - (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT :INITIAL-CONTENTS + '((42.73f0 -17.24f0 43.31f0) + (-16.12f0 -8.25f0 21.44f0) + (-49.08f0 -39.66f0 -49.46f0)))) + (M3 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT :INITIAL-CONTENTS + '((19.68f0 -5.55f0 -8.82f0) + (25.37f0 -30.58f0 31.67f0) + (29.36f0 -33.24f0 -27.03f0)))) + (S1 -41.67f0) + (S2 42.0f0)) + (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #2A((74519.41329d0 -16747.696061999995d0 61311.694176d0) (27307.276670999996d0 -6133.589574d0 -25711.752344999997d0) (-29088.718053000033d0 83072.022741d0 -11019.721527000016d0))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((42.73d0 -17.24d0 43.31d0) - (-16.12d0 -8.25d0 21.44d0) - (-49.08d0 -39.66d0 -49.46d0)))) - (M3 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((19.68d0 -5.55d0 -8.82d0) - (25.37d0 -30.58d0 31.67d0) - (29.36d0 -33.24d0 -27.03d0)))) - (S1 -41.67d0) - (S2 42.0d0)) - (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0)))) + (M3 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((19.68d0 -5.55d0 -8.82d0) + (25.37d0 -30.58d0 31.67d0) + (29.36d0 -33.24d0 -27.03d0)))) + (S1 -41.67d0) + (S2 42.0d0)) + (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2))))) #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(140927.64 -143005.16) #C(72986.305 -201162.86) - #C(65956.16 9034.215)) - (#C(-102500.125 118033.82) #C(-147775.0 58489.473) - #C(-9582.236 190719.98)) - (#C(-16551.412 336505.22) #C(-7668.242 385798.25) - #C(45313.527 140641.6)))) + #2A((#C(140927.64f0 -143005.16f0) #C(72986.305f0 -201162.86f0) + #C(65956.16f0 9034.215f0)) + (#C(-102500.125f0 118033.82f0) #C(-147775.0f0 58489.473f0) + #C(-9582.236f0 190719.98f0)) + (#C(-16551.412f0 336505.22f0) #C(-7668.242f0 385798.25f0) + #C(45313.527f0 140641.6f0)))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS - '((#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))))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS - '((#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))))) - (M3 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS - '((#C(19.68 -5.55) #C(-8.82 25.37) #C(-30.58 31.67)) - (#C(25.37 -30.58) #C(31.67 29.36) #C(-33.24 -27.03)) - (#C(29.36 -33.24) #C(-27.03 -41.67) #C(42.0 -20.81))))) - (S1 #C(-41.67 42.0)) - (S2 #C(42.0 -20.81))) - (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX SINGLE-FLOAT) + :INITIAL-CONTENTS + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX SINGLE-FLOAT) + :INITIAL-CONTENTS + '((#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)) + (#C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)) + (#C(-49.08f0 -39.66f0) #C(-49.46f0 19.68f0) #C(-5.55f0 -8.82f0))))) + (M3 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX SINGLE-FLOAT) + :INITIAL-CONTENTS + '((#C(19.68f0 -5.55f0) #C(-8.82f0 25.37f0) #C(-30.58f0 31.67f0)) + (#C(25.37f0 -30.58f0) #C(31.67f0 29.36f0) #C(-33.24f0 -27.03f0)) + (#C(29.36f0 -33.24f0) #C(-27.03f0 -41.67f0) #C(42.0f0 -20.81f0))))) + (S1 #C(-41.67f0 42.0f0)) + (S2 #C(42.0f0 -20.81f0))) + (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2))))) #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -120,98 +120,98 @@ #C(-7668.248943000013d0 385798.22976300004d0) #C(45313.51313299998d0 140641.59851399998d0)))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX DOUBLE-FLOAT) - :INITIAL-CONTENTS - '((#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))))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX DOUBLE-FLOAT) - :INITIAL-CONTENTS - '((#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))))) - (M3 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX DOUBLE-FLOAT) - :INITIAL-CONTENTS - '((#C(19.68d0 -5.55d0) #C(-8.82d0 25.37d0) #C(-30.58d0 31.67d0)) - (#C(25.37d0 -30.58d0) #C(31.67d0 29.36d0) #C(-33.24d0 -27.03d0)) - (#C(29.36d0 -33.24d0) #C(-27.03d0 -41.67d0) #C(42.0d0 -20.81d0))))) - (S1 #C(-41.67d0 42.0d0)) - (S2 #C(42.0d0 -20.81d0))) - (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX DOUBLE-FLOAT) + :INITIAL-CONTENTS + '((#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))))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX DOUBLE-FLOAT) + :INITIAL-CONTENTS + '((#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))))) + (M3 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX DOUBLE-FLOAT) + :INITIAL-CONTENTS + '((#C(19.68d0 -5.55d0) #C(-8.82d0 25.37d0) #C(-30.58d0 31.67d0)) + (#C(25.37d0 -30.58d0) #C(31.67d0 29.36d0) #C(-33.24d0 -27.03d0)) + (#C(29.36d0 -33.24d0) #C(-27.03d0 -41.67d0) #C(42.0d0 -20.81d0))))) + (S1 #C(-41.67d0 42.0d0)) + (S2 #C(42.0d0 -20.81d0))) + (GRID:COPY-TO (MATRIX-PRODUCT M1 M2 M3 S1 S2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(72971.1 60998.137 -184676.98)) + (LIST #(72971.1f0 60998.137f0 -184676.98f0)) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT :INITIAL-CONTENTS - '(42.73 -17.24 43.31))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-16.12 -8.25 21.44))) - (S1 -49.08) - (S2 -39.66)) - (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT :INITIAL-CONTENTS + '(42.73f0 -17.24f0 43.31f0))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT :INITIAL-CONTENTS + '(-16.12f0 -8.25f0 21.44f0))) + (S1 -49.08f0) + (S2 -39.66f0)) + (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(72971.10171599999d0 60998.13393599999d0 -184676.981676d0)) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0)))) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(42.73d0 -17.24d0 43.31d0))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-16.12d0 -8.25d0 21.44d0))) - (S1 -49.08d0) - (S2 -39.66d0)) - (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(42.73d0 -17.24d0 43.31d0))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(-16.12d0 -8.25d0 21.44d0))) + (S1 -49.08d0) + (S2 -39.66d0)) + (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2))))) #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #(#C(124163.57 -3332.2988) #C(119793.48 -166378.0) - #C(-189845.23 -81764.12))) + #(#C(124163.57f0 -3332.2988f0) #C(119793.48f0 -166378.0f0) + #C(-189845.23f0 -81764.12f0))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS - '((#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))))) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS - '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44)))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS - '(#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46)))) - (S1 #C(-49.08 -39.66)) - (S2 #C(-39.66 -49.46))) - (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX SINGLE-FLOAT) + :INITIAL-CONTENTS + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX SINGLE-FLOAT) + :INITIAL-CONTENTS + '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX SINGLE-FLOAT) + :INITIAL-CONTENTS + '(#C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)))) + (S1 #C(-49.08f0 -39.66f0)) + (S2 #C(-39.66f0 -49.46f0))) + (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2))))) #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -219,23 +219,23 @@ #C(119793.47618999999d0 -166378.00423d0) #C(-189845.21679399998d0 -81764.10481799999d0))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX DOUBLE-FLOAT) - :INITIAL-CONTENTS - '((#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))))) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX DOUBLE-FLOAT) - :INITIAL-CONTENTS - '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0)))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX DOUBLE-FLOAT) - :INITIAL-CONTENTS - '(#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0)))) - (S1 #C(-49.08d0 -39.66d0)) - (S2 #C(-39.66d0 -49.46d0))) - (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX DOUBLE-FLOAT) + :INITIAL-CONTENTS + '((#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))))) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX DOUBLE-FLOAT) + :INITIAL-CONTENTS + '(#C(42.73d0 -17.24d0) #C(43.31d0 -16.12d0) #C(-8.25d0 21.44d0)))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX DOUBLE-FLOAT) + :INITIAL-CONTENTS + '(#C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0) #C(-39.66d0 -49.46d0)))) + (S1 #C(-49.08d0 -39.66d0)) + (S2 #C(-39.66d0 -49.46d0))) + (GRID:COPY-TO (MATRIX-PRODUCT M1 V1 V2 S1 S2)))))) diff --git a/tests/matrix-set-all.lisp b/tests/matrix-set-all.lisp index 0cf3ffdf39a3d2d4602b6a4d92f2e9c63b50adde..e87e73c13c2b457c31bbeca14f97eff8cc2dcda1 100644 --- a/tests/matrix-set-all.lisp +++ b/tests/matrix-set-all.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-SET-ALL for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,105 +19,105 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-SET-ALL - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST - #2A((-34.5 -34.5 -34.5) - (-34.5 -34.5 -34.5) - (-34.5 -34.5 -34.5))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(3 3)))) - (GRID:COPY-TO (SET-ALL M1 -34.5))))) - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST - #2A((-34.5d0 -34.5d0 -34.5d0) - (-34.5d0 -34.5d0 -34.5d0) - (-34.5d0 -34.5d0 -34.5d0))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(3 3)))) - (GRID:COPY-TO (SET-ALL M1 -34.5d0))))) - #+fsbv - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST - #2A((#C(-34.5 8.24) #C(-34.5 8.24) #C(-34.5 8.24)) - (#C(-34.5 8.24) #C(-34.5 8.24) #C(-34.5 8.24)) - (#C(-34.5 8.24) #C(-34.5 8.24) #C(-34.5 8.24)))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) - :DIMENSIONS '(3 3)))) - (GRID:COPY-TO (SET-ALL M1 #C(-34.5 8.24)))))) - #+fsbv - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST - #2A((#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0) - #C(-34.5d0 8.24d0)) - (#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0) - #C(-34.5d0 8.24d0)) - (#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0) - #C(-34.5d0 8.24d0)))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT) - :DIMENSIONS '(3 3)))) - (GRID:COPY-TO (SET-ALL M1 #C(-34.5d0 8.24d0)))))) - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS - '(3 3)))) - (GRID:COPY-TO (SET-ALL M1 -64))))) - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST #2A((67 67 67) (67 67 67) (67 67 67))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS - '(3 3)))) - (GRID:COPY-TO (SET-ALL M1 67))))) - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS - '(3 3)))) - (GRID:COPY-TO (SET-ALL M1 -64))))) - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST #2A((67 67 67) (67 67 67) (67 67 67))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS - '(3 3)))) - (GRID:COPY-TO (SET-ALL M1 67))))) - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS - '(3 3)))) - (GRID:COPY-TO (SET-ALL M1 -64))))) - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST #2A((67 67 67) (67 67 67) (67 67 67))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS - '(3 3)))) - (GRID:COPY-TO (SET-ALL M1 67))))) - #+int64 - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS - '(3 3)))) - (GRID:COPY-TO (SET-ALL M1 -64))))) - #+int64 - (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST #2A((67 67 67) (67 67 67) (67 67 67))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS - '(3 3)))) - (GRID:COPY-TO (SET-ALL M1 67)))))) + (LISP-UNIT:ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5f0 -34.5f0 -34.5f0) + (-34.5f0 -34.5f0 -34.5f0) + (-34.5f0 -34.5f0 -34.5f0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(3 3)))) + (GRID:COPY-TO (SET-ALL M1 -34.5f0))))) + (LISP-UNIT:ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5d0 -34.5d0 -34.5d0) + (-34.5d0 -34.5d0 -34.5d0) + (-34.5d0 -34.5d0 -34.5d0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(3 3)))) + (GRID:COPY-TO (SET-ALL M1 -34.5d0))))) + #+fsbv + (LISP-UNIT:ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0)) + (#C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0)) + (#C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0)))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) + :DIMENSIONS '(3 3)))) + (GRID:COPY-TO (SET-ALL M1 #C(-34.5f0 8.24f0)))))) + #+fsbv + (LISP-UNIT:ASSERT-NUMERICAL-EQUAL + (LIST + #2A((#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0) + #C(-34.5d0 8.24d0)) + (#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0) + #C(-34.5d0 8.24d0)) + (#C(-34.5d0 8.24d0) #C(-34.5d0 8.24d0) + #C(-34.5d0 8.24d0)))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX DOUBLE-FLOAT) + :DIMENSIONS '(3 3)))) + (GRID:COPY-TO (SET-ALL M1 #C(-34.5d0 8.24d0)))))) + (LISP-UNIT:ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS + '(3 3)))) + (GRID:COPY-TO (SET-ALL M1 -64))))) + (LISP-UNIT:ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 67 67) (67 67 67) (67 67 67))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS + '(3 3)))) + (GRID:COPY-TO (SET-ALL M1 67))))) + (LISP-UNIT:ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS + '(3 3)))) + (GRID:COPY-TO (SET-ALL M1 -64))))) + (LISP-UNIT:ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 67 67) (67 67 67) (67 67 67))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS + '(3 3)))) + (GRID:COPY-TO (SET-ALL M1 67))))) + (LISP-UNIT:ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS + '(3 3)))) + (GRID:COPY-TO (SET-ALL M1 -64))))) + (LISP-UNIT:ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 67 67) (67 67 67) (67 67 67))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS + '(3 3)))) + (GRID:COPY-TO (SET-ALL M1 67))))) + #+int64 + (LISP-UNIT:ASSERT-NUMERICAL-EQUAL + (LIST #2A((-64 -64 -64) (-64 -64 -64) (-64 -64 -64))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS + '(3 3)))) + (GRID:COPY-TO (SET-ALL M1 -64))))) + #+int64 + (LISP-UNIT:ASSERT-NUMERICAL-EQUAL + (LIST #2A((67 67 67) (67 67 67) (67 67 67))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS + '(3 3)))) + (GRID:COPY-TO (SET-ALL M1 67)))))) diff --git a/tests/matrix-set-zero.lisp b/tests/matrix-set-zero.lisp index 404839e6e55c9016f4637a6fb3f19e922beb5cef..a4ac57c4197a42ec6561f27d07e7b9fe98e44671 100644 --- a/tests/matrix-set-zero.lisp +++ b/tests/matrix-set-zero.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-SET-ZERO for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,14 +20,14 @@ (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))) + (LIST #2A((0.0f0 0.0f0 0.0f0) (0.0f0 0.0f0 0.0f0) (0.0f0 0.0f0 0.0f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) (SET-ZERO M1) (GRID:COPY-TO M1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL @@ -54,9 +54,9 @@ (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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)))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))) (SET-ZERO M1) (GRID:COPY-TO M1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/matrix-standard-deviation-with-fixed-mean.lisp b/tests/matrix-standard-deviation-with-fixed-mean.lisp index 5d828d61f5995a64a8531673d6b48523fb7b4baf..990c48a0f54da54d2a0bf6ea025ddef869e32499 100644 --- a/tests/matrix-standard-deviation-with-fixed-mean.lisp +++ b/tests/matrix-standard-deviation-with-fixed-mean.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-STANDARD-DEVIATION-WITH-FIXED-MEAN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,95 +19,97 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-STANDARD-DEVIATION-WITH-FIXED-MEAN - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 25.290257201025927d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 25.290257236950186d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0))))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 70.39570693980959d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 53.10599696437538d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 70.39570693980959d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 53.10599696437538d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 70.39570693980959d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 53.10599696437538d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 70.39570693980959d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 53.10599696437538d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 25.290257201025927d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 25.290257236950186d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 70.39570693980959d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 53.10599696437538d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 70.39570693980959d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 53.10599696437538d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 70.39570693980959d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 53.10599696437538d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 70.39570693980959d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN M1 (MEAN M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 53.10599696437538d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (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 index a89173a272fef59a4a3ab78ceca4e42ecaa0d18c..3112a4026075b5ee7a6be3f7991bb707fdf74a80 100644 --- a/tests/matrix-standard-deviation-with-mean.lisp +++ b/tests/matrix-standard-deviation-with-mean.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-STANDARD-DEVIATION-WITH-MEAN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,95 +19,97 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-STANDARD-DEVIATION-WITH-MEAN - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 26.824368547196023d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) - (STANDARD-DEVIATION M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 26.82436858529945d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0))))) - (STANDARD-DEVIATION M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 74.66592261534039d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (STANDARD-DEVIATION M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 56.32741586277306d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (STANDARD-DEVIATION M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 74.66592261534039d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (STANDARD-DEVIATION M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 56.32741586277306d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (STANDARD-DEVIATION M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 74.66592261534039d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (STANDARD-DEVIATION M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 56.32741586277306d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (STANDARD-DEVIATION M1 (MEAN M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 74.66592261534039d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (STANDARD-DEVIATION M1 (MEAN M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 56.32741586277306d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (STANDARD-DEVIATION M1 (MEAN M1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.824368547196023d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.82436858529945d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (STANDARD-DEVIATION M1 (MEAN M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (STANDARD-DEVIATION M1 (MEAN M1)))))) diff --git a/tests/matrix-standard-deviation.lisp b/tests/matrix-standard-deviation.lisp index f03008bcc9c3460143d987466006ce755eac2b06..e0409c367d8fb5420e6e1c5ada8b44bfe91f5446 100644 --- a/tests/matrix-standard-deviation.lisp +++ b/tests/matrix-standard-deviation.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-STANDARD-DEVIATION for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,95 +19,97 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-STANDARD-DEVIATION - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 26.824368547196023d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) - (STANDARD-DEVIATION M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 26.82436858529945d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0))))) - (STANDARD-DEVIATION M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 74.66592261534039d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (STANDARD-DEVIATION M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 56.32741586277306d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (STANDARD-DEVIATION M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 74.66592261534039d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (STANDARD-DEVIATION M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 56.32741586277306d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (STANDARD-DEVIATION M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 74.66592261534039d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (STANDARD-DEVIATION M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 56.32741586277306d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (STANDARD-DEVIATION M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 74.66592261534039d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (STANDARD-DEVIATION M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 56.32741586277306d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (STANDARD-DEVIATION M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.824368547196023d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.82436858529945d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (STANDARD-DEVIATION M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (STANDARD-DEVIATION M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 74.66592261534039d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (STANDARD-DEVIATION M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 56.32741586277306d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (STANDARD-DEVIATION M1))))) diff --git a/tests/matrix-sub.lisp b/tests/matrix-sub.lisp index f34a2da4e905f6bd89cf6e248f3d54d9a67d0e8f..8b1421d72b3de0b5e8845b838489e35da26cbff2 100644 --- a/tests/matrix-sub.lisp +++ b/tests/matrix-sub.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-SUB for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,160 +19,164 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-SUB - (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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((42.73 -17.24 43.31) - (-16.12 -8.25 21.44) - (-49.08 -39.66 -49.46))))) - (GRID:COPY-TO (ELT- M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((-77.22999999999999d0 25.479999999999997d0 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-77.229996f0 25.48f0 -40.02f0) + (7.1900005f0 42.37f0 -27.59f0) + (98.350006f0 26.17f0 81.96f0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((42.73f0 -17.24f0 43.31f0) + (-16.12f0 -8.25f0 21.44f0) + (-49.08f0 -39.66f0 -49.46f0))))) + (GRID:COPY-TO (ELT- 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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((42.73d0 -17.24d0 43.31d0) - (-16.12d0 -8.25d0 21.44d0) - (-49.08d0 -39.66d0 -49.46d0))))) - (GRID:COPY-TO (ELT- M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT- M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((39 34 170) (88 241 179) (125 106 132))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT- M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT- M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((39 34 170) (88 65521 65459) (125 106 65412))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT- M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT- M1 M2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((39 34 170) - (88 4294967281 4294967219) - (125 106 4294967172))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT- M1 M2))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (GRID:COPY-TO (ELT- M1 M2))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((39 34 170) - (88 18446744073709551601 18446744073709551539) - (125 106 18446744073709551492))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (GRID:COPY-TO (ELT- M1 M2)))))) + (7.190000000000001d0 42.37d0 + -27.590000000000003d0) + (98.35d0 26.169999999999995d0 + 81.96000000000001d0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0))))) + (GRID:COPY-TO (ELT- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((39 34 170) (88 241 179) (125 106 132))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((39 34 170) (88 65521 65459) (125 106 65412))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT- M1 M2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((39 34 170) + (88 4294967281 4294967219) + (125 106 4294967172))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT- M1 M2))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-96 -96 41) (-128 125 -2) (88 17 55))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (GRID:COPY-TO (ELT- M1 M2))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((39 34 170) + (88 18446744073709551601 18446744073709551539) + (125 106 18446744073709551492))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (GRID:COPY-TO (ELT- M1 M2)))))) diff --git a/tests/matrix-swap.lisp b/tests/matrix-swap.lisp index 7102432173be4c9537c71088bffd74a3291dbcde..d204d7f2966b972ef1d2f0e159bb909a8ef3c1cb 100644 --- a/tests/matrix-swap.lisp +++ b/tests/matrix-swap.lisp @@ -22,27 +22,29 @@ (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)))) + #2A((42.73f0 -17.24f0 43.31f0) + (-16.12f0 -8.25f0 21.44f0) + (-49.08f0 -39.66f0 -49.46f0)) + #2A((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT :INITIAL-CONTENTS - '((42.73 -17.24 43.31) - (-16.12 -8.25 21.44) - (-49.08 -39.66 -49.46))))) - (SWAP M2 M1) - (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((42.73f0 -17.24f0 43.31f0) + (-16.12f0 -8.25f0 21.44f0) + (-49.08f0 -39.66f0 -49.46f0))))) + (SWAP M2 M1) + (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST @@ -53,47 +55,46 @@ (-8.93d0 34.12d0 -6.15d0) (49.27d0 -13.49d0 32.5d0)))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((42.73d0 -17.24d0 43.31d0) - (-16.12d0 -8.25d0 21.44d0) - (-49.08d0 -39.66d0 -49.46d0))))) - (SWAP M2 M1) - (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((42.73d0 -17.24d0 43.31d0) + (-16.12d0 -8.25d0 21.44d0) + (-49.08d0 -39.66d0 -49.46d0))))) + (SWAP M2 M1) + (LIST (GRID:COPY-TO M1) (GRID:COPY-TO 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))))) + #2A((#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)) + (#C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)) + (#C(-49.08f0 -39.66f0) #C(-49.46f0 19.68f0) #C(-5.55f0 -8.82f0))) + #2A((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS - '((#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))))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS - '((#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)))))) - (SWAP M2 M1) - (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX SINGLE-FLOAT) + :INITIAL-CONTENTS + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX SINGLE-FLOAT) + :INITIAL-CONTENTS + '((#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)) + (#C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)) + (#C(-49.08f0 -39.66f0) #C(-49.46f0 19.68f0) #C(-5.55f0 -8.82f0)))))) + (SWAP M2 M1) + (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST @@ -104,156 +105,156 @@ (#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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX DOUBLE-FLOAT) - :INITIAL-CONTENTS - '((#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))))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX DOUBLE-FLOAT) - :INITIAL-CONTENTS - '((#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)))))) - (SWAP M2 M1) - (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX DOUBLE-FLOAT) + :INITIAL-CONTENTS + '((#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))))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX DOUBLE-FLOAT) + :INITIAL-CONTENTS + '((#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)))))) + (SWAP M2 M1) + (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68)) #2A((-64 -68 71) (-91 52 -10) (73 -5 123)))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (SWAP M2 M1) - (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (SWAP M2 M1) + (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST #2A((28 10 19) (28 178 217) (36 109 222)) #2A((67 44 189) (116 163 140) (161 215 98)))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (SWAP M2 M1) - (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (SWAP M2 M1) + (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68)) #2A((-64 -68 71) (-91 52 -10) (73 -5 123)))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (SWAP M2 M1) - (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (SWAP M2 M1) + (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST #2A((28 10 19) (28 178 217) (36 109 222)) #2A((67 44 189) (116 163 140) (161 215 98)))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (SWAP M2 M1) - (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (SWAP M2 M1) + (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST #2A((32 28 30) (37 -73 -8) (-15 -22 68)) #2A((-64 -68 71) (-91 52 -10) (73 -5 123)))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (SWAP M2 M1) - (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (SWAP M2 M1) + (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST (LIST #2A((28 10 19) (28 178 217) (36 109 222)) #2A((67 44 189) (116 163 140) (161 215 98)))) (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (SWAP M2 M1) - (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (SWAP M2 M1) + (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) #+int64 (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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((32 28 30) (37 -73 -8) - (-15 -22 68))))) - (SWAP M2 M1) - (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((32 28 30) (37 -73 -8) + (-15 -22 68))))) + (SWAP M2 M1) + (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2))))) #+int64 (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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((28 10 19) (28 178 217) - (36 109 222))))) - (SWAP M2 M1) - (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))) + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((28 10 19) (28 178 217) + (36 109 222))))) + (SWAP M2 M1) + (LIST (GRID:COPY-TO M1) (GRID:COPY-TO M2)))))) diff --git a/tests/matrix-transpose-copy.lisp b/tests/matrix-transpose-copy.lisp index 181803c49f793639d1a66a596401a3b0df6add29..1c5c094372a6f04399969f64b76f184d0b6fe3c9 100644 --- a/tests/matrix-transpose-copy.lisp +++ b/tests/matrix-transpose-copy.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-TRANSPOSE for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,16 +21,16 @@ (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))) + #2A((-34.5f0 -8.93f0 49.27f0) + (8.24f0 34.12f0 -13.49f0) + (3.29f0 -6.15f0 32.5f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) (M2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(3 3)))) (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2))))) @@ -51,17 +51,17 @@ (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(-34.5 8.24) #C(-8.93 34.12) #C(49.27 -13.49)) - (#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)))) + #2A((#C(-34.5f0 8.24f0) #C(-8.93f0 34.12f0) #C(49.27f0 -13.49f0)) + (#C(3.29f0 -8.93f0) #C(-6.15f0 49.27f0) #C(32.5f0 42.73f0)) + (#C(34.12f0 -6.15f0) #C(-13.49f0 32.5f0) #C(-17.24f0 43.31f0)))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) (M2 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '(3 3)))) (GRID:COPY-TO (MATRIX-TRANSPOSE M1 M2))))) diff --git a/tests/matrix-transpose.lisp b/tests/matrix-transpose.lisp index 78013e6fe8225ded4bf5d291adce35919484b7bd..b2407770a4bdf025add16a8217c3ab2f2248aeb4 100644 --- a/tests/matrix-transpose.lisp +++ b/tests/matrix-transpose.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-TRANSPOSE for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,16 +21,16 @@ (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))) + #2A((-34.5f0 -8.93f0 49.27f0) + (8.24f0 34.12f0 -13.49f0) + (3.29f0 -6.15f0 32.5f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) (GRID:COPY-TO (MATRIX-TRANSPOSE* M1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -47,18 +47,17 @@ (GRID:COPY-TO (MATRIX-TRANSPOSE* M1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(-34.5 8.24) #C(-8.93 34.12) #C(49.27 -13.49)) - (#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)))) + #2A((#C(-34.5f0 8.24f0) #C(-8.93f0 34.12f0) #C(49.27f0 -13.49f0)) + (#C(3.29f0 -8.93f0) #C(-6.15f0 49.27f0) #C(32.5f0 42.73f0)) + (#C(34.12f0 -6.15f0) #C(-13.49f0 32.5f0) #C(-17.24f0 43.31f0)))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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)))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))) (GRID:COPY-TO (MATRIX-TRANSPOSE* M1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST diff --git a/tests/matrix-variance-with-fixed-mean.lisp b/tests/matrix-variance-with-fixed-mean.lisp index 6c66e156cbbc27dec7b7b3bd0a9613dd3031a31b..018852e0168bad94425277c7e48ef5aebc2f3ed6 100644 --- a/tests/matrix-variance-with-fixed-mean.lisp +++ b/tests/matrix-variance-with-fixed-mean.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-VARIANCE-WITH-FIXED-MEAN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,95 +20,97 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-VARIANCE-WITH-FIXED-MEAN - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 639.5971092940438d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) - (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 639.5971111111112d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0))))) - (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 4955.555555555556d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 2820.246913580247d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 4955.555555555556d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 2820.246913580247d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 4955.555555555556d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 2820.246913580247d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 4955.555555555556d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 2820.246913580247d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 639.5971092940438d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 639.5971111111112d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4955.555555555556d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2820.246913580247d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4955.555555555556d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2820.246913580247d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4955.555555555556d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2820.246913580247d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4955.555555555556d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 2820.246913580247d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (VARIANCE-WITH-FIXED-MEAN M1 (MEAN M1)))))) diff --git a/tests/matrix-variance-with-mean.lisp b/tests/matrix-variance-with-mean.lisp index 4c376ae3105d17a81b6e19c5ace9251eb31a5e94..ec72c61800e129ea85ea48e9fdd0c910d3250f03 100644 --- a/tests/matrix-variance-with-mean.lisp +++ b/tests/matrix-variance-with-mean.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-VARIANCE-WITH-MEAN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,124 +19,126 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-VARIANCE-WITH-MEAN - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 719.5467479557992d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) - (VARIANCE M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 719.5467500000001d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0))))) - (VARIANCE M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (VARIANCE M1 - (MEAN - M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 3172.777777777778d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (VARIANCE M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (VARIANCE M1 - (MEAN - M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 3172.777777777778d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (VARIANCE M1 (MEAN M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (VARIANCE M1 - (MEAN - M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 3172.777777777778d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (VARIANCE M1 (MEAN M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (VARIANCE M1 - (MEAN - M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 3172.777777777778d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (VARIANCE M1 (MEAN M1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.5467479557992d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (VARIANCE M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.5467500000001d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))))) + (VARIANCE M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (VARIANCE M1 + (MEAN + M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (VARIANCE M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (VARIANCE M1 + (MEAN + M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (VARIANCE M1 (MEAN M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (VARIANCE M1 + (MEAN + M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (VARIANCE M1 (MEAN M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (VARIANCE M1 + (MEAN + M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (VARIANCE M1 (MEAN M1)))))) diff --git a/tests/matrix-variance.lisp b/tests/matrix-variance.lisp index db95eafb16798d294dee4a77355f299425a0864b..c5744bd7880ac32126d46d6fdda295895c6821e2 100644 --- a/tests/matrix-variance.lisp +++ b/tests/matrix-variance.lisp @@ -1,6 +1,6 @@ ;; Regression test MATRIX-VARIANCE for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,116 +19,118 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST MATRIX-VARIANCE - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 719.5467479557992d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) - (VARIANCE M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 719.5467500000001d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0))))) - (VARIANCE M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (VARIANCE M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 3172.777777777778d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (VARIANCE M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (VARIANCE M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 3172.777777777778d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (VARIANCE M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (VARIANCE M1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 3172.777777777778d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (VARIANCE M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '((-64 -68 - 71) - (-91 52 - -10) - (73 -5 - 123))))) - (VARIANCE M1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 3172.777777777778d0) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (VARIANCE M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.5467479557992d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.5467500000001d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (VARIANCE M1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (VARIANCE M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 5575.0d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '((-64 -68 + 71) + (-91 52 + -10) + (73 -5 + 123))))) + (VARIANCE M1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3172.777777777778d0) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (VARIANCE M1))))) diff --git a/tests/permutation.lisp b/tests/permutation.lisp index 435f0eb7b96ad6043114d36b043bc104f9e68b5e..a6ee02a9d420a60611b7613ee10f8c92355ebc8d 100644 --- a/tests/permutation.lisp +++ b/tests/permutation.lisp @@ -23,7 +23,7 @@ (LIST 2) (MULTIPLE-VALUE-LIST (LET ((PERM-1 (MAKE-PERMUTATION 4 T))) - (grid:gref PERM-1 2)))) + (grid:aref PERM-1 2)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 1 2 3)) (MULTIPLE-VALUE-LIST diff --git a/tests/rank-1-update.lisp b/tests/rank-1-update.lisp index 0214352f4611da05f26312aa362b7cdf0e523346..b522c047dd2d71ebe035ffa1259f39187c462b4b 100644 --- a/tests/rank-1-update.lisp +++ b/tests/rank-1-update.lisp @@ -1,26 +1,42 @@ ;; Regression test RANK-1-UPDATE for GSLL, automatically generated +;; +;; Copyright 2009, 2011 Liam M. Healy +;; Distributed under the terms of the GNU General Public License +;; +;; This program is free software: you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. +;; +;; This program is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. +;; +;; You should have received a copy of the GNU General Public License +;; along with this program. If not, see <http://www.gnu.org/licenses/>. (in-package :gsl) (LISP-UNIT:DEFINE-TEST RANK-1-UPDATE (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST - #2A((33772.18 17310.045 -44960.434) - (-13648.694 -6946.5283 18135.074) - (34314.832 17523.164 -45541.547))) + #2A((33772.18f0 17310.045f0 -44960.434f0) + (-13648.694f0 -6946.5283f0 18135.074f0) + (34314.832f0 17523.164f0 -45541.547f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) (V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(42.73 -17.24 43.31))) + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(42.73f0 -17.24f0 43.31f0))) (V2 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-16.12 -8.25 21.44))) - (S1 -49.08)) + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-16.12f0 -8.25f0 21.44f0))) + (S1 -49.08f0)) (GRID:COPY-TO (RANK-1-UPDATE S1 V1 V2 M1))))) (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST @@ -43,31 +59,31 @@ (GRID:COPY-TO (RANK-1-UPDATE S1 V1 V2 M1))))) (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(37793.65 36629.23) #C(-101265.76 118286.42) - #C(68357.26 171191.28)) - (#C(36918.79 37780.418) #C(-104760.06 115889.945) - #C(63820.45 173533.31)) - (#C(-26166.797 1319.2356) #C(-8642.514 -77109.22) - #C(-85661.76 -33283.21)))) + #2A((#C(37793.65f0 36629.23f0) #C(-101265.76f0 118286.42f0) + #C(68357.26f0 171191.28f0)) + (#C(36918.79f0 37780.418f0) #C(-104760.06f0 115889.945f0) + #C(63820.45f0 173533.31f0)) + (#C(-26166.797f0 1319.2356f0) #C(-8642.514f0 -77109.22f0) + #C(-85661.76f0 -33283.21f0)))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) (V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44)))) + '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)))) (V2 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-16.12 -8.25) #C(21.44 -49.08) #C(-39.66 -49.46)))) - (S1 #C(-49.08 -39.66))) + '(#C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0) #C(-39.66f0 -49.46f0)))) + (S1 #C(-49.08f0 -39.66f0))) (GRID:COPY-TO (RANK-1-UPDATE S1 V1 V2 M1))))) (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST diff --git a/tests/row.lisp b/tests/row.lisp index abda2bbb8deafbe8ddf34699e71e14d32cc86a46..9440c8dc446c434df00844fb6938453d87f72b18 100644 --- a/tests/row.lisp +++ b/tests/row.lisp @@ -1,6 +1,6 @@ ;; Regression test ROW for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,15 +20,15 @@ (LISP-UNIT:DEFINE-TEST ROW (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(-8.93 34.12 -6.15)) + (LIST #(-8.93f0 34.12f0 -6.15f0)) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) (ROW (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3))) (GRID:COPY-TO (ROW M1 1 ROW))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL @@ -45,15 +45,15 @@ (GRID:COPY-TO (ROW M1 1 ROW))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))) + #(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) (ROW (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3))) diff --git a/tests/scale.lisp b/tests/scale.lisp index 5055a6c9c217bb68766ff0c1bd0777774603945e..4826c303e24e7374c71cba40f99a11bfbaa5e7a7 100644 --- a/tests/scale.lisp +++ b/tests/scale.lisp @@ -1,6 +1,6 @@ ;; Regression test SCALE for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,19 +21,19 @@ (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))) + #(#C(-1121.25f0 267.8f0) #C(106.924995f0 -290.225f0) + #C(1108.9f0 -199.875f0) #C(1601.275f0 -438.425f0) + #C(1056.25f0 1388.725f0) #C(-560.3f0 1407.5751f0) + #C(-523.9f0 -268.125f0) #C(696.8f0 -1595.1001f0))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) - #C(49.27 -13.49) #C(32.5 42.73) - #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))) - (SCALAR 32.5)) + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0) + #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) + #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))) + (SCALAR 32.5f0)) (GRID:COPY-TO (SCALE SCALAR V1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -54,14 +54,14 @@ (SCALAR 32.5d0)) (GRID:COPY-TO (SCALE SCALAR V1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(-1121.25 267.8 106.924995 -290.225 1108.9 -199.875 1601.275 -438.425)) + (LIST #(-1121.25f0 267.8f0 106.924995f0 -290.225f0 1108.9f0 -199.875f0 1601.275f0 -438.425f0)) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49))) - (SCALAR 32.5)) + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))) + (SCALAR 32.5f0)) (GRID:COPY-TO (SCALE SCALAR V1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -79,19 +79,19 @@ #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #(#C(-1473.3452 -1206.385) #C(488.5039 -149.64331) - #C(1371.6895 1258.0725) #C(2177.7026 1666.8821) - #C(-769.6029 2777.45) #C(-2410.9363 670.9099) - #C(-171.37753 -956.9326) #C(2793.9885 -678.9689))) + #(#C(-1473.3452f0 -1206.385f0) #C(488.5039f0 -149.64331f0) + #C(1371.6895f0 1258.0725f0) #C(2177.7026f0 1666.8821f0) + #C(-769.6029f0 2777.45f0) #C(-2410.9363f0 670.9099f0) + #C(-171.37753f0 -956.9326f0) #C(2793.9885f0 -678.9689f0))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) - #C(49.27 -13.49) #C(32.5 42.73) - #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08)))) - (SCALAR #C(32.5 42.73))) + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0) + #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) + #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0)))) + (SCALAR #C(32.5f0 42.73f0))) (GRID:COPY-TO (SCALE SCALAR V1))))) #+fsbv (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/set-basis.lisp b/tests/set-basis.lisp index ab80bdf3d26a56eaf65408a646e6c4645a3a0bcb..3571e72b05fed0db43413cf5c2c7eb8a7f9d2c5f 100644 --- a/tests/set-basis.lisp +++ b/tests/set-basis.lisp @@ -1,6 +1,6 @@ ;; Regression test SET-BASIS for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,13 +20,13 @@ (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)) + (LIST #(0.0f0 0.0f0 1.0f0 0.0f0 0.0f0 0.0f0 0.0f0 0.0f0)) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)))) + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) (SET-BASIS V1 2) (GRID:COPY-TO V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL @@ -42,16 +42,16 @@ (GRID:COPY-TO V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #(#C(0.0 0.0) #C(0.0 0.0) #C(1.0 0.0) #C(0.0 0.0) - #C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0))) + #(#C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(1.0f0 0.0f0) #C(0.0f0 0.0f0) + #C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(0.0f0 0.0f0))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) - #C(34.12 -6.15) #C(49.27 -13.49) #C(32.5 42.73) - #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))) + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) + #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) + #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))) (SET-BASIS V1 2) (GRID:COPY-TO V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/set-identity.lisp b/tests/set-identity.lisp index 97e06458ea1636decc64fbf511b64cc9f12a385e..d2b401db65688c36e4197cfa2697767d4f746416 100644 --- a/tests/set-identity.lisp +++ b/tests/set-identity.lisp @@ -1,6 +1,6 @@ ;; Regression test SET-IDENTITY for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,15 +20,15 @@ (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))) + (LIST #2A((1.0f0 0.0f0 0.0f0) (0.0f0 1.0f0 0.0f0) (0.0f0 0.0f0 1.0f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) (GRID:COPY-TO (SET-IDENTITY M1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -46,17 +46,17 @@ (GRID:COPY-TO (SET-IDENTITY M1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(1.0 0.0) #C(0.0 0.0) #C(0.0 0.0)) - (#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)))) + #2A((#C(1.0f0 0.0f0) #C(0.0f0 0.0f0) #C(0.0f0 0.0f0)) + (#C(0.0f0 0.0f0) #C(1.0f0 0.0f0) #C(0.0f0 0.0f0)) + (#C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(1.0f0 0.0f0)))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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)))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))) (GRID:COPY-TO (SET-IDENTITY M1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST diff --git a/tests/setf-column.lisp b/tests/setf-column.lisp index 91b5ede0883a2b413dfb29090b35446c62787352..55a5691b3f0cb6baef7db0435205e4a41984eb8a 100644 --- a/tests/setf-column.lisp +++ b/tests/setf-column.lisp @@ -1,6 +1,6 @@ ;; Regression test SETF-COLUMN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,20 +21,20 @@ (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))) + #2A((-34.5f0 8.24f0 42.73f0) + (-8.93f0 34.12f0 -17.24f0) + (49.27f0 -13.49f0 43.31f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) (COL (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(42.73 -17.24 43.31)))) + '(42.73f0 -17.24f0 43.31f0)))) (SETF (COLUMN M1 2) COL) (GRID:COPY-TO M1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL @@ -57,22 +57,22 @@ (GRID:COPY-TO M1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(42.73 -17.24)) - (#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)))) + #2A((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(42.73f0 -17.24f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(43.31f0 -16.12f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-8.25f0 21.44f0)))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) (COL (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))))) + '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0))))) (SETF (COLUMN M1 2) COL) (GRID:COPY-TO M1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/setf-row.lisp b/tests/setf-row.lisp index 688a0c9b45bf5cd8f2d44eaf553270a2124d01bd..a469859323742c5838dd42e6a4e7f362ee02bbcd 100644 --- a/tests/setf-row.lisp +++ b/tests/setf-row.lisp @@ -1,6 +1,6 @@ ;; Regression test SETF-ROW for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,21 +21,21 @@ (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))) + #2A((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (42.73f0 -17.24f0 43.31f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) (ROW (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT - :INITIAL-CONTENTS '(42.73 -17.24 43.31)))) + :INITIAL-CONTENTS '(42.73f0 -17.24f0 43.31f0)))) (SETF (ROW M1 2) ROW) (GRID:COPY-TO M1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL @@ -59,22 +59,21 @@ (GRID:COPY-TO M1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)) - (#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)))) + #2A((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0)))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0))))) (ROW (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS '(#C(42.73 -17.24) #C(43.31 -16.12) #C(-8.25 21.44))))) + :INITIAL-CONTENTS '(#C(42.73f0 -17.24f0) #C(43.31f0 -16.12f0) #C(-8.25f0 21.44f0))))) (SETF (ROW M1 2) ROW) (GRID:COPY-TO M1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/sort-matrix-largest.lisp b/tests/sort-matrix-largest.lisp index e2c737000cf3e20eed1ba4e77f7b42cf353582be..0703f60320eed8f61c66481b80317279cf6ddf48 100644 --- a/tests/sort-matrix-largest.lisp +++ b/tests/sort-matrix-largest.lisp @@ -1,6 +1,6 @@ ;; Regression test SORT-MATRIX-LARGEST for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,124 +19,126 @@ (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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3)))) - (GRID:COPY-TO (SORT-LARGEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #2A((49.27d0 34.12d0 32.5d0) (8.24d0 3.29d0 -6.15d0))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 3)))) - (GRID:COPY-TO (SORT-LARGEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((123 73 71) (52 -5 -10))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-LARGEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((215 189 163) (161 140 116))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-LARGEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((123 73 71) (52 -5 -10))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-LARGEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((215 189 163) (161 140 116))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-LARGEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((123 73 71) (52 -5 -10))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-LARGEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((215 189 163) (161 140 116))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-LARGEST M2 M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((123 73 71) (52 -5 -10))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-LARGEST M2 M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((215 189 163) (161 140 116))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-LARGEST M2 M1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((49.27f0 34.12f0 32.5f0) (8.24f0 3.29f0 -6.15f0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3)))) + (GRID:COPY-TO (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((49.27d0 34.12d0 32.5d0) (8.24d0 3.29d0 -6.15d0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 3)))) + (GRID:COPY-TO (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((123 73 71) (52 -5 -10))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((215 189 163) (161 140 116))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((123 73 71) (52 -5 -10))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((215 189 163) (161 140 116))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((123 73 71) (52 -5 -10))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-LARGEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((215 189 163) (161 140 116))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-LARGEST M2 M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((123 73 71) (52 -5 -10))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-LARGEST M2 M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((215 189 163) (161 140 116))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-LARGEST M2 M1)))))) diff --git a/tests/sort-matrix-smallest.lisp b/tests/sort-matrix-smallest.lisp index 36e10a61e0cc82be7da37800d290e15bf437eefa..8e7ef7ad21daffb66bfbf9762ccdeccc2728aeaf 100644 --- a/tests/sort-matrix-smallest.lisp +++ b/tests/sort-matrix-smallest.lisp @@ -1,6 +1,6 @@ ;; Regression test SORT-MATRIX-SMALLEST for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,125 +19,126 @@ (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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3)))) - (GRID:COPY-TO (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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 3)))) - (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-91 -68 -64) (-10 -5 52))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((44 67 98) (116 140 161))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-91 -68 -64) (-10 -5 52))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((44 67 98) (116 140 161))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-91 -68 -64) (-10 -5 52))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((44 67 98) (116 140 161))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-91 -68 -64) (-10 -5 52))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((44 67 98) (116 140 161))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98)))) - (M2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS - '(2 3)))) - (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-34.5f0 -13.49f0 -8.93f0) (-6.15f0 3.29f0 8.24f0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '(2 3)))) + (GRID:COPY-TO (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 + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :DIMENSIONS '(2 3)))) + (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-SMALLEST M2 M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98)))) + (M2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) :DIMENSIONS + '(2 3)))) + (GRID:COPY-TO (SORT-SMALLEST M2 M1)))))) diff --git a/tests/sort-matrix.lisp b/tests/sort-matrix.lisp index 90cb6129e372f995369d01e6e542819b3764e9e2..a79066b040721dab794259e1289ae8967feb790a 100644 --- a/tests/sort-matrix.lisp +++ b/tests/sort-matrix.lisp @@ -1,6 +1,6 @@ ;; Regression test SORT-MATRIX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,101 +19,103 @@ (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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) - (GRID:COPY-TO (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 - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '((-34.5d0 8.24d0 3.29d0) - (-8.93d0 34.12d0 -6.15d0) - (49.27d0 -13.49d0 32.5d0))))) - (GRID:COPY-TO (MSORT M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (GRID:COPY-TO (MSORT M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((44 67 98) (116 140 161) (163 189 215))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (GRID:COPY-TO (MSORT M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (GRID:COPY-TO (MSORT M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((44 67 98) (116 140 161) (163 189 215))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (GRID:COPY-TO (MSORT M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (GRID:COPY-TO (MSORT M1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((44 67 98) (116 140 161) (163 189 215))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (GRID:COPY-TO (MSORT M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '((-64 -68 71) (-91 52 -10) - (73 -5 123))))) - (GRID:COPY-TO (MSORT M1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #2A((44 67 98) (116 140 161) (163 189 215))) - (MULTIPLE-VALUE-LIST - (LET ((M1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '((67 44 189) (116 163 140) - (161 215 98))))) - (GRID:COPY-TO (MSORT M1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #2A((-34.5f0 -13.49f0 -8.93f0) + (-6.15f0 3.29f0 8.24f0) + (32.5f0 34.12f0 49.27f0))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) + (GRID:COPY-TO (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 + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '((-34.5d0 8.24d0 3.29d0) + (-8.93d0 34.12d0 -6.15d0) + (49.27d0 -13.49d0 32.5d0))))) + (GRID:COPY-TO (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (GRID:COPY-TO (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161) (163 189 215))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (GRID:COPY-TO (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (GRID:COPY-TO (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161) (163 189 215))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (GRID:COPY-TO (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (GRID:COPY-TO (MSORT M1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161) (163 189 215))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (GRID:COPY-TO (MSORT M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((-91 -68 -64) (-10 -5 52) (71 73 123))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '((-64 -68 71) (-91 52 -10) + (73 -5 123))))) + (GRID:COPY-TO (MSORT M1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #2A((44 67 98) (116 140 161) (163 189 215))) + (MULTIPLE-VALUE-LIST + (LET ((M1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '((67 44 189) (116 163 140) + (161 215 98))))) + (GRID:COPY-TO (MSORT M1)))))) diff --git a/tests/sort-vector-index.lisp b/tests/sort-vector-index.lisp index dd0dc70d438d623cfbf414356752a17ed0d593f0..16819a9aa29789cd5899627db93dcf61aa497f5f 100644 --- a/tests/sort-vector-index.lisp +++ b/tests/sort-vector-index.lisp @@ -1,6 +1,6 @@ ;; Regression test SORT-VECTOR-INDEX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,106 +19,106 @@ (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 - (LET ((PERM (MAKE-PERMUTATION 8)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 - -6.15 49.27 -13.49)))) - (SORT-VECTOR-INDEX PERM V1) - (GRID:COPY-TO PERM)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(0 7 3 5 2 1 4 6)) - (MULTIPLE-VALUE-LIST - (LET ((PERM (MAKE-PERMUTATION 8)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0 -8.93d0 - 34.12d0 -6.15d0 49.27d0 - -13.49d0)))) - (SORT-VECTOR-INDEX PERM V1) - (GRID:COPY-TO PERM)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(3 1 0 5 7 4 2 6)) - (MULTIPLE-VALUE-LIST - (LET ((PERM (MAKE-PERMUTATION 8)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (SORT-VECTOR-INDEX PERM V1) - (GRID:COPY-TO PERM)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(1 0 3 5 6 4 2 7)) - (MULTIPLE-VALUE-LIST - (LET ((PERM (MAKE-PERMUTATION 8)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (SORT-VECTOR-INDEX PERM V1) - (GRID:COPY-TO PERM)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(3 1 0 5 7 4 2 6)) - (MULTIPLE-VALUE-LIST - (LET ((PERM (MAKE-PERMUTATION 8)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (SORT-VECTOR-INDEX PERM V1) - (GRID:COPY-TO PERM)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(1 0 3 5 6 4 2 7)) - (MULTIPLE-VALUE-LIST - (LET ((PERM (MAKE-PERMUTATION 8)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (SORT-VECTOR-INDEX PERM V1) - (GRID:COPY-TO PERM)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(3 1 0 5 7 4 2 6)) - (MULTIPLE-VALUE-LIST - (LET ((PERM (MAKE-PERMUTATION 8)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (SORT-VECTOR-INDEX PERM V1) - (GRID:COPY-TO PERM)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(1 0 3 5 6 4 2 7)) - (MULTIPLE-VALUE-LIST - (LET ((PERM (MAKE-PERMUTATION 8)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (SORT-VECTOR-INDEX PERM V1) - (GRID:COPY-TO PERM)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(3 1 0 5 7 4 2 6)) - (MULTIPLE-VALUE-LIST - (LET ((PERM (MAKE-PERMUTATION 8)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (SORT-VECTOR-INDEX PERM V1) - (GRID:COPY-TO PERM)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(1 0 3 5 6 4 2 7)) - (MULTIPLE-VALUE-LIST - (LET ((PERM (MAKE-PERMUTATION 8)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (SORT-VECTOR-INDEX PERM V1) - (GRID:COPY-TO PERM))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 7 3 5 2 1 4 6)) + (MULTIPLE-VALUE-LIST + (LET ((PERM (MAKE-PERMUTATION 8)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (SORT-VECTOR-INDEX PERM V1) + (GRID:COPY-TO PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 7 3 5 2 1 4 6)) + (MULTIPLE-VALUE-LIST + (LET ((PERM (MAKE-PERMUTATION 8)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0)))) + (SORT-VECTOR-INDEX PERM V1) + (GRID:COPY-TO PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(3 1 0 5 7 4 2 6)) + (MULTIPLE-VALUE-LIST + (LET ((PERM (MAKE-PERMUTATION 8)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (SORT-VECTOR-INDEX PERM V1) + (GRID:COPY-TO PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(1 0 3 5 6 4 2 7)) + (MULTIPLE-VALUE-LIST + (LET ((PERM (MAKE-PERMUTATION 8)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (SORT-VECTOR-INDEX PERM V1) + (GRID:COPY-TO PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(3 1 0 5 7 4 2 6)) + (MULTIPLE-VALUE-LIST + (LET ((PERM (MAKE-PERMUTATION 8)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (SORT-VECTOR-INDEX PERM V1) + (GRID:COPY-TO PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(1 0 3 5 6 4 2 7)) + (MULTIPLE-VALUE-LIST + (LET ((PERM (MAKE-PERMUTATION 8)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (SORT-VECTOR-INDEX PERM V1) + (GRID:COPY-TO PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(3 1 0 5 7 4 2 6)) + (MULTIPLE-VALUE-LIST + (LET ((PERM (MAKE-PERMUTATION 8)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (SORT-VECTOR-INDEX PERM V1) + (GRID:COPY-TO PERM)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(1 0 3 5 6 4 2 7)) + (MULTIPLE-VALUE-LIST + (LET ((PERM (MAKE-PERMUTATION 8)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (SORT-VECTOR-INDEX PERM V1) + (GRID:COPY-TO PERM)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(3 1 0 5 7 4 2 6)) + (MULTIPLE-VALUE-LIST + (LET ((PERM (MAKE-PERMUTATION 8)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (SORT-VECTOR-INDEX PERM V1) + (GRID:COPY-TO PERM)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(1 0 3 5 6 4 2 7)) + (MULTIPLE-VALUE-LIST + (LET ((PERM (MAKE-PERMUTATION 8)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (SORT-VECTOR-INDEX PERM V1) + (GRID:COPY-TO PERM))))) diff --git a/tests/sort-vector-largest-index.lisp b/tests/sort-vector-largest-index.lisp index 3e2c0e76c411e852421f7520b540967d1999b1d2..01d7bbaa163c3cfd524254943dea2081f8cf7af6 100644 --- a/tests/sort-vector-largest-index.lisp +++ b/tests/sort-vector-largest-index.lisp @@ -1,6 +1,6 @@ ;; Regression test SORT-VECTOR-LARGEST-INDEX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,176 +19,170 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST SORT-VECTOR-LARGEST-INDEX - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 4 1)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS - '(-34.5 8.24 - 3.29 -8.93 - 34.12 - -6.15 - 49.27 - -13.49)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 4 1)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '(-34.5d0 - 8.24d0 - 3.29d0 - -8.93d0 - 34.12d0 - -6.15d0 - 49.27d0 - -13.49d0)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST-INDEX - COMB V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST-INDEX - COMB V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST-INDEX - COMB V1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(6 4 1)) + (MULTIPLE-VALUE-LIST + (LET ((COMB (MAKE-COMBINATION 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 4 1)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '(-34.5d0 + 8.24d0 + 3.29d0 + -8.93d0 + 34.12d0 + -6.15d0 + 49.27d0 + -13.49d0)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(6 2 4)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST-INDEX + COMB V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(7 2 4)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST-INDEX + COMB V1)))))) diff --git a/tests/sort-vector-largest.lisp b/tests/sort-vector-largest.lisp index 0b6fc92dcf549853201dc0a2d9da90e0dfc373f4..30b528f1d39c3a93490e1d691f744cd09a08a2e9 100644 --- a/tests/sort-vector-largest.lisp +++ b/tests/sort-vector-largest.lisp @@ -1,6 +1,6 @@ ;; Regression test SORT-VECTOR-LARGEST for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,193 +19,194 @@ (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 - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 - -6.15 49.27 -13.49))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(32.5 42.73 -17.24)))) - (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(49.27d0 34.12d0 8.24d0)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0 -8.93d0 - 34.12d0 -6.15d0 49.27d0 - -13.49d0))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(32.5d0 42.73d0 -17.24d0)))) - (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(123 32 - 28)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST - V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(98 28 - 10)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST - V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(123 32 - 28)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST - V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(98 28 - 10)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST - V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(123 32 - 28)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST - V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(98 28 - 10)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST - V2 V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(123 32 - 28)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST - V2 V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(98 28 - 10)))) - (GRID:COPY-TO - (SORT-VECTOR-LARGEST - V2 V1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(49.27f0 34.12f0 8.24f0)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS '(32.5f0 42.73f0 -17.24f0)))) + (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(49.27d0 34.12d0 8.24d0)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 + 34.12d0 -6.15d0 49.27d0 + -13.49d0))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(32.5d0 42.73d0 -17.24d0)))) + (GRID:COPY-TO (SORT-VECTOR-LARGEST V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(123 32 + 28)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(98 28 + 10)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(123 32 + 28)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(98 28 + 10)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(123 32 + 28)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(98 28 + 10)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST + V2 V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(73 71 52)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(123 32 + 28)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST + V2 V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 189 163)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(98 28 + 10)))) + (GRID:COPY-TO + (SORT-VECTOR-LARGEST + V2 V1)))))) diff --git a/tests/sort-vector-smallest-index.lisp b/tests/sort-vector-smallest-index.lisp index 1aede641df89f116dc9fd61a5327354e0e3352d9..078279d0f41d0e2915053b212f388f1695df65aa 100644 --- a/tests/sort-vector-smallest-index.lisp +++ b/tests/sort-vector-smallest-index.lisp @@ -1,6 +1,6 @@ ;; Regression test SORT-VECTOR-SMALLEST-INDEX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,176 +19,168 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST SORT-VECTOR-SMALLEST-INDEX - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 7 3)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS - '(-34.5 8.24 - 3.29 -8.93 - 34.12 - -6.15 - 49.27 - -13.49)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 7 3)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '(-34.5d0 - 8.24d0 - 3.29d0 - -8.93d0 - 34.12d0 - -6.15d0 - 49.27d0 - -13.49d0)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST-INDEX - COMB V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST-INDEX - COMB V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST-INDEX - COMB V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) - (MULTIPLE-VALUE-LIST - (LET ((COMB - (MAKE-COMBINATION - 8 3 NIL)) - (V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST-INDEX - COMB V1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(0 7 3)) + (MULTIPLE-VALUE-LIST + (LET ((COMB (MAKE-COMBINATION 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (GRID:COPY-TO (SORT-VECTOR-SMALLEST-INDEX COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(0 7 3)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '(-34.5d0 + 8.24d0 + 3.29d0 + -8.93d0 + 34.12d0 + -6.15d0 + 49.27d0 + -13.49d0)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(3 1 0)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST-INDEX + COMB V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(1 0 3)) + (MULTIPLE-VALUE-LIST + (LET ((COMB + (MAKE-COMBINATION + 8 3 NIL)) + (V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST-INDEX + COMB V1)))))) diff --git a/tests/sort-vector-smallest.lisp b/tests/sort-vector-smallest.lisp index 485b04c68fd7b231328fec5d3a44a289fd2f4f3d..99594965ac4ad8637861abbb3d009ffaa9ff3334 100644 --- a/tests/sort-vector-smallest.lisp +++ b/tests/sort-vector-smallest.lisp @@ -1,6 +1,6 @@ ;; Regression test SORT-VECTOR-SMALLEST for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,193 +19,195 @@ (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 - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 - -6.15 49.27 -13.49))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(32.5 42.73 -17.24)))) - (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(-34.5d0 -13.49d0 -8.93d0)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0 -8.93d0 - 34.12d0 -6.15d0 49.27d0 - -13.49d0))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(32.5d0 42.73d0 -17.24d0)))) - (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(123 32 - 28)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST - V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(98 28 - 10)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST - V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(123 32 - 28)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST - V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(98 28 - 10)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST - V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(123 32 - 28)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST - V2 V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(98 28 - 10)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST - V2 V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(123 32 - 28)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST - V2 V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(98 28 - 10)))) - (GRID:COPY-TO - (SORT-VECTOR-SMALLEST - V2 V1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-34.5f0 -13.49f0 -8.93f0)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS '(32.5f0 42.73f0 -17.24f0)))) + (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-34.5d0 -13.49d0 -8.93d0)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 + 34.12d0 -6.15d0 49.27d0 + -13.49d0))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(32.5d0 42.73d0 -17.24d0)))) + (GRID:COPY-TO (SORT-VECTOR-SMALLEST V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(123 32 + 28)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(98 28 + 10)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(123 32 + 28)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(98 28 + 10)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(123 32 + 28)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST + V2 V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(98 28 + 10)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST + V2 V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-91 -68 -64)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(123 32 + 28)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST + V2 V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(44 67 116)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(98 28 + 10)))) + (GRID:COPY-TO + (SORT-VECTOR-SMALLEST + V2 V1)))))) diff --git a/tests/sort-vector.lisp b/tests/sort-vector.lisp index b101ffff7aad09d2799d5543c308ae90393b330c..deb0ad0f74e967f6da8ded50900a6a1eaaca6bc5 100644 --- a/tests/sort-vector.lisp +++ b/tests/sort-vector.lisp @@ -1,6 +1,6 @@ ;; Regression test SORT-VECTOR for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,89 +19,89 @@ (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 - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 - -6.15 49.27 -13.49)))) - (GRID:COPY-TO (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 - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0 -8.93d0 - 34.12d0 -6.15d0 49.27d0 - -13.49d0)))) - (GRID:COPY-TO (SORT-VECTOR V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(-91 -68 -64 -10 -5 52 71 73)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (GRID:COPY-TO (SORT-VECTOR V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(44 67 116 140 161 163 189 215)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (GRID:COPY-TO (SORT-VECTOR V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(-91 -68 -64 -10 -5 52 71 73)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (GRID:COPY-TO (SORT-VECTOR V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(44 67 116 140 161 163 189 215)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (GRID:COPY-TO (SORT-VECTOR V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(-91 -68 -64 -10 -5 52 71 73)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (GRID:COPY-TO (SORT-VECTOR V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(44 67 116 140 161 163 189 215)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (GRID:COPY-TO (SORT-VECTOR V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(-91 -68 -64 -10 -5 52 71 73)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (GRID:COPY-TO (SORT-VECTOR V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(44 67 116 140 161 163 189 215)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (GRID:COPY-TO (SORT-VECTOR V1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-34.5f0 -13.49f0 -8.93f0 -6.15f0 3.29f0 8.24f0 34.12f0 49.27f0)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (GRID:COPY-TO (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 + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 + 34.12d0 -6.15d0 49.27d0 + -13.49d0)))) + (GRID:COPY-TO (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-91 -68 -64 -10 -5 52 71 73)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (GRID:COPY-TO (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(44 67 116 140 161 163 189 215)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (GRID:COPY-TO (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-91 -68 -64 -10 -5 52 71 73)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (GRID:COPY-TO (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(44 67 116 140 161 163 189 215)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (GRID:COPY-TO (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-91 -68 -64 -10 -5 52 71 73)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (GRID:COPY-TO (SORT-VECTOR V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(44 67 116 140 161 163 189 215)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (GRID:COPY-TO (SORT-VECTOR V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-91 -68 -64 -10 -5 52 71 73)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (GRID:COPY-TO (SORT-VECTOR V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(44 67 116 140 161 163 189 215)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (GRID:COPY-TO (SORT-VECTOR V1)))))) diff --git a/tests/swap-columns.lisp b/tests/swap-columns.lisp index 58253aec9050987f1e7d01a045066108e24c0e08..93bf963d5209bce2ab3dd4f7d2c43e696472dba9 100644 --- a/tests/swap-columns.lisp +++ b/tests/swap-columns.lisp @@ -1,6 +1,6 @@ ;; Regression test SWAP-COLUMNS for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,17 +21,17 @@ (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))) + #2A((-34.5f0 3.29f0 8.24f0) + (-8.93f0 -6.15f0 34.12f0) + (49.27f0 32.5f0 -13.49f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) (GRID:COPY-TO (SWAP-COLUMNS M1 1 2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -49,18 +49,18 @@ (GRID:COPY-TO (SWAP-COLUMNS M1 1 2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(-34.5 8.24) #C(34.12 -6.15) #C(3.29 -8.93)) - (#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)))) + #2A((#C(-34.5f0 8.24f0) #C(34.12f0 -6.15f0) #C(3.29f0 -8.93f0)) + (#C(-8.93f0 34.12f0) #C(-13.49f0 32.5f0) #C(-6.15f0 49.27f0)) + (#C(49.27f0 -13.49f0) #C(-17.24f0 43.31f0) + #C(32.5f0 42.73f0)))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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)))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))) (GRID:COPY-TO (SWAP-COLUMNS M1 1 2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST diff --git a/tests/swap-elements.lisp b/tests/swap-elements.lisp index 1a1fa95d034d7fd06c100ddef1bd2f22628c6026..ef41c52d7d95b81becc125e83644624dae9603d6 100644 --- a/tests/swap-elements.lisp +++ b/tests/swap-elements.lisp @@ -1,6 +1,6 @@ ;; Regression test SWAP-ELEMENTS for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,13 +21,13 @@ (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)) + #(-34.5f0 8.24f0 -6.15f0 -8.93f0 34.12f0 3.29f0 49.27f0 -13.49f0)) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)))) + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) (SWAP-ELEMENTS V1 2 5) (GRID:COPY-TO V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL @@ -43,16 +43,16 @@ (GRID:COPY-TO V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #(#C(-34.5 8.24) #C(3.29 -8.93) #C(-17.24 43.31) - #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))) + #(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(-17.24f0 43.31f0) + #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(34.12f0 -6.15f0) + #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) #C(49.27 -13.49) - #C(32.5 42.73) #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))) + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0) #C(49.27f0 -13.49f0) + #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))) (SWAP-ELEMENTS V1 2 5) (GRID:COPY-TO V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/swap-row-column.lisp b/tests/swap-row-column.lisp index 21863d94bff16e718299b83c01c671abdd553304..892973a63416f280bc32e6ff754fe25bc2af3ee9 100644 --- a/tests/swap-row-column.lisp +++ b/tests/swap-row-column.lisp @@ -1,6 +1,6 @@ ;; Regression test SWAP-ROW-COLUMN for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,17 +21,17 @@ (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))) + #2A((3.29f0 -6.15f0 32.5f0) + (-8.93f0 34.12f0 8.24f0) + (49.27f0 -13.49f0 -34.5f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -49,17 +49,17 @@ (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(34.12 -6.15) #C(-13.49 32.5) #C(-17.24 43.31)) - (#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)))) + #2A((#C(34.12f0 -6.15f0) #C(-13.49f0 32.5f0) #C(-17.24f0 43.31f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(3.29f0 -8.93f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-34.5f0 8.24f0)))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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)))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))) (GRID:COPY-TO (SWAP-ROW-COLUMN M1 0 2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST diff --git a/tests/swap-rows.lisp b/tests/swap-rows.lisp index b2c80c339de811b92d22b4b8cfd5584e1433652a..ce11e4463d7b8c44d019e937be6fb6f0ccc7d20e 100644 --- a/tests/swap-rows.lisp +++ b/tests/swap-rows.lisp @@ -1,6 +1,6 @@ ;; Regression test SWAP-ROWS for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -21,17 +21,17 @@ (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))) + #2A((-8.93f0 34.12f0 -6.15f0) + (-34.5f0 8.24f0 3.29f0) + (49.27f0 -13.49f0 32.5f0))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '((-34.5 8.24 3.29) - (-8.93 34.12 -6.15) - (49.27 -13.49 32.5))))) + '((-34.5f0 8.24f0 3.29f0) + (-8.93f0 34.12f0 -6.15f0) + (49.27f0 -13.49f0 32.5f0))))) (GRID:COPY-TO (SWAP-ROWS M1 0 1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST @@ -49,18 +49,18 @@ (GRID:COPY-TO (SWAP-ROWS M1 0 1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #2A((#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5)) - (#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)))) + #2A((#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) + #C(-17.24f0 43.31f0)))) (MULTIPLE-VALUE-LIST (LET ((M1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '((#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)))))) + '((#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)) + (#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + (#C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) #C(-17.24f0 43.31f0)))))) (GRID:COPY-TO (SWAP-ROWS M1 0 1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST diff --git a/tests/vector-add.lisp b/tests/vector-add.lisp index 1bd99ee9e67b12a8362ced38d6d927cc47524a8e..ea7a01643851e73e8a572cab1c89d7a17c9d22d2 100644 --- a/tests/vector-add.lisp +++ b/tests/vector-add.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-ADD for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -22,14 +22,14 @@ (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-43.43 42.36 -2.8600001))) + '(-43.43f0 42.36f0 -2.8600001f0))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29))) + '(-34.5f0 8.24f0 3.29f0))) (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-8.93 34.12 -6.15)))) + '(-8.93f0 34.12f0 -6.15f0)))) (ELT+ V1 V2)))) (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST diff --git a/tests/vector-div.lisp b/tests/vector-div.lisp index 0d628edd334cbb61f483262126f56152f9c2dabf..e05282e7d2027ad04bda4a49635e6b920f0be90a 100644 --- a/tests/vector-div.lisp +++ b/tests/vector-div.lisp @@ -20,14 +20,14 @@ (LISP-UNIT:DEFINE-TEST VECTOR-DIV (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(3.8633816 0.24150059 -0.5349593)) + (LIST #(3.8633816f0 0.24150059f0 -0.5349593f0)) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29))) + '(-34.5f0 8.24f0 3.29f0))) (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-8.93 34.12 -6.15)))) + '(-8.93f0 34.12f0 -6.15f0)))) (GRID:COPY-TO (ELT/ V1 V2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST diff --git a/tests/vector-max-index.lisp b/tests/vector-max-index.lisp index bf98bb0abc126af57f10bfcb4747445011acebea..fbf6199152421da6264f0e992b8a5f60040088c6 100644 --- a/tests/vector-max-index.lisp +++ b/tests/vector-max-index.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-MAX-INDEX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,126 +19,96 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST VECTOR-MAX-INDEX - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS - '(-34.5 8.24 - 3.29 -8.93 - 34.12 - -6.15 - 49.27 - -13.49)))) - (MAX-INDEX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '(-34.5d0 - 8.24d0 - 3.29d0 - -8.93d0 - 34.12d0 - -6.15d0 - 49.27d0 - -13.49d0)))) - (MAX-INDEX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (MAX-INDEX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (MAX-INDEX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (MAX-INDEX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (MAX-INDEX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (MAX-INDEX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (MAX-INDEX V1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 6) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (MAX-INDEX V1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 7) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (MAX-INDEX V1))))) - + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0)))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 8) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 7) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 7) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (MAX-INDEX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 7) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (MAX-INDEX V1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 6) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (MAX-INDEX V1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 7) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (MAX-INDEX V1))))) diff --git a/tests/vector-max.lisp b/tests/vector-max.lisp index 130d92fb82db7a543a0de916b36f49520799ad47..d28fc53251da7621af033a91d25d514d77031ad3 100644 --- a/tests/vector-max.lisp +++ b/tests/vector-max.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-MAX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,105 +19,94 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST VECTOR-MAX - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 8.24) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS - '(-34.5 8.24 - 3.29)))) - (MMAX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 8.24d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '(-34.5d0 - 8.24d0 - 3.29d0)))) - (MMAX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(-64 -68 - 71)))) - (MMAX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(67 44 - 189)))) - (MMAX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(-64 -68 - 71)))) - (MMAX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(67 44 - 189)))) - (MMAX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(-64 -68 - 71)))) - (MMAX V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(67 44 - 189)))) - (MMAX V1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 71) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(-64 -68 - 71)))) - (MMAX V1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 189) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(67 44 - 189)))) - (MMAX V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 8.24f0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0)))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 8.24d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0)))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 71) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 8) + :INITIAL-CONTENTS '(-64 -68 71)))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 189) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS '(67 44 189)))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 71) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 16) + :INITIAL-CONTENTS '(-64 -68 71)))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 189) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '(67 44 189)))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 71) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '(-64 -68 71)))) + (MMAX V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 189) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(67 44 + 189)))) + (MMAX V1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 71) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '(-64 -68 71)))) + (MMAX V1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 189) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '(67 44 189)))) + (MMAX V1))))) diff --git a/tests/vector-mean.lisp b/tests/vector-mean.lisp index 257240f90bede5b32ce9705370ccdf3e2809fe74..62ed0c2911c60c20b574726478494919c9a95585 100644 --- a/tests/vector-mean.lisp +++ b/tests/vector-mean.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-MEAN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,121 +19,92 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST VECTOR-MEAN - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 3.9812498688697815d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 - -6.15 49.27 -13.49)))) - (MEAN V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3.98125d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '(-34.5d0 - 8.24d0 - 3.29d0 - -8.93d0 - 34.12d0 - -6.15d0 - 49.27d0 - -13.49d0)))) - (MEAN V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (MEAN V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (MEAN V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (MEAN V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (MEAN V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (MEAN V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (MEAN V1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (MEAN V1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3.9812498688697815d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT :INITIAL-CONTENTS + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 3.98125d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0)))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -5.25d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 8) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 136.875d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -5.25d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 136.875d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST -5.25d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (MEAN V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (MEAN V1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -5.25d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (MEAN V1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 136.875d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (MEAN V1))))) diff --git a/tests/vector-min-index.lisp b/tests/vector-min-index.lisp index 61b5bdc0655da436e7ebfc0bc5ca21626b09fc86..2f6f6bb088ee6066e7fc9778b1291de7c5ab85e2 100644 --- a/tests/vector-min-index.lisp +++ b/tests/vector-min-index.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-MIN-INDEX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -25,12 +25,12 @@ (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 - 3.29 -8.93 - 34.12 - -6.15 - 49.27 - -13.49)))) + '(-34.5f0 8.24f0 + 3.29f0 -8.93f0 + 34.12f0 + -6.15f0 + 49.27f0 + -13.49f0)))) (MIN-INDEX V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0) (MULTIPLE-VALUE-LIST diff --git a/tests/vector-min.lisp b/tests/vector-min.lisp index 543313949c8c83c8c10abd80a62c1c7f4965023b..dffc7c74b7ce1e14c5f02426bb8fc47717b9651e 100644 --- a/tests/vector-min.lisp +++ b/tests/vector-min.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-MIN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,14 +19,13 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST VECTOR-MIN - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5f0) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 - 3.29)))) + '(-34.5f0 8.24f0 3.29f0)))) (MMIN V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0) (MULTIPLE-VALUE-LIST diff --git a/tests/vector-minmax-index.lisp b/tests/vector-minmax-index.lisp index 16c0da8efca4d79703ba2cfd87df1324644dfa1b..9c8aef726dddaf39585998ec93908239f4f744ea 100644 --- a/tests/vector-minmax-index.lisp +++ b/tests/vector-minmax-index.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-MINMAX-INDEX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -25,12 +25,12 @@ (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 - 3.29 -8.93 - 34.12 - -6.15 - 49.27 - -13.49)))) + '(-34.5f0 8.24f0 + 3.29f0 -8.93f0 + 34.12f0 + -6.15f0 + 49.27f0 + -13.49f0)))) (MINMAX-INDEX V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 0 6) diff --git a/tests/vector-minmax.lisp b/tests/vector-minmax.lisp index 8589a4fef2c268061e167b4e8615d83dc2fd0d38..e827d6b3f4c45ca6fdfaf46a7183c779f841f12b 100644 --- a/tests/vector-minmax.lisp +++ b/tests/vector-minmax.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-MINMAX for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,14 +19,13 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST VECTOR-MINMAX - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5 8.24) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5f0 8.24f0) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 - 3.29)))) + '(-34.5f0 8.24f0 3.29f0)))) (MINMAX V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST -34.5d0 8.24d0) (MULTIPLE-VALUE-LIST diff --git a/tests/vector-mult.lisp b/tests/vector-mult.lisp index 604d4d7083b1b81df91078e2ee5bfda0532d5383..03d8786106257beaa6673158708a3e8bd32db76d 100644 --- a/tests/vector-mult.lisp +++ b/tests/vector-mult.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-MULT for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,14 +20,14 @@ (LISP-UNIT:DEFINE-TEST VECTOR-MULT (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(308.08502 281.14877 -20.2335)) + (LIST #(308.08502f0 281.14877f0 -20.2335f0)) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29))) + '(-34.5f0 8.24f0 3.29f0))) (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-8.93 34.12 -6.15)))) + '(-8.93f0 34.12f0 -6.15f0)))) (GRID:COPY-TO (ELT* V1 V2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(308.085d0 281.1488d0 -20.233500000000003d0)) diff --git a/tests/vector-reverse.lisp b/tests/vector-reverse.lisp index 7b753f8a9e36b62e3d776d2773e8b4d685ecc18e..e0bd759e7dfcaae5438e2bf5654ae1fd719353ba 100644 --- a/tests/vector-reverse.lisp +++ b/tests/vector-reverse.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-REVERSE for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,40 +19,40 @@ (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 - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - 'SINGLE-FLOAT - :INITIAL-CONTENTS '(-34.5 8.24 3.29 -8.93 34.12 -6.15 49.27 -13.49)))) - (GRID:COPY-TO (VECTOR-REVERSE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-13.49f0 49.27f0 -6.15f0 34.12f0 -8.93f0 3.29f0 8.24f0 -34.5f0)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (GRID:COPY-TO (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 - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - 'DOUBLE-FLOAT - :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0)))) - (GRID:COPY-TO (VECTOR-REVERSE V1))))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0)))) + (GRID:COPY-TO (VECTOR-REVERSE V1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST - #(#C(21.44 -49.08) #C(-16.12 -8.25) #C(-17.24 43.31) - #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))) + #(#C(21.44f0 -49.08f0) #C(-16.12f0 -8.25f0) #C(-17.24f0 43.31f0) + #C(32.5f0 42.73f0) #C(49.27f0 -13.49f0) #C(34.12f0 -6.15f0) + #C(3.29f0 -8.93f0) #C(-34.5f0 8.24f0))) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15) - #C(49.27 -13.49) #C(32.5 42.73) - #C(-17.24 43.31) #C(-16.12 -8.25) #C(21.44 -49.08))))) - (GRID:COPY-TO (VECTOR-REVERSE V1))))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX SINGLE-FLOAT) + :INITIAL-CONTENTS + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0) + #C(49.27f0 -13.49f0) #C(32.5f0 42.73f0) + #C(-17.24f0 43.31f0) #C(-16.12f0 -8.25f0) #C(21.44f0 -49.08f0))))) + (GRID:COPY-TO (VECTOR-REVERSE V1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(#C(21.44d0 -49.08d0) #C(-16.12d0 -8.25d0) @@ -60,79 +60,79 @@ #C(49.27d0 -13.49d0) #C(34.12d0 -6.15d0) #C(3.29d0 -8.93d0) #C(-34.5d0 8.24d0))) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(COMPLEX DOUBLE-FLOAT) - :INITIAL-CONTENTS - '(#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) - #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0))))) - (GRID:COPY-TO (VECTOR-REVERSE V1))))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(COMPLEX DOUBLE-FLOAT) + :INITIAL-CONTENTS + '(#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) + #C(-16.12d0 -8.25d0) #C(21.44d0 -49.08d0))))) + (GRID:COPY-TO (VECTOR-REVERSE V1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-5 73 -10 52 -91 71 -68 -64)) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE 8) - :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) - (GRID:COPY-TO (VECTOR-REVERSE V1))))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 8) + :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) + (GRID:COPY-TO (VECTOR-REVERSE V1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 161 140 163 116 189 44 67)) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) - (GRID:COPY-TO (VECTOR-REVERSE V1))))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) + (GRID:COPY-TO (VECTOR-REVERSE V1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-5 73 -10 52 -91 71 -68 -64)) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE 16) - :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) - (GRID:COPY-TO (VECTOR-REVERSE V1))))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 16) + :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) + (GRID:COPY-TO (VECTOR-REVERSE V1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 161 140 163 116 189 44 67)) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) - (GRID:COPY-TO (VECTOR-REVERSE V1))))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) + (GRID:COPY-TO (VECTOR-REVERSE V1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-5 73 -10 52 -91 71 -68 -64)) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE 32) - :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) - (GRID:COPY-TO (VECTOR-REVERSE V1))))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 32) + :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) + (GRID:COPY-TO (VECTOR-REVERSE V1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 161 140 163 116 189 44 67)) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) - (GRID:COPY-TO (VECTOR-REVERSE V1))))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) + (GRID:COPY-TO (VECTOR-REVERSE V1))))) #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(-5 73 -10 52 -91 71 -68 -64)) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE 64) - :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) - (GRID:COPY-TO (VECTOR-REVERSE V1))))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 64) + :INITIAL-CONTENTS '(-64 -68 71 -91 52 -10 73 -5)))) + (GRID:COPY-TO (VECTOR-REVERSE V1))))) #+int64 (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(215 161 140 163 116 189 44 67)) (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) - (GRID:COPY-TO (VECTOR-REVERSE V1)))))) + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS '(67 44 189 116 163 140 161 215)))) + (GRID:COPY-TO (VECTOR-REVERSE V1)))))) diff --git a/tests/vector-set-all.lisp b/tests/vector-set-all.lisp index 9d2b34692b66eb1e4a428390275b7ad0dba717ba..41f4c9403e4f50c45223dee2e7c9a3bd4b5b5fc1 100644 --- a/tests/vector-set-all.lisp +++ b/tests/vector-set-all.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-SET-ALL for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,10 +20,10 @@ (LISP-UNIT:DEFINE-TEST VECTOR-SET-ALL (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST #(-34.5 -34.5 -34.5)) + (LIST #(-34.5f0 -34.5f0 -34.5f0)) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :DIMENSIONS '3))) - (GRID:COPY-TO (SET-ALL V1 -34.5))))) + (GRID:COPY-TO (SET-ALL V1 -34.5f0))))) (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST #(-34.5d0 -34.5d0 -34.5d0)) (MULTIPLE-VALUE-LIST @@ -31,12 +31,12 @@ (GRID:COPY-TO (SET-ALL V1 -34.5d0))))) #+fsbv (LISP-UNIT:ASSERT-NUMERICAL-EQUAL - (LIST #(#C(-34.5 8.24) #C(-34.5 8.24) #C(-34.5 8.24))) + (LIST #(#C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0) #C(-34.5f0 8.24f0))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :DIMENSIONS '3))) - (GRID:COPY-TO (SET-ALL V1 #C(-34.5 8.24)))))) + (GRID:COPY-TO (SET-ALL V1 #C(-34.5f0 8.24f0)))))) #+fsbv (LISP-UNIT:ASSERT-NUMERICAL-EQUAL (LIST diff --git a/tests/vector-set-zero.lisp b/tests/vector-set-zero.lisp index a996afdf736a856f83692c18d6661247df1c9c1d..26cf9efe25d1c03a1fef6efc0150d811b99991b5 100644 --- a/tests/vector-set-zero.lisp +++ b/tests/vector-set-zero.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-SET-ZERO for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,10 +20,10 @@ (LISP-UNIT:DEFINE-TEST VECTOR-SET-ZERO (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(0.0 0.0 0.0)) + (LIST #(0.0f0 0.0f0 0.0f0)) (MULTIPLE-VALUE-LIST (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5 8.24 3.29)))) + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0)))) (SET-ZERO V1) (GRID:COPY-TO V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL @@ -34,12 +34,12 @@ (SET-ZERO V1) (GRID:COPY-TO V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(#C(0.0 0.0) #C(0.0 0.0) #C(0.0 0.0))) + (LIST #(#C(0.0f0 0.0f0) #C(0.0f0 0.0f0) #C(0.0f0 0.0f0))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) - :INITIAL-CONTENTS '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15))))) + :INITIAL-CONTENTS '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0))))) (SET-ZERO V1) (GRID:COPY-TO V1)))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/vector-standard-deviation-with-fixed-mean.lisp b/tests/vector-standard-deviation-with-fixed-mean.lisp index 461606835516fe0a43401cdd9bb1142ed0d23685..2da23145f83bbcd23169a89ae8c5e39ce478b226 100644 --- a/tests/vector-standard-deviation-with-fixed-mean.lisp +++ b/tests/vector-standard-deviation-with-fixed-mean.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-STANDARD-DEVIATION-WITH-FIXED-MEAN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,86 +19,87 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST VECTOR-STANDARD-DEVIATION-WITH-FIXED-MEAN - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 25.08341998337271d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 - -6.15 49.27 -13.49)))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 25.08342004068624d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0 -8.93d0 - 34.12d0 -6.15d0 49.27d0 - -13.49d0)))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 61.216317269172606d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 54.81659762334762d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 61.216317269172606d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 54.81659762334762d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 61.216317269172606d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 54.81659762334762d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 61.216317269172606d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 54.81659762334762d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 25.08341998337271d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 25.08342004068624d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 + 34.12d0 -6.15d0 49.27d0 + -13.49d0)))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 61.216317269172606d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 54.81659762334762d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 61.216317269172606d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 54.81659762334762d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 61.216317269172606d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 54.81659762334762d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 61.216317269172606d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (STANDARD-DEVIATION-WITH-FIXED-MEAN V1 (MEAN V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 54.81659762334762d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (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 index 70861eef49453862a0d292b14f23630d1b74fa7c..4742663cc80367b381b41130cea0e551c56fba9c 100644 --- a/tests/vector-standard-deviation-with-mean.lisp +++ b/tests/vector-standard-deviation-with-mean.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-STANDARD-DEVIATION-WITH-MEAN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,86 +19,85 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST VECTOR-STANDARD-DEVIATION-WITH-MEAN - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 26.815303904668458d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 - -6.15 49.27 -13.49)))) - (STANDARD-DEVIATION V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 26.815303965939197d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0 -8.93d0 - 34.12d0 -6.15d0 49.27d0 - -13.49d0)))) - (STANDARD-DEVIATION V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 65.44299591465624d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (STANDARD-DEVIATION V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 58.60140783291814d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (STANDARD-DEVIATION V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 65.44299591465624d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (STANDARD-DEVIATION V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 58.60140783291814d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (STANDARD-DEVIATION V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 65.44299591465624d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (STANDARD-DEVIATION V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 58.60140783291814d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (STANDARD-DEVIATION V1 (MEAN V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 65.44299591465624d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (STANDARD-DEVIATION V1 (MEAN V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 58.60140783291814d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (STANDARD-DEVIATION V1 (MEAN V1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.815303904668458d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.815303965939197d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0)))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (STANDARD-DEVIATION V1 (MEAN V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (STANDARD-DEVIATION V1 (MEAN V1)))))) diff --git a/tests/vector-standard-deviation.lisp b/tests/vector-standard-deviation.lisp index 1fde788bae6930fd73bd77614c2860a6615a4a6d..083ee98dcfd217c56e1afca24bb8addd20791794 100644 --- a/tests/vector-standard-deviation.lisp +++ b/tests/vector-standard-deviation.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-STANDARD-DEVIATION for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,86 +19,87 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST VECTOR-STANDARD-DEVIATION - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 26.815303904668458d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 - -6.15 49.27 -13.49)))) - (STANDARD-DEVIATION V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 26.815303965939197d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0 -8.93d0 - 34.12d0 -6.15d0 49.27d0 - -13.49d0)))) - (STANDARD-DEVIATION V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 65.44299591465624d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (STANDARD-DEVIATION V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 58.60140783291814d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (STANDARD-DEVIATION V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 65.44299591465624d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (STANDARD-DEVIATION V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 58.60140783291814d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (STANDARD-DEVIATION V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 65.44299591465624d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (STANDARD-DEVIATION V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 58.60140783291814d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (STANDARD-DEVIATION V1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 65.44299591465624d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (STANDARD-DEVIATION V1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 58.60140783291814d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS - '(67 44 189 116 163 140 161 215)))) - (STANDARD-DEVIATION V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.815303904668458d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 26.815303965939197d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 + 34.12d0 -6.15d0 49.27d0 + -13.49d0)))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 8) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (STANDARD-DEVIATION V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (STANDARD-DEVIATION V1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 65.44299591465624d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (STANDARD-DEVIATION V1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 58.60140783291814d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS + '(67 44 189 116 163 140 161 215)))) + (STANDARD-DEVIATION V1))))) diff --git a/tests/vector-sub.lisp b/tests/vector-sub.lisp index ec1875e09a2f6f3c0a483c9f5748f3012361c5d0..a6c77915116abfa0615ddad9a397319aa549ba10 100644 --- a/tests/vector-sub.lisp +++ b/tests/vector-sub.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-SUB for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,147 +19,147 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST VECTOR-SUB - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(-25.57 -25.88 9.440001)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-8.93 34.12 -6.15)))) - (GRID:COPY-TO (ELT- V1 V2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST - #(-25.57d0 -25.879999999999995d0 9.440000000000001d0)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-8.93d0 34.12d0 -6.15d0)))) - (GRID:COPY-TO (ELT- V1 V2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(-64 -68 - 71))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(-91 52 - -10)))) - (GRID:COPY-TO - (ELT- V1 V2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(207 137 49)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(67 44 - 189))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(116 163 - 140)))) - (GRID:COPY-TO - (ELT- V1 V2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(-64 -68 - 71))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(-91 52 - -10)))) - (GRID:COPY-TO - (ELT- V1 V2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(65487 65417 49)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS '(67 44 189))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) - :INITIAL-CONTENTS '(116 163 140)))) - (GRID:COPY-TO (ELT- V1 V2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(-64 -68 - 71))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(-91 52 - -10)))) - (GRID:COPY-TO - (ELT- V1 V2))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(4294967247 4294967177 49)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS '(67 44 189))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) - :INITIAL-CONTENTS '(116 163 140)))) - (GRID:COPY-TO (ELT- V1 V2))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(-64 -68 - 71))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(-91 52 - -10)))) - (GRID:COPY-TO - (ELT- V1 V2))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST #(18446744073709551567 18446744073709551497 49)) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS '(67 44 189))) - (V2 - (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) - :INITIAL-CONTENTS '(116 163 140)))) - (GRID:COPY-TO (ELT- V1 V2)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(-25.57f0 -25.88f0 9.440001f0)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '(-34.5f0 8.24f0 3.29f0))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS + '(-8.93f0 34.12f0 -6.15f0)))) + (GRID:COPY-TO (ELT- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST + #(-25.57d0 -25.879999999999995d0 9.440000000000001d0)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(-8.93d0 34.12d0 -6.15d0)))) + (GRID:COPY-TO (ELT- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(-64 -68 + 71))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(-91 52 + -10)))) + (GRID:COPY-TO + (ELT- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(207 137 49)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(67 44 + 189))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(116 163 + 140)))) + (GRID:COPY-TO + (ELT- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(-64 -68 + 71))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(-91 52 + -10)))) + (GRID:COPY-TO + (ELT- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(65487 65417 49)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS '(67 44 189))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 16) + :INITIAL-CONTENTS '(116 163 140)))) + (GRID:COPY-TO (ELT- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(-64 -68 + 71))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(-91 52 + -10)))) + (GRID:COPY-TO + (ELT- V1 V2))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(4294967247 4294967177 49)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS '(67 44 189))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 32) + :INITIAL-CONTENTS '(116 163 140)))) + (GRID:COPY-TO (ELT- V1 V2))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST #(27 -120 81)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(-64 -68 + 71))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(-91 52 + -10)))) + (GRID:COPY-TO + (ELT- V1 V2))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST #(18446744073709551567 18446744073709551497 49)) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS '(67 44 189))) + (V2 + (GRID:MAKE-FOREIGN-ARRAY '(UNSIGNED-BYTE 64) + :INITIAL-CONTENTS '(116 163 140)))) + (GRID:COPY-TO (ELT- V1 V2)))))) diff --git a/tests/vector-swap.lisp b/tests/vector-swap.lisp index 0284afebb65f359f9b902b8099dcd034d605bec7..c9ed03b64c95addab524c204940028cfa5049851 100644 --- a/tests/vector-swap.lisp +++ b/tests/vector-swap.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-SWAP for GSLL, automatically generated ;; -;; Copyright 2009, 2010 Liam M. Healy +;; Copyright 2009, 2010, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -20,16 +20,16 @@ (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))) + (LIST (LIST #(-8.93f0 34.12f0 -6.15f0) #(-34.5f0 8.24f0 3.29f0))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT - :INITIAL-CONTENTS '(-34.5 8.24 3.29))) + :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0))) (V2 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT - :INITIAL-CONTENTS '(-8.93 34.12 -6.15)))) + :INITIAL-CONTENTS '(-8.93f0 34.12f0 -6.15f0)))) (SWAP V2 V1) (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL @@ -50,19 +50,19 @@ (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)))) + #(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0)) + #(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)))) (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-34.5 8.24) #C(3.29 -8.93) #C(34.12 -6.15)))) + '(#C(-34.5f0 8.24f0) #C(3.29f0 -8.93f0) #C(34.12f0 -6.15f0)))) (V2 (GRID:MAKE-FOREIGN-ARRAY '(COMPLEX SINGLE-FLOAT) :INITIAL-CONTENTS - '(#C(-8.93 34.12) #C(-6.15 49.27) #C(-13.49 32.5))))) + '(#C(-8.93f0 34.12f0) #C(-6.15f0 49.27f0) #C(-13.49f0 32.5f0))))) (SWAP V2 V1) (LIST (GRID:COPY-TO V1) (GRID:COPY-TO V2))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL diff --git a/tests/vector-variance-with-fixed-mean.lisp b/tests/vector-variance-with-fixed-mean.lisp index 17101679afe1f835334ee262d7e5d2a362856375..abc6a545a9a010f2469600d4fcb052a6d40a7d1a 100644 --- a/tests/vector-variance-with-fixed-mean.lisp +++ b/tests/vector-variance-with-fixed-mean.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-VARIANCE-WITH-FIXED-MEAN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,123 +19,123 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST VECTOR-VARIANCE-WITH-FIXED-MEAN - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 629.1779580622615d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 - -6.15 49.27 -13.49)))) - (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 629.1779609375001d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0 -8.93d0 - 34.12d0 -6.15d0 49.27d0 - -13.49d0)))) - (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (VARIANCE-WITH-FIXED-MEAN - V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (VARIANCE-WITH-FIXED-MEAN - V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (VARIANCE-WITH-FIXED-MEAN - V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (VARIANCE-WITH-FIXED-MEAN - V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (VARIANCE-WITH-FIXED-MEAN - V1 (MEAN V1))))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (VARIANCE-WITH-FIXED-MEAN - V1 (MEAN V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(SIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(-64 -68 71 - -91 52 -10 - 73 -5)))) - (VARIANCE-WITH-FIXED-MEAN - V1 (MEAN V1))))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (VARIANCE-WITH-FIXED-MEAN - V1 (MEAN V1)))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 629.1779580622615d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 629.1779609375001d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 + 34.12d0 -6.15d0 49.27d0 + -13.49d0)))) + (VARIANCE-WITH-FIXED-MEAN V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5)))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5)))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5)))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3747.4375d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(-64 -68 71 + -91 52 -10 + 73 -5)))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1))))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3004.859375d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (VARIANCE-WITH-FIXED-MEAN + V1 (MEAN V1)))))) diff --git a/tests/vector-variance-with-mean.lisp b/tests/vector-variance-with-mean.lisp index fd2ba2dd1137af8ad41d1e886ef8828d549b6f20..775a540a620a09fc12c6f37ca99313708a9e267c 100644 --- a/tests/vector-variance-with-mean.lisp +++ b/tests/vector-variance-with-mean.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-VARIANCE-WITH-MEAN for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -24,8 +24,8 @@ (MULTIPLE-VALUE-LIST (LET ((V1 (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 - -6.15 49.27 -13.49)))) + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 + -6.15f0 49.27f0 -13.49f0)))) (VARIANCE V1 (MEAN V1))))) (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 719.0605267857144d0) diff --git a/tests/vector-variance.lisp b/tests/vector-variance.lisp index 0d64116a247dea4bcdb00dc18e14085193b68464..45aa4f51f0dc0c6a751e2e461eebe75ad141499b 100644 --- a/tests/vector-variance.lisp +++ b/tests/vector-variance.lisp @@ -1,6 +1,6 @@ ;; Regression test VECTOR-VARIANCE for GSLL, automatically generated ;; -;; Copyright 2009 Liam M. Healy +;; Copyright 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -19,102 +19,105 @@ (in-package :gsl) (LISP-UNIT:DEFINE-TEST VECTOR-VARIANCE - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 719.0605234997274d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'SINGLE-FLOAT :INITIAL-CONTENTS - '(-34.5 8.24 3.29 -8.93 34.12 - -6.15 49.27 -13.49)))) - (VARIANCE V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 719.0605267857144d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY 'DOUBLE-FLOAT :INITIAL-CONTENTS - '(-34.5d0 8.24d0 3.29d0 -8.93d0 - 34.12d0 -6.15d0 49.27d0 - -13.49d0)))) - (VARIANCE V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 4282.785714285714d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 8) :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (VARIANCE V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 8) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (VARIANCE V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 4282.785714285714d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (VARIANCE V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 16) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (VARIANCE V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 4282.785714285714d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (VARIANCE V1)))) - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 32) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (VARIANCE V1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL - (LIST 4282.785714285714d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) - :INITIAL-CONTENTS - '(-64 -68 71 -91 52 -10 73 -5)))) - (VARIANCE V1)))) - #+int64 - (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) - (MULTIPLE-VALUE-LIST - (LET ((V1 - (GRID:MAKE-FOREIGN-ARRAY - '(UNSIGNED-BYTE - 64) - :INITIAL-CONTENTS - '(67 44 189 - 116 163 - 140 161 - 215)))) - (VARIANCE V1))))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.0605234997274d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'SINGLE-FLOAT + :INITIAL-CONTENTS + '(-34.5f0 8.24f0 3.29f0 -8.93f0 34.12f0 -6.15f0 49.27f0 -13.49f0)))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 719.0605267857144d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + 'DOUBLE-FLOAT + :INITIAL-CONTENTS + '(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0 49.27d0 -13.49d0)))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4282.785714285714d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(SIGNED-BYTE 8) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 8) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4282.785714285714d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 16) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 16) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4282.785714285714d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 32) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (VARIANCE V1)))) + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 32) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (VARIANCE V1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL + (LIST 4282.785714285714d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY '(SIGNED-BYTE 64) + :INITIAL-CONTENTS + '(-64 -68 71 -91 52 -10 73 -5)))) + (VARIANCE V1)))) + #+int64 + (LISP-UNIT::ASSERT-NUMERICAL-EQUAL (LIST 3434.125d0) + (MULTIPLE-VALUE-LIST + (LET ((V1 + (GRID:MAKE-FOREIGN-ARRAY + '(UNSIGNED-BYTE + 64) + :INITIAL-CONTENTS + '(67 44 189 + 116 163 + 140 161 + 215)))) + (VARIANCE V1))))) diff --git a/wavelet.lisp b/wavelet.lisp index 7fda318cb691d0f6d17d4ce30bf8f8109a24270d..1ab3aac38604b790569d96bd4ee825310c28b612 100644 --- a/wavelet.lisp +++ b/wavelet.lisp @@ -1,8 +1,8 @@ ;; Wavelet transforms. ;; Liam Healy, Mon Nov 26 2007 - 20:43 -;; Time-stamp: <2010-07-07 14:24:54EDT wavelet.lisp> +;; Time-stamp: <2011-05-26 12:37:28EDT wavelet.lisp> ;; -;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy +;; Copyright 2006, 2007, 2008, 2009, 2011 Liam M. Healy ;; Distributed under the terms of the GNU General Public License ;; ;; This program is free software: you can redistribute it and/or modify @@ -105,7 +105,7 @@ (defmfun wavelet-transform (wavelet data stride direction workspace) "gsl_wavelet_transform" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) (stride sizet) ((dim0 data) sizet) ((forward-backward direction) :int) ((mpointer workspace) :pointer)) :documentation ; FDL @@ -131,7 +131,7 @@ (defmfun wavelet-transform-forward (wavelet data stride workspace) "gsl_wavelet_transform_forward" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) (stride sizet) ((dim0 data) sizet) ((mpointer workspace) :pointer)) :documentation ; FDL "Compute in-place forward and inverse discrete wavelet @@ -153,7 +153,7 @@ (defmfun wavelet-transform-inverse (wavelet data stride workspace) "gsl_wavelet_transform_inverse" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) (stride sizet) ((dim0 data) sizet) ((mpointer workspace) :pointer)) :documentation ; FDL "Compute in-place inverse discrete wavelet @@ -179,7 +179,7 @@ (defmfun wavelet-2d-transform (wavelet data tda direction workspace) "gsl_wavelet2d_transform" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) (tda sizet) ((dim0 data) sizet) ((dim1 data) sizet) ((forward-backward direction) :int) ((mpointer workspace) :pointer)) :documentation ; FDL @@ -199,7 +199,7 @@ (defmfun wavelet-2d-transform-forward (wavelet data tda workspace) "gsl_wavelet2d_transform_forward" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) (tda sizet) ((dim0 data) sizet) ((dim1 data) sizet) ((mpointer workspace) :pointer)) :documentation ; FDL @@ -217,7 +217,7 @@ (defmfun wavelet-2d-transform-inverse (wavelet data tda workspace) "gsl_wavelet2d_transform_inverse" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) (tda sizet) ((dim0 data) sizet) ((dim1 data) sizet) ((mpointer workspace) :pointer)) :documentation ; FDL @@ -233,28 +233,28 @@ (defmfun wavelet-2d-transform-matrix (wavelet data direction workspace) "gsl_wavelet2d_transform_matrix" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) ((forward-backward direction) :int) ((mpointer workspace) :pointer)) :documentation ; FDL "Compute the two-dimensional in-place wavelet transform on a matrix.") (defmfun wavelet-2d-transform-matrix-forward (wavelet data workspace) "gsl_wavelet2d_transform_matrix_forward" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) ((mpointer workspace) :pointer)) :documentation ; FDL "Compute the two-dimensional in-place wavelet transform on a matrix.") (defmfun wavelet-2d-transform-matrix-inverse (wavelet data workspace) "gsl_wavelet2d_transform_matrix_inverse" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) ((mpointer workspace) :pointer)) :documentation ; FDL "Compute the two-dimensional in-place wavelet transform on a matrix.") (defmfun wavelet-2d-nonstandard-transform (wavelet data tda direction workspace) "gsl_wavelet2d_nstransform" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) (tda sizet) ((dim0 data) sizet) ((dim1 data) sizet) (direction :int) ((mpointer workspace) :pointer)) :documentation ; FDL @@ -262,7 +262,7 @@ (defmfun wavelet-2d-nonstandard-transform-forward (wavelet data tda workspace) "gsl_wavelet2d_nstransform_forward" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) (tda sizet) ((dim0 data) sizet) ((dim1 data) sizet) ((mpointer workspace) :pointer)) :documentation ; FDL @@ -270,7 +270,7 @@ (defmfun wavelet-2d-nonstandard-transform-inverse (wavelet data tda workspace) "gsl_wavelet2d_nstransform_inverse" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) (tda sizet) ((dim0 data) sizet) ((dim1 data) sizet) ((mpointer workspace) :pointer)) :documentation ; FDL @@ -278,7 +278,7 @@ (defmfun wavelet-2d-nonstandard-transform-matrix (wavelet data direction workspace) "gsl_wavelet2d_nstransform_matrix" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) (direction :int) ((mpointer workspace) :pointer)) :documentation "Compute the non-standard form of the two-dimensional in-place wavelet @@ -286,7 +286,7 @@ (defmfun wavelet-2d-nonstandard-transform-matrix-forward (wavelet data workspace) "gsl_wavelet2d_nstransform_matrix_forward" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) ((mpointer workspace) :pointer)) :documentation ; FDL "Compute the non-standard form of the two-dimensional in-place wavelet @@ -294,7 +294,7 @@ (defmfun wavelet-2d-nonstandard-transform-matrix-inverse (wavelet data workspace) "gsl_wavelet2d_nstransform_matrix_inverse" - (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer) + (((mpointer wavelet) :pointer) ((grid:foreign-pointer data) :pointer) ((mpointer workspace) :pointer)) :documentation ; FDL "Compute the non-standard form of the two-dimensional in-place wavelet @@ -388,13 +388,13 @@ (let ((absvector (grid:make-foreign-array 'double-float :dimensions n)) (permutation (make-permutation n))) (dotimes (i n) - (setf (grid:gref absvector i) (abs (grid:gref vector i)))) + (setf (grid:aref absvector i) (abs (grid:aref vector i)))) ;; Sort and set to 0 all but the largest 20. (sort-vector-index permutation absvector) (dotimes (i (- n 20)) - (setf (grid:gref vector (grid:gref permutation i)) + (setf (grid:aref vector (grid:aref permutation i)) 0.0d0))) ;; Transform back - (dotimes (i n) (format t "~&~a" (grid:gref vector i))) + (dotimes (i n) (format t "~&~a" (grid:aref vector i))) (wavelet-transform-inverse wavelet vector 1 workspace) (grid:copy-to vector)))