Index: trunk/psLib/src/math/psPolynomial.c
===================================================================
--- trunk/psLib/src/math/psPolynomial.c	(revision 4991)
+++ trunk/psLib/src/math/psPolynomial.c	(revision 5066)
@@ -7,6 +7,6 @@
 *  polynomials.  It also contains a Gaussian functions.
 *
-*  @version $Revision: 1.120 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-11 22:18:40 $
+*  @version $Revision: 1.121 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-09-19 19:53:13 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -162,5 +162,5 @@
 outer coefficients of the Chebyshev polynomials.
  *****************************************************************************/
-static psPolynomial1D **createChebyshevPolys(psS32 maxChebyPoly)
+static psPolynomial1D **createChebyshevPolys(unsigned int maxChebyPoly)
 {
     PS_ASSERT_INT_NONNEGATIVE(maxChebyPoly, NULL);
@@ -169,5 +169,5 @@
 
     chebPolys = (psPolynomial1D **) psAlloc(maxChebyPoly * sizeof(psPolynomial1D *));
-    for (psS32 i = 0; i < maxChebyPoly; i++) {
+    for (unsigned int i = 0; i < maxChebyPoly; i++) {
         chebPolys[i] = psPolynomial1DAlloc(i + 1, PS_POLYNOMIAL_ORD);
     }
@@ -191,5 +191,5 @@
     } else {
         // XXX: Code this.
-        printf("WARNING: %d-order chebyshev polynomials not correctly implemented.\n", maxChebyPoly);
+        printf("WARNING: %u-order chebyshev polynomials not correctly implemented.\n", maxChebyPoly);
     }
 
@@ -200,7 +200,8 @@
     Polynomial coefficients will be accessed in [w][x][y][z] fashion.
  *****************************************************************************/
-static psF64 ordPolynomial1DEval(psF64 x, const psPolynomial1D* poly)
-{
-    psS32 loop_x = 0;
+static psF64 ordPolynomial1DEval(psF64 x,
+                                 const psPolynomial1D* poly)
+{
+    unsigned int loop_x = 0;
     psF64 polySum = 0.0;
     psF64 xSum = 1.0;
@@ -209,8 +210,8 @@
             "---- Calling ordPolynomial1DEval(%lf)\n", x);
     psTrace(".psLib.dataManip.psPolynomial.ordPolynomial1DEval", 4,
-            "Polynomial order is %d\n", poly->n);
+            "Polynomial order is %u\n", poly->n);
     for (loop_x = 0; loop_x < poly->n; loop_x++) {
         psTrace(".psLib.dataManip.psPolynomial.ordPolynomial1DEval", 4,
-                "Polynomial coeff[%d] is %lf\n", loop_x, poly->coeff[loop_x]);
+                "Polynomial coeff[%u] is %lf\n", loop_x, poly->coeff[loop_x]);
     }
 
@@ -230,15 +231,16 @@
 // XXX: How does the mask vector effect Crenshaw's formula?
 // XXX: We assume that x is scaled between -1.0 and 1.0;
-static psF64 chebPolynomial1DEval(psF64 x, const psPolynomial1D* poly)
+static psF64 chebPolynomial1DEval(psF64 x,
+                                  const psPolynomial1D* poly)
 {
     PS_ASSERT_DOUBLE_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     // XXX: Create a macro for this in psConstants.h
     if (poly->n < 1) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Error: Chebyshev polynomial as order %d.", poly->n);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Error: Chebyshev polynomial as order %u.", poly->n);
         return(NAN);
     }
     psVector *d;
-    psS32 n = poly->n;
-    psS32 i;
+    unsigned int n = poly->n;
+    unsigned int i;
     psF64 tmp = 0.0;
 
@@ -318,6 +320,6 @@
     PS_ASSERT_POLY_NON_NULL(poly, NAN);
 
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
+    unsigned int loop_x = 0;
+    unsigned int loop_y = 0;
     psF64 polySum = 0.0;
     psF64 xSum = 1.0;
@@ -338,5 +340,7 @@
 }
 
-static psF64 chebPolynomial2DEval(psF64 x, psF64 y, const psPolynomial2D* poly)
+static psF64 chebPolynomial2DEval(psF64 x,
+                                  psF64 y,
+                                  const psPolynomial2D* poly)
 {
     PS_ASSERT_DOUBLE_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
@@ -344,10 +348,10 @@
     PS_ASSERT_POLY_NON_NULL(poly, NAN);
 
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 i = 0;
+    unsigned int loop_x = 0;
+    unsigned int loop_y = 0;
+    unsigned int i = 0;
     psF64 polySum = 0.0;
     psPolynomial1D* *chebPolys = NULL;
-    psS32 maxChebyPoly = 0;
+    unsigned int maxChebyPoly = 0;
 
     // Determine how many Chebyshev polynomials
@@ -375,9 +379,12 @@
 }
 
-static psF64 ordPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psPolynomial3D* poly)
-{
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
+static psF64 ordPolynomial3DEval(psF64 x,
+                                 psF64 y,
+                                 psF64 z,
+                                 const psPolynomial3D* poly)
+{
+    unsigned int loop_x = 0;
+    unsigned int loop_y = 0;
+    unsigned int loop_z = 0;
     psF64 polySum = 0.0;
     psF64 xSum = 1.0;
@@ -403,16 +410,19 @@
 }
 
-static psF64 chebPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psPolynomial3D* poly)
+static psF64 chebPolynomial3DEval(psF64 x,
+                                  psF64 y,
+                                  psF64 z,
+                                  const psPolynomial3D* poly)
 {
     PS_ASSERT_DOUBLE_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     PS_ASSERT_DOUBLE_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     PS_ASSERT_DOUBLE_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    psS32 i = 0;
+    unsigned int loop_x = 0;
+    unsigned int loop_y = 0;
+    unsigned int loop_z = 0;
+    unsigned int i = 0;
     psF64 polySum = 0.0;
     psPolynomial1D* *chebPolys = NULL;
-    psS32 maxChebyPoly = 0;
+    unsigned int maxChebyPoly = 0;
 
     // Determine how many Chebyshev polynomials
@@ -447,10 +457,14 @@
 }
 
-static psF64 ordPolynomial4DEval(psF64 x, psF64 y, psF64 z, psF64 t, const psPolynomial4D* poly)
-{
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    psS32 loop_t = 0;
+static psF64 ordPolynomial4DEval(psF64 x,
+                                 psF64 y,
+                                 psF64 z,
+                                 psF64 t,
+                                 const psPolynomial4D* poly)
+{
+    unsigned int loop_x = 0;
+    unsigned int loop_y = 0;
+    unsigned int loop_z = 0;
+    unsigned int loop_t = 0;
     psF64 polySum = 0.0;
     psF64 xSum = 1.0;
@@ -481,5 +495,9 @@
 }
 
-static psF64 chebPolynomial4DEval(psF64 x, psF64 y, psF64 z, psF64 t, const psPolynomial4D* poly)
+static psF64 chebPolynomial4DEval(psF64 x,
+                                  psF64 y,
+                                  psF64 z,
+                                  psF64 t,
+                                  const psPolynomial4D* poly)
 {
     PS_ASSERT_DOUBLE_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
@@ -487,12 +505,12 @@
     PS_ASSERT_DOUBLE_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
     PS_ASSERT_DOUBLE_WITHIN_RANGE(t, -1.0, 1.0, 0.0);
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    psS32 loop_t = 0;
-    psS32 i = 0;
+    unsigned int loop_x = 0;
+    unsigned int loop_y = 0;
+    unsigned int loop_z = 0;
+    unsigned int loop_t = 0;
+    unsigned int i = 0;
     psF64 polySum = 0.0;
     psPolynomial1D* *chebPolys = NULL;
-    psS32 maxChebyPoly = 0;
+    unsigned int maxChebyPoly = 0;
 
     // Determine how many Chebyshev polynomials
@@ -542,5 +560,8 @@
     evaluated Gaussian is: \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f]
  *****************************************************************************/
-float psGaussian(float x, float mean, float sigma, bool normal)
+float psGaussian(float x,
+                 float mean,
+                 float sigma,
+                 bool normal)
 {
     psF32 tmp = 1.0;
@@ -568,5 +589,7 @@
  *****************************************************************************/
 #define PS_XXX_GAUSSIAN_SEED 1995
-psVector* p_psGaussianDev(psF32 mean, psF32 sigma, psS32 Npts)
+psVector* p_psGaussianDev(psF32 mean,
+                          psF32 sigma,
+                          unsigned int Npts)
 {
     PS_ASSERT_INT_NONNEGATIVE(Npts, NULL);
@@ -575,5 +598,5 @@
     psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, PS_XXX_GAUSSIAN_SEED);
     psVector* gauss = psVectorAlloc(Npts, PS_TYPE_F32);
-    for (psS32 i = 0; i < Npts; i++) {
+    for (unsigned int i = 0; i < Npts; i++) {
         gauss->data.F32[i] = mean + p_psRandomGaussian(r, sigma);
     }
@@ -586,10 +609,10 @@
     This routine must allocate memory for the polynomial structures.
  *****************************************************************************/
-psPolynomial1D* psPolynomial1DAlloc(int n,
+psPolynomial1D* psPolynomial1DAlloc(unsigned int n,
                                     psPolynomialType type)
 {
     PS_ASSERT_INT_POSITIVE(n, NULL);
 
-    int i = 0;
+    unsigned int i = 0;
     psPolynomial1D* newPoly = NULL;
 
@@ -601,5 +624,5 @@
     newPoly->coeff = psAlloc(n * sizeof(psF64));
     newPoly->coeffErr = psAlloc(n * sizeof(psF64));
-    newPoly->mask = (char *)psAlloc(n * sizeof(char));
+    newPoly->mask = (psMaskType *)psAlloc(n * sizeof(psMaskType));
     for (i = 0; i < n; i++) {
         newPoly->coeff[i] = 0.0;
@@ -611,5 +634,6 @@
 }
 
-psPolynomial2D* psPolynomial2DAlloc( int nX,  int nY,
+psPolynomial2D* psPolynomial2DAlloc( unsigned int nX,
+                                     unsigned int nY,
                                      psPolynomialType type)
 {
@@ -617,6 +641,6 @@
     PS_ASSERT_INT_POSITIVE(nY, NULL);
 
-    int x = 0;
-    int y = 0;
+    unsigned int x = 0;
+    unsigned int y = 0;
     psPolynomial2D* newPoly = NULL;
 
@@ -630,9 +654,9 @@
     newPoly->coeff = psAlloc(nX * sizeof(psF64 *));
     newPoly->coeffErr = psAlloc(nX * sizeof(psF64 *));
-    newPoly->mask = (char **)psAlloc(nX * sizeof(char *));
+    newPoly->mask = (psMaskType **)psAlloc(nX * sizeof(psMaskType *));
     for (x = 0; x < nX; x++) {
         newPoly->coeff[x] = psAlloc(nY * sizeof(psF64));
         newPoly->coeffErr[x] = psAlloc(nY * sizeof(psF64));
-        newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char));
+        newPoly->mask[x] = (psMaskType *)psAlloc(nY * sizeof(psMaskType));
     }
     for (x = 0; x < nX; x++) {
@@ -647,5 +671,7 @@
 }
 
-psPolynomial3D* psPolynomial3DAlloc( int nX,  int nY,  int nZ,
+psPolynomial3D* psPolynomial3DAlloc( unsigned int nX,
+                                     unsigned int nY,
+                                     unsigned int nZ,
                                      psPolynomialType type)
 {
@@ -654,7 +680,7 @@
     PS_ASSERT_INT_POSITIVE(nZ, NULL);
 
-    psS32 x = 0;
-    psS32 y = 0;
-    psS32 z = 0;
+    unsigned int x = 0;
+    unsigned int y = 0;
+    unsigned int z = 0;
     psPolynomial3D* newPoly = NULL;
 
@@ -669,13 +695,13 @@
     newPoly->coeff = psAlloc(nX * sizeof(psF64 **));
     newPoly->coeffErr = psAlloc(nX * sizeof(psF64 **));
-    newPoly->mask = (char ***)psAlloc(nX * sizeof(char **));
+    newPoly->mask = (psMaskType ***)psAlloc(nX * sizeof(psMaskType **));
     for (x = 0; x < nX; x++) {
         newPoly->coeff[x] = psAlloc(nY * sizeof(psF64 *));
         newPoly->coeffErr[x] = psAlloc(nY * sizeof(psF64 *));
-        newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *));
+        newPoly->mask[x] = (psMaskType **)psAlloc(nY * sizeof(psMaskType *));
         for (y = 0; y < nY; y++) {
             newPoly->coeff[x][y] = psAlloc(nZ * sizeof(psF64));
             newPoly->coeffErr[x][y] = psAlloc(nZ * sizeof(psF64));
-            newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char));
+            newPoly->mask[x][y] = (psMaskType *)psAlloc(nZ * sizeof(psMaskType));
         }
     }
@@ -693,5 +719,8 @@
 }
 
-psPolynomial4D* psPolynomial4DAlloc( int nX,  int nY,  int nZ,  int nT,
+psPolynomial4D* psPolynomial4DAlloc( unsigned int nX,
+                                     unsigned int nY,
+                                     unsigned int nZ,
+                                     unsigned int nT,
                                      psPolynomialType type)
 {
@@ -701,8 +730,8 @@
     PS_ASSERT_INT_POSITIVE(nT, NULL);
 
-    psS32 x = 0;
-    psS32 y = 0;
-    psS32 z = 0;
-    psS32 t = 0;
+    unsigned int x = 0;
+    unsigned int y = 0;
+    unsigned int z = 0;
+    unsigned int t = 0;
     psPolynomial4D* newPoly = NULL;
 
@@ -718,17 +747,17 @@
     newPoly->coeff = psAlloc(nX * sizeof(psF64 ***));
     newPoly->coeffErr = psAlloc(nX * sizeof(psF64 ***));
-    newPoly->mask = (char ****)psAlloc(nX * sizeof(char ***));
+    newPoly->mask = (psMaskType ****)psAlloc(nX * sizeof(psMaskType ***));
     for (x = 0; x < nX; x++) {
         newPoly->coeff[x] = psAlloc(nY * sizeof(psF64 **));
         newPoly->coeffErr[x] = psAlloc(nY * sizeof(psF64 **));
-        newPoly->mask[x] = (char ***)psAlloc(nY * sizeof(char **));
+        newPoly->mask[x] = (psMaskType ***)psAlloc(nY * sizeof(psMaskType **));
         for (y = 0; y < nY; y++) {
             newPoly->coeff[x][y] = psAlloc(nZ * sizeof(psF64 *));
             newPoly->coeffErr[x][y] = psAlloc(nZ * sizeof(psF64 *));
-            newPoly->mask[x][y] = (char **)psAlloc(nZ * sizeof(char *));
+            newPoly->mask[x][y] = (psMaskType **)psAlloc(nZ * sizeof(psMaskType *));
             for (z = 0; z < nZ; z++) {
                 newPoly->coeff[x][y][z] = psAlloc(nT * sizeof(psF64));
                 newPoly->coeffErr[x][y][z] = psAlloc(nT * sizeof(psF64));
-                newPoly->mask[x][y][z] = (char *)psAlloc(nT * sizeof(char));
+                newPoly->mask[x][y][z] = (psMaskType *)psAlloc(nT * sizeof(psMaskType));
             }
         }
@@ -749,5 +778,6 @@
 }
 
-psF64 psPolynomial1DEval(const psPolynomial1D* poly, psF64 x)
+psF64 psPolynomial1DEval(const psPolynomial1D* poly,
+                         psF64 x)
 {
     PS_ASSERT_POLY_NON_NULL(poly, NAN);
@@ -775,5 +805,5 @@
 
     tmp = psVectorAlloc(x->n, PS_TYPE_F64);
-    for (psS32 i=0;i<x->n;i++) {
+    for (unsigned int i=0;i<x->n;i++) {
         tmp->data.F64[i] = psPolynomial1DEval(poly, x->data.F64[i]);
     }
@@ -782,5 +812,7 @@
 }
 
-psF64 psPolynomial2DEval(const psPolynomial2D* poly, psF64 x, psF64 y)
+psF64 psPolynomial2DEval(const psPolynomial2D* poly,
+                         psF64 x,
+                         psF64 y)
 {
     PS_ASSERT_POLY_NON_NULL(poly, NAN);
@@ -810,5 +842,5 @@
 
     psVector *tmp;
-    psS32 vecLen=x->n;
+    unsigned int vecLen=x->n;
 
     // Determine the length of the output vector to by the minimum of the x,y vectors
@@ -821,5 +853,5 @@
 
     // Evaluate the polynomial at the specified points
-    for (psS32 i=0; i<vecLen; i++) {
+    for (unsigned int i=0; i<vecLen; i++) {
         tmp->data.F64[i] = psPolynomial2DEval(poly,x->data.F64[i],y->data.F64[i]);
     }
@@ -829,5 +861,8 @@
 }
 
-psF64 psPolynomial3DEval(const psPolynomial3D* poly, psF64 x, psF64 y, psF64 z)
+psF64 psPolynomial3DEval(const psPolynomial3D* poly,
+                         psF64 x,
+                         psF64 y,
+                         psF64 z)
 {
     PS_ASSERT_POLY_NON_NULL(poly, NAN);
@@ -860,5 +895,5 @@
 
     psVector *tmp;
-    psS32 vecLen=x->n;
+    unsigned int vecLen=x->n;
 
     // Determine the length of output vector from min of the input vectors
@@ -874,5 +909,5 @@
 
     // Evaluate polynomial
-    for (psS32 i = 0; i < vecLen; i++) {
+    for (unsigned int i = 0; i < vecLen; i++) {
         tmp->data.F64[i] = psPolynomial3DEval(poly,
                                               x->data.F64[i],
@@ -885,5 +920,9 @@
 }
 
-psF64 psPolynomial4DEval(const psPolynomial4D* poly, psF64 x, psF64 y, psF64 z, psF64 t)
+psF64 psPolynomial4DEval(const psPolynomial4D* poly,
+                         psF64 x,
+                         psF64 y,
+                         psF64 z,
+                         psF64 t)
 {
     PS_ASSERT_POLY_NON_NULL(poly, NAN);
@@ -918,5 +957,5 @@
 
     psVector *tmp;
-    psS32 vecLen=x->n;
+    unsigned int vecLen=x->n;
 
     // Determine output vector size from min of input vectors
@@ -935,5 +974,5 @@
 
     // Evaluate polynomial
-    for (psS32 i = 0; i < vecLen; i++) {
+    for (unsigned int i = 0; i < vecLen; i++) {
         tmp->data.F64[i] = psPolynomial4DEval(poly,
                                               x->data.F64[i],