Commit b09dc9d2 authored by Liam Healy's avatar Liam Healy

Full use of defmobject; elimination of letm

All GSL objects are full CL objects with garbage collection.  There is
no need to manually free the associated memory.  All objects may be
assigned in the normal CL way, e.g. let, so there is not #'letm macro
anymore.  Everything compiles cleanly in gsll, but nothing has been
tested.
parent 7c66d57b
;; Basis splines.
;; Liam Healy 2008-02-18 14:43:20EST basis-splines.lisp
;; Time-stamp: <2008-12-26 10:25:46EST basis-splines.lisp>
;; Time-stamp: <2008-12-26 12:51:25EST basis-splines.lisp>
;; $Id$
(in-package :gsl)
......@@ -8,7 +8,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Should be subclass of interpolation?
#|
(defmobject basis-spline "gsl_bspline"
((order sizet) (number-of-breakpoints sizet))
"basis spline" ; FDL
......@@ -16,31 +15,6 @@
breakpoints is given by number-of-breakpoints. This leads to n =
nbreak + k - 2 basis functions where k = order. Cubic B-splines are
specified by k = 4. The size of the workspace is O(5k + nbreak).")
|#
;;; Initializing the B-splines solver
(defgo-s (basis-spline order number-of-breakpoints) allocate-basis-spline free-basis-spline nil 2)
(defmfun allocate-basis-spline (order number-of-breakpoints)
"gsl_bspline_alloc"
((order sizet) (number-of-breakpoints sizet))
:c-return :pointer
:export nil
:index (letm basis-spline)
:documentation ; FDL
"Allocate a workspace for computing B-splines. The number of
breakpoints is given by number-of-breakpoints. This leads to n =
nbreak + k - 2 basis functions where k = order. Cubic B-splines are
specified by k = 4. The size of the workspace is O(5k + nbreak)." )
(defmfun free-basis-spline (bspline)
"gsl_bspline_free"
((bspline :pointer))
:c-return :void
:export nil
:index (letm basis-spline)
:documentation ; FDL
"Free the memory associated with the workspace of the bspline.")
;;; Constructing the knots vector
(defmfun knots (breakpoints workspace)
......@@ -101,17 +75,13 @@
;;; Examples and unit test
#|
|#
(defun bspline-example (&optional (ncoeffs 8))
(letm ((order 4) ; cubic
(let* ((order 4) ; cubic
(ndata 200)
(nbreak (+ ncoeffs 2 (- order)))
(bw (make-basis-spline order nbreak))
(mw (fit-workspace ndata ncoeffs))
(rng (random-number-generator *mt19937* 0))
(mw (make-fit-workspace ndata ncoeffs))
(rng (make-random-number-generator *mt19937* 0))
(B (make-marray 'double-float :dimensions ncoeffs))
(c (make-marray 'double-float :dimensions ncoeffs))
(cov (make-marray 'double-float :dimensions (list ncoeffs ncoeffs)))
......@@ -141,11 +111,11 @@
(weighted-linear-mfit Xmatrix w y c cov mw)
;; Return the smoothed curve
(loop for xi from 0.0d0 to 15.0d0 by 0.1d0
with yval and yerr
do
(evaluate-bspline xi B bw)
(multiple-value-setq (yval yerr)
(multi-linear-estimate B c cov))
collect yval into yvals
collect yerr into yerrs
finally (return (values yvals yerrs)))))
with yval and yerr
do
(evaluate-bspline xi B bw)
(multiple-value-setq (yval yerr)
(multi-linear-estimate B c cov))
collect yval into yvals
collect yerr into yerrs
finally (return (values yvals yerrs)))))
;; Chebyshev Approximations
;; Liam Healy Sat Nov 17 2007 - 20:36
;; Time-stamp: <2008-12-23 21:46:27EST chebyshev.lisp>
;; Time-stamp: <2008-12-26 11:21:25EST chebyshev.lisp>
;; $Id$
(in-package :gsl)
#|
;;;;****************************************************************************
;;;; Creation and calculation of Chebyshev series
;;;;****************************************************************************
(defmobject chebyshev "gsl_cheb"
((order sizet))
"Chebyshev series" ; FDL
"Make a Chebyshev series of specified order."
"init"
((function :pointer) (lower-limit :double) (upper-limit :double)))
|#
;;;;****************************************************************************
;;;; Creation and calculation of Chebyshev series
;;;;****************************************************************************
(defgo-s (chebyshev order function lower-limit upper-limit)
allocate-chebyshev free-chebyshev initialize-chebyshev)
(defmfun allocate-chebyshev (order)
"gsl_cheb_alloc"
((order sizet))
:c-return :pointer
:export nil
:index (letm chebyshev)
:documentation ; FDL
"Allocate a Chebyshev series of specified order
and return a pointer to it.")
(defmfun free-chebyshev (chebyshev)
"gsl_cheb_free"
((chebyshev :pointer))
:c-return :void
:export nil
:index (letm chebyshev)
:documentation ; FDL
"Free a previously allocated Chebyshev series.")
(defmfun initialize-chebyshev (chebyshev function lower-limit upper-limit)
"gsl_cheb_init"
((chebyshev :pointer) (function :pointer)
(lower-limit :double) (upper-limit :double))
:export nil
:index (letm chebyshev)
:documentation ; FDL
"Compute the Chebyshev approximation for the function over the range
(lower-limit, upper-limit) to the previously specified order. The
computation of the Chebyshev approximation is an O(n^2)
process, and requires n function evaluations.")
;;;;****************************************************************************
;;;; Chebyshev series evaluation
......@@ -111,7 +75,7 @@
(defun chebyshev-table-example ()
(let ((steps 100))
(letm ((cheb (chebyshev 40 chebyshev-step 0.0d0 1.0d0)))
(let ((cheb (make-chebyshev 40 chebyshev-step 0.0d0 1.0d0)))
(dotimes (i steps)
(let ((x (coerce (/ i steps) 'double-float)))
(format t "~&~a ~a ~a ~a"
......@@ -122,9 +86,9 @@
(defun chebyshev-point-example (x)
(check-type x double-float)
(letm ((cheb (chebyshev 40 chebyshev-step 0.0d0 1.0d0))
(deriv (chebyshev 40))
(integ (chebyshev 40)))
(let ((cheb (make-chebyshev 40 chebyshev-step 0.0d0 1.0d0))
(deriv (make-chebyshev 40))
(integ (make-chebyshev 40)))
(derivative-chebyshev deriv cheb)
(integral-chebyshev integ cheb)
(list
......
;; Tests of array functions
;; Liam Healy 2008-10-20 22:41:48EDT array-tests.lisp
;; Time-stamp: <2008-11-30 22:51:15EST array-tests.lisp>
;; Time-stamp: <2008-12-26 12:23:58EST array-tests.lisp>
;; $Id: $
;;; Generate each file with #'write-test-to-file, e.g.
......@@ -17,7 +17,7 @@
(generate-all-array-tests
vector-set-all-m+ :no-complex
(letm ((v1 (array-default 3 t))
(let ((v1 (array-default 3 t))
(v2 (array-default 3)))
(set-all v1 (scalar-default))
(cl-array (m+ v1 v2))))
......@@ -31,40 +31,40 @@
(generate-all-array-tests
vector-set-zero t
(letm ((v1 (array-default 3)))
(let ((v1 (array-default 3)))
(set-zero v1)
(cl-array v1)))
(generate-all-array-tests
matrix-set-zero t
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(set-zero m1)
(cl-array m1)))
(generate-all-array-tests
vector-copy t
(letm ((v1 (array-default 3))
(let ((v1 (array-default 3))
(v2 (array-default 3 t)))
(copy v2 v1)
(cl-array v2)))
(generate-all-array-tests
matrix-copy t
(letm ((m1 (array-default '(3 3)))
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3) t)))
(copy m2 m1)
(cl-array m2)))
(generate-all-array-tests
vector-swap t
(letm ((v1 (array-default 3))
(let ((v1 (array-default 3))
(v2 (array-default 3)))
(swap v2 v1)
(list (cl-array v1) (cl-array v2))))
(generate-all-array-tests
matrix-swap t
(letm ((m1 (array-default '(3 3)))
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3))))
(swap m2 m1)
(list (cl-array m1) (cl-array m2))))
......@@ -74,59 +74,59 @@
;;;;****************************************************************************
(generate-all-array-tests vector-m+ :no-complex
(letm ((v1 (array-default 3))
(let ((v1 (array-default 3))
(v2 (array-default 3)))
(cl-array (m+ v1 v2))))
(generate-all-array-tests matrix-m+ :no-complex
(letm ((m1 (array-default '(3 3)))
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3))))
(cl-array (m+ m1 m2))))
(generate-all-array-tests vector-m- :no-complex
(letm ((v1 (array-default 3))
(let ((v1 (array-default 3))
(v2 (array-default 3)))
(cl-array (m- v1 v2))))
(generate-all-array-tests matrix-m- :no-complex
(letm ((m1 (array-default '(3 3)))
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3))))
(cl-array (m- m1 m2))))
(generate-all-array-tests vector-mult :no-complex
(letm ((v1 (array-default 3))
(let ((v1 (array-default 3))
(v2 (array-default 3)))
(cl-array (m* v1 v2))))
(generate-all-array-tests matrix-mult :no-complex
(letm ((m1 (array-default '(3 3)))
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3))))
(cl-array (m* m1 m2))))
(generate-all-array-tests vector-div :no-complex
(letm ((v1 (array-default 3))
(let ((v1 (array-default 3))
(v2 (array-default 3)))
(cl-array (m/ v1 v2))))
(generate-all-array-tests matrix-div :no-complex
(letm ((m1 (array-default '(3 3)))
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3))))
(cl-array (m/ m1 m2))))
(generate-all-array-tests vector-mult-scalar :no-complex
(letm ((v1 (array-default 3)))
(let ((v1 (array-default 3)))
(cl-array (m*c v1 1.39d0))))
(generate-all-array-tests matrix-mult-scalar :no-complex
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(cl-array (m*c m1 1.39d0))))
(generate-all-array-tests vector-add-scalar :no-complex
(letm ((v1 (array-default 3)))
(let ((v1 (array-default 3)))
(cl-array (m+c v1 18.19d0))))
(generate-all-array-tests matrix-add-scalar :no-complex
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(cl-array (m+c m1 18.19d0))))
;;;;****************************************************************************
......@@ -134,53 +134,53 @@
;;;;****************************************************************************
(generate-all-array-tests vector-max :no-complex
(letm ((v1 (array-default 3)))
(let ((v1 (array-default 3)))
(mmax v1)))
(generate-all-array-tests matrix-max :no-complex
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(mmax m1)))
#| Temporarily commented out twos-complement answer for SIGNED-BYTE-8 and SIGNED-BYTE-16
(generate-all-array-tests vector-min :no-complex
(letm ((v1 (array-default 3)))
(let ((v1 (array-default 3)))
(mmin v1)))
(generate-all-array-tests matrix-min :no-complex
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(mmin m1)))
|#
(generate-all-array-tests vector-minmax :no-complex
(letm ((v1 (array-default 3)))
(let ((v1 (array-default 3)))
(minmax v1)))
(generate-all-array-tests matrix-minmax :no-complex
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(minmax m1)))
(generate-all-array-tests vector-min-index :no-complex
(letm ((v1 (array-default 8)))
(let ((v1 (array-default 8)))
(min-index v1)))
(generate-all-array-tests matrix-min-index :no-complex
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(min-index m1)))
(generate-all-array-tests vector-max-index :no-complex
(letm ((v1 (array-default 8)))
(let ((v1 (array-default 8)))
(max-index v1)))
(generate-all-array-tests matrix-max-index :no-complex
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(max-index m1)))
(generate-all-array-tests vector-minmax-index :no-complex
(letm ((v1 (array-default 8)))
(let ((v1 (array-default 8)))
(minmax-index v1)))
(generate-all-array-tests matrix-minmax-index :no-complex
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(minmax-index m1)))
;;; No test for mzerop yet.
......@@ -190,17 +190,17 @@
;;;;****************************************************************************
(generate-all-array-tests set-basis t
(letm ((v1 (array-default 8)))
(let ((v1 (array-default 8)))
(set-basis v1 2)
(cl-array v1)))
(generate-all-array-tests swap-elements t
(letm ((v1 (array-default 8)))
(let ((v1 (array-default 8)))
(swap-elements v1 2 5)
(cl-array v1)))
(generate-all-array-tests vector-reverse t
(letm ((v1 (array-default 8)))
(let ((v1 (array-default 8)))
(cl-array (vector-reverse v1))))
;;;;****************************************************************************
......@@ -208,48 +208,48 @@
;;;;****************************************************************************
(generate-all-array-tests set-identity t
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(cl-array (set-identity m1))))
(generate-all-array-tests row t
(letm ((m1 (array-default '(3 3)))
(let ((m1 (array-default '(3 3)))
(row (array-default 3 t)))
(cl-array (row row m1 1))))
(generate-all-array-tests setf-row t
(letm ((m1 (array-default '(3 3)))
(let ((m1 (array-default '(3 3)))
(row (array-default 3)))
(setf (row m1 2) row)
(cl-array m1)))
(generate-all-array-tests column t
(letm ((m1 (array-default '(3 3)))
(let ((m1 (array-default '(3 3)))
(col (array-default 3 t)))
(cl-array (column col m1 1))))
(generate-all-array-tests setf-column t
(letm ((m1 (array-default '(3 3)))
(let ((m1 (array-default '(3 3)))
(col (array-default 3)))
(setf (column m1 2) col)
(cl-array m1)))
(generate-all-array-tests swap-rows t
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(cl-array (swap-rows m1 0 1))))
(generate-all-array-tests swap-columns t
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(cl-array (swap-columns m1 1 2))))
(generate-all-array-tests swap-row-column t
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(cl-array (swap-row-column m1 0 2))))
(generate-all-array-tests matrix-transpose t
(letm ((m1 (array-default '(3 3))))
(let ((m1 (array-default '(3 3))))
(cl-array (matrix-transpose m1))))
(generate-all-array-tests matrix-transpose-copy t
(letm ((m1 (array-default '(3 3)))
(let ((m1 (array-default '(3 3)))
(m2 (array-default '(3 3) t)))
(cl-array (matrix-transpose-copy m2 m1))))
;; A "marray" is an array in both GSL and CL
;; Liam Healy 2008-04-06 21:23:41EDT
;; Time-stamp: <2008-12-26 10:25:50EST marray.lisp>
;; Time-stamp: <2008-12-26 12:49:10EST marray.lisp>
;; $Id$
(in-package :gsl)
......@@ -283,6 +283,6 @@
(unless (eq blockptr array-struct)
(cffi:foreign-free blockptr))
(cffi:foreign-free array-struct)))
(setf (mpointer object) array-struct))))))
(setf (slot-value object 'mpointer) array-struct))))))
;;; For #-native, do the whole thing using _alloc, _free functions.
;; Eigenvectors and eigenvalues
;; Liam Healy, Sun May 21 2006 - 19:52
;; Time-stamp: <2008-12-26 10:28:19EST eigensystems.lisp>
;; Time-stamp: <2008-12-26 11:14:06EST eigensystems.lisp>
;; $Id$
(in-package :gsl)
......@@ -9,112 +9,33 @@
;;;; Workspace
;;;;****************************************************************************
#|
(defmobject eigen-symm
"gsl_eigen_symm" ((n sizet))
"symmetric eigenvalue workspace" ; FDL
"Make a workspace for computing eigenvalues of
n-by-n real symmetric matrices. The size of the workspace
is O(2n).")
|#
(defgo-s (eigen-symm n) eigen-symm-alloc eigen-symm-free)
(defmfun eigen-symm-alloc (n)
"gsl_eigen_symm_alloc" ((n sizet))
:c-return :pointer
:export nil
:index '(letm eigen-symm)
:documentation ; FDL
"Allocate a workspace for computing eigenvalues of
n-by-n real symmetric matrices. The size of the workspace
is O(2n).")
(defmfun eigen-symm-free (w)
"gsl_eigen_symm_free" ((w :pointer))
:c-return :void
:export nil
:index '(letm eigen-symm)
:documentation ; FDL
"Free the memory associated with the workspace w.")
#|
(defmobject eigen-symmv
"gsl_eigen_symmv" ((n sizet))
"symmetric eigensystem workspace" ; FDL
"Make a workspace for computing eigenvalues and
eigenvectors of n-by-n real symmetric matrices. The size of
the workspace is O(4n).")
|#
(defgo-s (eigen-symmv n) eigen-symmv-alloc eigen-symmv-free)
(defmfun eigen-symmv-alloc (n)
"gsl_eigen_symmv_alloc" ((n sizet))
:c-return :pointer
:export nil
:index '(letm eigen-symmv)
:documentation ; FDL
"Allocate a workspace for computing eigenvalues and
eigenvectors of n-by-n real symmetric matrices. The size of
the workspace is O(4n).")
(defmfun eigen-symmv-free (w)
"gsl_eigen_symmv_free" ((w :pointer))
:index '(letm eigen-symmv)
:c-return :void
:documentation ; FDL
"Free the memory associated with the workspace w.")
#|
(defmobject eigen-herm
"gsl_eigen_herm" ((n sizet))
"Hermitian eigenvalue workspace" ; FDL
"Make a workspace for computing eigenvalues of
n-by-n complex Hermitian matrices. The size of the workspace
is O(3n).")
|#
(defgo-s (eigen-herm n) eigen-herm-alloc eigen-herm-free)
(defmfun eigen-herm-alloc (n)
"gsl_eigen_herm_alloc" ((n sizet))
:documentation ; FDL
"Allocate a workspace for computing eigenvalues of
n-by-n complex hermitian matrices. The size of the workspace
is O(3n)."
:c-return :pointer)
(defmfun eigen-herm-free (w)
"gsl_eigen_herm_free" ((w :pointer))
:c-return :void
:documentation ; FDL
"Free the memory associated with the workspace w.")
#|
(defmobject eigen-hermv
"gsl_eigen_hermv" ((n sizet))
"Hermitian eigensystem workspace" ; FDL
"Make a workspace for computing eigenvalues and
eigenvectors of n-by-n complex hermitian matrices. The size of
the workspace is O(5n).")
|#
(defgo-s (eigen-hermv n) eigen-hermv-alloc eigen-hermv-free)
(defmfun eigen-hermv-alloc (n)
"gsl_eigen_hermv_alloc" ((n sizet))
:documentation ; FDL
"Allocate a workspace for computing eigenvalues and
eigenvectors of n-by-n complex hermitian matrices. The size of
the workspace is O(5n)."
:c-return :pointer)
(defmfun eigen-hermv-free (w)
"gsl_eigen_hermv_free" ((w :pointer))
:c-return :void
:documentation ; FDL
"Free the memory associated with the workspace w.")
;;;;****************************************************************************
;;;; Eigenvalues and eigenvectors
......@@ -194,9 +115,9 @@
;;;;****************************************************************************
(defun eigenvalue-eigenvectors-example ()
(letm ((evecs (make-marray 'double-float :dimensions '(3 3)))
(let ((evecs (make-marray 'double-float :dimensions '(3 3)))
(evals (make-marray 'double-float :dimensions 3))
(ws (eigen-symmv 3))
(ws (make-eigen-symmv 3))
(mat #m((20.0d0 -10.0d0 0.0d0)
(-10.0d0 30.0d0 0.0d0)
(0.0d0 0.0d0 40.0d0))))
......
;; Discrete Hankel Transforms.
;; Liam Healy, Sat Dec 8 2007 - 16:50
;; Time-stamp: <2008-12-21 21:38:24EST hankel.lisp>
;; Time-stamp: <2008-12-26 11:56:49EST hankel.lisp>
;; $Id$
(in-package :gsl)
#|
;;; Everything compiles, but not tested -- need example.
;;; Create the Hankel transform object and essential methods/functions.
(defmobject hankel "gsl_dht"
((size sizet))
......@@ -14,52 +15,7 @@
optionally initialize the transform for the given values of nu and x."
"new"
((nu :double) (xmax :double)))
|#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Everything compiles, but not tested -- need example.
(defgo-s (hankel size nu xmax) allocate-hankel free-hankel init-hankel)
(defmfun allocate-hankel (size)
"gsl_dht_alloc"
((size sizet))
:c-return :pointer
:export nil
:index (letm hankel)
:documentation ; FDL
"Allocate a Discrete Hankel transform object of given size.")
(defmfun init-hankel (hankel nu xmax)
"gsl_dht_new"
((hankel :pointer) (nu :double) (xmax :double))
:export nil
:index (letm hankel)
:documentation ; FDL
"Initialize the transform for the given values of nu and x.")
;; This seems redundant; does it effectively combine allocate-hankel
;; and init-hankel? In this case we don't really need, and shouldn't
;; export it.
(defmfun new-hankel (size nu xmax)
"gsl_dht_new"
((size sizet) (nu :double) (xmax :double))
:c-return :pointer
:documentation ; FDL
"Allocate a Discrete Hankel transform object of size
size and initializes it for the given values of nu and
xmax.")
(defmfun free-hankel (hankel)
"gsl_dht_free"
((hankel :pointer))
:c-return :void
:export nil
:index (letm hankel)
:documentation ; FDL
"Free the Hankel object.")
;;; We don't use gsl_dht_init because we use gsl_dht_new?
(defmfun apply-hankel (hankel array-in array-out)
"gsl_dht_apply"
......
;; The histogram structure
;; Liam Healy, Mon Jan 1 2007 - 11:32
;; Time-stamp: <2008-12-25 22:49:25EST histogram.lisp>
;; Time-stamp: <2008-12-26 12:31:18EST histogram.lisp>
;; $Id$
(in-package :gsl)
......@@ -32,7 +32,7 @@
(export 'set-ranges-uniform)
(defgeneric set-ranges-uniform
(histogram minimum maximum &optional minimum2 maximum2 )
(histogram minimum maximum &optional minimum2 maximum2)
(:documentation ;; FDL
"Set the ranges of the existing histogram h to cover
the range xmin to xmax uniformly. The values of the
......@@ -46,7 +46,8 @@
;;; GSL documentation does not state what the return value for the
;;; C function for set-ranges-uniform means; assumed to be error code.
(defmfun set-ranges-uniform ((histogram histogram) minimum maximum)
(defmfun set-ranges-uniform
((histogram histogram) minimum maximum &optional minimum2 maximum2)
"gsl_histogram_set_ranges_uniform"
(((mpointer histogram) :pointer) (minimum :double) (maximum :double))
:definition :method
......@@ -55,7 +56,8 @@
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun set-ranges-uniform
((histogram histogram2d) x-minimum x-maximum &optional y-minimum y-maximum)
((histogram histogram2d) x-minimum x-maximum
&optional (y-minimum 0.0d0) (y-maximum 100.0d0))
"gsl_histogram2d_set_ranges_uniform"
(((mpointer histogram) :pointer)
(x-minimum :double) (x-maximum :double)
......
;; Histogram operations
;; Liam Healy, Mon Jan 1 2007 - 16:47
;; Time-stamp: <2008-08-31 10:05:41EDT operations.lisp>
;; Time-stamp: <2008-12-26 14:47:49EST operations.lisp>
;; $Id$
(in-package :gsl)
(defmfun equal-bins-p-1 (histogram1 histogram2)
(export 'equal-bins-p)
(defgeneric equal-bins-p (histogram1 histogram2)
(:documentation ;; FDL
"Are all of the individual bin ranges of the two histograms are identical?"))