Commit 0d2f9357 authored by Liam Healy's avatar Liam Healy

Complete definition of GSL objects with defmobject

Defined make-load-form method for data.  For histogram and random
number generators, old code has been removed.  Nothing has been
compiled.
parent e5e286ac
;; "Data" is bulk arrayed data, like vectors, matrices, permutations,
;; combinations, or histograms.
;; Liam Healy 2008-04-06 21:23:41EDT
;; Time-stamp: <2008-12-21 17:58:34EST data.lisp>
;; Time-stamp: <2008-12-25 09:40:55EST data.lisp>
;; $Id$
(in-package :gsl)
......@@ -66,6 +66,17 @@
#-native (copy-c-to-cl object)
(princ (cl-array object) stream)))
(defmethod make-load-form ((object gsl-data) &optional env)
(declare (ignore env))
`(make-array*
',(element-type object)
:initial-contents
',(loop for elt across
(subseq (original-array object)
(offset object)
(+ (offset object) (total-size object)))
collect elt)))
(defun dim0 (object)
"The first dimension of the object."
(first (dimensions object)))
......
;; Eigenvectors and eigenvalues
;; Liam Healy, Sun May 21 2006 - 19:52
;; Time-stamp: <2008-11-30 23:37:31EST eigensystems.lisp>
;; Time-stamp: <2008-12-25 11:28:44EST eigensystems.lisp>
;; $Id$
(in-package :gsl)
......@@ -9,6 +9,15 @@
;;;; 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)
......@@ -29,6 +38,15 @@
: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)
......@@ -48,6 +66,15 @@
: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)
......@@ -64,6 +91,15 @@
: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)
......
;; The histogram structure
;; Liam Healy, Mon Jan 1 2007 - 11:32
;; Time-stamp: <2008-11-16 13:46:24EST histogram.lisp>
;; Time-stamp: <2008-12-25 14:30:48EST histogram.lisp>
;; $Id$
(in-package :gsl)
;;; Define, make, copy histograms in one or two dimensions.
(defgo histogram (size &rest from-or-ranges)
(list `(make-histogram ,size
,(when from-or-ranges
`(when (typep (first ,from-or-ranges) 'histogram)
(first ,from-or-ranges))))
'free
(when from-or-ranges
(lambda (sym)
`(unless (typep (first ,from-or-ranges) 'histogram)
(set-ranges ,sym ,@from-or-ranges))))))
(defclass histogram ()
((pointer
:initarg :pointer :accessor mpointer
:documentation "A C pointer to the GSL representation of the histogram.")
(number-of-bins :initarg :number-of-bins :accessor number-of-bins))
(:documentation
"A histogram, including bin boundaries and bin contents."))
(defun assign-pointer (object pointer)
"Check that a GSL data pointer is not null, then assign it to the object."
(check-null-pointer
pointer
'memory-allocation-failure
(format nil "for ~a."
(with-output-to-string (stream) (princ object stream))))
(setf (mpointer object) pointer))
(defmfun alloc-histo-1 (object)
"gsl_histogram_alloc"
(((number-of-bins object) sizet))
:export nil
:index (letm histogram)
:c-return (cr :pointer)
:return ((assign-pointer object cr)))
(defmfun alloc-histo-2 (object)
"gsl_histogram2d_alloc"
(((first (number-of-bins object)) sizet)
((second (number-of-bins object)) sizet))
:export nil
:index (letm histogram)
:c-return (cr :pointer)
:return ((assign-pointer object cr)))
(defmacro histo-1d2d
(object base-function-name &optional args1 args2)
`(if (listp (number-of-bins ,object))
(,(intern
(concatenate 'string (string base-function-name) "-2"))
,object ,@(or args2 args1))
(,(intern
(concatenate 'string (string base-function-name) "-1"))
,object ,@args1)))
(defmethod alloc ((object histogram))
(histo-1d2d object alloc-histo))
(defmfun free-histo-1 (object)
"gsl_histogram_free"
(((mpointer object) :pointer))
:c-return :void
:export nil
:index (letm histogram))
(defmfun free-histo-2 (object)
"gsl_histogram2d_free"
(((mpointer object) :pointer))
:c-return :void
:export nil
:index (letm histogram))
(defmethod free ((object histogram))
(histo-1d2d object free-histo))
;; /usr/include/gsl/gsl_histogram.h
;; /usr/include/gsl/gsl_histogram2d.h
(defmobject histogram
"gsl_histogram"
((number-of-bins sizet))
"one-dimensional histogram, including bin boundaries and bin contents."
NIL
"set_ranges"
(((c-pointer ranges) :pointer) ((dim0 ranges) sizet)))
(defmobject histogram2d
"gsl_histogram2d"
((number-of-bins-x sizet) (number-of-bins-y sizet))
"two-dimensional histogram, including bin boundaries and bin contents."
NIL
"set_ranges"
(((c-pointer x-ranges) :pointer) ((dim0 x-ranges) sizet)
((c-pointer y-ranges) :pointer) ((dim0 y-ranges) sizet)))
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun set-ranges-1 (histogram ranges)
"gsl_histogram_set_ranges"
(((mpointer histogram) :pointer)
((c-pointer ranges) :pointer) ((dim0 ranges) sizet))
:export nil
:index (letm histogram)
:documentation ; FDL
"Set the ranges of the existing histogram using
the gsl-vector of ranges. The values of the histogram
bins are reset to zero. The ranges array should contain the
desired bin limits. The ranges can be arbitrary, subject to the
restriction that they are monotonically increasing.")
;;; C function for reinitialization means; assumed to be error code.
(defmfun set-ranges-2 (histogram x-ranges y-ranges)
"gsl_histogram2d_set_ranges"
(((mpointer histogram) :pointer)
((c-pointer x-ranges) :pointer) ((dim0 x-ranges) sizet)
((c-pointer y-ranges) :pointer) ((dim0 y-ranges) sizet))
:export nil
:index (letm histogram))
(export 'set-ranges)
(defun set-ranges (histogram &rest ranges)
"Set the ranges of the existing histogram using
the gsl-vector(s) of ranges. The values of the histogram
bins are reset to zero. The ranges array(s) should contain the
desired bin limits. The ranges can be arbitrary, subject to the
restriction that they are monotonically increasing.
For a 2d histogram, supply two gsl-vectors."
(histo-1d2d histogram set-ranges
((first ranges))
((first ranges) (second ranges))))
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun set-ranges-uniform-1 (histogram minimum maximum)
"gsl_histogram_set_ranges_uniform"
(((mpointer histogram) :pointer) (minimum :double) (maximum :double))
:export nil
:index set-ranges-uniform
:documentation ; FDL
"Set the ranges of the existing histogram h to cover
(export 'set-ranges-uniform)
(defgeneric set-ranges-uniform
(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
histogram bins are reset to zero. The bin ranges are shown in the table
below,
......@@ -133,87 +42,68 @@
bin[1] corresponds to xmin + d <= x < xmin + 2 d
......
bin[n-1] corresponds to xmin + (n-1)d <= x < xmax
where d is the bin spacing, d = (xmax-xmin)/n.")
where d is the bin spacing, d = (xmax-xmin)/n."))
;;; 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)
"gsl_histogram_set_ranges_uniform"
(((mpointer histogram) :pointer) (minimum :double) (maximum :double))
:definition :method
:return (histogram))
;;; GSL documentation does not state what the return value for the
;;; C function means; assumed to be error code.
(defmfun set-ranges-uniform-2
(histogram x-minimum x-maximum y-minimum y-maximum)
(defmfun set-ranges-uniform
((histogram histogram2d) x-minimum x-maximum &optional y-minimum y-maximum)
"gsl_histogram2d_set_ranges_uniform"
(((mpointer histogram) :pointer)
(x-minimum :double) (x-maximum :double)
(y-minimum :double) (y-maximum :double))
:export nil
:index set-ranges-uniform)
(export 'set-ranges-uniform)
(defun set-ranges-uniform (histogram &rest limits)
;; FDL
"Set the ranges of the existing histogram h to cover
the range xmin to xmax uniformly. The values of the
histogram bins are reset to zero. The bin ranges are shown in the table
below,
bin[0] corresponds to xmin <= x < xmin + d
bin[1] corresponds to xmin + d <= x < xmin + 2 d
......
bin[n-1] corresponds to xmin + (n-1)d <= x < xmax
where d is the bin spacing, d = (xmax-xmin)/n."
(histo-1d2d histogram set-ranges-uniform
((first limits) (second limits))
((first limits) (second limits)
(third limits) (fourth limits))))
:definition :method
:return (histogram))
(defmfun copy-1 (destination source)
(defmfun copy ((destination histogram) (source histogram))
"gsl_histogram_memcpy"
(((mpointer destination) :pointer) ((mpointer source) :pointer))
:export nil
:index copy
:definition :method
:return (destination)
:documentation ; FDL
"Copy the histogram source into the pre-existing
histogram destination, making the latter into
an exact copy of the former.
The two histograms must be of the same size.")
(defmfun copy-2 (destination source)
(defmfun copy ((destination histogram2d) (source histogram2d))
"gsl_histogram2d_memcpy"
(((mpointer destination) :pointer) ((mpointer source) :pointer))
:export nil
:index copy)
:definition :method
:return (destination)
:documentation ; FDL
"Copy the histogram source into the pre-existing
histogram destination, making the latter into
an exact copy of the former.
The two histograms must be of the same size.")
(defmethod copy ((destination histogram) (source histogram))
(histo-1d2d destination copy (source)))
;;; Could be part of copy when the second argument is optional?
(export 'clone)
(defgeneric clone (object)
(:documentation "Create a duplicate object."))
(defmfun clone-1 (source)
"gsl_histogram_memcpy"
;;; This returns a bare C pointer, which isn't too useful.
(defmfun clone ((source histogram))
"gsl_histogram_clone"
(((mpointer source) :pointer))
:export nil
:index clone
:c-return :pointer
:definition :method
:documentation ; FDL
"Create a new histogram which is an
exact copy of the histogram source, and return the pointer.")
(defmfun clone-2 (source)
"gsl_histogram2d_memcpy"
(defmfun clone (source)
"gsl_histogram2d_clone"
(((mpointer source) :pointer))
:export nil
:index clone
:definition :method
:documentation ; FDL
"Create a new histogram which is an
exact copy of the histogram source, and return the pointer.")
(export 'clone)
(defun clone (source)
;; FDL
"Create a new histogram which is an
exact copy of the histogram source, and return the pointer."
(histo-1d2d source clone))
(defun make-histogram (size &optional from)
"Make a histogram, optionally filling it with
data from an existing histogram."
(let ((ret
(make-instance 'histogram :number-of-bins size
:pointer (when from (clone from)))))
(unless (mpointer ret)
(alloc ret))
ret))
;; Histogram probability distribution.
;; Liam Healy, Mon Jan 1 2007 - 17:51
;; Time-stamp: <2008-11-16 13:26:02EST probability-distribution.lisp>
;; Time-stamp: <2008-12-25 13:06:55EST probability-distribution.lisp>
;; $Id$
(in-package :gsl)
(defclass histogram-pdf ()
((pointer
:initarg :pointer :accessor mpointer
:documentation
"A C pointer to the GSL representation of the histogram.")
(number-of-bins :initarg :number-of-bins :accessor number-of-bins))
(:documentation
"A histogram, including bin boundaries and bin contents."))
;; /usr/include/gsl/gsl_histogram.h
;; /usr/include/gsl/gsl_histogram2d.h
(defmfun alloc-1 (object)
"gsl_histogram_pdf_alloc"
(((number-of-bins object) sizet))
:export nil
:index alloc
:c-return (cr :pointer)
:return ((assign-pointer object cr)))
(defmfun alloc-2 (object)
"gsl_histogram2d_pdf_alloc"
(((number-of-bins object) sizet))
:export nil
:index alloc
:c-return (cr :pointer)
:return ((assign-pointer object cr)))
(defmethod alloc ((object histogram-pdf))
(histo-1d2d object alloc))
(defmfun free-1 (object)
"gsl_histogram_pdf_free"
(((mpointer object) :pointer))
:export nil
:index free
:c-return :void)
(defmfun free-2 (object)
"gsl_histogram2d_pdf_free"
(((mpointer object) :pointer))
:export nil
:index free
:c-return :void)
(defmethod free ((object histogram-pdf))
(histo-1d2d object free))
(defmfun pdf-init-1 (pdf histogram)
"gsl_histogram_pdf_init"
(((mpointer pdf) :pointer) ((mpointer histogram) :pointer))
:return ()
:export nil
:index pdf-init
:documentation ; FDL
"Initialize the probability distribution pdf with the contents
(defmobject histogram-pdf
"gsl_histogram_pdf"
((number-of-bins sizet))
"one-dimensional histogram PDF"
"Optionally initialize the probability distribution pdf with the contents
of the histogram. If any of the bins are negative then an
input-domain error is signalled because a probability distribution
cannot contain negative values.")
(defmfun pdf-init-2 (pdf histogram)
"gsl_histogram2d_pdf_init"
(((mpointer pdf) :pointer) ((mpointer histogram) :pointer))
:return ()
:export nil
:index pdf-init
:documentation ; FDL
"Initialize the probability distribution pdf with the contents
of the histogram. If any of the bins are negative then an
input-domain error is signalled because a probability distribution
cannot contain negative values.")
(export 'pdf-init)
(defun pdf-init (pdf histogram) ; FDL
"Initialize the probability distribution pdf with the contents
cannot contain negative values."
"init"
(((mpointer histogram) :pointer)))
(defmobject histogram2d-pdf
"gsl_histogram2d_pdf"
((number-of-bins-x sizet) (number-of-bins-y sizet))
"two-dimensional histogram PDF"
"Optionally initialize the probability distribution pdf with the contents
of the histogram. If any of the bins are negative then an
input-domain error is signalled because a probability distribution
cannot contain negative values."
(histo-1d2d pdf pdf-init (histogram)))
"init"
(((mpointer histogram) :pointer)))
(defmfun sample-1 (pdf value)
"gsl_histogram_pdf_sample"
(((mpointer pdf) :pointer) (value :double))
:c-return :double
:export nil
:index sample
:documentation ; FDL
"Given a uniform random number between zero and one,
(export 'sample)
(defgeneric sample (pdf value)
(:documentation ;; FDL
"Given a uniform random number between zero and one,
compute a single random sample from the probability distribution
'pdf. The algorithm used to compute the sample s is given by
s = range[i] + delta * (range[i+1] - range[i])
where i is the index which satisfies
sum[i] <= r < sum[i+1] and delta is
(r - sum[i])/(sum[i+1] - sum[i]).")
(r - sum[i])/(sum[i+1] - sum[i])."))
(defmfun sample ((pdf histogram-pdf) value)
"gsl_histogram_pdf_sample"
(((mpointer pdf) :pointer) (value :double))
:definition :method
:c-return :double)
(defmfun sample-2 (pdf value)
"gsl_histogram2d_pdf_sample"
(((mpointer pdf) :pointer) (value :double))
:c-return :double
:export nil
:index sample
:documentation ; FDL
"Given a uniform random number between zero and one,
compute a single random sample from the probability distribution
'pdf. The algorithm used to compute the sample s is given by
s = range[i] + delta * (range[i+1] - range[i])
where i is the index which satisfies
sum[i] <= r < sum[i+1] and delta is
(r - sum[i])/(sum[i+1] - sum[i]).")
:definition :method
:c-return :double)
;; Definition of GSL objects and ways to use them.
;; Liam Healy, Sun Dec 3 2006 - 10:21
;; Time-stamp: <2008-12-23 19:30:28EST gsl-objects.lisp>
;; Time-stamp: <2008-12-25 12:03:18EST gsl-objects.lisp>
;; $Id$
(in-package :gsl)
......@@ -11,8 +11,14 @@
:documentation "A pointer to the GSL representation of the object.")))
(defmacro defmobject
(class prefix allocation-args description docstring
&optional initialize-suffix initialize-args arglists-function)
(class prefix allocation-args description
&optional docstring initialize-suffix initialize-args arglists-function
inputs)
"Define the class, initialize-instance and reinitialize-instance methods,
and the make-* function for the GSL object."
;; If prefix is a list, the first is the actual prefix, and the
;; second is the name of the allocateor. I'm looking at you,
;; discrete-random. Grrr.
(let* ((settingp (make-symbol "SETTINGP"))
(arglists
(when arglists-function
......@@ -21,7 +27,8 @@
(maker (intern (format nil "MAKE-~:@(~a~)" class) :gsl))
(cl-alloc-args (variables-used-in-c-arguments allocation-args))
(cl-initialize-args
(variables-used-in-c-arguments initialize-args)))
(variables-used-in-c-arguments initialize-args))
(realprefix (if (listp prefix) (first prefix) prefix)))
`(progn
(defclass ,class (mobject)
()
......@@ -29,7 +36,7 @@
,(format nil "The GSL representation of the ~a." description)))
(defmfun initialize-instance ((object ,class) &key ,@cl-alloc-args)
,(format nil "~a_alloc" prefix)
,(if (listp prefix) (second prefix) (format nil "~a_alloc" prefix))
,allocation-args
:definition :method
:qualifier :after
......@@ -38,18 +45,23 @@
(tg:finalize
object
(lambda ()
(foreign-funcall ,(format nil "~a_free" prefix) :pointer ,mptr :void))))
(foreign-funcall ,(format nil "~a_free" realprefix)
:pointer ,mptr :void))))
:return (object)
:export nil
:index ,maker)
,@(when initialize-suffix
`((defmfun reinitialize-instance ((object ,class) &key ,@cl-initialize-args)
,(format nil "~a_~a" prefix initialize-suffix)
`((defmfun reinitialize-instance
,(if initialize-args
`((object ,class) &key ,@cl-initialize-args)
`((object ,class)))
,(format nil "~a_~a" realprefix initialize-suffix)
(((mpointer object) :pointer) ,@initialize-args)
:definition :method
:qualifier :after
:return (object)
,@(when inputs `(:inputs ,inputs))
:export nil
:index (reinitialize-instance ,class))))
......@@ -58,12 +70,12 @@
,(if arglists
(first arglists)
`(,@cl-alloc-args
,@(when initialize-suffix
,@(when initialize-args
(append
(list '&optional
(list (first cl-initialize-args) nil settingp))
(rest cl-initialize-args)))))
,(format nil "Create the GSL object representing a ~a (class ~a).~&~a"
,(format nil "Create the GSL object representing a ~a (class ~a).~@[~&~a~]"
description class docstring)
(let ((object
(make-instance
......@@ -71,13 +83,16 @@
,@(if arglists
(second arglists)
(symbol-keyword-symbol cl-alloc-args)))))
;; There is an initialization step
,@(when initialize-suffix
`((when ,settingp
(reinitialize-instance
object
,@(if arglists
(third arglists)
(symbol-keyword-symbol cl-initialize-args))))))
(if initialize-args ; with arguments
`((when ,settingp
(reinitialize-instance
object
,@(if arglists
(third arglists)
(symbol-keyword-symbol cl-initialize-args)))))
'((reinitialize-instance object)))) ; without arguments
object)))))
(defun symbol-keyword-symbol (symbol)
......
;; Macros to interface GSL functions, including definitions necessary for defmfun.
;; Liam Healy
;; Time-stamp: <2008-11-16 18:57:24EST interface.lisp>
;; Time-stamp: <2008-12-25 14:11:57EST interface.lisp>
;; $Id$
(in-package :gsl)
......@@ -126,10 +126,11 @@
;;;; Variables in library
;;;;****************************************************************************
(defmacro defmpar (cl-symbol gsl-symbol documentation)
(defmacro defmpar
(cl-symbol gsl-symbol documentation &optional (c-type :pointer) (read-only t))
"Define a library variable pointer."
`(progn
(cffi:defcvar (,gsl-symbol ,cl-symbol :read-only t) :pointer
(cffi:defcvar (,gsl-symbol ,cl-symbol :read-only ,read-only) ,c-type
,documentation)
(map-name ',cl-symbol ,gsl-symbol)
(export ',cl-symbol)))
......
;; Index lookup and acceleration
;; Liam Healy, Sun Nov 4 2007 - 18:09
;; Time-stamp: <2008-12-21 22:20:36EST lookup.lisp>
;; Time-stamp: <2008-12-25 11:11:51EST lookup.lisp>
;; $Id$
(in-package :gsl)
......@@ -11,7 +11,7 @@
(defmobject acceleration "gsl_interp_accel"
()
"acceleration for interpolation" ; FDL
"Allocate an accelerator object, which is a
"Make an accelerator object, which is a
kind of iterator for interpolation lookups. It tracks the state of
lookups, thus allowing for application of various acceleration
strategies.")
......
;; Monte Carlo Integration
;; Liam Healy Sat Feb 3 2007 - 17:42
;; Time-stamp: <2008-11-30 23:04:24EST monte-carlo.lisp>
;; Time-stamp: <2008-12-25 11:42:39EST monte-carlo.lisp>
;; $Id$
(in-package :gsl)
......@@ -13,6 +13,16 @@
(dim sizet)
(x :pointer))
#|
(defmobject monte-carlo-plain
"gsl_monte_plain"
((dim sizet))
"plain Monte Carlo integration" ; FDL
"Make and initialize a workspace for Monte Carlo integration in dim dimensions."
"init"
nil)
|#
(defgo-s (monte-carlo-plain dim) monte-carlo-plain-alloc monte-carlo-plain-free)
(defmfun monte-carlo-plain-alloc (dim)
......@@ -97,6 +107,18 @@
(hits-l :pointer)
(hits-r :pointer))
#|
(defmobject monte-carlo-miser
"gsl_monte_miser"
((dim sizet))
"miser Monte Carlo integration" ; FDL
"Make and initialize a workspace for Monte Carlo integration in
dim dimensions. The workspace is used to maintain
the state of the integration."
"init"
nil)
|#
(defgo-s (monte-carlo-miser dim) monte-carlo-miser-alloc monte-carlo-miser-free)
(defmfun monte-carlo-miser-alloc (dim)
......@@ -201,6 +223,18 @@
(calls-per-box :uint)
(ostream :pointer))
#|
(defmobject monte-carlo-vegas
"gsl_monte_vegas"
((dim sizet))
"vegas Monte Carlo integration" ; FDL
"Make and initialize a workspace for Monte Carlo integration in
dim dimensions. The workspace is used to maintain
the state of the integration. Returns a pointer to vegas-state."
"init"
nil)
|#
(defgo-s (monte-carlo-vegas dim) monte-carlo-vegas-alloc monte-carlo-vegas-free)
(defmfun monte-carlo-vegas-alloc (dim)
......
;; Numerical integration
;; Liam Healy, Wed Jul 5 2006 - 23:14
;; Time-stamp: <2008-12-07 18:51:13EST numerical-integration.lisp>
;; Time-stamp: <2008-12-25 11:22:57EST numerical-integration.lisp>
;; $Id$
;;; To do: QAWS, QAWO, QAWF, more tests
......@@ -36,6 +36,14 @@
;;;; QAG adaptive Gauss-Kronrod integration
;;;;****************************************************************************
#|
(defmobject integration-workspace
"gsl_integration_workspace" ((size sizet))
"integration workspace" ; FDL
"Make a workspace sufficient to hold n double
precision intervals, their integration results and error estimates.")
|#
(defgo-s