diff --git a/calculus/monte-carlo.lisp b/calculus/monte-carlo.lisp
index 6c895d963ae2eeace8f851fdae1c981e6b8e97ba..573a9f9e17c1fb7088185a479fa87d743221f420 100644
--- a/calculus/monte-carlo.lisp
+++ b/calculus/monte-carlo.lisp
@@ -1,6 +1,6 @@
 ;; Monte Carlo Integration
 ;; Liam Healy Sat Feb  3 2007 - 17:42
-;; Time-stamp: <2009-12-27 09:42:11EST monte-carlo.lisp>
+;; Time-stamp: <2010-06-27 18:13:57EDT monte-carlo.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -51,7 +51,7 @@
 	      (scalars t))
   "gsl_monte_plain_integrate"
   ((callback :pointer)
-   ((c-pointer lower-limits) :pointer) ((c-pointer upper-limits) :pointer)
+   ((foreign-pointer lower-limits) :pointer) ((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)
-   ((c-pointer lower-limits) :pointer) ((c-pointer upper-limits) :pointer)
+   ((foreign-pointer lower-limits) :pointer) ((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)
-   ((c-pointer lower-limits) :pointer) ((c-pointer upper-limits) :pointer)
+   ((foreign-pointer lower-limits) :pointer) ((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 24615517ec93740a68a7562711522b7e29cafab8..5e85d20091b16bf266b64d8e020c837cef536124 100644
--- a/calculus/numerical-integration.lisp
+++ b/calculus/numerical-integration.lisp
@@ -1,6 +1,6 @@
 ;; Numerical integration
 ;; Liam Healy, Wed Jul  5 2006 - 23:14
-;; Time-stamp: <2009-12-27 09:42:09EST numerical-integration.lisp>
+;; Time-stamp: <2010-06-27 18:13:57EDT numerical-integration.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -157,7 +157,7 @@
 	      (limit 1000) (workspace (make-integration-workspace limit)))
   "gsl_integration_qagp"
   ((callback :pointer)
-   ((c-pointer points) :pointer) ((dim0 points) sizet)
+   ((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/chebyshev.lisp b/chebyshev.lisp
index e55be8c777abbfab49fcd6fbf6b1fb912fa22a09..ce16b2ebc571321fc4affec283ab2a125d61c45b 100644
--- a/chebyshev.lisp
+++ b/chebyshev.lisp
@@ -1,6 +1,6 @@
 ;; Chebyshev Approximations
 ;; Liam Healy Sat Nov 17 2007 - 20:36
-;; Time-stamp: <2010-04-26 09:48:32EDT chebyshev.lisp>
+;; Time-stamp: <2010-06-27 18:03:23EDT chebyshev.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -60,7 +60,7 @@
   :c-return (crtn :pointer)
   :documentation
   "The Chebyshev coefficient array as a CL array (foreign-friendly)."
-  :return ((c-array:copy-foreign-vector crtn (size chebyshev)))
+  :return ((grid:copy-foreign-vector crtn (size chebyshev)))
   :gsl-version (1 12))
 
 ;;;;****************************************************************************
diff --git a/data/both.lisp b/data/both.lisp
index cf618ed8911314136417f9b3e8cdf4bee0096011..49133350c3d8bc8613caf17818918949f6be6c09 100644
--- a/data/both.lisp
+++ b/data/both.lisp
@@ -1,6 +1,6 @@
 ;; Functions for both vectors and matrices.
 ;; Liam Healy 2008-04-26 20:48:44EDT both.lisp
-;; Time-stamp: <2009-12-27 09:42:06EST both.lisp>
+;; Time-stamp: <2010-06-27 18:03:26EDT both.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -68,7 +68,7 @@
   :c-return :void
   :documentation "Set all elements to 0.")
 
-(defmfun c-array:copy-to-destination
+(defmfun grid:copy-to-destination
     ((source both) (destination both))
   ("gsl_" :category :type "_memcpy")
   (((mpointer destination) :pointer) ((mpointer source) :pointer))
@@ -76,7 +76,7 @@
   :inputs (source)
   :outputs (destination))
 
-(defmfun c-array:copy-making-destination
+(defmfun grid:copy-making-destination
     ((source both) &aux 
      (destination
       (make-marray element-type :dimensions (dimensions source))))
diff --git a/data/combination.lisp b/data/combination.lisp
index 702d005ba5fd71ed30632c658d14f03526ddc012..8a12a0cc1f367342a7c4e69bc8f8df47dc83e42c 100644
--- a/data/combination.lisp
+++ b/data/combination.lisp
@@ -1,6 +1,6 @@
 ;; Combinations
 ;; Liam Healy, Sun Mar 26 2006 - 11:51
-;; Time-stamp: <2009-12-27 09:42:06EST combination.lisp>
+;; Time-stamp: <2010-06-27 18:14:05EDT combination.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -26,7 +26,7 @@
 ;;;; Combination structure and CL object
 ;;;;****************************************************************************
 
-(defclass combination (mobject c-array:foreign-array)
+(defclass combination (mobject grid:foreign-array)
   ((element-type
     :initform
     #+int64 '(unsigned-byte 64)
@@ -42,7 +42,7 @@
     (setf (slot-value object 'mpointer)
 	  mptr
 	  (cffi:foreign-slot-value mptr 'gsl-combination-c 'data)
-	  (c-pointer object)
+	  (foreign-pointer object)
 	  (cffi:foreign-slot-value mptr 'gsl-combination-c 'choice-of)
 	  choice-of
 	  (cffi:foreign-slot-value mptr 'gsl-combination-c 'size)
@@ -89,7 +89,7 @@
   "Initialize the combination c to the lexicographically
    last combination, i.e. (n-k,n-k+1,...,n-1).")
 
-(defmfun c-array:copy-to-destination ((source combination) (destination combination))
+(defmfun grid:copy-to-destination ((source combination) (destination combination))
   "gsl_combination_memcpy"
   (((mpointer destination) :pointer)
    ((mpointer source) :pointer))
diff --git a/data/copy-cl.lisp b/data/copy-cl.lisp
index 554367223033028cdccc5ec86beb3c18322ed59b..d183099852ddd0678c46351188116b81bab39bd6 100644
--- a/data/copy-cl.lisp
+++ b/data/copy-cl.lisp
@@ -1,6 +1,6 @@
 ;; Copy marrays to/from CL arrays
 ;; Liam Healy 2009-02-11 19:28:44EST copy-cl.lisp
-;; Time-stamp: <2009-12-27 09:42:05EST copy-cl.lisp>
+;; Time-stamp: <2010-06-27 18:03:25EDT copy-cl.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -38,52 +38,52 @@
 ;;; These make destination but are methods of copy-to-destination so
 ;;; that the class argument may be supplied.
 
-(defmethod c-array:copy-to-destination ((source mvector) (destination array))
+(defmethod grid:copy-to-destination ((source mvector) (destination array))
   (unless (equal (dimensions source) (array-dimensions destination))
-    (error 'c-array:array-mismatch))
+    (error 'grid:array-mismatch))
   (loop for i below (dim0 source)
        do (setf (aref destination i) (maref source i)))
   destination)
 
-(defmethod c-array:copy-to-destination ((source matrix) (destination array))
+(defmethod grid:copy-to-destination ((source matrix) (destination array))
   (unless (equal (dimensions source) (array-dimensions destination))
-    (error 'c-array:array-mismatch))
+    (error 'grid:array-mismatch))
   (loop for i below (dim0 source) do
        (loop for j below (dim1 source) do
 	    (setf (aref destination i j) (maref source i j))))
   destination)
 
-(defmethod c-array:copy-to-destination ((source array) (destination mvector))
+(defmethod grid:copy-to-destination ((source array) (destination mvector))
   (unless (equal (array-dimensions source) (dimensions destination))
-    (error 'c-array:array-mismatch))
+    (error 'grid:array-mismatch))
   (loop for i below (length source)
        do (setf (maref destination i) (aref source i)))
   destination)
 
-(defmethod c-array:copy-to-destination ((source array) (destination matrix))
+(defmethod grid:copy-to-destination ((source array) (destination matrix))
   (unless (equal (array-dimensions source) (dimensions destination))
-    (error 'c-array:array-mismatch))
+    (error 'grid:array-mismatch))
   (loop for i below (array-dimension source 0) do
        (loop for j below (array-dimension source 1) do
 	    (setf (maref destination i j) (aref source i j))))
   destination)
 
-(defmethod c-array:copy-to-destination ((source marray) (destclass (eql 'array)))
+(defmethod grid:copy-to-destination ((source marray) (destclass (eql 'array)))
   (let ((destination
-	 (c-array:make-ffa (element-type source) :dimensions (dimensions source))))
-    (c-array:copy-to-destination source destination)))
+	 (grid:make-ffa (element-type source) :dimensions (dimensions source))))
+    (grid:copy-to-destination source destination)))
 
 ;;; Copy to a named marray element-type, where the type is a symbol
-(defmethod c-array:copy-to-destination ((source array) (destclass symbol))
+(defmethod grid:copy-to-destination ((source array) (destclass symbol))
   (let ((destination
 	 (make-marray destclass :dimensions (array-dimensions source))))
-    (c-array:copy-to-destination source destination)))
+    (grid:copy-to-destination source destination)))
 
 ;;; Copy to a named marray element-type, where the type is a list
-(defmethod c-array:copy-to-destination ((source array) (destclass list))
+(defmethod grid:copy-to-destination ((source array) (destclass list))
   (let ((destination
 	 (make-marray destclass :dimensions (array-dimensions source))))
-    (c-array:copy-to-destination source destination)))
+    (grid:copy-to-destination source destination)))
 
 ;;; Examples and tests
 
diff --git a/data/foreign-array.lisp b/data/foreign-array.lisp
index a5fc37395552d5f656360adc5014cf07ee5ca6b7..55b4eb4b60362b63d9e374224bf50ad77ea151f4 100644
--- a/data/foreign-array.lisp
+++ b/data/foreign-array.lisp
@@ -1,6 +1,6 @@
 ;; A grid:foreign-array with added metadata for GSL.
 ;; Liam Healy 2008-04-06 21:23:41EDT
-;; Time-stamp: <2010-06-27 08:48:58EDT foreign-array.lisp>
+;; Time-stamp: <2010-06-27 18:27:37EDT foreign-array.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -88,15 +88,26 @@
      `((grid:foreign-array ,@dimensions) element-type)
      keys)))
 
+(defun make-marray-or-default
+    (default dimensions
+     &optional dont-make-if-nil (element-type 'double-float) initial-element)
+  "If default is T or dont-make-if-nil, make a marray and
+   returned with the dimensions and element-type.  If default is a
+   marray, it is returned."
+  (if (member default (list t dont-make-if-nil))
+      (if initial-element
+	  (make-marray
+	   element-type :dimensions dimensions :initial-element initial-element)
+	  (make-marray element-type :dimensions dimensions))
+      default))
+
 ;;;;****************************************************************************
 ;;;; Make from GSL mpointers 
 ;;;;****************************************************************************
 
 ;; Some functions in solve-minimize-fit return a pointer to a GSL
-;; vector of double-floats.  This function turns that into a
-;; foreign-friendly array.  There is no choice but to copy over the
-;; data even on native implementations; because GSL is doing the
-;; mallocing, the data are not CL-accessible.
+;; vector of double-floats.  This function turns it into a
+;; foreign-array.  
 
 (defun make-foreign-array-from-mpointer
     (mpointer &optional (element-type 'double-float) (category :vector))
@@ -107,7 +118,7 @@
 	    (:vector 'gsl-vector-c)
 	    (:matrix 'gsl-matrix-c)
 	    (t (error "Unrecognized category ~a" category))))
-	 (c-pointer (cffi:foreign-slot-value mpointer cstruct 'data)))
+	 (foreign-pointer (cffi:foreign-slot-value mpointer cstruct 'data)))
     (grid:make-grid
      (case category
        (:vector
@@ -118,25 +129,5 @@
 	   ,(cffi:foreign-slot-value mpointer cstruct size0)
 	   ,(cffi:foreign-slot-value mpointer cstruct size1)))
 	,element-type))
-     :foreign-pointer c-pointer
+     :foreign-pointer foreign-pointer
      :foreign-metadata mpointer)))
-
-;;;;****************************************************************************
-;;;; Convenient defaulting of defmfun arguments 
-;;;;****************************************************************************
-
-(defun make-marray-or-default
-    (default dimensions
-     &optional dont-make-if-nil (element-type 'double-float) initial-element)
-  "If default is T or dont-make-if-nil, make a marray and
-   returned with the dimensions and element-type.  If default is a
-   marray, it is returned after being synced for non-native."
-  (if (member default (list t dont-make-if-nil))
-      (if initial-element
-	  (make-marray
-	   element-type :dimensions dimensions :initial-element initial-element)
-	  (make-marray element-type :dimensions dimensions))
-      (progn #-native
-	     (when (typep default 'marray)
-	       (c-array:copy-cl-to-c default))
-	     default)))
diff --git a/data/maref.lisp b/data/maref.lisp
index 767e399769b41516aa8466cca4a79fc8c3448c21..fb2885c81ad0138e001f83c8ad574a9ad88c6391 100644
--- a/data/maref.lisp
+++ b/data/maref.lisp
@@ -1,6 +1,6 @@
 ;; Get/set array or elements: cl-array, maref
 ;; Liam Healy 2008-08-27 22:43:10EDT maref.lisp
-;; Time-stamp: <2009-12-27 09:42:05EST maref.lisp>
+;; Time-stamp: <2010-06-27 18:03:27EDT maref.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -43,9 +43,9 @@
 		       category tp)
 		     ,@ffrestargs
 		     ,@(if value-symbol
-			   (list (c-array:cl-cffi tp) value-symbol)
-			   (list (c-array:cl-cffi tp))))))
-		c-array:*array-element-types*)))
+			   (list (grid:cl-cffi tp) value-symbol)
+			   (list (grid:cl-cffi tp))))))
+		grid:*array-element-types*)))
 
 (defgeneric maref (object index &optional index2 type)
   (:documentation
@@ -75,14 +75,14 @@
 		     ,(actual-gsl-function-name
 		       `("gsl_" :category :type ,"_get")
 		       'vector tp)))
-		 c-array:*array-element-types*)
+		 grid:*array-element-types*)
 	 (mapcar (lambda (tp)
 		   `(map-name
 		     'maref
 		     ,(actual-gsl-function-name
 		       `("gsl_" :category :type ,"_get")
 		       'matrix tp)))
-		 c-array:*array-element-types*)))
+		 grid:*array-element-types*)))
 
 (defgeneric (setf maref) (value object index &optional index2 type)
   (:documentation
@@ -113,11 +113,11 @@
 		     ,(actual-gsl-function-name
 		       `("gsl_" :category :type ,"_set")
 		       'vector tp)))
-		 c-array:*array-element-types*)
+		 grid:*array-element-types*)
 	 (mapcar (lambda (tp)
 		   `(map-name
 		     '(setf maref)
 		     ,(actual-gsl-function-name
 		       `("gsl_" :category :type ,"_set")
 		       'matrix tp)))
-		 c-array:*array-element-types*)))
+		 grid:*array-element-types*)))
diff --git a/data/matrix.lisp b/data/matrix.lisp
index 110a5b9e082e0e78686308f6d57f33972c9c4ade..fee58c4ca08fbdad0c2fa3c9a661c4cbe181f460 100644
--- a/data/matrix.lisp
+++ b/data/matrix.lisp
@@ -1,6 +1,6 @@
 ;; Matrices
 ;; Liam Healy 2008-04-15 21:57:52EDT matrix.lisp
-;; Time-stamp: <2010-06-26 19:16:41EDT matrix.lisp>
+;; Time-stamp: <2010-06-27 18:03:26EDT matrix.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -36,7 +36,7 @@
        collect (loop for j below dim1
 		  collect (maref pointer i j element-type)))))
 
-(defmethod c-array:copy-to-destination
+(defmethod grid:copy-to-destination
     ((object matrix) (pointer #.+foreign-pointer-class+))
   (foreign-pointer-method
    pointer
diff --git a/data/permutation.lisp b/data/permutation.lisp
index fcc5e0b64e08e9dc226fd58c0075d85e8a5c5abd..520835f7d7df665bf9d0bf05087ce22825b6cd21 100644
--- a/data/permutation.lisp
+++ b/data/permutation.lisp
@@ -1,6 +1,6 @@
 ;; Permutations
 ;; Liam Healy, Sun Mar 26 2006 - 11:51
-;; Time-stamp: <2009-12-27 09:42:03EST permutation.lisp>
+;; Time-stamp: <2010-06-27 18:14:06EDT permutation.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -27,7 +27,7 @@
 ;;;; Permutation structure and CL object
 ;;;;****************************************************************************
    
-(defclass permutation (mobject c-array:foreign-array)
+(defclass permutation (mobject grid:foreign-array)
   ((element-type
     :initform
     #+int64 '(unsigned-byte 64)
@@ -41,7 +41,7 @@
     (setf (slot-value object 'mpointer)
 	  mptr
 	  (cffi:foreign-slot-value mptr 'gsl-permutation-c 'data)
-	  (c-pointer object)
+	  (foreign-pointer object)
 	  (cffi:foreign-slot-value mptr 'gsl-permutation-c 'size)
 	  dimensions)
     (tg:finalize object (lambda () (cffi:foreign-free mptr)))))
@@ -77,7 +77,7 @@
   "Initialize the permutation p to the identity, i.e.
    (0,1,2,...,n-1).")
 
-(defmfun c-array:copy-to-destination ((source permutation) (destination permutation))
+(defmfun grid:copy-to-destination ((source permutation) (destination permutation))
   "gsl_permutation_memcpy"
   (((mpointer destination) :pointer)
    ((mpointer source) :pointer))
diff --git a/data/vector.lisp b/data/vector.lisp
index aaae5856fdb9e99a7e64f66fb58b63a1892edc67..d37fe787e1ed94cc809b34df064e52c1fda060d0 100644
--- a/data/vector.lisp
+++ b/data/vector.lisp
@@ -1,6 +1,6 @@
 ;; Vectors
 ;; Liam Healy 2008-04-13 09:39:02EDT vector.lisp
-;; Time-stamp: <2010-06-26 19:16:43EDT vector.lisp>
+;; Time-stamp: <2010-06-27 18:03:25EDT vector.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -32,7 +32,7 @@
   (loop for i below (cffi:foreign-slot-value pointer struct-type 'size)
      collect (maref pointer i nil element-type)))
 
-(defmethod c-array:copy-to-destination
+(defmethod grid:copy-to-destination
     ((object mvector) (pointer #.+foreign-pointer-class+))
   (foreign-pointer-method
    pointer
diff --git a/documentation/index.html b/documentation/index.html
index b80a9b520be890a8765500ab268a9d66a68c6e55..40152e642e7240f4b249a5992e882a59a07a4c50 100644
--- a/documentation/index.html
+++ b/documentation/index.html
@@ -113,7 +113,7 @@ combination for which the following are supported:</p>
 </li>
 <li><a href="http://www.cliki.net/trivial-garbage">trivial-garbage</a>
 <li><a href="http://repo.or.cz/w/gsd.git">GSD</a>, the <i>Grid Structured Data</i>; in particular,
-  the <code>c-array</code> and <code>grid</code> systems</li>
+  the <code>foreign-array</code> and <code>grid</code> systems</li>
 <li><a href="http://common-lisp.net/project/cl-utilities/">cl-utilities</a>
 </li>
 <li><a href="http://www.cliki.net/asdf">ASDF</a></li>
@@ -161,7 +161,7 @@ can be used to browse or retrieve a compressed tarball (click the most
 recent "snapshot" link).
 You will need to make a link
   of <code>gsll.asd</code>, <code>grid.asd</code>,
-  <code>c-array.asd</code>, and
+  <code>foreign-array.asd</code>, and
   optionally <code>gsll-tests.asd</code> and
   <code>fsbv.asd</code>
   to some directory known to ASDF.
@@ -283,7 +283,7 @@ GSLL has many functions that work on vectors (one-dimensional arrays)
 and matrices (two-dimensional arrays).  GSLL supports all array
 element types that are supported by CFFI, the CL implementation,
 GSL, and the platform.  This list is available in the
-variable <code>c-array:*array-element-types*</code>.  On implementations that
+variable <code>grid:*array-element-types*</code>.  On implementations that
 support it (currently only SBCL), the contents are directly available
 to the GSL functions without copying between the Lisp area and the C
 area of memory.</p>
@@ -472,7 +472,7 @@ and arrays used internally or for function return.
 <!-- Created: Feb 25 2005 -->
 <!-- hhmts start -->
 <small>
-Time-stamp: <2010-06-08 12:58:19EDT index.html>
+Time-stamp: <2010-06-27 18:05:50EDT index.html>
 </small>
 <!-- hhmts end -->
  </div>
diff --git a/fast-fourier-transforms/backward.lisp b/fast-fourier-transforms/backward.lisp
index 5d3eaad7363fa2cf0a16f34c76a20ee045ca1928..e9866b4ff15e6ca96271d569ead820b31ff38b80 100644
--- a/fast-fourier-transforms/backward.lisp
+++ b/fast-fourier-transforms/backward.lisp
@@ -1,6 +1,6 @@
 ;; Backward FFT
 ;; Sumant Oemrawsingh, Sat Oct 24 2009 - 12:55
-;; Time-stamp: <2009-12-27 09:45:34EST backward.lisp>
+;; Time-stamp: <2010-06-27 18:13:59EDT backward.lisp>
 ;;
 ;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -33,7 +33,7 @@
 (defmfun backward-fourier-transform-radix2
   ((vector vector) &key (stride 1))
   ("gsl_fft" :type "_radix2_backward")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :complex
   :inputs (vector)
diff --git a/fast-fourier-transforms/discrete.lisp b/fast-fourier-transforms/discrete.lisp
index ded9e2d1cec7045be5249fc94595c3dc207e3cf4..82d428197b7f7003b6f7606ec86c9f87a57b7b70 100644
--- a/fast-fourier-transforms/discrete.lisp
+++ b/fast-fourier-transforms/discrete.lisp
@@ -1,6 +1,6 @@
 ;; Discrete Fourier Transforms
 ;; Liam Healy 2009-11-07 14:24:07EST
-;; Time-stamp: <2009-12-27 09:45:34EST discrete.lisp>
+;; Time-stamp: <2010-06-27 18:13:59EDT discrete.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -31,8 +31,8 @@
      &key (stride 1)
      (result (make-marray element-type :dimensions (dimensions vector))))
   ("gsl_dft" :type "_forward")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
-   ((c-pointer result) :pointer))
+  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+   ((foreign-pointer result) :pointer))
   :definition :generic
   :element-types :complex
   :inputs (vector)
@@ -47,8 +47,8 @@
      &key (stride 1)
      (result (make-marray element-type :dimensions (dimensions vector))))
   ("gsl_dft" :type "_backward")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
-   ((c-pointer result) :pointer))
+  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+   ((foreign-pointer result) :pointer))
   :definition :generic
   :element-types :complex
   :inputs (vector)
@@ -63,8 +63,8 @@
      &key (stride 1)
      (result (make-marray element-type :dimensions (dimensions vector))))
   ("gsl_dft" :type "_inverse")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
-   ((c-pointer result) :pointer))
+  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+   ((foreign-pointer result) :pointer))
   :definition :generic
   :element-types :complex
   :inputs (vector)
@@ -79,8 +79,8 @@
      &key (stride 1)
      (result (make-marray element-type :dimensions (dimensions vector))))
   ("gsl_dft" :type "_transform")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
-   ((c-pointer result) :pointer))
+  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+   ((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 56cb4bff0da0a3d5458561567604726f90d2ae92..734cc2afd03b987fd68502ca2ebdf09541f8dbeb 100644
--- a/fast-fourier-transforms/example.lisp
+++ b/fast-fourier-transforms/example.lisp
@@ -1,6 +1,6 @@
 ;; Example FFT: transform a pulse (using the "clean" fft interface)
 ;; Sumant Oemrawsingh, Sat Oct 31 2009 - 00:24
-;; Time-stamp: <2009-12-27 09:45:34EST example.lisp>
+;; Time-stamp: <2010-06-27 18:03:24EDT example.lisp>
 ;;
 ;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -76,7 +76,7 @@
 ;; (make-urand-vector '(complex double-float) 5)
 (defun make-urand-vector (element-type dimension &key (stride 1))
   "Make a vector with random elements."
-  (let ((vec (make-marray `(complex ,(c-array:component-float-type element-type))
+  (let ((vec (make-marray `(complex ,(grid:component-float-type element-type))
 			  :dimensions (list (* stride dimension)))))
     (loop for i from 0 below (* stride dimension) by stride
        do
@@ -90,7 +90,7 @@
   "The real vector consisting of the real part of the complex vector."
   (let ((real-vector
 	 (make-marray
-	  (c-array:component-float-type (element-type complex-vector))
+	  (grid:component-float-type (element-type complex-vector))
 	  :dimensions (dimensions complex-vector))))
     (loop for i below (total-size complex-vector) do
 	 (setf (maref real-vector i)
diff --git a/fast-fourier-transforms/forward.lisp b/fast-fourier-transforms/forward.lisp
index 4bb4f0d1d7f6e08eb0d7e642e44172d664bd0227..b5eb8a3e64789dde7936bb6ef8851c45f1ff9d7c 100644
--- a/fast-fourier-transforms/forward.lisp
+++ b/fast-fourier-transforms/forward.lisp
@@ -1,6 +1,6 @@
 ;; Forward FFT.
 ;; Sumant Oemrawsingh, Sat Oct 31 2009 - 23:48
-;; Time-stamp: <2009-12-27 09:45:33EST forward.lisp>
+;; Time-stamp: <2010-06-27 18:13:58EDT forward.lisp>
 ;;
 ;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((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 dec04dd82ff9b5c650f869ca849a7d94dec76469..8ec19f30abf79dabc52ac482425b8a02e0a79e1a 100644
--- a/fast-fourier-transforms/inverse.lisp
+++ b/fast-fourier-transforms/inverse.lisp
@@ -1,6 +1,6 @@
 ;; Inverse FFT
 ;; Sumant Oemrawsingh, Sat Oct 24 2009 - 12:55
-;; Time-stamp: <2009-12-27 09:45:33EST inverse.lisp>
+;; Time-stamp: <2010-06-27 18:14:00EDT inverse.lisp>
 ;;
 ;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -33,7 +33,7 @@
 (defmfun inverse-fourier-transform-radix2
   ((vector vector) &key (stride 1))
   ("gsl_fft" :type "_radix2_inverse")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet)
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
+  (((foreign-pointer vector) :pointer) (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :complex
   :inputs (vector)
diff --git a/fast-fourier-transforms/select-direction.lisp b/fast-fourier-transforms/select-direction.lisp
index cf8c284d53069bf915571450b02eed1220aa7334..115fe4e639ba962944c291d972142d3c7bd1c7c5 100644
--- a/fast-fourier-transforms/select-direction.lisp
+++ b/fast-fourier-transforms/select-direction.lisp
@@ -1,6 +1,6 @@
 ;; FFT where direction is selected.
 ;; Sumant Oemrawsingh, Sat Oct 24 2009 - 12:55
-;; Time-stamp: <2009-12-27 09:45:32EST select-direction.lisp>
+;; Time-stamp: <2010-06-27 18:13:58EDT select-direction.lisp>
 ;;
 ;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -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")
-  (((c-pointer vector) :pointer) (stride sizet) (n sizet) (direction fft-direction))
+  (((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")
-  (((c-pointer vector) :pointer) (stride sizet) (n sizet) (direction fft-direction))
+  (((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 fdb286a85deb601be5add5927b2f8fb58f51a128..c676830846d09cac5a84c88d71b3ebe042741296 100644
--- a/fast-fourier-transforms/unpack.lisp
+++ b/fast-fourier-transforms/unpack.lisp
@@ -1,6 +1,6 @@
 ;; Unpack functions for FFT vectors.
 ;; Sumant Oemrawsingh, Sun Oct 25 2009 - 16:35
-;; Time-stamp: <2009-12-27 09:45:32EST unpack.lisp>
+;; Time-stamp: <2010-06-27 18:14:00EDT unpack.lisp>
 ;;
 ;; Copyright 2009 Sumant Oemrawsingh, Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -34,8 +34,8 @@
 		  t
 		  (make-marray '(complex double-float) :dimensions (size vector)))))
   ("gsl_fft_real" :type "_unpack")
-  (((c-pointer vector) :pointer)
-   ((c-pointer output) :pointer)
+  (((foreign-pointer vector) :pointer)
+   ((foreign-pointer output) :pointer)
    (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :float
@@ -58,8 +58,8 @@
 		  t
 		  (make-marray '(complex double-float) :dimensions (size vector)))))
   ("gsl_fft_halfcomplex" :type "_radix2_unpack")
-  (((c-pointer vector) :pointer)
-   ((c-pointer output) :pointer)
+  (((foreign-pointer vector) :pointer)
+   ((foreign-pointer output) :pointer)
    (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :float
@@ -81,8 +81,8 @@
 		  t
 		  (make-marray '(complex double-float) :dimensions (size vector)))))
   ("gsl_fft_halfcomplex" :type "_unpack")
-  (((c-pointer vector) :pointer)
-   ((c-pointer output) :pointer)
+  (((foreign-pointer vector) :pointer)
+   ((foreign-pointer output) :pointer)
    (stride sizet) ((floor (size vector) stride) sizet))
   :definition :generic
   :element-types :float
diff --git a/gsll.asd b/gsll.asd
index c0ec10fd3581e64ca9c3ad2fa2915708e9c8954f..13f47de5cbf9c76bcd43cce42b82b989bb8b1472 100644
--- a/gsll.asd
+++ b/gsll.asd
@@ -1,6 +1,6 @@
 ;; Definition of GSLL system 
 ;; Liam Healy
-;; Time-stamp: <2010-05-25 11:54:09EDT gsll.asd>
+;; Time-stamp: <2010-06-27 17:57:19EDT gsll.asd>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -30,7 +30,7 @@
   :version "0"
   :author "Liam M. Healy"
   :licence "GPL v3"
-  :depends-on (c-array grid cffi cffi-grovel trivial-garbage cl-utilities #+fsbv fsbv)
+  :depends-on (foreign-array grid cffi cffi-grovel trivial-garbage cl-utilities #+fsbv fsbv)
   :components
   ((:module init
 	    :components
@@ -70,6 +70,7 @@
 	    ((:file "mathematical")
 	     #+fsbv
 	     (:file "complex")))
+   #+(or)
    (:module data
 	    :depends-on (init)
 	    :components
@@ -83,7 +84,9 @@
 	     (:file "array-tests" :depends-on ("both"))
 	     (:file "permutation" :depends-on ("marray" "array-structs"))
 	     (:file "combination" :depends-on ("marray" "array-structs"))))
+   #+(or)
    (:file "polynomial" :depends-on (init data))
+   #+(or)
    (:module special-functions
 	    :depends-on (init)
 	    :components
@@ -118,7 +121,9 @@
 	     (:file "transport" :depends-on ("return-structures"))
 	     (:file "trigonometry" :depends-on ("return-structures"))
 	     (:file "zeta" :depends-on ("return-structures"))))
+   #+(or)
    (:file "sorting" :depends-on (init data))
+   #+(or)
    (:module linear-algebra
 	    :depends-on (init data special-functions)
 	    :components
@@ -134,6 +139,7 @@
 	     (:file "cholesky")
 	     (:file "diagonal")
 	     (:file "householder")))
+   #+(or)
    (:module eigensystems
 	    :depends-on (init data)
 	    :components
@@ -142,6 +148,7 @@
 	     (:file "nonsymmetric" :depends-on ("eigen-struct"))
 	     (:file "generalized")
 	     (:file "nonsymmetric-generalized")))
+   #+(or)
    (:module fast-fourier-transforms
             :depends-on (init data)
             :components
@@ -154,6 +161,7 @@
              (:file "discrete")
              (:file "extras")
 	     (:file "example")))
+   #+(or)
    (:module random
 	    :depends-on (init data)
 	    :components
@@ -196,6 +204,7 @@
 	     (:file "hypergeometric" :depends-on ("rng-types"))
 	     (:file "logarithmic" :depends-on ("rng-types"))
 	     (:file "shuffling-sampling" :depends-on ("rng-types"))))
+   #+(or)
    (:module statistics
 	    :depends-on (init data)
 	    :components
@@ -206,6 +215,7 @@
 	     (:file "covariance")
 	     ;; minimum and maximum values provided in vector.lisp
 	     (:file "median-percentile")))
+   #+(or)
    (:module histogram
 	    :depends-on (init linear-algebra random)
 	    :components
@@ -215,6 +225,7 @@
 	     (:file "operations" :depends-on ("histogram"))
 	     (:file "probability-distribution" :depends-on ("histogram"))
 	     (:file "ntuple")))
+   #+(or)
    (:module calculus
 	    :depends-on (init data random)
 	    :components
@@ -224,6 +235,7 @@
 	     (cffi-grovel:grovel-file "monte-carlo-structs")
 	     (:file "monte-carlo")
 	     (:file "numerical-differentiation")))
+   #+(or)
    (:module ordinary-differential-equations
 	    :depends-on (init)
 	    :components
@@ -233,6 +245,7 @@
 	     (:file "control")
 	     (:file "evolution")
 	     (:file "ode-example" :depends-on ("ode-system" "stepping"))))
+   #+(or)
    (:module interpolation
 	    :depends-on (init)
 	    :components
@@ -241,11 +254,17 @@
 	     (:file "lookup")
 	     (:file "evaluation")
 	     (:file "spline-example" :depends-on ("types"))))
+   #+(or)
    (:file "chebyshev" :depends-on (init))
+   #+(or)
    (cffi-grovel:grovel-file "series-struct")
+   #+(or)
    (:file "series-acceleration" :depends-on (init "series-struct"))
+   #+(or)
    (:file "wavelet" :depends-on (init data))
+   #+(or)
    (:file "hankel" :depends-on (init data))
+   #+(or)
    (:module solve-minimize-fit
 	    :depends-on (init data random)
 	    :components
@@ -260,6 +279,7 @@
 		    :depends-on ("generic" "solver-struct"))
 	     #+fsbv
 	     (:file "simulated-annealing")))
+   #+(or)
    (:file "basis-splines" :depends-on (init data random))
    (:module physical-constants
 	    :depends-on (init)
diff --git a/hankel.lisp b/hankel.lisp
index 6cf1c07f92b02a32a241b1421bc936e53c6522a5..8365576f6566fc5752911f094adbe5d048629f3f 100644
--- a/hankel.lisp
+++ b/hankel.lisp
@@ -1,6 +1,6 @@
 ;; Discrete Hankel Transforms.
 ;; Liam Healy, Sat Dec  8 2007 - 16:50
-;; Time-stamp: <2009-12-27 09:47:41EST hankel.lisp>
+;; Time-stamp: <2010-06-27 18:13:50EDT hankel.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -41,8 +41,8 @@
      &optional
      (array-out (make-marray 'double-float :dimensions (dimensions array-in))))
   "gsl_dht_apply"
-  (((mpointer hankel) :pointer) ((c-pointer array-in) :pointer)
-   ((c-pointer array-out) :pointer))
+  (((mpointer hankel) :pointer) ((foreign-pointer array-in) :pointer)
+   ((foreign-pointer array-out) :pointer))
   :inputs (array-in)
   :outputs (array-out)
   :return (array-out)
diff --git a/histogram/histogram.lisp b/histogram/histogram.lisp
index 2ba42eb9207acca33f5f97b56f2e6f7591602609..4ca778ba05b0723252f829765f89a8356b2e5118 100644
--- a/histogram/histogram.lisp
+++ b/histogram/histogram.lisp
@@ -1,6 +1,6 @@
 ;; The histogram structure
 ;; Liam Healy, Mon Jan  1 2007 - 11:32
-;; Time-stamp: <2009-12-27 09:47:40EST histogram.lisp>
+;; Time-stamp: <2010-06-27 18:13:52EDT histogram.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -30,7 +30,7 @@
   ((number-of-bins sizet))
   "one-dimensional histogram, including bin boundaries and bin contents."
   :initialize-suffix "set_ranges"
-  :initialize-args (((c-pointer ranges) :pointer) ((dim0 ranges) sizet)))
+  :initialize-args (((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
-  (((c-pointer x-ranges) :pointer) ((dim0 x-ranges) sizet)
-   ((c-pointer y-ranges) :pointer) ((dim0 y-ranges) sizet)))
+  (((foreign-pointer x-ranges) :pointer) ((dim0 x-ranges) sizet)
+   ((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.
@@ -79,7 +79,7 @@
   :definition :method
   :return (histogram))
 
-(defmfun c-array:copy-to-destination ((source histogram) (destination histogram))
+(defmfun grid:copy-to-destination ((source histogram) (destination histogram))
   "gsl_histogram_memcpy"
   (((mpointer destination) :pointer) ((mpointer source) :pointer))
   :definition :method
@@ -91,7 +91,7 @@
    an exact copy of the former.
    The two histograms must be of the same size.")
 
-(defmfun c-array:copy-to-destination ((source histogram2d) (destination histogram2d))
+(defmfun grid:copy-to-destination ((source histogram2d) (destination histogram2d))
   "gsl_histogram2d_memcpy"
   (((mpointer destination) :pointer) ((mpointer source) :pointer))
   :definition :method
@@ -103,14 +103,14 @@
    an exact copy of the former.
    The two histograms must be of the same size.")
 
-(defmfun c-array:copy-making-destination ((source histogram))
+(defmfun grid:copy-making-destination ((source histogram))
   "gsl_histogram_clone"
   (((mpointer source) :pointer))
   :definition :method
   :c-return :pointer
   :index copy)
 
-(defmfun c-array:copy-making-destination ((source histogram2d))
+(defmfun grid:copy-making-destination ((source histogram2d))
   "gsl_histogram2d_clone"
   (((mpointer source) :pointer))
   :definition :method
diff --git a/init/body-expand.lisp b/init/body-expand.lisp
index ceefd8db6cc31a7ee26007f1a9e0d16855350ceb..abf3aa5e0072aaeded65e8b23aa6185a86d111a5 100644
--- a/init/body-expand.lisp
+++ b/init/body-expand.lisp
@@ -1,6 +1,6 @@
 ;; Expand the body of a defmfun
 ;; Liam Healy 2009-04-13 22:07:13EDT body-expand.lisp
-;; Time-stamp: <2010-06-10 11:03:23EDT body-expand.lisp>
+;; Time-stamp: <2010-06-27 18:25:27EDT body-expand.lisp>
 ;;
 ;; Copyright 2009, 2010 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -22,13 +22,13 @@
 
 (defun creturn-st (c-return)
   "The symbol-type of the return from the C function."
-  (c-array:make-st
+  (grid:make-st
    (if (listp c-return)
-       (c-array:st-symbol c-return)
+       (grid:st-symbol c-return)
        (make-symbol "CRETURN"))
    (if (member c-return *special-c-return*)
        :int
-       (if (listp c-return) (c-array:st-type c-return) c-return))))
+       (if (listp c-return) (grid:st-type c-return) c-return))))
 
 #+fsbv
 (defun variables-passed-by-value (c-arguments-st)
@@ -36,11 +36,11 @@
   variable in the C argument list."
   (loop for sd in c-arguments-st
      collect
-     (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))))))
+     (when (fsbv:defined-type-p (grid:st-type sd))
+       (list (grid:st-symbol sd)
+	     (grid:make-st
+	      (make-symbol (string (grid:st-symbol sd)))
+	      (grid:st-type sd))))))
 
 ;;; This function should never be called even when FSBV is absent,
 ;;; because the potential callers should all have #-fsbv
@@ -60,7 +60,7 @@
       (fsbv:defcfun-args-from-ff-args ff-args)
     (let ((gsl-name-symbol (make-symbol gsl-name))
 	  (symbargs
-	   (mapcar (lambda (st) (c-array:make-st (gensym "ARG") (c-array:st-type st)))
+	   (mapcar (lambda (st) (grid:make-st (gensym "ARG") (grid:st-type st)))
 		   args)))
       (values
        `(fsbv:defcfun (,gsl-name-symbol ,gsl-name) ,return-type
@@ -84,19 +84,19 @@
 
 (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)
+  (case (grid:st-actual-type decl)
     (sf-result 
-     `((val ,(c-array:st-symbol decl))
-       (err ,(c-array:st-symbol decl))))
+     `((val ,(grid:st-symbol decl))
+       (err ,(grid: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))))))
+     `((val ,(grid:st-symbol decl) 'sf-result-e10)
+       (e10 ,(grid:st-symbol decl))
+       (err ,(grid:st-symbol decl) 'sf-result-e10)))
+    (grid:complex-double-c
+     `((grid:complex-to-cl ,(grid:st-symbol decl) 0 'grid:complex-double-c)))
+    (grid:complex-float-c
+     `((grid:complex-to-cl ,(grid:st-symbol decl) 0 'grid:complex-float-c)))
+    (t `((cffi:mem-aref ,(grid:st-symbol decl) ',(grid:st-actual-type decl))))))
 
 (defun body-expand (name arglist gsl-name c-arguments key-args)
   "Expand the body (computational part) of the defmfun."
@@ -105,7 +105,7 @@
 	   (allocated-return ; Allocated and then returned from CL function
 	    (mapcar
 	     (lambda (s)
-	       (or (find s c-arguments :key #'c-array:st-symbol)
+	       (or (find s c-arguments :key #'grid:st-symbol)
 		   ;; Catch programming errors, usually typos
 		   (error "Could not find ~a among the arguments" s)))
 	     (remove-if
@@ -118,19 +118,19 @@
 	    #-fsbv nil)
 	   (clret (or			; better as a symbol macro
 		   (substitute
-		    (c-array:st-symbol creturn-st) :c-return
+		    (grid:st-symbol creturn-st) :c-return
 		    (mapcar (lambda (sym)
-			      (let ((it (find sym allocated-return :key 'c-array:st-symbol)))
+			      (let ((it (find sym allocated-return :key 'grid:st-symbol)))
 				(if it
 				    (first (cl-convert-form it))
 				    sym)))
 			    return))
 		   (mappend
 		    #'cl-convert-form
-		    (callback-remove-arg allocated-return cbinfo 'c-array:st-symbol))
+		    (callback-remove-arg allocated-return cbinfo 'grid:st-symbol))
 		   outputs
 		   (unless (eq c-return :void)
-		     (list (c-array:st-symbol creturn-st))))))
+		     (list (grid:st-symbol creturn-st))))))
       (wrap-letlike
        allocated-return
        (mapcar (lambda (d) (wfo-declare d cbinfo))
@@ -143,41 +143,34 @@
 	    (when callback-object (callback-set-dynamic callback-object arglist)))
 	   ,@(callback-set-slots
 	      cbinfo callback-dynamic-variables callback-dynamic)
-	   (let ((,(c-array:st-symbol creturn-st)
+	   (let ((,(grid:st-symbol creturn-st)
 		  ,(ffexpand (some 'identity pbv)
 			     gsl-name
 			     (append
 			      (mappend
 			       (lambda (arg)
 				 (list (cond
-					 ((member (c-array:st-symbol arg)
+					 ((member (grid:st-symbol arg)
 						  allocated-return)
 					  :pointer)
-					 (t (c-array:st-type arg)))
-				       (c-array:st-symbol arg)))
-			       (mapcar 'c-array:st-pointer-generic-pointer
+					 (t (grid:st-type arg)))
+				       (grid:st-symbol arg)))
+			       (mapcar 'grid:st-pointer-generic-pointer
 				       c-arguments))
-			      (list (c-array:st-type creturn-st))))))
+			      (list (grid:st-type creturn-st))))))
 	     ,@(case c-return
-		     (:void `((declare (ignore ,(c-array:st-symbol creturn-st)))))
+		     (:void `((declare (ignore ,(grid:st-symbol creturn-st)))))
 		     (:error-code	; fill in arguments
-		      `((check-gsl-status ,(c-array:st-symbol creturn-st)
+		      `((check-gsl-status ,(grid:st-symbol creturn-st)
 					  ',(or (defgeneric-method-p name) name)))))
-	     #-native
-	     ,@(when outputs
-		     (mapcar
-		      (lambda (x)
-			`(setf (c-array:cl-invalid ,x) t
-			       (c-array:c-invalid ,x) nil))
-		      outputs))
-	     ,@(when (eq (c-array:st-type creturn-st) :pointer)
+	     ,@(when (eq (grid:st-type creturn-st) :pointer)
 		     `((check-null-pointer
-			,(c-array:st-symbol creturn-st)
+			,(grid:st-symbol creturn-st)
 			,@'('memory-allocation-failure "No memory allocated."))))
 	     ,@after
 	     (values
 	      ,@(defmfun-return
-		 c-return (c-array:st-symbol creturn-st) clret
+		 c-return (grid:st-symbol creturn-st) clret
 		 allocated-return
 		 return return-supplied-p
 		 enumeration outputs))))))))
diff --git a/init/callback.lisp b/init/callback.lisp
index 67ab9ee3d3d63fc6a6a31a77c7ba300d696307ff..4782896b1559ba727137634f8ef8ea95a86d882a 100644
--- a/init/callback.lisp
+++ b/init/callback.lisp
@@ -1,6 +1,6 @@
 ;; Foreign callback functions.               
 ;; Liam Healy 
-;; Time-stamp: <2009-12-27 09:50:33EST callback.lisp>
+;; Time-stamp: <2010-06-27 18:03:22EDT callback.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -236,4 +236,4 @@
        ;; CL specials to do the same job.
        (declare ,@(when (member :slug args) `((ignore ,slug)))
 		(special ,dynamic-variable))
-       (funcall ,dynamic-variable ,@(mapcar 'c-array:st-symbol (remove :slug args))))))
+       (funcall ,dynamic-variable ,@(mapcar 'grid:st-symbol (remove :slug args))))))
diff --git a/init/defmfun-array.lisp b/init/defmfun-array.lisp
index 2d9bc3fd3fbef5490880b4198af3de81782b3dd2..ecd29c7595fe44d7e9c52a364dbd99c1ca551d16 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-27 09:50:32EST defmfun-array.lisp>
+;; Time-stamp: <2010-06-27 18:03:21EDT defmfun-array.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -95,9 +95,9 @@
 			 gsl-function-name)))
 		(remf key-args :documentation)
 		(when (eq c-return :element-c-type)
-		  (setf (getf key-args :c-return) (c-array:cl-cffi eltype)))
+		  (setf (getf key-args :c-return) (grid:cl-cffi eltype)))
 		(when (eq c-return :component-float-type)
-		  (setf (getf key-args :c-return) (c-array:component-type eltype)))
+		  (setf (getf key-args :c-return) (grid:component-type eltype)))
 		(if (optional-args-to-switch-gsl-functions arglist gsl-name)
 		    ;; The methods have optional argument(s) and
 		    ;; multiple GSL functions for presence/absence of
@@ -119,7 +119,7 @@
 		     (actual-gfn gsl-name)
 		     (actual-element-c-type eltype c-arguments)
 		     key-args))))
-	    (c-array:element-types element-types))))
+	    (grid:element-types element-types))))
 
 (defun actual-gsl-function-name (base-name category type)
   "Create the GSL or BLAS function name for data from the base name
@@ -130,7 +130,7 @@
   (if (listp base-name)
       (if (symbolp (first base-name))
 	  ;; An explicit listing of types with function names
-	  (getf base-name (c-array:cl-single type :gsl))
+	  (getf base-name (grid:cl-single type :gsl))
 	  (let ((blas (search "blas" (first base-name) :test 'string-equal)))
 	    (apply #'concatenate 'string
 		   (substitute
@@ -141,7 +141,7 @@
 		      (cl-gsl type (not blas) blas) :type
 		      (substitute
 		       (if (subtypep type 'complex)
-			   (cl-gsl (c-array:component-float-type type) nil blas)
+			   (cl-gsl (grid:component-float-type type) nil blas)
 			   "") :component-float-type
 		       (substitute
 			(string-downcase (symbol-name category)) :category
@@ -160,9 +160,9 @@
      (if (and replacing (listp arg))
 	 (list (first arg)
 	       (case (second arg)
-		 (:element-type (c-array:number-class element-type))
+		 (:element-type (grid:number-class element-type))
 		 (:component-float-type
-		  (c-array:number-class (c-array:component-float-type element-type)))
+		  (grid:number-class (grid:component-float-type element-type)))
 		 (otherwise
 		  (data-class-name
 		   (if (and (eq (second arg) 'both) replace-both)
@@ -173,8 +173,8 @@
 	 ;; specially for array methods.
 	 (if (and (listp arg) (numberp (second arg)))
 	     (let ((actual-type
-		    (c-array:cffi-cl
-		     (c-array:st-type (find (first arg) carg-actual :key 'c-array:st-symbol)))))
+		    (grid:cffi-cl
+		     (grid:st-type (find (first arg) carg-actual :key 'grid:st-symbol)))))
 	       (list (first arg) ; Optional arg default numerical value
 		     (if actual-type
 		     ;; coerce to the right type
@@ -213,6 +213,6 @@
    actual element type."
   (mapcar 
    (lambda (v)
-     (subst (c-array:cl-cffi element-type) :element-c-type
-	    (subst (c-array:component-type element-type) :component-float-type v)))
+     (subst (grid:cl-cffi element-type) :element-c-type
+	    (subst (grid:component-type element-type) :component-float-type v)))
    c-arguments))
diff --git a/init/defmfun-single.lisp b/init/defmfun-single.lisp
index df84a78fe77a1c7c271fb9bd5b99c51ddde1aa28..3e1db2c819b34196f9b43753095b3fed32e50d94 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: <2010-04-20 14:42:10EDT defmfun-single.lisp>
+;; Time-stamp: <2010-06-27 18:28:23EDT defmfun-single.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -44,19 +44,10 @@
   quality code walker, but is sufficient for actual usage of defmfun."
   (remove-duplicates
    (mappend (lambda (carg)
-	     (stupid-code-walk-find-variables (c-array:st-symbol carg)))
+	     (stupid-code-walk-find-variables (grid:st-symbol carg)))
 	   c-arguments)
    :from-end t))
 
-#+native
-(defun native-pointer (array-symbols body)
-  "Wrap the body with a form that obtains the native pointer
-   and protects it during execution of the body."
-  (if array-symbols
-      ;; http://www.sbcl.org/manual/Calling-Lisp-From-C.html
-      (c-array:native-pointer-protect array-symbols body)
-      body))
-
 (define-condition obsolete-gsl-version (error)
   ((name :initarg :name :reader name)
    (gsl-name :initarg :gsl-name :reader gsl-name)
@@ -134,16 +125,5 @@
 (defun body-no-optional-arg (name arglist gsl-name c-arguments key-args)
   "Wrap necessary array-handling forms around the expanded unswitched
   body form."
-  #-native
-  (destructuring-bind (&key inputs &allow-other-keys) key-args
-    `(progn
-       ,@(mapcar (lambda (v) `(c-array:copy-cl-to-c ,v))
-		 (intersection
-		  inputs (arglist-plain-and-categories arglist nil)))
-       ,(body-expand name arglist gsl-name c-arguments key-args)))
-  #+native
-  (destructuring-bind (&key inputs outputs &allow-other-keys) key-args
-    (native-pointer
-     (intersection
-      (union inputs outputs) (arglist-plain-and-categories arglist nil))
-     (body-expand name arglist gsl-name c-arguments key-args))))
+  ;; With static-vectors, nothing is now necessary, so this just calls body-expand.
+  (body-expand name arglist gsl-name c-arguments key-args))
diff --git a/init/defmfun.lisp b/init/defmfun.lisp
index 3f14c154b256d7b8a0525a4cfb531c219d0c7443..79c0c470ee3c5f356a5b99be6f6be50be96e4738 100644
--- a/init/defmfun.lisp
+++ b/init/defmfun.lisp
@@ -1,6 +1,6 @@
 ;; Macro for defining GSL functions.
 ;; Liam Healy 2008-04-16 20:49:50EDT defmfun.lisp
-;; Time-stamp: <2009-12-27 09:50:32EST defmfun.lisp>
+;; Time-stamp: <2010-06-27 18:03:23EDT defmfun.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -57,7 +57,7 @@
 ;;; qualifier  A method qualifier such as :after or :before.
 ;;; element-types
 ;;;            Permissible types for elements of arrays.  May be
-;;;            NIL meaning all of c-array:*array-element-types*, :no-complex
+;;;            NIL meaning all of grid:*array-element-types*, :no-complex
 ;;;            meaning that list without the complex types, 
 ;;;	       :float meaning only the float types, :complex only
 ;;;	       the complex types, :float-complex both float and complex,
diff --git a/init/funcallable.lisp b/init/funcallable.lisp
index 2c403edfbd845fa36129482b17b428e3e8bc0605..91fd397652755329c7642d0f2b4e13f667c7d994 100644
--- a/init/funcallable.lisp
+++ b/init/funcallable.lisp
@@ -1,6 +1,6 @@
 ;; Generate a lambda that calls the user function; will be called by callback.
 ;; Liam Healy 
-;; Time-stamp: <2009-12-27 09:50:30EST funcallable.lisp>
+;; Time-stamp: <2010-06-27 18:03:18EDT funcallable.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -79,7 +79,7 @@
 			(floor linear-index
 			       (first dims)))
 		       (list linear-index nil)))
-	    ',(c-array:cffi-cl (parse-callback-argspec argspec 'element-type)))
+	    ',(grid:cffi-cl (parse-callback-argspec argspec 'element-type)))
 	  `(cffi:mem-aref
 	    ,foreign-variable-name
 	    ',(parse-callback-argspec argspec 'element-type)
diff --git a/init/generate-examples.lisp b/init/generate-examples.lisp
index c4d1b2e5c1702368b1bc0290482fb2ee3acb28f4..71cff4ed2841a528e0c952051e0976451193d43a 100644
--- a/init/generate-examples.lisp
+++ b/init/generate-examples.lisp
@@ -1,6 +1,6 @@
 ;; Define examples.
 ;; Liam Healy 2008-09-07 21:00:48EDT generate-tests.lisp
-;; Time-stamp: <2009-12-27 09:50:30EST generate-examples.lisp>
+;; Time-stamp: <2010-06-27 18:03:19EDT generate-examples.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -95,7 +95,7 @@
    length using the pool data for the type and starting at the
    specified point in the pool."
   (mapcar
-   (lambda (num) (coerce num (c-array:component-float-type type)))
+   (lambda (num) (coerce num (grid:component-float-type type)))
    (subseq
     (cond ((subtypep type 'unsigned-byte) *unsigned-byte-pool*)
 	  ((subtypep type 'signed-byte) *signed-byte-pool*)
@@ -142,7 +142,7 @@
 	  (if float-type
 	      (first
 	       (make-list-from-pool
-		(c-array:component-float-type default-element-type) 1 starting-element))
+		(grid:component-float-type default-element-type) 1 starting-element))
 	      (apply
 	       #'complex
 	       (make-list-from-pool default-element-type 1 starting-element)))
@@ -163,7 +163,7 @@
 		  form))))
 
 (defun generate-all-array-tests-body (element-types test)
-  (loop for det in (c-array:element-types element-types)
+  (loop for det in (grid:element-types element-types)
      collect
      (let ((default-element-type det))
        (declare (special default-element-type starting-element))
diff --git a/init/init.lisp b/init/init.lisp
index 9df5144c0cc979751d370c26d8218788a0ba7ac0..33fb7301bbf7e1b2dd58b84b29889d5ba504d0a0 100644
--- a/init/init.lisp
+++ b/init/init.lisp
@@ -1,6 +1,6 @@
 ;; Load GSL
 ;; Liam Healy Sat Mar  4 2006 - 18:53
-;; Time-stamp: <2009-12-27 09:50:30EST init.lisp>
+;; Time-stamp: <2010-06-27 18:20:14EDT init.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -22,9 +22,11 @@
   (:nicknames :gsl)
   (:use :common-lisp :cffi)
   (:import-from
-   :c-array
+   :grid
    #:cl-array #:dimensions #:total-size #:element-type #:dim0 #:dim1
-   #:c-pointer #:copy #:clone)
+    ; #:copy #:clone
+   )
+  (:shadowing-import-from :grid #:foreign-pointer)
   (:export
    #:cl-array #:dimensions #:total-size #:element-type #:dim0 #:dim1
    #:copy #:clone))
diff --git a/init/interface.lisp b/init/interface.lisp
index f5ba4d1754fc4cd3ccb5b439c2af35fe832647a8..f251e524c3784b5d78e2e4ecd5fcb9fac1e7121a 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-27 09:50:29EST interface.lisp>
+;; Time-stamp: <2010-06-27 18:03:21EDT interface.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -46,11 +46,11 @@
   `(cffi:mem-aref ,size 'sizet ,index))
 
 (defun wfo-declare (d cbinfo)
-  `(,(c-array:st-symbol d)
-     ,@(if (eq (c-array:st-symbol d)
+  `(,(grid:st-symbol d)
+     ,@(if (eq (grid:st-symbol d)
 	       (parse-callback-static cbinfo 'foreign-argument))
 	   `(',(parse-callback-static cbinfo 'callback-fnstruct))
-	   `(',(c-array:st-actual-type d)))))
+	   `(',(grid:st-actual-type d)))))
 
 ;;;;****************************************************************************
 ;;;; Checking results from GSL functions
@@ -87,10 +87,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 (c-array:st-type sd))
+	for cl-type = (grid:cffi-cl (grid:st-type sd))
 	append
-	(when (and cl-type (member (c-array:st-symbol sd) (cl-symbols cl-arguments)))
-	  (list (list (c-array:st-symbol sd) cl-type)))))
+	(when (and cl-type (member (grid:st-symbol sd) (cl-symbols cl-arguments)))
+	  (list (list (grid:st-symbol sd) cl-type)))))
 
 (defun declaration-form (cl-argument-types &optional ignores specials)
   (cons 'declare
diff --git a/init/mobject.lisp b/init/mobject.lisp
index 25bc68c51fad66307be8976970ddebfb8d3779de..348484673fb3ae463803e14a746aa6e6b164dab3 100644
--- a/init/mobject.lisp
+++ b/init/mobject.lisp
@@ -1,6 +1,6 @@
 ;; Definition of GSL objects and ways to use them.
 ;; Liam Healy, Sun Dec  3 2006 - 10:21
-;; Time-stamp: <2009-12-27 09:50:29EST mobject.lisp>
+;; Time-stamp: <2010-06-27 18:26:32EDT mobject.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -335,12 +335,7 @@
   #-clisp
   form)
 
-;;; Some functions in solve-minimize-fit return a pointer to a GSL
-;;; vector with double-floats.  This function will return a contents
-;;; form suitable for make-marray.  There is no choice but to copy
-;;; over the data even on native implementations; because GSL is doing
-;;; the mallocing, the data are not CL-accessible.
-
+;;; Is this obsolete?  We no longer handle raw pointers.
 (defmethod mpointer ((object #.+foreign-pointer-class+))
   #+clisp (check-type object #.+foreign-pointer-type+)
   object)
@@ -353,7 +348,8 @@
 ;;;; Making objects from existing objects
 ;;;;****************************************************************************
 
-(defmethod c-array:copy-making-destination :around ((object mobject))
+#|
+(defmethod grid:copy-making-destination :around ((object mobject))
   (if (next-method-p)
       ;; The subclass method should only return the malloced
       ;; mpointer (as from a "_clone" function); it will be put into
@@ -370,5 +366,6 @@
       ;; by default.  We can only try to make something from the load form.
       (eval (make-load-form object))))
 
-(defmethod c-array:clone :around ((object mobject))
+(defmethod grid:clone :around ((object mobject))
   (make-instance (class-of object) :mpointer (call-next-method)))
+|#
diff --git a/init/types.lisp b/init/types.lisp
index 94230552bb54789f4bb4a419dfad74f2ae092378..566145454c9ac8c797a995c08bd7b305dcc3054b 100644
--- a/init/types.lisp
+++ b/init/types.lisp
@@ -1,6 +1,6 @@
 ;; Number types used by GSL functions, and specification conversion
 ;; Liam Healy 2008-12-31 21:06:34EST types.lisp
-;; Time-stamp: <2009-12-27 09:50:28EST types.lisp>
+;; Time-stamp: <2010-06-27 18:03:22EDT types.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -83,11 +83,11 @@
 			 "long-long"))
 		   (concatenate 'string (subseq ut 0 (- (length ut) 9)) "llong")
 		   ut))))
-     c-array:*cstd-integer-types*))
+     grid:*cstd-integer-types*))
    ;; The floating types are associated by order, so it is important that
    ;; order of *fp-type-mapping* and *gsl-splice-fp-types* match,
    ;; though the latter may be longer.
-   (c-array:floating-point-association *gsl-splice-fp-types*))
+   (grid:floating-point-association *gsl-splice-fp-types*))
   "Mapping the C standard types to the GSL splice name.")
 
 (defparameter *blas-splice-fp-types*
@@ -101,7 +101,7 @@
   ;; The floating types are associated by order, so it is important that
   ;; order of *fp-type-mapping* and *blas-splice-fp-types* match,
   ;; though the latter may be longer.
-  (c-array:floating-point-association *blas-splice-fp-types*)
+  (grid:floating-point-association *blas-splice-fp-types*)
   "Mapping the C standard types to the BLAS splice name.")
 
 ;;;;****************************************************************************
@@ -114,8 +114,8 @@
 (defun cl-gsl (cl-type &optional prepend-underscore blas)
   "The GSL splice string from the CL type."
   (let ((string
-	 (c-array:lookup-type
-	  (c-array:lookup-type cl-type c-array:*cstd-cl-type-mapping* t)
+	 (grid:lookup-type
+	  (grid:lookup-type cl-type grid:*cstd-cl-type-mapping* t)
 	  (if blas *cstd-blas-mapping* *cstd-gsl-mapping*))))
     (if (and prepend-underscore (plusp (length string)))
 	(concatenate 'string "_" string)
diff --git a/interpolation/evaluation.lisp b/interpolation/evaluation.lisp
index fb1e57f06b0998a1019ceebf22a568bc5b787ff4..0c7c6c0c1002f0872e4ce631a388097cea636ba8 100644
--- a/interpolation/evaluation.lisp
+++ b/interpolation/evaluation.lisp
@@ -1,6 +1,6 @@
 ;; Evaluation of interpolation functions.
 ;; Liam Healy Sun Nov  4 2007 - 18:40
-;; Time-stamp: <2010-03-28 16:40:16EDT evaluation.lisp>
+;; Time-stamp: <2010-06-27 18:13:56EDT evaluation.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -27,8 +27,8 @@
      &key xa ya (acceleration (make-acceleration)))
   "gsl_interp_eval"
   (((mpointer interpolation) :pointer)
-   ((c-pointer xa) :pointer)
-   ((c-pointer ya) :pointer)
+   ((foreign-pointer xa) :pointer)
+   ((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)
-   ((c-pointer xa) :pointer)
-   ((c-pointer ya) :pointer)
+   ((foreign-pointer xa) :pointer)
+   ((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)
-   ((c-pointer xa) :pointer)
-   ((c-pointer ya) :pointer)
+   ((foreign-pointer xa) :pointer)
+   ((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)
-   ((c-pointer xa) :pointer)
-   ((c-pointer ya) :pointer)
+   ((foreign-pointer xa) :pointer)
+   ((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 c45df356b47fc301f63020c82f03fc4cde6a6313..f7845f4f8efdf5a4b2944ceb75d1c6a35d5f45af 100644
--- a/interpolation/interpolation.lisp
+++ b/interpolation/interpolation.lisp
@@ -1,6 +1,6 @@
 ;; Interpolation allocation, initialization, and freeing.
 ;; Liam Healy, Sun Nov  4 2007 - 17:24
-;; Time-stamp: <2009-12-27 09:52:14EST interpolation.lisp>
+;; Time-stamp: <2010-06-27 18:13:56EDT interpolation.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -37,7 +37,7 @@
   strictly ordered; the behavior for other arrangements is not defined."
   :initialize-suffix "init"
   :initialize-args
-  (((c-pointer xa) :pointer) ((c-pointer ya) :pointer) ((dim0 xa) sizet))
+  (((foreign-pointer xa) :pointer) ((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
-  (((c-pointer xa) :pointer) ((c-pointer ya) :pointer) ((dim0 xa) sizet))
+  (((foreign-pointer xa) :pointer) ((foreign-pointer ya) :pointer) ((dim0 xa) sizet))
   :inputs (xa ya)
   :arglists-function
   (lambda (set)
diff --git a/linear-algebra/blas1.lisp b/linear-algebra/blas1.lisp
index c0d9e9a72a2d18f799a3ab00210c38d8b02d93fa..7da4379a6580beadb4472dade9fb6f291d50b78a 100644
--- a/linear-algebra/blas1.lisp
+++ b/linear-algebra/blas1.lisp
@@ -1,6 +1,6 @@
 ;; BLAS level 1, Vector operations
 ;; Liam Healy, Wed Apr 26 2006 - 15:23
-;; Time-stamp: <2009-12-27 09:55:01EST blas1.lisp>
+;; Time-stamp: <2010-06-27 18:13:54EDT blas1.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -153,8 +153,8 @@
 
 (defmfun givens-rotation ((x vector) (y vector) (c vector) (s vector))
   ("gsl_blas_" :type "rotg")
-  (((c-pointer x) :pointer) ((c-pointer y) :pointer)
-   ((c-pointer c) :pointer) ((c-pointer s) :pointer))
+  (((foreign-pointer x) :pointer) ((foreign-pointer y) :pointer)
+   ((foreign-pointer c) :pointer) ((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")
-  (((c-pointer d1) :pointer) ((c-pointer d2) :pointer)
-   ((c-pointer b1) :pointer) (b2 :element-c-type)
-   ((c-pointer P) :pointer))
+  (((foreign-pointer d1) :pointer) ((foreign-pointer d2) :pointer)
+   ((foreign-pointer b1) :pointer) (b2 :element-c-type)
+   ((foreign-pointer P) :pointer))
   :definition :generic
   :element-types :float
   :inputs (d1 d2 b1 P)
diff --git a/linear-algebra/qrpt.lisp b/linear-algebra/qrpt.lisp
index 4692d64975689468e861229514e13cee6ff99670..eabfef773c0b8ca6957a5c19b0809edd4429e9f5 100644
--- a/linear-algebra/qrpt.lisp
+++ b/linear-algebra/qrpt.lisp
@@ -1,6 +1,6 @@
 ;; QR with column pivoting
 ;; Liam Healy, Fri Apr 28 2006 - 16:53
-;; Time-stamp: <2009-12-27 09:54:58EST qrpt.lisp>
+;; Time-stamp: <2010-06-27 18:27:59EDT qrpt.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -183,7 +183,7 @@
 		   'double-float :dimensions (dimensions qr)
 		   ;; It shouldn't be necessary to initialize values
 		   ;; because we are going to setf every row,
-		   ;; but it is for #-native.  See Sat Dec 26 2009.
+		   ;; Sat Dec 26 2009.
 		   :initial-element 0)))
 	(dotimes (i (dim0 qr) ans)
 	  (setf (row ans i) (permute-inverse permutation (row qr i))))))))
diff --git a/mathematical/complex.lisp b/mathematical/complex.lisp
index 6ec0a235a44342d5c03ac052fdcd8d09af8cd886..dac764392595239c9a34906f69a034f2f2422b22 100644
--- a/mathematical/complex.lisp
+++ b/mathematical/complex.lisp
@@ -1,6 +1,6 @@
 ;; Functions of complex numbers
 ;; Liam Healy 2009-01-13 21:19:38EST complex.lisp
-;; Time-stamp: <2009-12-27 09:55:42EST complex.lisp>
+;; Time-stamp: <2010-06-27 18:03:16EDT complex.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -28,26 +28,26 @@
 
 (defmfun argument (number)
   "gsl_complex_arg"
-  ((number c-array:complex-double-c))
+  ((number grid:complex-double-c))
   :c-return :double
   :documentation
   "The angle of the complex number.")
 
 (defmfun modulus (number)
   "gsl_complex_abs"
-  ((number c-array:complex-double-c))
+  ((number grid:complex-double-c))
   :c-return :double
   :documentation "The magnitude, or modulus of the complex number.")
 
 (defmfun modulus2 (number)
   "gsl_complex_abs2"
-  ((number c-array:complex-double-c))
+  ((number grid:complex-double-c))
   :c-return :double
   :documentation "The magnitude squared of the complex number.")
 
 (defmfun log-modulus (number)
   "gsl_complex_logabs"
-  ((number c-array:complex-double-c))
+  ((number grid:complex-double-c))
   :c-return :double
   :documentation "The logarithm of the magnitude of the complex number.")
 
@@ -61,78 +61,78 @@
 
 (defmfun cx-add (c1 c2)
   "gsl_complex_add"
-  ((c1 c-array:complex-double-c) (c2 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (c2 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-sub (c1 c2)
   "gsl_complex_sub"
-  ((c1 c-array:complex-double-c) (c2 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (c2 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-mul (c1 c2)
   "gsl_complex_mul"
-  ((c1 c-array:complex-double-c) (c2 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (c2 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-div (c1 c2)
   "gsl_complex_div"
-  ((c1 c-array:complex-double-c) (c2 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (c2 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-add-real (c1 num)
   "gsl_complex_add_real"
-  ((c1 c-array:complex-double-c) (num :double))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (num :double))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-sub-real (c1 num)
   "gsl_complex_sub_real"
-  ((c1 c-array:complex-double-c) (num :double))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (num :double))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-mul-real (c1 num)
   "gsl_complex_mul_real"
-  ((c1 c-array:complex-double-c) (num :double))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (num :double))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-div-real (c1 num)
   "gsl_complex_div_real"
-  ((c1 c-array:complex-double-c) (num :double))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (num :double))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-add-imag (c1 num)
   "gsl_complex_add_imag"
-  ((c1 c-array:complex-double-c) (num :double))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (num :double))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-sub-imag (c1 num)
   "gsl_complex_sub_imag"
-  ((c1 c-array:complex-double-c) (num :double))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (num :double))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-mul-imag (c1 num)
   "gsl_complex_mul_imag"
-  ((c1 c-array:complex-double-c) (num :double))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (num :double))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-div-imag (c1 num)
   "gsl_complex_div_imag"
-  ((c1 c-array:complex-double-c) (num :double))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (num :double))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-conjugate (c1)
   "gsl_complex_conjugate"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-inverse (c1)
   "gsl_complex_inverse"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-negative (c1)
   "gsl_complex_negative"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 ;;;;****************************************************************************
 ;;; Complex functions
@@ -144,43 +144,43 @@
 
 (defmfun cx-sqrt (c1)
   "gsl_complex_sqrt"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-sqrt-real (num)
   "gsl_complex_sqrt_real"
   ((num :double))
-  :c-return c-array:complex-double-c)
+  :c-return grid:complex-double-c)
 
 (defmfun cx-expt (c1 c2)
   "gsl_complex_pow"
-  ((c1 c-array:complex-double-c) (c2 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (c2 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-expt-real (c1 num)
   "gsl_complex_pow_real"
-  ((c1 c-array:complex-double-c) (num :double))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (num :double))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-exp (c1)
   "gsl_complex_exp"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-log (c1)
   "gsl_complex_log"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-log10 (c1)
   "gsl_complex_log10"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-logb (c1 c2)
   "gsl_complex_log_b"
-  ((c1 c-array:complex-double-c) (c2 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c) (c2 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 ;;;;****************************************************************************
 ;;; Trigonometric functions
@@ -192,33 +192,33 @@
 
 (defmfun cx-sin (c1)
   "gsl_complex_sin"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-cos (c1)
   "gsl_complex_cos"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-sec (c1)
   "gsl_complex_sec"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-csc (c1)
   "gsl_complex_csc"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-tan (c1)
   "gsl_complex_tan"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-cot (c1)
   "gsl_complex_cot"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 ;;;;****************************************************************************
 ;;; Inverse trigonometric functions
@@ -230,53 +230,53 @@
 
 (defmfun cx-arcsin (c1)
   "gsl_complex_arcsin"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arcsin-real (num)
   "gsl_complex_arcsin_real"
   ((num :double))
-  :c-return c-array:complex-double-c)
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arccos (c1)
   "gsl_complex_arccos"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arccos-real (num)
   "gsl_complex_arccos_real"
   ((num :double))
-  :c-return c-array:complex-double-c)
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arcsec (c1)
   "gsl_complex_arcsec"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arcsec-real (num)
   "gsl_complex_arcsec_real"
   ((num :double))
-  :c-return c-array:complex-double-c)
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arccsc (c1)
   "gsl_complex_arccsc"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arccsc-real (num)
   "gsl_complex_arccsc_real"
   ((num :double))
-  :c-return c-array:complex-double-c)
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arctan (c1)
   "gsl_complex_arctan"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arccot (c1)
   "gsl_complex_arccot"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 ;;;;****************************************************************************
 ;;; Hyperbolic functions
@@ -284,33 +284,33 @@
 
 (defmfun cx-sinh (c1)
   "gsl_complex_sinh"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-cosh (c1)
   "gsl_complex_cosh"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-sech (c1)
   "gsl_complex_sech"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-csch (c1)
   "gsl_complex_csch"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-tanh (c1)
   "gsl_complex_tanh"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-coth (c1)
   "gsl_complex_coth"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 ;;;;****************************************************************************
 ;;; Inverse trigonometric functions
@@ -318,40 +318,40 @@
 
 (defmfun cx-arcsinh (c1)
   "gsl_complex_arcsinh"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arccosh (c1)
   "gsl_complex_arccosh"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arccosh-real (num)
   "gsl_complex_arccosh_real"
   ((num :double))
-  :c-return c-array:complex-double-c)
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arcsech (c1)
   "gsl_complex_arcsech"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arccsch (c1)
   "gsl_complex_arccsch"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arctanh (c1)
   "gsl_complex_arctanh"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arctanh-real (num)
   "gsl_complex_arctanh_real"
   ((num :double))
-  :c-return c-array:complex-double-c)
+  :c-return grid:complex-double-c)
 
 (defmfun cx-arccoth (c1)
   "gsl_complex_arccoth"
-  ((c1 c-array:complex-double-c))
-  :c-return c-array:complex-double-c)
+  ((c1 grid:complex-double-c))
+  :c-return grid:complex-double-c)
diff --git a/ordinary-differential-equations/evolution.lisp b/ordinary-differential-equations/evolution.lisp
index ae033d14b6c67f0dde9e5bde7b9f9e5d2101370e..eff0e004c2072d763c0bce9b119086d66ea4cc4d 100644
--- a/ordinary-differential-equations/evolution.lisp
+++ b/ordinary-differential-equations/evolution.lisp
@@ -1,6 +1,6 @@
 ;; Evolution functions for ODE integration.
 ;; Liam Healy, Sun Sep 30 2007 - 14:31
-;; Time-stamp: <2009-12-27 09:56:56EST evolution.lisp>
+;; Time-stamp: <2010-06-27 18:13:51EDT evolution.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -32,9 +32,9 @@
   "gsl_odeiv_evolve_apply"
   (((mpointer evolution) :pointer) ((mpointer control) :pointer)
    ((mpointer stepper) :pointer)
-   ((callback-struct stepper) :pointer) ((c-pointer time) :pointer)
+   ((callback-struct stepper) :pointer) ((foreign-pointer time) :pointer)
    (max-time :double)
-   ((c-pointer step-size) :pointer) ((c-pointer y) :pointer))
+   ((foreign-pointer step-size) :pointer) ((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/stepping.lisp b/ordinary-differential-equations/stepping.lisp
index e5604cf105f1b2f10c75cda5ab4fb7f5c27ab3b0..b1deaa2023e35518d44ef502af8fda8aaee6a46c 100644
--- a/ordinary-differential-equations/stepping.lisp
+++ b/ordinary-differential-equations/stepping.lisp
@@ -1,6 +1,6 @@
 ;; Stepping functions for ODE systems.
 ;; Liam Healy, Mon Sep 24 2007 - 21:33
-;; Time-stamp: <2009-12-27 09:56:54EST stepping.lisp>
+;; Time-stamp: <2010-06-27 18:13:51EDT stepping.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -106,10 +106,10 @@ values):
   (((mpointer stepper) :pointer)
    (time :double)
    (step-size :double)
-   ((c-pointer y) :pointer)
-   ((c-pointer yerr) :pointer)
-   ((c-pointer dydt-in) :pointer)
-   ((c-pointer dydt-out) :pointer)
+   ((foreign-pointer y) :pointer)
+   ((foreign-pointer yerr) :pointer)
+   ((foreign-pointer dydt-in) :pointer)
+   ((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 5c9bf18523f071c68216fc26f10053c2516fe9c4..839ecf8df4e7b6cff3b695203b04b8b2af16deba 100644
--- a/polynomial.lisp
+++ b/polynomial.lisp
@@ -1,6 +1,6 @@
 ;; Polynomials
 ;; Liam Healy, Tue Mar 21 2006 - 18:33
-;; Time-stamp: <2009-12-27 10:00:04EST polynomial.lisp>
+;; Time-stamp: <2010-06-27 18:14:53EDT polynomial.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -29,10 +29,10 @@
 (defmfun evaluate
     ((coefficients vector-double-float) (x float) &key divided-difference)
   ("gsl_poly_eval" "gsl_poly_dd_eval")
-  ((((c-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
+  ((((foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
     (x :double))
-   (((c-pointer divided-difference) :pointer)
-    ((c-pointer coefficients) :pointer)
+   (((foreign-pointer divided-difference) :pointer)
+    ((foreign-pointer coefficients) :pointer)
     ((dim0 coefficients) sizet)
     (x :double)))
   :definition :method
@@ -46,12 +46,12 @@
     ((coefficients vector-double-float) (x complex)
      &key)
   "gsl_poly_complex_eval"
-  (((c-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
-   (x c-array:complex-double-c))
+  (((foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
+   (x grid:complex-double-c))
   :definition :method
   :gsl-version (1 11)
   :inputs (coefficients)
-  :c-return c-array:complex-double-c
+  :c-return grid:complex-double-c
   :documentation			; FDL
   "Evaluate the polyonomial with coefficients at the complex value x.")
 
@@ -60,12 +60,12 @@
     ((coefficients vector-complex-double-float) (x complex)
      &key)
   "gsl_complex_poly_complex_eval"
-  (((c-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
-   (x c-array:complex-double-c))
+  (((foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
+   (x grid:complex-double-c))
   :definition :method
   :gsl-version (1 11)
   :inputs (coefficients)
-  :c-return c-array:complex-double-c
+  :c-return grid:complex-double-c
   :documentation			; FDL
   "Evaluate the polyonomial with coefficients at the complex value x.")
 
@@ -76,8 +76,8 @@
 (defmfun divided-difference
     (xa ya &optional (dd (make-marray 'double-float :dimensions (dim0 xa))))
   "gsl_poly_dd_init"
-  (((c-pointer dd) :pointer)
-   ((c-pointer xa) :pointer) ((c-pointer ya) :pointer)
+  (((foreign-pointer dd) :pointer)
+   ((foreign-pointer xa) :pointer) ((foreign-pointer ya) :pointer)
    ((dim0 xa) sizet))
   :inputs (xa ya)
   :outputs (dd)
@@ -95,12 +95,12 @@
 	(coefficients (make-marray 'double-float :dimensions (dim0 xa)))
 	(workspace (make-marray 'double-float :dimensions (dim0 xa))))
   "gsl_poly_dd_taylor"
-  (((c-pointer coefficients) :pointer)
+  (((foreign-pointer coefficients) :pointer)
    (xp :double)
-   ((c-pointer dd) :pointer)
-   ((c-pointer xa) :pointer)
+   ((foreign-pointer dd) :pointer)
+   ((foreign-pointer xa) :pointer)
    ((dim0 xa) sizet)
-   ((c-pointer workspace) :pointer))
+   ((foreign-pointer workspace) :pointer))
   :inputs (dd xa)
   :outputs (coefficients)
   :documentation			; FDL
@@ -128,7 +128,7 @@
 (defmfun solve-quadratic-complex (a b c)
   "gsl_poly_complex_solve_quadratic"
   ((a :double) (b :double) (c :double)
-   (root1 (:pointer c-array:complex-double-c)) (root2 (:pointer c-array:complex-double-c)))
+   (root1 (:pointer grid:complex-double-c)) (root2 (:pointer grid:complex-double-c)))
   :c-return :number-of-answers
   :documentation			; FDL
   "The complex roots of the quadratic equation a x^2 + b x + c = 0.
@@ -154,8 +154,8 @@
 (defmfun solve-cubic-complex (a b c)
   "gsl_poly_complex_solve_cubic"
   ((a :double) (b :double) (c :double)
-   (root1 (:pointer c-array:complex-double-c)) (root2 (:pointer c-array:complex-double-c))
-   (root3 (:pointer c-array:complex-double-c)))
+   (root1 (:pointer grid:complex-double-c)) (root2 (:pointer grid:complex-double-c))
+   (root3 (:pointer grid:complex-double-c)))
   :c-return :number-of-answers
   :documentation			; FDL
   "Find the complex roots of the cubic equation, x^3 + a x^2 + b x + c = 0
@@ -177,8 +177,8 @@
 			  :dimensions (1- (size coefficients))))
      (workspace (make-polynomial-complex-workspace (size coefficients))))
   "gsl_poly_complex_solve"
-  (((c-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
-   ((mpointer workspace) :pointer) ((c-pointer answer) :pointer))
+  (((foreign-pointer coefficients) :pointer) ((dim0 coefficients) sizet)
+   ((mpointer workspace) :pointer) ((foreign-pointer answer) :pointer))
   :inputs (coefficients)
   :outputs (answer)
   :return (answer)
diff --git a/random/dirichlet.lisp b/random/dirichlet.lisp
index 4ebf502fcf95595d60995cad25c0072ac68ff431..34f3f2ec2174a398fc313a1013c457849f72b9e4 100644
--- a/random/dirichlet.lisp
+++ b/random/dirichlet.lisp
@@ -1,6 +1,6 @@
 ;; Dirichlet distribution
 ;; Liam Healy, Sun Oct 29 2006
-;; Time-stamp: <2010-01-17 10:09:21EST dirichlet.lisp>
+;; Time-stamp: <2010-06-27 18:13:44EDT dirichlet.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -28,9 +28,9 @@
   "gsl_ran_dirichlet"
   (((mpointer generator) :pointer)
    ((dim0 alpha) sizet)
-   ((c-pointer alpha) :pointer)
+   ((foreign-pointer alpha) :pointer)
    ;; theta had better be at least as long as alpha, or they'll be trouble
-   ((c-pointer theta) :pointer))
+   ((foreign-pointer theta) :pointer))
   :definition :method
   :inputs (alpha)
   :outputs (theta)
@@ -55,9 +55,9 @@
 (defmfun dirichlet-pdf (alpha theta)
   "gsl_ran_dirichlet_pdf"
   (((1- (dim0 alpha)) sizet)
-   ((c-pointer alpha) :pointer)
+   ((foreign-pointer alpha) :pointer)
    ;; theta had better be at least as long as alpha, or they'll be trouble
-   ((c-pointer theta) :pointer))
+   ((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"
   (((1- (dim0 alpha)) sizet)
-   ((c-pointer alpha) :pointer)
+   ((foreign-pointer alpha) :pointer)
    ;; theta had better be at least as long as alpha, or they'll be trouble
-   ((c-pointer theta) :pointer))
+   ((foreign-pointer theta) :pointer))
   :inputs (alpha theta)
   :c-return :double
   :documentation			; FDL
diff --git a/random/discrete.lisp b/random/discrete.lisp
index e7451c7377ae12b38af25c08e2bf996fc65f4e55..0d8b0501126a04f00855770e5e1f816ab7430e6c 100644
--- a/random/discrete.lisp
+++ b/random/discrete.lisp
@@ -1,6 +1,6 @@
 ;; Discrete random variables
 ;; Liam Healy, Sat Nov 11 2006 - 21:51
-;; Time-stamp: <2010-01-17 10:10:00EST discrete.lisp>
+;; Time-stamp: <2010-06-27 18:14:53EDT discrete.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -23,7 +23,7 @@
 ;;; /usr/include/gsl/gsl_randist.h
 
 (defmobject discrete-random "gsl_ran_discrete"
-  (((dim0 probabilities) sizet) ((c-pointer probabilities) :pointer))
+  (((dim0 probabilities) sizet) ((foreign-pointer probabilities) :pointer))
   "lookup table for the discrete random number generator"
   :allocator "gsl_ran_discrete_preproc"
   :allocate-inputs (probabilities)
diff --git a/random/generators.lisp b/random/generators.lisp
index 1038e80a07ca9df46327cac8ed7763c9732a28bf..73e70a0210707e9e6bf7717e9c346706c66551d9 100644
--- a/random/generators.lisp
+++ b/random/generators.lisp
@@ -1,6 +1,6 @@
 ;; Generators of random numbers.
 ;; Liam Healy, Sat Jul 15 2006 - 14:43
-;; Time-stamp: <2010-01-17 10:21:31EST generators.lisp>
+;; Time-stamp: <2010-06-27 18:07:07EDT generators.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -176,7 +176,7 @@
 ;;;; Copying state
 ;;;;****************************************************************************
 
-(defmfun c-array:copy-to-destination
+(defmfun grid:copy-to-destination
     ((source random-number-generator) (destination random-number-generator))
   "gsl_rng_memcpy"
   (((mpointer destination) :pointer) ((mpointer source) :pointer))
@@ -188,7 +188,7 @@
    making destination into an exact copy
    of source.  The two generators must be of the same type.")
 
-(defmfun c-array:copy-making-destination ((instance random-number-generator))
+(defmfun grid:copy-making-destination ((instance random-number-generator))
   "gsl_rng_clone" (((mpointer instance) :pointer))
   :definition :method
   :c-return :pointer
diff --git a/random/multinomial.lisp b/random/multinomial.lisp
index 6af8b3a288c4dc1d03a495a1cdae7e5d2c12fb5e..c4a25c4fad4df40ca68f2782dc5fd6b9feb03f72 100644
--- a/random/multinomial.lisp
+++ b/random/multinomial.lisp
@@ -1,6 +1,6 @@
 ;; Multinomial distribution
 ;; Liam Healy, Sat Nov 25 2006 - 16:00
-;; Time-stamp: <2010-01-17 10:28:22EST multinomial.lisp>
+;; Time-stamp: <2010-06-27 18:13:43EDT multinomial.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -31,9 +31,9 @@
   (((mpointer generator) :pointer) 
    ((dim0 probabilities) sizet)
    (sum sizet)
-   ((c-pointer probabilities) :pointer)
+   ((foreign-pointer probabilities) :pointer)
    ;; technically, n should be a uint array, but integers work
-   ((c-pointer n) :pointer))
+   ((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) ((c-pointer p) :pointer) ((c-pointer n) :pointer))
+  (((dim0 p) sizet) ((foreign-pointer p) :pointer) ((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) ((c-pointer p) :pointer) ((c-pointer n) :pointer))
+  (((dim0 p) sizet) ((foreign-pointer p) :pointer) ((foreign-pointer n) :pointer))
   :inputs (p n)
   :c-return :double
   :documentation			; FDL
diff --git a/random/quasi.lisp b/random/quasi.lisp
index bcebff52239e17f5cc9080fea72a72b7f8c00290..0a7253903d49aa5ae0ea3db801c03a2054a1cedc 100644
--- a/random/quasi.lisp
+++ b/random/quasi.lisp
@@ -1,6 +1,6 @@
 ;; Quasi-random sequences in arbitrary dimensions.
 ;; Liam Healy, Sun Jul 16 2006 - 15:54
-;; Time-stamp: <2009-12-27 10:03:51EST quasi.lisp>
+;; Time-stamp: <2010-06-27 18:13:45EDT quasi.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -36,7 +36,7 @@
 
 (defmfun qrng-get (generator return-vector)
   "gsl_qrng_get"
-  (((mpointer generator) :pointer) ((c-pointer return-vector) :pointer))
+  (((mpointer generator) :pointer) ((foreign-pointer return-vector) :pointer))
   :outputs (return-vector)
   :return (return-vector)
   :documentation			; FDL
@@ -64,7 +64,7 @@
   :export nil
   :index gsl-random-state)
 
-(defmfun c-array:copy-to-destination
+(defmfun grid:copy-to-destination
     ((source quasi-random-number-generator)
      (destination quasi-random-number-generator))
   "gsl_qrng_memcpy"
@@ -76,7 +76,7 @@
    pre-existing generator dest, making dest into an exact copy
    of src.  The two generators must be of the same type.")
 
-(defmfun c-array:copy-making-destination ((instance quasi-random-number-generator))
+(defmfun grid:copy-making-destination ((instance quasi-random-number-generator))
   "gsl_qrng_clone" (((mpointer instance) :pointer))
   :definition :method
   :c-return :pointer
diff --git a/random/rng-types.lisp b/random/rng-types.lisp
index cc3b83e1c62d47f8259a73a081a2c5386052df7f..24edac392a652b8d464d79ca60a2480de695fb99 100644
--- a/random/rng-types.lisp
+++ b/random/rng-types.lisp
@@ -1,6 +1,6 @@
 ;; Random number generation
 ;; Liam Healy, Tue Jul 11 2006 - 23:39
-;; Time-stamp: <2009-12-27 10:03:50EST rng-types.lisp>
+;; Time-stamp: <2010-06-27 18:13:40EDT rng-types.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
diff --git a/random/shuffling-sampling.lisp b/random/shuffling-sampling.lisp
index 83a248ce3a9f00a38f74a443761c96082941c846..25a4f298b759aa52d6e6302dc45877dd14ae1dbf 100644
--- a/random/shuffling-sampling.lisp
+++ b/random/shuffling-sampling.lisp
@@ -1,6 +1,6 @@
 ;; Shuffling and sampling
 ;; Liam Healy, Sat Dec  2 2006 - 18:40
-;; Time-stamp: <2010-01-17 10:33:13EST shuffling-sampling.lisp>
+;; Time-stamp: <2010-06-27 18:13:45EDT shuffling-sampling.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -27,7 +27,7 @@
      &key base)
   "gsl_ran_shuffle"
   (((mpointer generator) :pointer)
-   ((c-pointer base) :pointer) ((dim0 base) sizet) ((c-array:element-size base) sizet))
+   ((foreign-pointer base) :pointer) ((dim0 base) sizet) ((grid:element-size base) sizet))
   :definition :method
   :inputs (base)
   :outputs (base)
@@ -50,8 +50,8 @@
 	  dest)))
   "gsl_ran_choose"
   (((mpointer generator) :pointer)
-   ((c-pointer destarr) :pointer) ((dim0 destarr) sizet)
-   ((c-pointer src) :pointer) ((dim0 src) sizet) ((c-array:element-size src) sizet))
+   ((foreign-pointer destarr) :pointer) ((dim0 destarr) sizet)
+   ((foreign-pointer src) :pointer) ((dim0 src) sizet) ((grid:element-size src) sizet))
   :definition :method
   :inputs (src)
   :outputs (destarr)
@@ -78,8 +78,8 @@
 	  dest)))
   "gsl_ran_sample"
   (((mpointer generator) :pointer)
-   ((c-pointer destarr) :pointer) ((dim0 destarr) sizet)
-   ((c-pointer src) :pointer) ((dim0 src) sizet) ((c-array:element-size src) sizet))
+   ((foreign-pointer destarr) :pointer) ((dim0 destarr) sizet)
+   ((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 249844ad0c1e3f0770754ff1103ee90b3d686d05..70f70667853f15f66968159f7c8f796d05c596fd 100644
--- a/random/spherical-vector.lisp
+++ b/random/spherical-vector.lisp
@@ -1,6 +1,6 @@
 ;; Spherical Vector distribution
 ;; Liam Healy, Sun Oct  22 2006
-;; Time-stamp: <2010-01-17 10:35:25EST spherical-vector.lisp>
+;; Time-stamp: <2010-06-27 18:13:44EDT spherical-vector.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -68,7 +68,7 @@
     ((generator random-number-generator) (type (eql :direction-Nd)) &key vector)
   "gsl_ran_dir_nd"
   (((mpointer generator) :pointer) ((dim0 vector) sizet)
-   ((c-pointer vector) :pointer))
+   ((foreign-pointer vector) :pointer))
   :definition :method
   :c-return :void
   :outputs (vector)
diff --git a/series-acceleration.lisp b/series-acceleration.lisp
index f79624520fad1baa7f5e633c2bfd8515482d5b24..8bd218b9bcca24199728c2cca811f64eadde904c 100644
--- a/series-acceleration.lisp
+++ b/series-acceleration.lisp
@@ -1,6 +1,6 @@
 ;; Series acceleration.
 ;; Liam Healy, Wed Nov 21 2007 - 18:41
-;; Time-stamp: <2009-12-27 10:05:34EST series-acceleration.lisp>
+;; Time-stamp: <2010-06-27 18:13:55EDT series-acceleration.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -38,7 +38,7 @@
 
 (defmfun accelerate (array levin)
   "gsl_sum_levin_u_accel"
-  (((c-pointer array) :pointer) ((dim0 array) sizet) ((mpointer levin) :pointer)
+  (((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"
-  (((c-pointer array) :pointer) ((dim0 array) sizet) ((mpointer levin) :pointer)
+  (((foreign-pointer array) :pointer) ((dim0 array) sizet) ((mpointer levin) :pointer)
    (accelerated-sum (:pointer :double)) (abserr (:pointer :double)))
   :inputs (array)
   :documentation			; FDL
diff --git a/solve-minimize-fit/linear-least-squares.lisp b/solve-minimize-fit/linear-least-squares.lisp
index 8874334dee16b1167d8074699b9f5e4d7be06085..0b19ff6ba336e386aa8fc796583d5213b493133d 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: <2010-01-17 10:40:22EST linear-least-squares.lisp>
+;; Time-stamp: <2010-06-27 18:13:53EDT linear-least-squares.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -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")
-  ((((c-pointer x) :pointer) (x-stride sizet)
-    ((c-pointer y) :pointer) (y-stride sizet)
+  ((((foreign-pointer x) :pointer) (x-stride sizet)
+    ((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)))
-   (((c-pointer x) :pointer) (x-stride sizet)
-    ((c-pointer weight) :pointer) (weight-stride sizet)
-    ((c-pointer y) :pointer) (y-stride sizet)
+   (((foreign-pointer x) :pointer) (x-stride sizet)
+    ((foreign-pointer weight) :pointer) (weight-stride sizet)
+    ((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")
-  ((((c-pointer x) :pointer) (x-stride sizet)
-    ((c-pointer y) :pointer) (y-stride sizet)
+  ((((foreign-pointer x) :pointer) (x-stride sizet)
+    ((foreign-pointer y) :pointer) (y-stride sizet)
     ((dim0 x) sizet)
     (c1 (:pointer :double)) (cov11 (:pointer :double))
     (sumsq (:pointer :double)))
-   (((c-pointer x) :pointer) (x-stride sizet)
-    ((c-pointer weight) :pointer) (weight-stride sizet)
-    ((c-pointer y) :pointer) (y-stride sizet)
+   (((foreign-pointer x) :pointer) (x-stride sizet)
+    ((foreign-pointer weight) :pointer) (weight-stride sizet)
+    ((foreign-pointer y) :pointer) (y-stride sizet)
     ((dim0 x) sizet)
     (c1 (:pointer :double)) (cov11 (:pointer :double))
     (sumsq (:pointer :double))))
@@ -202,7 +202,7 @@
   :inputs (model weight observations)
   :outputs (parameters covariance)
   :switch (weight)
-  :return (parameters covariance (c-array:dcref chisq))
+  :return (parameters covariance (grid:dcref chisq))
   :export nil
   :index linear-mfit
   :documentation			; FDL
@@ -247,7 +247,7 @@
   :inputs (model weight observations)
   :outputs (parameters covariance)
   :switch (weight)
-  :return ((c-array:dcref chisq) (scref rank))
+  :return ((grid: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 208e0722721705e9ccc37e379f568b0bb2cb4a30..0b1db42a17fa9cbad30db132471588513e32accc 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-06-27 08:39:24EDT minimization-multi.lisp>
+;; Time-stamp: <2010-06-27 18:03:17EDT minimization-multi.lisp>
 ;;
 ;; Copyright 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -422,7 +422,7 @@
 (defun paraboloid-and-derivative
     (arguments-gv-pointer value-pointer derivative-gv-pointer)
   (prog1
-      (setf (c-array:dcref value-pointer)
+      (setf (grid:dcref value-pointer)
 	    (paraboloid-vector arguments-gv-pointer))
     (paraboloid-derivative
      arguments-gv-pointer derivative-gv-pointer)))
diff --git a/sorting.lisp b/sorting.lisp
index ea900f2e43645e670581279356bc7eced6d71b10..592374bab730b47aec68e83f77c017fe70271ff4 100644
--- a/sorting.lisp
+++ b/sorting.lisp
@@ -1,6 +1,6 @@
 ;; Sorting
 ;; Liam Healy, Fri Apr 14 2006 - 20:20
-;; Time-stamp: <2009-12-27 10:10:08EST sorting.lisp>
+;; Time-stamp: <2010-06-27 18:13:49EDT sorting.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -75,7 +75,7 @@
 
 (defmfun msort ((v both))
   ("gsl_sort" :type)
-  (((c-pointer v) :pointer) (1 sizet) ((size v) sizet))
+  (((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)
-   ((c-pointer vector) :pointer)
+   ((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")
-  (((c-pointer dest) :pointer) ((dim0 dest) sizet)
+  (((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")
-  (((c-pointer dest) :pointer) ((size dest) sizet)
-   ((c-pointer v) :pointer)
+  (((foreign-pointer dest) :pointer) ((size dest) sizet)
+   ((foreign-pointer v) :pointer)
    (1 sizet)				; stride, set to 1 for now
    ((size v) sizet))
   :definition :generic
@@ -166,7 +166,7 @@
 
 (defmfun sort-vector-smallest-index (combination (v vector))
   ("gsl_sort_vector" :type "_smallest_index")
-  (((c-pointer combination) :pointer) ((size combination) sizet)
+  (((foreign-pointer combination) :pointer) ((size combination) sizet)
    ((mpointer v) :pointer)
    (1 sizet)				; stride, set to 1 for now
    ((first (dimensions combination)) sizet))
@@ -184,8 +184,8 @@
 
 (defmfun sort-smallest-index (combination (v vector))
   ("gsl_sort" :type "_smallest_index")
-  (((c-pointer combination) :pointer) ((size combination) sizet)
-   ((c-pointer v) :pointer)
+  (((foreign-pointer combination) :pointer) ((size combination) sizet)
+   ((foreign-pointer v) :pointer)
    (1 sizet)				; stride, set to 1 for now
    ((first (dimensions combination)) sizet))
   :definition :generic
@@ -202,7 +202,7 @@
 
 (defmfun sort-vector-largest (dest (v vector))
   ("gsl_sort_vector" :type "_largest")
-  (((c-pointer dest) :pointer) ((dim0 dest) sizet)
+  (((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")
-  (((c-pointer dest) :pointer) ((size dest) sizet)
-   ((c-pointer v) :pointer)
+  (((foreign-pointer dest) :pointer) ((size dest) sizet)
+   ((foreign-pointer v) :pointer)
    (1 sizet)				; stride, set to 1 for now
    ((size v) sizet))
   :definition :generic
@@ -230,7 +230,7 @@
 
 (defmfun sort-vector-largest-index (combination (v vector))
   ("gsl_sort_vector" :type "_largest_index")
-  (((c-pointer combination) :pointer) ((size combination) sizet)
+  (((foreign-pointer combination) :pointer) ((size combination) sizet)
    ((mpointer v) :pointer)
    (1 sizet)				; stride, set to 1 for now
    ((first (dimensions combination)) sizet))
@@ -248,8 +248,8 @@
 
 (defmfun sort-largest-index (combination (v vector))
   ("gsl_sort" :type "_largest_index")
-  (((c-pointer combination) :pointer) ((size combination) sizet)
-   ((c-pointer v) :pointer)
+  (((foreign-pointer combination) :pointer) ((size combination) sizet)
+   ((foreign-pointer v) :pointer)
    (1 sizet)				; stride, set to 1 for now
    ((first (dimensions combination)) sizet))
   :element-types :no-complex
diff --git a/special-functions/bessel.lisp b/special-functions/bessel.lisp
index 0124ca40d15305e7fc0909bff7cb62bd3a7aa527..0f0fb7b5d4b83124cbed1379c67ce2aff9c0a77e 100644
--- a/special-functions/bessel.lisp
+++ b/special-functions/bessel.lisp
@@ -1,6 +1,6 @@
 ;; Bessel functions
 ;; Liam Healy, Fri Mar 17 2006 - 18:42
-;; Time-stamp: <2009-12-27 10:10:07EST bessel.lisp>
+;; Time-stamp: <2010-06-27 18:13:48EDT bessel.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -49,7 +49,7 @@
        &aux (array (vdf size-or-array)))
   "gsl_sf_bessel_Jn_array"
   ((nmin :int) ((+ nmin (dim0 array) -1) :int) (x :double)
-   ((c-pointer array) :pointer))
+   ((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) ((c-pointer v) :pointer))
+  ((nu :double) (mode sf-mode) ((dim0 v) :int) ((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)
-   ((c-pointer array) :pointer))
+   ((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)
-   ((c-pointer array) :pointer))
+   ((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)
-   ((c-pointer array) :pointer))
+   ((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)
-   ((c-pointer array) :pointer))
+   ((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)
-   ((c-pointer array) :pointer))
+   ((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) ((c-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((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) ((c-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((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) ((c-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((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) ((c-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((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) ((c-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((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 333829c3bd6c303bf288c06edcc23004ada4bd3b..7ba3d5016583413b7e24804599993ed4e3f91f56 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-12-27 10:10:06EST coulomb.lisp>
+;; Time-stamp: <2010-06-27 18:13:47EDT coulomb.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -53,7 +53,7 @@
    (exp-F (:pointer :double)) (exp-G (:pointer :double)))
   :return
   ((val F) (val Fp) (val G) (val Gp)
-   (c-array:dcref exp-F) (c-array:dcref exp-G)
+   (grid:dcref exp-F) (grid:dcref exp-G)
    (err F) (err Fp) (err G) (err Gp))
   :documentation			; FDL
   "The Coulomb wave functions F_L(\eta,x),
@@ -70,9 +70,9 @@
 	   &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)
-   ((c-pointer fc-array) :pointer) (F-exponent (:pointer :double)))
+   ((foreign-pointer fc-array) :pointer) (F-exponent (:pointer :double)))
   :outputs (fc-array)
-  :return (fc-array (c-array:dcref F-exponent))
+  :return (fc-array (grid:dcref F-exponent))
   :documentation			; FDL
   "The Coulomb wave function F_L(\eta,x) for
   L = Lmin ... Lmin + kmax, storing the results in fc-array.
@@ -86,10 +86,10 @@
 	   (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)
-   ((c-pointer fc-array) :pointer) ((c-pointer gc-array) :pointer)
+   ((foreign-pointer fc-array) :pointer) ((foreign-pointer gc-array) :pointer)
    (F-exponent (:pointer :double)) (G-exponent (:pointer :double)))
   :outputs (fc-array gc-array)
-  :return (fc-array gc-array (c-array:dcref F-exponent) (c-array:dcref G-exponent))
+  :return (fc-array gc-array (grid:dcref F-exponent) (grid:dcref G-exponent))
   :documentation			; FDL
   "The functions F_L(\eta,x),
   G_L(\eta,x) for L = Lmin ... Lmin + kmax storing the
@@ -108,13 +108,13 @@
 	   (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)
-   ((c-pointer fc-array) :pointer) ((c-pointer fcp-array) :pointer)
-   ((c-pointer gc-array) :pointer) ((c-pointer gcp-array) :pointer)
+   ((foreign-pointer fc-array) :pointer) ((foreign-pointer fcp-array) :pointer)
+   ((foreign-pointer gc-array) :pointer) ((foreign-pointer gcp-array) :pointer)
    (F-exponent (:pointer :double)) (G-exponent (:pointer :double)))
   :outputs (fc-array fcp-array gc-array gcp-array)
   :return
   (fc-array fcp-array gc-array gcp-array
-	    (c-array:dcref F-exponent) (c-array:dcref G-exponent))
+	    (grid:dcref F-exponent) (grid:dcref G-exponent))
   :documentation			; FDL
   "The functions F_L(\eta,x),
   G_L(\eta,x) and their derivatives F'_L(\eta,x),
@@ -128,9 +128,9 @@
 	   &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)
-   ((c-pointer fc-array) :pointer) (F-exponent (:pointer :double)))
+   ((foreign-pointer fc-array) :pointer) (F-exponent (:pointer :double)))
   :outputs (fc-array)
-  :return (fc-array (c-array:dcref F-exponent))
+  :return (fc-array (grid: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
@@ -153,7 +153,7 @@
 	   &aux (array (vdf size-or-array)))
   "gsl_sf_coulomb_CL_array"
   ((L-min :double) ((1- (dim0 array)) :int) (eta :double)
-   ((c-pointer array) :pointer))
+   ((foreign-pointer array) :pointer))
   :outputs (array)
   :documentation			; FDL
   "The Coulomb wave function normalization constant C_L(\eta)
diff --git a/special-functions/gamma.lisp b/special-functions/gamma.lisp
index 99648cf0643941e197c035a0b2f0505dcce62c21..66b8645124c99e9435e59df8e6932f537ec5aebd 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-12-27 10:10:03EST gamma.lisp>
+;; Time-stamp: <2010-06-27 18:03:15EDT gamma.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -52,7 +52,7 @@
 (defmfun log-gamma-sign (x)
   "gsl_sf_lngamma_sgn_e"
   ((x :double) (ret sf-result) (sign (:pointer :double)))
-  :return ((val ret) (c-array:dcref sign) (err ret))
+  :return ((val ret) (grid: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
@@ -151,7 +151,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) (c-array:dcref sign) (err ret)))
+  :return ((val ret) (grid:dcref sign) (err ret)))
 
 (defmfun relative-pochammer (a x)
   "gsl_sf_pochrel_e" ((a :double) (x :double) (ret sf-result))
diff --git a/special-functions/gegenbauer.lisp b/special-functions/gegenbauer.lisp
index 7dba8eb62b84979a43f3bfd1d014b5e91c0c7f88..6279f4ba32491efab3301ae7cc04a3a4bd336e92 100644
--- a/special-functions/gegenbauer.lisp
+++ b/special-functions/gegenbauer.lisp
@@ -1,6 +1,6 @@
 ;; Gegenbauer polynomials
 ;; Liam Healy, Fri Apr 28 2006 - 20:40
-;; Time-stamp: <2009-12-27 10:10:02EST gegenbauer.lisp>
+;; Time-stamp: <2010-06-27 18:13:48EDT gegenbauer.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -47,7 +47,7 @@
 	    &aux (array (vdf size-or-array)))
   "gsl_sf_gegenpoly_array"
   (((1- (dim0 array)) :int)
-   (lambda :double) (x :double) ((c-pointer array) :pointer))
+   (lambda :double) (x :double) ((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 559ef97c74f139b96d132ea36e68ee9547baa283..d4f329a1460b36b31a5da3564b4e9218992bceed 100644
--- a/special-functions/legendre.lisp
+++ b/special-functions/legendre.lisp
@@ -1,6 +1,6 @@
 ;; Legendre functions
 ;; Liam Healy, Sat Apr 29 2006 - 19:16
-;; Time-stamp: <2009-12-27 10:10:01EST legendre.lisp>
+;; Time-stamp: <2010-06-27 18:13:46EDT legendre.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -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) ((c-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((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) ((c-pointer array) :pointer))
+  (((1- (dim0 array)) :int) (x :double) ((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)
-   ((c-pointer array) :pointer))
+   ((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)
-   ((c-pointer values) :pointer) ((c-pointer derivatives) :pointer))
+   ((foreign-pointer values) :pointer) ((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)
-   ((c-pointer array) :pointer))
+   ((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)
-   ((c-pointer values) :pointer) ((c-pointer derivatives) :pointer))
+   ((foreign-pointer values) :pointer) ((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)
-   ((c-pointer array) :pointer))
+   ((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 f248a7d72f1a581a5c405dc594a5be94f3676ac5..6f5b389f04a53b657ff6b26c76daec7da1a3c956 100644
--- a/special-functions/mathieu.lisp
+++ b/special-functions/mathieu.lisp
@@ -1,6 +1,6 @@
 ;; Mathieu functions
 ;; Liam Healy 2009-02-16 16:30:59EST mathieu.lisp
-;; Time-stamp: <2009-12-27 10:10:01EST mathieu.lisp>
+;; Time-stamp: <2010-06-27 18:13:47EDT mathieu.lisp>
 ;;
 ;; Copyright 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -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) :int) (q :double)
-   ((mpointer workspace) :pointer) ((c-pointer result-array) :pointer))
+   ((mpointer workspace) :pointer) ((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) :int) (q :double)
-   ((mpointer workspace) :pointer) ((c-pointer result-array) :pointer))
+   ((mpointer workspace) :pointer) ((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) :int)
    (q :double) (x :double)
-   ((mpointer workspace) :pointer) ((c-pointer result-array) :pointer))
+   ((mpointer workspace) :pointer) ((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) :int)
    (q :double) (x :double)
-   ((mpointer workspace) :pointer) ((c-pointer result-array) :pointer))
+   ((mpointer workspace) :pointer) ((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) ((c-pointer result-array) :pointer))
+   ((mpointer workspace) :pointer) ((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) ((c-pointer result-array) :pointer))
+   ((mpointer workspace) :pointer) ((foreign-pointer result-array) :pointer))
   :gsl-version (1 9)
   :outputs (result-array)
   :return (result-array)
diff --git a/statistics/absolute-deviation.lisp b/statistics/absolute-deviation.lisp
index 93853c67f8bc32e9faf0d5edae5337eca61261f6..64f598de83f4bf7b694f325f3605e1eb30384854 100644
--- a/statistics/absolute-deviation.lisp
+++ b/statistics/absolute-deviation.lisp
@@ -1,6 +1,6 @@
 ;; Absolute deviation
 ;; Liam Healy, Sun Dec 31 2006 - 13:19
-;; Time-stamp: <2009-12-27 10:11:29EST absolute-deviation.lisp>
+;; Time-stamp: <2010-06-27 18:14:02EDT absolute-deviation.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -26,8 +26,8 @@
 (defmfun absolute-deviation ((data vector) &optional mean)
   (("gsl_stats" :type "_absdev")
    ("gsl_stats" :type "_absdev_m"))
-  ((((c-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
-   (((c-pointer data) :pointer) (1 :int) ((dim0 data) sizet)
+  ((((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
+   (((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"))
-  ((((c-pointer weights) :pointer) (1 :int)
-    ((c-pointer data) :pointer) (1 :int)
+  ((((foreign-pointer weights) :pointer) (1 :int)
+    ((foreign-pointer data) :pointer) (1 :int)
     ((dim0 data) sizet))
-   (((c-pointer weights) :pointer) (1 :int)
-    ((c-pointer data) :pointer) (1 :int)
+   (((foreign-pointer weights) :pointer) (1 :int)
+    ((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 3475c4aeaa758a5b9ad9d325227189af15484b62..20d29fe261684e6ae639d9bd83ba7ffa6d2bb3d0 100644
--- a/statistics/autocorrelation.lisp
+++ b/statistics/autocorrelation.lisp
@@ -1,6 +1,6 @@
 ;; Autocorrelation
 ;; Liam Healy, Sun Dec 31 2006 - 13:19
-;; Time-stamp: <2009-12-27 10:11:28EST autocorrelation.lisp>
+;; Time-stamp: <2010-06-27 18:14:03EDT autocorrelation.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -26,8 +26,8 @@
 (defmfun autocorrelation ((data vector) &optional mean)
   (("gsl_stats" :type "_lag1_autocorrelation")
    ("gsl_stats" :type "_lag1_autocorrelation_m"))
-  ((((c-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
-   (((c-pointer data) :pointer) (1 :int) ((dim0 data) sizet)
+  ((((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
+   (((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 ba391006793489feb58995d83fbab5e9c97ece97..6d7ce75615333ce49930c0eee73670017c72715a 100644
--- a/statistics/covariance.lisp
+++ b/statistics/covariance.lisp
@@ -1,6 +1,6 @@
 ;; Covariance
 ;; Liam Healy, Sun Dec 31 2006 - 13:19
-;; Time-stamp: <2009-12-27 10:11:28EST covariance.lisp>
+;; Time-stamp: <2010-06-27 18:14:03EDT covariance.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -27,10 +27,10 @@
     ((data1 vector) (data2 vector) &optional mean1 mean2)
   (("gsl_stats" :type "_covariance")
    ("gsl_stats" :type "_covariance_m"))
-  ((((c-pointer data1) :pointer) (1 :int)
-    ((c-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet))
-   (((c-pointer data1) :pointer) (1 :int)
-    ((c-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet)
+  ((((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)
     (mean1 :double) (mean2 :double)))
   :definition :generic
   :element-types :no-complex
@@ -44,8 +44,8 @@
 
 (defmfun correlation ((data1 vector) (data2 vector))
   ("gsl_stats" :type "_correlation")
-  (((c-pointer data1) :pointer) (1 :int)
-    ((c-pointer data2) :pointer) (1 :int) ((dim0 data2) sizet))
+  (((foreign-pointer data1) :pointer) (1 :int)
+    ((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 f6f4907c985b23e9f74eaf02ee38984f795b5b10..179bbc012ba3c35ec1ee431bd8c1958b981c12b5 100644
--- a/statistics/higher-moments.lisp
+++ b/statistics/higher-moments.lisp
@@ -1,6 +1,6 @@
 ;; Skewness and kurtosis.
 ;; Liam Healy, Sun Dec 31 2006 - 14:20
-;; Time-stamp: <2009-12-27 10:11:27EST higher-moments.lisp>
+;; Time-stamp: <2010-06-27 18:14:02EDT higher-moments.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -25,8 +25,8 @@
 (defmfun skewness ((data vector) &optional mean standard-deviation)
   (("gsl_stats" :type "_skew")
    ("gsl_stats" :type "_skew_m_sd"))
-  ((((c-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
-   (((c-pointer data) :pointer) (1 :int) ((dim0 data) sizet)
+  ((((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
+   (((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"))
-  ((((c-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
-   (((c-pointer data) :pointer) (1 :int) ((dim0 data) sizet)
+  ((((foreign-pointer data) :pointer) (1 :int) ((dim0 data) sizet))
+   (((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"))
-  ((((c-pointer weights) :pointer) (1 :int)
-    ((c-pointer data) :pointer) (1 :int)
+  ((((foreign-pointer weights) :pointer) (1 :int)
+    ((foreign-pointer data) :pointer) (1 :int)
     ((dim0 data) sizet))
-   (((c-pointer weights) :pointer) (1 :int)
-    ((c-pointer data) :pointer) (1 :int)
+   (((foreign-pointer weights) :pointer) (1 :int)
+    ((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"))
-  ((((c-pointer weights) :pointer) (1 :int)
-    ((c-pointer data) :pointer) (1 :int)
+  ((((foreign-pointer weights) :pointer) (1 :int)
+    ((foreign-pointer data) :pointer) (1 :int)
     ((dim0 data) sizet))
-   (((c-pointer weights) :pointer) (1 :int)
-    ((c-pointer data) :pointer) (1 :int)
+   (((foreign-pointer weights) :pointer) (1 :int)
+    ((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 8daa2a1ec8bc844eb5ff289414de0bdc3e692e49..7d17160ad6a7e334565f307aa612cc3eb891dd34 100644
--- a/statistics/mean-variance.lisp
+++ b/statistics/mean-variance.lisp
@@ -1,6 +1,6 @@
 ;; Mean, standard deviation, and variance    
 ;; Liam Healy, Sat Dec  2 2006 - 22:15
-;; Time-stamp: <2009-12-27 10:11:27EST mean-variance.lisp>
+;; Time-stamp: <2010-06-27 18:14:01EDT mean-variance.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -29,7 +29,7 @@
 
 (defmfun mean ((array both))
   ("gsl_stats" :type "_mean")
-  (((c-pointer array) :pointer) (1 :int) ((size array) sizet))
+  (((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")
-  (((c-pointer weights) :pointer) (1 :int)
-   ((c-pointer array) :pointer) (1 :int)
+  (((foreign-pointer weights) :pointer) (1 :int)
+   ((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"))
-  ((((c-pointer array) :pointer) (1 :int) ((size array) sizet))
-   (((c-pointer array) :pointer) (1 :int)
+  ((((foreign-pointer array) :pointer) (1 :int) ((size array) sizet))
+   (((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"))
-  ((((c-pointer weights) :pointer) (1 :int)
-    ((c-pointer array) :pointer) (1 :int)
+  ((((foreign-pointer weights) :pointer) (1 :int)
+    ((foreign-pointer array) :pointer) (1 :int)
     ((size array) sizet))
-   (((c-pointer weights) :pointer) (1 :int)
-    ((c-pointer array) :pointer) (1 :int)
+   (((foreign-pointer weights) :pointer) (1 :int)
+    ((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"))
-  ((((c-pointer array) :pointer) (1 :int) ((size array) sizet))
-   (((c-pointer array) :pointer) (1 :int)
+  ((((foreign-pointer array) :pointer) (1 :int) ((size array) sizet))
+   (((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"))
-  ((((c-pointer weights) :pointer) (1 :int)
-    ((c-pointer array) :pointer) (1 :int)
+  ((((foreign-pointer weights) :pointer) (1 :int)
+    ((foreign-pointer array) :pointer) (1 :int)
     ((size array) sizet))
-   (((c-pointer weights) :pointer) (1 :int)
-    ((c-pointer array) :pointer) (1 :int)
+   (((foreign-pointer weights) :pointer) (1 :int)
+    ((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")
-  (((c-pointer array) :pointer) (1 :int)
+  (((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")
-  (((c-pointer array) :pointer) (1 :int)
+  (((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")
-  (((c-pointer weights) :pointer) (1 :int)
-   ((c-pointer array) :pointer) (1 :int)
+  (((foreign-pointer weights) :pointer) (1 :int)
+   ((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")
-  (((c-pointer weights) :pointer) (1 :int)
-   ((c-pointer array) :pointer) (1 :int)
+  (((foreign-pointer weights) :pointer) (1 :int)
+   ((foreign-pointer array) :pointer) (1 :int)
    ((size array) sizet) (mean :double))
   :definition :generic
   :element-types :float
diff --git a/statistics/median-percentile.lisp b/statistics/median-percentile.lisp
index e56ca0cd194cb1399afae0e15bdf3894e018f006..c29993dec1db1acae8dcda1f83217b084be567dd 100644
--- a/statistics/median-percentile.lisp
+++ b/statistics/median-percentile.lisp
@@ -1,6 +1,6 @@
 ;; Median and percentile
 ;; Liam Healy, Sun Dec 31 2006 - 13:19
-;; Time-stamp: <2009-12-27 10:11:27EST median-percentile.lisp>
+;; Time-stamp: <2010-06-27 18:14:04EDT median-percentile.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -25,7 +25,7 @@
 
 (defmfun median ((sorted-data vector))
   ("gsl_stats" :type "_median_from_sorted_data")
-  (((c-pointer sorted-data) :pointer) (1 :int) ((dim0 sorted-data) sizet))
+  (((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")
-  (((c-pointer sorted-data) :pointer) (1 :int) ((dim0 sorted-data) sizet)
+  (((foreign-pointer sorted-data) :pointer) (1 :int) ((dim0 sorted-data) sizet)
    (fraction :double))
   :definition :generic
   :element-types :no-complex
diff --git a/wavelet.lisp b/wavelet.lisp
index a05af7a9d15e32b93b764816351bc69b3606912c..294808e6b0f1da7dfb3a9e755f073bb9c981cc02 100644
--- a/wavelet.lisp
+++ b/wavelet.lisp
@@ -1,6 +1,6 @@
 ;; Wavelet transforms.
 ;; Liam Healy, Mon Nov 26 2007 - 20:43
-;; Time-stamp: <2009-12-27 10:27:41EST wavelet.lisp>
+;; Time-stamp: <2010-06-27 18:13:46EDT wavelet.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -105,7 +105,7 @@
 
 (defmfun wavelet-transform (wavelet data stride direction workspace)
   "gsl_wavelet_transform"
-  (((mpointer wavelet) :pointer) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((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) ((c-pointer data) :pointer)
+  (((mpointer wavelet) :pointer) ((foreign-pointer data) :pointer)
    ((mpointer workspace) :pointer))
   :documentation			; FDL
   "Compute the non-standard form of the two-dimensional in-place wavelet