From ce261d71f3ac90cf3e5f01b9c9e9c9aceba2189b Mon Sep 17 00:00:00 2001
From: Liam Healy <liam@thinkpad.local>
Date: Sun, 20 Dec 2009 23:19:39 -0500
Subject: [PATCH] Move symbol-type and number-conversion to grid

Move number-conversion.lisp from init/ to grid/ and symbol-type
portion of init/interface.lisp to grid/symbol-type.lisp.
All tests pass
TOTAL: 1627 assertions passed, 6 failed, 0 execution errors.
---
 grid/number-conversion.lisp                  | 36 +++++++++++
 grid/symbol-type.lisp                        | 46 +++++++++++++
 gsll.asd                                     | 14 ++--
 init/body-expand.lisp                        | 68 ++++++++++++--------
 init/callback.lisp                           |  4 +-
 init/defmfun-array.lisp                      |  4 +-
 init/defmfun-single.lisp                     |  4 +-
 init/interface.lisp                          | 53 ++++-----------
 init/number-conversion.lisp                  | 57 ----------------
 solve-minimize-fit/linear-least-squares.lisp |  6 +-
 solve-minimize-fit/minimization-multi.lisp   |  4 +-
 special-functions/coulomb.lisp               | 12 ++--
 special-functions/gamma.lisp                 |  6 +-
 13 files changed, 163 insertions(+), 151 deletions(-)
 create mode 100644 grid/number-conversion.lisp
 create mode 100644 grid/symbol-type.lisp
 delete mode 100644 init/number-conversion.lisp

diff --git a/grid/number-conversion.lisp b/grid/number-conversion.lisp
new file mode 100644
index 00000000..35dd0fa4
--- /dev/null
+++ b/grid/number-conversion.lisp
@@ -0,0 +1,36 @@
+;; Conversion of numbers C->CL
+;; Liam Healy, Sun May 28 2006 - 22:04
+;; Time-stamp: <2009-12-20 23:12:25EST number-conversion.lisp>
+;; $Id$
+
+(in-package :c-array)
+
+(export '(complex-to-cl))
+
+;;;;****************************************************************************
+;;;; Built-in numerical types
+;;;;****************************************************************************
+
+(export '(dcref))
+
+(defmacro dcref (double &optional (index 0))
+  "Reference C double(s)."
+  `(cffi:mem-aref ,double :double ,index))
+
+;;;;****************************************************************************
+;;;; Complex numbers
+;;;;****************************************************************************
+
+;;; GSL complex struct is defined in init/complex-types.lisp.
+(defun complex-to-cl
+    (gsl-complex &optional (index 0) (complex-type 'complex-double-c))
+  "Make a CL complex number from the GSL pointer to a complex struct or
+   an array of complex structs and an index into the array." 
+  (let ((carr (cffi:foreign-slot-value
+	       (cffi:inc-pointer
+		gsl-complex
+		(* index (cffi:foreign-type-size complex-type)))
+	       complex-type 'dat)))
+    (complex (dcref carr 0)
+	     (dcref carr 1))))
+	
diff --git a/grid/symbol-type.lisp b/grid/symbol-type.lisp
new file mode 100644
index 00000000..55bccc21
--- /dev/null
+++ b/grid/symbol-type.lisp
@@ -0,0 +1,46 @@
+;; Symbol-type declaration
+;; Liam Healy 2009-12-20 22:27:54EST symbol-type.lisp
+;; Time-stamp: <2009-12-20 22:41:13EST symbol-type.lisp>
+
+;;; An "st" or symbol-type is a list (symbol type) where
+;;; type could be (element-type array-dim).  These are examples of lists
+;;; of sts: 
+ ;; ((#:RET3500 SF-RESULT))
+ ;; ((#:RET3501 (:DOUBLE (- NMAX NMIN)))) 
+ ;; ((#:RET3502 (:DOUBLE (1+ KMAX))) (#:RET3503 (:DOUBLE (1+ KMAX)))
+ ;;  (#:RET3504 (:DOUBLE (1+ KMAX))) (#:RET3505 (:DOUBLE (1+ KMAX)))
+ ;;  (#:RET3506 :DOUBLE) (#:RET3507 :DOUBLE))
+
+(in-package :c-array)
+
+(export
+ '(make-st st-symbol st-type st-pointerp st-actual-type
+   st-pointer-generic-pointer))
+
+(defun make-st (symbol type)
+  (list symbol type))
+
+(defun st-symbol (decl)
+  (first decl))
+
+(defun st-type (decl)
+  (second decl))
+
+(defun st-pointerp (decl)
+  "If this st represents a pointer, return the type of the object."
+  (if
+   (eq (st-type decl) :pointer)
+   t				   ; return T for type if unknown type
+   (if (and (listp (st-type decl))
+	    (eq (first (st-type decl)) :pointer))
+       (second (st-type decl)))))
+
+(defun st-actual-type (decl)
+  (or (st-pointerp decl) (st-type decl)))
+
+(defun st-pointer-generic-pointer (decl)
+  (if (st-pointerp decl)
+      (make-st (st-symbol decl) :pointer)
+      decl))
+
+
diff --git a/gsll.asd b/gsll.asd
index f4a5b203..ded20826 100644
--- a/gsll.asd
+++ b/gsll.asd
@@ -1,6 +1,6 @@
 ;; Definition of GSLL system 
 ;; Liam Healy
-;; Time-stamp: <2009-12-07 22:58:36EST gsll.asd>
+;; Time-stamp: <2009-12-20 22:50:14EST gsll.asd>
 
 (when (asdf:find-system :fsbv nil)
   (pushnew :fsbv *features*))
@@ -21,7 +21,10 @@
 	    ((:file "pkgdcl")
 	     (:file "types" :depends-on ("pkgdcl"))
 	     (:file "complex-types" :depends-on ("pkgdcl" "types"))
-	     (:file "element-types" :depends-on ("pkgdcl"))))
+	     (:file "element-types" :depends-on ("pkgdcl"))
+	     (:file "symbol-type" :depends-on ("pkgdcl"))
+	     (:file "number-conversion"
+		    :depends-on ("pkgdcl" "complex-types" "symbol-type"))))
    (:module init
 	    :depends-on (grid)
 	    :components
@@ -30,20 +33,19 @@
 	     (:file "utility")
 	     (:file "forms")
 	     (:file "conditions" :depends-on ("init" "libgsl"))
-	     (:file "number-conversion" :depends-on ("init" "libgsl"))
 	     (:file "callback-compile-defs" :depends-on ("init"))
 	     (:file "mobject" :depends-on ("init" "callback-compile-defs"))
 	     (:file "callback-included" :depends-on ("mobject"))
 	     (:file "callback"
 		    :depends-on
-		    ("init" "utility" "forms" "number-conversion"
+		    ("init" "utility" "forms"
 			    "callback-included"))
 	     (:file "types" :depends-on ("init" "libgsl"))
 	     (cffi-grovel:grovel-file "callback-struct"
 				      :depends-on ("types" "libgsl"))
 	     (:file "funcallable" :depends-on ("utility"))
 	     (:file "interface"
-		    :depends-on ("init" "conditions" "number-conversion"))
+		    :depends-on ("init" "conditions"))
 	     (:file "defmfun" :depends-on ("init" "forms" "interface"))
 	     (:file "defmfun-array"
 		    :depends-on ("defmfun" "callback-included"))
@@ -63,7 +65,7 @@
 	     #+fsbv
 	     (:file "complex")))
    (:module data
-	    :depends-on (init)
+	    :depends-on (init grid)
 	    :components
 	    ((:file "foreign-friendly")
 	     (:file "foreign-array" :depends-on ("foreign-friendly"))
diff --git a/init/body-expand.lisp b/init/body-expand.lisp
index 11d70cad..2ea74931 100644
--- a/init/body-expand.lisp
+++ b/init/body-expand.lisp
@@ -1,18 +1,18 @@
 ;; Expand the body of a defmfun
 ;; Liam Healy 2009-04-13 22:07:13EDT body-expand.lisp
-;; Time-stamp: <2009-11-18 09:56:18EST body-expand.lisp>
+;; Time-stamp: <2009-12-20 23:13:49EST body-expand.lisp>
 
 (in-package :gsl)
 
 (defun creturn-st (c-return)
   "The symbol-type of the return from the C function."
-  (make-st
+  (c-array:make-st
    (if (listp c-return)
-       (st-symbol c-return)
+       (c-array:st-symbol c-return)
        (make-symbol "CRETURN"))
    (if (member c-return *special-c-return*)
        :int
-       (if (listp c-return) (st-type c-return) c-return))))
+       (if (listp c-return) (c-array:st-type c-return) c-return))))
 
 #+fsbv
 (defun variables-passed-by-value (c-arguments-st)
@@ -20,11 +20,11 @@
   variable in the C argument list."
   (loop for sd in c-arguments-st
      collect
-     (when (fsbv:defined-type-p (st-type sd))
-       (list (st-symbol sd)
-	     (make-st
-	      (make-symbol (string (st-symbol sd)))
-	      (st-type sd))))))
+     (when (fsbv:defined-type-p (c-array:st-type sd))
+       (list (c-array:st-symbol sd)
+	     (c-array:make-st
+	      (make-symbol (string (c-array:st-symbol sd)))
+	      (c-array:st-type sd))))))
 
 ;;; This function should never be called even when FSBV is absent,
 ;;; because the potential callers should all have #-fsbv
@@ -44,7 +44,7 @@
       (fsbv:defcfun-args-from-ff-args ff-args)
     (let ((gsl-name-symbol (make-symbol gsl-name))
 	  (symbargs
-	   (mapcar (lambda (st) (make-st (gensym "ARG") (st-type st)))
+	   (mapcar (lambda (st) (c-array:make-st (gensym "ARG") (c-array:st-type st)))
 		   args)))
       (values
        `(fsbv:defcfun (,gsl-name-symbol gsl-name) ,return-type
@@ -66,6 +66,22 @@
       `(no-fsbv-error no-fsbv-error ,@args)
       `(cffi:foreign-funcall ,gsl-name ,@args)))
 
+(defun cl-convert-form (decl)
+  "Generate a form that calls the appropriate converter from C/GSL to CL."
+  (case (c-array:st-actual-type decl)
+    (sf-result 
+     `((val ,(c-array:st-symbol decl))
+       (err ,(c-array:st-symbol decl))))
+    (sf-result-e10
+     `((val ,(c-array:st-symbol decl) 'sf-result-e10)
+       (e10 ,(c-array:st-symbol decl))
+       (err ,(c-array:st-symbol decl) 'sf-result-e10)))
+    (c-array:complex-double-c
+     `((c-array:complex-to-cl ,(c-array:st-symbol decl) 0 'c-array:complex-double-c)))
+    (c-array:complex-float-c
+     `((c-array:complex-to-cl ,(c-array:st-symbol decl) 0 'c-array:complex-float-c)))
+    (t `((cffi:mem-aref ,(c-array:st-symbol decl) ',(c-array:st-actual-type decl))))))
+
 (defun body-expand (name arglist gsl-name c-arguments key-args)
   "Expand the body (computational part) of the defmfun."
   (with-defmfun-key-args key-args
@@ -73,7 +89,7 @@
 	   (allocated-return ; Allocated and then returned from CL function
 	    (mapcar
 	     (lambda (s)
-	       (or (find s c-arguments :key #'st-symbol)
+	       (or (find s c-arguments :key #'c-array:st-symbol)
 		   ;; Catch programming errors, usually typos
 		   (error "Could not find ~a among the arguments" s)))
 	     (remove-if
@@ -86,19 +102,19 @@
 	    #-fsbv nil)
 	   (clret (or			; better as a symbol macro
 		   (substitute
-		    (st-symbol creturn-st) :c-return
+		    (c-array:st-symbol creturn-st) :c-return
 		    (mapcar (lambda (sym)
-			      (let ((it (find sym allocated-return :key 'st-symbol)))
+			      (let ((it (find sym allocated-return :key 'c-array:st-symbol)))
 				(if it
 				    (first (cl-convert-form it))
 				    sym)))
 			    return))
 		   (mappend
 		    #'cl-convert-form
-		    (callback-remove-arg allocated-return cbinfo 'st-symbol))
+		    (callback-remove-arg allocated-return cbinfo 'c-array:st-symbol))
 		   outputs
 		   (unless (eq c-return :void)
-		     (list (st-symbol creturn-st))))))
+		     (list (c-array:st-symbol creturn-st))))))
       (wrap-letlike
        allocated-return
        (mapcar (lambda (d) (wfo-declare d cbinfo))
@@ -111,36 +127,36 @@
 	    (when callback-object (callback-set-dynamic callback-object arglist)))
 	   ,@(callback-set-slots
 	      cbinfo callback-dynamic-variables callback-dynamic)
-	   (let ((,(st-symbol creturn-st)
+	   (let ((,(c-array:st-symbol creturn-st)
 		  ,(ffexpand (some 'identity pbv)
 			     gsl-name
 			     (append
 			      (mappend
 			       (lambda (arg)
 				 (list (cond
-					 ((member (st-symbol arg) allocated-return) :pointer)
-					 (t (st-type arg)))
-				       (st-symbol arg)))
-			       (mapcar 'st-pointer-generic-pointer c-arguments))
-			      (list (st-type creturn-st))))))
+					 ((member (c-array:st-symbol arg) allocated-return) :pointer)
+					 (t (c-array:st-type arg)))
+				       (c-array:st-symbol arg)))
+			       (mapcar 'c-array:st-pointer-generic-pointer c-arguments))
+			      (list (c-array:st-type creturn-st))))))
 	     ,@(case c-return
-		     (:void `((declare (ignore ,(st-symbol creturn-st)))))
+		     (:void `((declare (ignore ,(c-array:st-symbol creturn-st)))))
 		     (:error-code	; fill in arguments
-		      `((check-gsl-status ,(st-symbol creturn-st)
+		      `((check-gsl-status ,(c-array:st-symbol creturn-st)
 					  ',(or (defgeneric-method-p name) name)))))
 	     #-native
 	     ,@(when outputs
 		     (mapcar
 		      (lambda (x) `(setf (cl-invalid ,x) t (c-invalid ,x) nil))
 		      outputs))
-	     ,@(when (eq (st-type creturn-st) :pointer)
+	     ,@(when (eq (c-array:st-type creturn-st) :pointer)
 		     `((check-null-pointer
-			,(st-symbol creturn-st)
+			,(c-array:st-symbol creturn-st)
 			,@'('memory-allocation-failure "No memory allocated."))))
 	     ,@after
 	     (values
 	      ,@(defmfun-return
-		 c-return (st-symbol creturn-st) clret
+		 c-return (c-array:st-symbol creturn-st) clret
 		 allocated-return
 		 return return-supplied-p
 		 enumeration outputs))))))))
diff --git a/init/callback.lisp b/init/callback.lisp
index 3a4ab042..4417f0ff 100644
--- a/init/callback.lisp
+++ b/init/callback.lisp
@@ -1,6 +1,6 @@
 ;; Foreign callback functions.               
 ;; Liam Healy 
-;; Time-stamp: <2009-05-04 21:44:08EDT callback.lisp>
+;; Time-stamp: <2009-12-20 22:34:34EST callback.lisp>
 ;; $Id$
 
 (in-package :gsl)
@@ -221,4 +221,4 @@
        ;; CL specials to do the same job.
        (declare ,@(when (member :slug args) `((ignore ,slug)))
 		(special ,dynamic-variable))
-       (funcall ,dynamic-variable ,@(mapcar 'st-symbol (remove :slug args))))))
+       (funcall ,dynamic-variable ,@(mapcar 'c-array:st-symbol (remove :slug args))))))
diff --git a/init/defmfun-array.lisp b/init/defmfun-array.lisp
index 2bdc5cbf..88719713 100644
--- a/init/defmfun-array.lisp
+++ b/init/defmfun-array.lisp
@@ -1,6 +1,6 @@
 ;; Helpers for defining GSL functions on arrays
 ;; Liam Healy 2009-01-07 22:01:16EST defmfun-array.lisp
-;; Time-stamp: <2009-12-07 22:55:39EST defmfun-array.lisp>
+;; Time-stamp: <2009-12-20 22:35:57EST defmfun-array.lisp>
 ;; $Id: $
 
 (in-package :gsl)
@@ -159,7 +159,7 @@
 	 (if (and (listp arg) (numberp (second arg)))
 	     (let ((actual-type
 		    (c-array:cffi-cl
-		     (st-type (find (first arg) carg-actual :key 'st-symbol)))))
+		     (c-array:st-type (find (first arg) carg-actual :key 'c-array:st-symbol)))))
 	       (list (first arg) ; Optional arg default numerical value
 		     (if actual-type
 		     ;; coerce to the right type
diff --git a/init/defmfun-single.lisp b/init/defmfun-single.lisp
index 6b5dc386..0b087854 100644
--- a/init/defmfun-single.lisp
+++ b/init/defmfun-single.lisp
@@ -1,6 +1,6 @@
 ;; Helpers that define a single GSL function interface
 ;; Liam Healy 2009-01-07 22:02:20EST defmfun-single.lisp
-;; Time-stamp: <2009-11-01 14:20:53EST defmfun-single.lisp>
+;; Time-stamp: <2009-12-20 22:34:33EST defmfun-single.lisp>
 ;; $Id: $
 
 (in-package :gsl)
@@ -29,7 +29,7 @@
   quality code walker, but is sufficient for actual usage of defmfun."
   (remove-duplicates
    (mappend (lambda (carg)
-	     (stupid-code-walk-find-variables (st-symbol carg)))
+	     (stupid-code-walk-find-variables (c-array:st-symbol carg)))
 	   c-arguments)
    :from-end t))
 
diff --git a/init/interface.lisp b/init/interface.lisp
index 22f10417..dc438a28 100644
--- a/init/interface.lisp
+++ b/init/interface.lisp
@@ -1,6 +1,6 @@
 ;; Macros to interface GSL functions, including definitions necessary for defmfun.
 ;; Liam Healy 
-;; Time-stamp: <2009-12-06 19:52:33EST interface.lisp>
+;; Time-stamp: <2009-12-20 23:03:02EST interface.lisp>
 
 (in-package :gsl)
 
@@ -22,50 +22,19 @@
   (gethash (string-downcase string) *gsl-symbol-equivalence*))
 
 ;;;;****************************************************************************
-;;;; Symbol-type declaration
+;;;; Declare foreign objects
 ;;;;****************************************************************************
 
-;;; An "st" or symbol-type is a list (symbol type) where
-;;; type could be (element-type array-dim).  These are examples of lists
-;;; of sts: 
- ;; ((#:RET3500 SF-RESULT))
- ;; ((#:RET3501 (:DOUBLE (- NMAX NMIN)))) 
- ;; ((#:RET3502 (:DOUBLE (1+ KMAX))) (#:RET3503 (:DOUBLE (1+ KMAX)))
- ;;  (#:RET3504 (:DOUBLE (1+ KMAX))) (#:RET3505 (:DOUBLE (1+ KMAX)))
- ;;  (#:RET3506 :DOUBLE) (#:RET3507 :DOUBLE))
-
-(defun make-st (symbol type)
-  (list symbol type))
-
-(defun st-symbol (decl)
-  (first decl))
-
-(defun st-type (decl)
-  (second decl))
-
-(defun st-pointerp (decl)
-  "If this st represents a pointer, return the type of the object."
-  (if
-   (eq (st-type decl) :pointer)
-   t				   ; return T for type if unknown type
-   (if (and (listp (st-type decl))
-	    (eq (first (st-type decl)) :pointer))
-       (second (st-type decl)))))
-
-(defun st-actual-type (decl)
-  (or (st-pointerp decl) (st-type decl)))
-
-(defun st-pointer-generic-pointer (decl)
-  (if (st-pointerp decl)
-      (make-st (st-symbol decl) :pointer)
-      decl))
+(defmacro scref (size &optional (index 0))
+  "Reference C size(s)."
+  `(cffi:mem-aref ,size 'sizet ,index))
 
 (defun wfo-declare (d cbinfo)
-  `(,(st-symbol d)
-     ,@(if (eq (st-symbol d)
+  `(,(c-array:st-symbol d)
+     ,@(if (eq (c-array:st-symbol d)
 	       (parse-callback-static cbinfo 'foreign-argument))
 	   `(',(parse-callback-static cbinfo 'callback-fnstruct))
-	   `(',(st-actual-type d)))))
+	   `(',(c-array:st-actual-type d)))))
 
 ;;;;****************************************************************************
 ;;;; Checking results from GSL functions
@@ -102,10 +71,10 @@
 (defun cl-argument-types (cl-arguments c-arguments-types)
   "Create CL argument and types from the C arguments."
   (loop for sd in c-arguments-types
-	for cl-type = (c-array:cffi-cl (st-type sd))
+	for cl-type = (c-array:cffi-cl (c-array:st-type sd))
 	append
-	(when (and cl-type (member (st-symbol sd) (cl-symbols cl-arguments)))
-	  (list (list (st-symbol sd) cl-type)))))
+	(when (and cl-type (member (c-array:st-symbol sd) (cl-symbols cl-arguments)))
+	  (list (list (c-array:st-symbol sd) cl-type)))))
 
 (defun declaration-form (cl-argument-types &optional ignores specials)
   (cons 'declare
diff --git a/init/number-conversion.lisp b/init/number-conversion.lisp
deleted file mode 100644
index 4580390f..00000000
--- a/init/number-conversion.lisp
+++ /dev/null
@@ -1,57 +0,0 @@
-;; Conversion of numbers C->CL
-;; Liam Healy, Sun May 28 2006 - 22:04
-;; Time-stamp: <2009-12-07 22:30:23EST number-conversion.lisp>
-;; $Id$
-
-(in-package :gsl)
-
-;;;;****************************************************************************
-;;;; Built-in numerical types
-;;;;****************************************************************************
-
-(export '(dcref scref))
-
-(defmacro dcref (double &optional (index 0))
-  "Reference C double(s)."
-  `(cffi:mem-aref ,double :double ,index))
-
-(defmacro scref (size &optional (index 0))
-  "Reference C size(s)."
-  `(cffi:mem-aref ,size 'sizet ,index))
-
-;;;;****************************************************************************
-;;;; Complex numbers
-;;;;****************************************************************************
-
-;;; GSL complex struct is defined in init/complex-types.lisp.
-(defun complex-to-cl
-    (gsl-complex &optional (index 0) (complex-type 'c-array:complex-double-c))
-  "Make a CL complex number from the GSL pointer to a complex struct or
-   an array of complex structs and an index into the array." 
-  (let ((carr (cffi:foreign-slot-value
-	       (cffi:inc-pointer
-		gsl-complex
-		(* index (cffi:foreign-type-size complex-type)))
-	       complex-type 'c-array::dat)))
-    (complex (dcref carr 0)
-	     (dcref carr 1))))
-
-;;;;****************************************************************************
-;;;; Conversion form
-;;;;****************************************************************************
-
-(defun cl-convert-form (decl)
-  "Generate a form that calls the appropriate converter from C/GSL to CL."
-  (case (st-actual-type decl)
-    (sf-result 
-     `((val ,(st-symbol decl))
-       (err ,(st-symbol decl))))
-    (sf-result-e10
-     `((val ,(st-symbol decl) 'sf-result-e10)
-       (e10 ,(st-symbol decl))
-       (err ,(st-symbol decl) 'sf-result-e10)))
-    (c-array:complex-double-c
-     `((complex-to-cl ,(st-symbol decl) 0 'c-array:complex-double-c)))
-    (c-array:complex-float-c
-     `((complex-to-cl ,(st-symbol decl) 0 'c-array:complex-float-c)))
-    (t `((cffi:mem-aref ,(st-symbol decl) ',(st-actual-type decl))))))	
diff --git a/solve-minimize-fit/linear-least-squares.lisp b/solve-minimize-fit/linear-least-squares.lisp
index 91435af2..4f976733 100644
--- a/solve-minimize-fit/linear-least-squares.lisp
+++ b/solve-minimize-fit/linear-least-squares.lisp
@@ -1,6 +1,6 @@
 ;; Linear least squares, or linear regression
 ;; Liam Healy <2008-01-21 12:41:46EST linear-least-squares.lisp>
-;; Time-stamp: <2009-05-24 22:56:00EDT linear-least-squares.lisp>
+;; Time-stamp: <2009-12-20 23:03:01EST linear-least-squares.lisp>
 ;; $Id$
 
 (in-package :gsl)
@@ -187,7 +187,7 @@
   :inputs (model weight observations)
   :outputs (parameters covariance)
   :switch (weight)
-  :return (parameters covariance (dcref chisq))
+  :return (parameters covariance (c-array:dcref chisq))
   :export nil
   :index linear-mfit
   :documentation			; FDL
@@ -232,7 +232,7 @@
   :inputs (model weight observations)
   :outputs (parameters covariance)
   :switch (weight)
-  :return ((dcref chisq) (scref rank))
+  :return ((c-array:dcref chisq) (scref rank))
   :export nil
   :index linear-mfit
   :documentation			; FDL
diff --git a/solve-minimize-fit/minimization-multi.lisp b/solve-minimize-fit/minimization-multi.lisp
index 0bf4fb3e..13528651 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: <2009-06-09 23:02:27EDT minimization-multi.lisp>
+;; Time-stamp: <2009-12-20 22:19:22EST minimization-multi.lisp>
 ;; $Id$
 
 (in-package :gsl)
@@ -407,7 +407,7 @@
 (defun paraboloid-and-derivative
     (arguments-gv-pointer value-pointer derivative-gv-pointer)
   (prog1
-      (setf (dcref value-pointer)
+      (setf (c-array:dcref value-pointer)
 	    (paraboloid-vector arguments-gv-pointer))
     (paraboloid-derivative
      arguments-gv-pointer derivative-gv-pointer)))
diff --git a/special-functions/coulomb.lisp b/special-functions/coulomb.lisp
index 9f5362b7..f9f67e74 100644
--- a/special-functions/coulomb.lisp
+++ b/special-functions/coulomb.lisp
@@ -1,6 +1,6 @@
 ;; Coulumb functions
 ;; Liam Healy, Sat Mar 18 2006 - 23:23
-;; Time-stamp: <2009-04-26 22:57:18EDT coulomb.lisp>
+;; Time-stamp: <2009-12-20 23:16:02EST coulomb.lisp>
 ;; $Id$
 
 (in-package :gsl)
@@ -38,7 +38,7 @@
    (exp-F (:pointer :double)) (exp-G (:pointer :double)))
   :return
   ((val F) (val Fp) (val G) (val Gp)
-   (dcref exp-F) (dcref exp-G)
+   (c-array:dcref exp-F) (c-array:dcref exp-G)
    (err F) (err Fp) (err G) (err Gp))
   :documentation			; FDL
   "The Coulomb wave functions F_L(\eta,x),
@@ -57,7 +57,7 @@
   ((L-min :double) ((1- (dim0 fc-array)) :int) (eta :double) (x :double)
    ((c-pointer fc-array) :pointer) (F-exponent (:pointer :double)))
   :outputs (fc-array)
-  :return (fc-array (dcref F-exponent))
+  :return (fc-array (c-array:dcref F-exponent))
   :documentation			; FDL
   "The Coulomb wave function F_L(\eta,x) for
   L = Lmin ... Lmin + kmax, storing the results in fc-array.
@@ -74,7 +74,7 @@
    ((c-pointer fc-array) :pointer) ((c-pointer gc-array) :pointer)
    (F-exponent (:pointer :double)) (G-exponent (:pointer :double)))
   :outputs (fc-array gc-array)
-  :return (fc-array gc-array (dcref F-exponent) (dcref G-exponent))
+  :return (fc-array gc-array (c-array:dcref F-exponent) (c-array:dcref G-exponent))
   :documentation			; FDL
   "The functions F_L(\eta,x),
   G_L(\eta,x) for L = Lmin ... Lmin + kmax storing the
@@ -99,7 +99,7 @@
   :outputs (fc-array fcp-array gc-array gcp-array)
   :return
   (fc-array fcp-array gc-array gcp-array
-	    (dcref F-exponent) (dcref G-exponent))
+	    (c-array:dcref F-exponent) (c-array:dcref G-exponent))
   :documentation			; FDL
   "The functions F_L(\eta,x),
   G_L(\eta,x) and their derivatives F'_L(\eta,x),
@@ -115,7 +115,7 @@
   ((L-min :double) ((1- (dim0 fc-array)) :int) (eta :double) (x :double)
    ((c-pointer fc-array) :pointer) (F-exponent (:pointer :double)))
   :outputs (fc-array)
-  :return (fc-array (dcref F-exponent))
+  :return (fc-array (c-array:dcref F-exponent))
   :documentation			; FDL
   "The Coulomb wave function divided by the argument
    F_L(\eta, x)/x for L = Lmin ... Lmin + kmax, storing the
diff --git a/special-functions/gamma.lisp b/special-functions/gamma.lisp
index 6bc05538..e3b9c142 100644
--- a/special-functions/gamma.lisp
+++ b/special-functions/gamma.lisp
@@ -1,6 +1,6 @@
 ;; Gamma functions
 ;; Liam Healy, Thu Apr 27 2006 - 22:06
-;; Time-stamp: <2009-04-26 22:59:46EDT gamma.lisp>
+;; Time-stamp: <2009-12-20 22:19:20EST gamma.lisp>
 ;; $Id$
 
 (in-package :gsl)
@@ -37,7 +37,7 @@
 (defmfun log-gamma-sign (x)
   "gsl_sf_lngamma_sgn_e"
   ((x :double) (ret sf-result) (sign (:pointer :double)))
-  :return ((val ret) (dcref sign) (err ret))
+  :return ((val ret) (c-array:dcref sign) (err ret))
   :documentation			; FDL
   "Compute the sign of the gamma function and the logarithm of
   its magnitude, subject to x not being a negative integer.  The
@@ -136,7 +136,7 @@
   The computed parameters are result =
   log(|(a)_x|) and sgn = sgn((a)_x) where (a)_x :=
   Gamma(a + x)/Gamma(a), subject to a, a+x not being negative integers."
-  :return ((val ret) (dcref sign) (err ret)))
+  :return ((val ret) (c-array:dcref sign) (err ret)))
 
 (defmfun relative-pochammer (a x)
   "gsl_sf_pochrel_e" ((a :double) (x :double) (ret sf-result))
-- 
GitLab