Index: trunk/psLib/src/dataManip/psFunctions.c
===================================================================
--- trunk/psLib/src/dataManip/psFunctions.c	(revision 4447)
+++ trunk/psLib/src/dataManip/psFunctions.c	(revision 4528)
@@ -7,6 +7,6 @@
  *  polynomials.  It also contains a Gaussian functions.
  *
- *  @version $Revision: 1.115 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-07-01 22:01:17 $
+ *  @version $Revision: 1.116 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-07-09 02:11:01 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -280,5 +280,5 @@
     Polynomial coefficients will be accessed in [w][x][y][z] fashion.
  *****************************************************************************/
-static psF32 ordPolynomial1DEval(psF32 x, const psPolynomial1D* poly)
+static psF64 ordPolynomial1DEval(psF64 x, const psPolynomial1D* poly)
 {
     psS32 loop_x = 0;
@@ -310,5 +310,5 @@
 // XXX: How does the mask vector effect Crenshaw's formula?
 // XXX: We assume that x is scaled between -1.0 and 1.0;
-static psF32 chebPolynomial1DEval(psF32 x, const psPolynomial1D* poly)
+static psF64 chebPolynomial1DEval(psF64 x, const psPolynomial1D* poly)
 {
     PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
@@ -392,6 +392,6 @@
 }
 
-static psF32 ordPolynomial2DEval(psF32 x,
-                                 psF32 y,
+static psF64 ordPolynomial2DEval(psF64 x,
+                                 psF64 y,
                                  const psPolynomial2D* poly)
 {
@@ -418,5 +418,5 @@
 }
 
-static psF32 chebPolynomial2DEval(psF32 x, psF32 y, const psPolynomial2D* poly)
+static psF64 chebPolynomial2DEval(psF64 x, psF64 y, const psPolynomial2D* poly)
 {
     PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
@@ -455,5 +455,5 @@
 }
 
-static psF32 ordPolynomial3DEval(psF32 x, psF32 y, psF32 z, const psPolynomial3D* poly)
+static psF64 ordPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psPolynomial3D* poly)
 {
     psS32 loop_x = 0;
@@ -483,5 +483,5 @@
 }
 
-static psF32 chebPolynomial3DEval(psF32 x, psF32 y, psF32 z, const psPolynomial3D* poly)
+static psF64 chebPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psPolynomial3D* poly)
 {
     PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
@@ -527,5 +527,5 @@
 }
 
-static psF32 ordPolynomial4DEval(psF32 x, psF32 y, psF32 z, psF32 t, const psPolynomial4D* poly)
+static psF64 ordPolynomial4DEval(psF64 x, psF64 y, psF64 z, psF64 t, const psPolynomial4D* poly)
 {
     psS32 loop_x = 0;
@@ -561,5 +561,5 @@
 }
 
-static psF32 chebPolynomial4DEval(psF32 x, psF32 y, psF32 z, psF32 t, const psPolynomial4D* poly)
+static psF64 chebPolynomial4DEval(psF64 x, psF64 y, psF64 z, psF64 t, const psPolynomial4D* poly)
 {
     PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
@@ -1069,5 +1069,5 @@
     This routine must allocate memory for the polynomial structures.
  *****************************************************************************/
-psPolynomial1D* psPolynomial1DAlloc(unsigned int n,
+psPolynomial1D* psPolynomial1DAlloc(int n,
                                     psPolynomialType type)
 {
@@ -1094,6 +1094,6 @@
 }
 
-psPolynomial2D* psPolynomial2DAlloc(unsigned int nX, unsigned int nY,
-                                    psPolynomialType type)
+psPolynomial2D* psPolynomial2DAlloc( int nX,  int nY,
+                                     psPolynomialType type)
 {
     PS_ASSERT_INT_POSITIVE(nX, NULL);
@@ -1130,6 +1130,6 @@
 }
 
-psPolynomial3D* psPolynomial3DAlloc(unsigned int nX, unsigned int nY, unsigned int nZ,
-                                    psPolynomialType type)
+psPolynomial3D* psPolynomial3DAlloc( int nX,  int nY,  int nZ,
+                                     psPolynomialType type)
 {
     PS_ASSERT_INT_POSITIVE(nX, NULL);
@@ -1176,6 +1176,6 @@
 }
 
-psPolynomial4D* psPolynomial4DAlloc(unsigned int nX, unsigned int nY, unsigned int nZ, unsigned int nT,
-                                    psPolynomialType type)
+psPolynomial4D* psPolynomial4DAlloc( int nX,  int nY,  int nZ,  int nT,
+                                     psPolynomialType type)
 {
     PS_ASSERT_INT_POSITIVE(nX, NULL);
@@ -1431,6 +1431,6 @@
 
 
-psDPolynomial1D* psDPolynomial1DAlloc(unsigned int n,
-                                      psPolynomialType type)
+psDPolynomial1D* psDPolynomial1DAlloc( int n,
+                                       psPolynomialType type)
 {
     PS_ASSERT_INT_POSITIVE(n, NULL);
@@ -1456,6 +1456,6 @@
 }
 
-psDPolynomial2D* psDPolynomial2DAlloc(unsigned int nX, unsigned int nY,
-                                      psPolynomialType type)
+psDPolynomial2D* psDPolynomial2DAlloc( int nX,  int nY,
+                                       psPolynomialType type)
 {
     PS_ASSERT_INT_POSITIVE(nX, NULL);
@@ -1492,6 +1492,6 @@
 }
 
-psDPolynomial3D* psDPolynomial3DAlloc(unsigned int nX, unsigned int nY, unsigned int nZ,
-                                      psPolynomialType type)
+psDPolynomial3D* psDPolynomial3DAlloc( int nX,  int nY,  int nZ,
+                                       psPolynomialType type)
 {
     PS_ASSERT_INT_POSITIVE(nX, NULL);
@@ -1538,6 +1538,6 @@
 }
 
-psDPolynomial4D* psDPolynomial4DAlloc(unsigned int nX, unsigned int nY, unsigned int nZ, unsigned int nT,
-                                      psPolynomialType type)
+psDPolynomial4D* psDPolynomial4DAlloc( int nX,  int nY,  int nZ,  int nT,
+                                       psPolynomialType type)
 {
     PS_ASSERT_INT_POSITIVE(nX, NULL);
@@ -1822,8 +1822,8 @@
 XXX: What should be the defualty type for knots be?  psF32 is assumed.
  *****************************************************************************/
-psSpline1D *psSpline1DAlloc(unsigned int numSplines,
-                            unsigned int order,
-                            float min,
-                            float max)
+psSpline1D *psSpline1DAlloc( int numSplines,
+                             int order,
+                             float min,
+                             float max)
 {
     PS_ASSERT_INT_NONNEGATIVE(numSplines, NULL);
@@ -1867,5 +1867,5 @@
  *****************************************************************************/
 psSpline1D *psSpline1DAllocGeneric(const psVector *bounds,
-                                   unsigned int order)
+                                   int order)
 {
     PS_ASSERT_VECTOR_NON_NULL(bounds, NULL);
@@ -2045,5 +2045,5 @@
 psScalar *p_psVectorInterpolate(psVector *domain,
                                 psVector *range,
-                                unsigned int order,
+                                int order,
                                 psScalar *x)
 {