Index: trunk/psLib/src/math/psPolynomial.c
===================================================================
--- trunk/psLib/src/math/psPolynomial.c	(revision 5180)
+++ trunk/psLib/src/math/psPolynomial.c	(revision 5294)
@@ -7,6 +7,6 @@
 *  polynomials.  It also contains a Gaussian functions.
 *
-*  @version $Revision: 1.129 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-29 20:06:58 $
+*  @version $Revision: 1.130 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-10-12 21:02:20 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -95,5 +95,5 @@
     unsigned int x = 0;
 
-    for (x = 0; x < (1 + poly->COOL_2D_nX); x++) {
+    for (x = 0; x < (1 + poly->nX); x++) {
         psFree(poly->coeff[x]);
         psFree(poly->coeffErr[x]);
@@ -110,6 +110,6 @@
     unsigned int y = 0;
 
-    for (x = 0; x < (1 + poly->COOL_3D_nX); x++) {
-        for (y = 0; y < (1 + poly->COOL_3D_nY); y++) {
+    for (x = 0; x < (1 + poly->nX); x++) {
+        for (y = 0; y < (1 + poly->nY); y++) {
             psFree(poly->coeff[x][y]);
             psFree(poly->coeffErr[x][y]);
@@ -132,7 +132,7 @@
     unsigned int z = 0;
 
-    for (x = 0; x < (1 + poly->COOL_4D_nX); x++) {
-        for (y = 0; y < (1 + poly->COOL_4D_nY); y++) {
-            for (z = 0; z < (1 + poly->COOL_4D_nZ); z++) {
+    for (x = 0; x < (1 + poly->nX); x++) {
+        for (y = 0; y < (1 + poly->nY); y++) {
+            for (z = 0; z < (1 + poly->nZ); z++) {
                 psFree(poly->coeff[x][y][z]);
                 psFree(poly->coeffErr[x][y][z]);
@@ -185,8 +185,8 @@
 
         for (psS32 i = 2; i < maxChebyPoly; i++) {
-            for (psS32 j = 0; j < chebPolys[i - 1]->COOL_1D_n; j++) {
+            for (psS32 j = 0; j < chebPolys[i - 1]->nX; j++) {
                 chebPolys[i]->coeff[j + 1] = 2 * chebPolys[i - 1]->coeff[j];
             }
-            for (psS32 j = 0; j < chebPolys[i - 2]->COOL_1D_n; j++) {
+            for (psS32 j = 0; j < chebPolys[i - 2]->nX; j++) {
                 chebPolys[i]->coeff[j] -= chebPolys[i - 2]->coeff[j];
             }
@@ -213,11 +213,11 @@
             "---- Calling ordPolynomial1DEval(%lf)\n", x);
     psTrace(".psLib.dataManip.psPolynomial.ordPolynomial1DEval", 4,
-            "Polynomial order is %u\n", poly->COOL_1D_n);
-    for (loop_x = 0; loop_x < poly->COOL_1D_n+1; loop_x++) {
+            "Polynomial order is %u\n", poly->nX);
+    for (loop_x = 0; loop_x < poly->nX+1; loop_x++) {
         psTrace(".psLib.dataManip.psPolynomial.ordPolynomial1DEval", 4,
                 "Polynomial coeff[%u] is %lf\n", loop_x, poly->coeff[loop_x]);
     }
 
-    for (loop_x = 0; loop_x < poly->COOL_1D_n+1; loop_x++) {
+    for (loop_x = 0; loop_x < poly->nX+1; loop_x++) {
         if (poly->mask[loop_x] == 0) {
             // XXX: If you set the tracelevel to 10 here, and later set the tracelevel to
@@ -241,11 +241,11 @@
     PS_ASSERT_DOUBLE_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     // XXX: Create a macro for this in psConstants.h
-    if (poly->COOL_1D_n < 1) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Error: Chebyshev polynomial is order %u.", poly->COOL_1D_n);
+    if (poly->nX < 1) {
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Error: Chebyshev polynomial is order %u.", poly->nX);
         return(NAN);
     }
     psVector *d;
     // XXX: n should be nTerms here (for clarity).  Or get rid of the variable.
-    unsigned int n = 1 + poly->COOL_1D_n;
+    unsigned int n = 1 + poly->nX;
     unsigned int i;
     psF64 tmp = 0.0;
@@ -305,8 +305,8 @@
     psPolynomial1D **chebPolys = NULL;
 
-    chebPolys = createChebyshevPolys(1 + poly->COOL_1D_n);
+    chebPolys = createChebyshevPolys(1 + poly->nX);
 
     tmp = 0.0;
-    for (i=0;i<(1 + poly->COOL_1D_n);i++) {
+    for (i=0;i<(1 + poly->nX);i++) {
         tmp+= (poly->coeff[i] * psPolynomial1DEval(x, chebPolys[i]));
     }
@@ -330,7 +330,7 @@
     psF64 ySum = 1.0;
 
-    for (loop_x = 0; loop_x < (1 + poly->COOL_2D_nX); loop_x++) {
+    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
         ySum = xSum;
-        for (loop_y = 0; loop_y < (1 + poly->COOL_2D_nY); loop_y++) {
+        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
             if (poly->mask[loop_x][loop_y] == 0) {
                 polySum += ySum * poly->coeff[loop_x][loop_y];
@@ -361,12 +361,12 @@
     // Determine how many Chebyshev polynomials
     // are needed, then create them.
-    maxChebyPoly = poly->COOL_2D_nX;
-    if (poly->COOL_2D_nY > maxChebyPoly) {
-        maxChebyPoly = poly->COOL_2D_nY;
+    maxChebyPoly = poly->nX;
+    if (poly->nY > maxChebyPoly) {
+        maxChebyPoly = poly->nY;
     }
     chebPolys = createChebyshevPolys(maxChebyPoly + 1);
 
-    for (loop_x = 0; loop_x < (1 + poly->COOL_2D_nX); loop_x++) {
-        for (loop_y = 0; loop_y < (1 + poly->COOL_2D_nY); loop_y++) {
+    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
+        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
             if (poly->mask[loop_x][loop_y] == 0) {
                 polySum += poly->coeff[loop_x][loop_y] *
@@ -396,9 +396,9 @@
     psF64 zSum = 1.0;
 
-    for (loop_x = 0; loop_x < (1 + poly->COOL_3D_nX); loop_x++) {
+    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
         ySum = xSum;
-        for (loop_y = 0; loop_y < (1 + poly->COOL_3D_nY); loop_y++) {
+        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
             zSum = ySum;
-            for (loop_z = 0; loop_z < (1 + poly->COOL_3D_nZ); loop_z++) {
+            for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
                 if (poly->mask[loop_x][loop_y][loop_z] == 0) {
                     polySum += zSum * poly->coeff[loop_x][loop_y][loop_z];
@@ -432,16 +432,16 @@
     // Determine how many Chebyshev polynomials
     // are needed, then create them.
-    maxChebyPoly = poly->COOL_3D_nX;
-    if (poly->COOL_3D_nY > maxChebyPoly) {
-        maxChebyPoly = poly->COOL_3D_nY;
-    }
-    if (poly->COOL_3D_nZ > maxChebyPoly) {
-        maxChebyPoly = poly->COOL_3D_nZ;
+    maxChebyPoly = poly->nX;
+    if (poly->nY > maxChebyPoly) {
+        maxChebyPoly = poly->nY;
+    }
+    if (poly->nZ > maxChebyPoly) {
+        maxChebyPoly = poly->nZ;
     }
     chebPolys = createChebyshevPolys(maxChebyPoly + 1);
 
-    for (loop_x = 0; loop_x < (1 + poly->COOL_3D_nX); loop_x++) {
-        for (loop_y = 0; loop_y < (1 + poly->COOL_3D_nY); loop_y++) {
-            for (loop_z = 0; loop_z < (1 + poly->COOL_3D_nZ); loop_z++) {
+    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
+        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
+            for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
                 if (poly->mask[loop_x][loop_y][loop_z] == 0) {
                     polySum += poly->coeff[loop_x][loop_y][loop_z] *
@@ -477,11 +477,11 @@
     psF64 tSum = 1.0;
 
-    for (loop_x = 0; loop_x < (1 + poly->COOL_4D_nX); loop_x++) {
+    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
         ySum = xSum;
-        for (loop_y = 0; loop_y < (1 + poly->COOL_4D_nY); loop_y++) {
+        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
             zSum = ySum;
-            for (loop_z = 0; loop_z < (1 + poly->COOL_4D_nZ); loop_z++) {
+            for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
                 tSum = zSum;
-                for (loop_t = 0; loop_t < (1 + poly->COOL_4D_nT); loop_t++) {
+                for (loop_t = 0; loop_t < (1 + poly->nT); loop_t++) {
                     if (poly->mask[loop_x][loop_y][loop_z][loop_t] == 0) {
                         polySum += tSum * poly->coeff[loop_x][loop_y][loop_z][loop_t];
@@ -520,21 +520,21 @@
     // Determine how many Chebyshev polynomials
     // are needed, then create them.
-    maxChebyPoly = poly->COOL_4D_nX;
-    if (poly->COOL_4D_nY > maxChebyPoly) {
-        maxChebyPoly = poly->COOL_4D_nY;
-    }
-    if (poly->COOL_4D_nZ > maxChebyPoly) {
-        maxChebyPoly = poly->COOL_4D_nZ;
-    }
-    if (poly->COOL_4D_nT > maxChebyPoly) {
-        maxChebyPoly = poly->COOL_4D_nT;
+    maxChebyPoly = poly->nX;
+    if (poly->nY > maxChebyPoly) {
+        maxChebyPoly = poly->nY;
+    }
+    if (poly->nZ > maxChebyPoly) {
+        maxChebyPoly = poly->nZ;
+    }
+    if (poly->nT > maxChebyPoly) {
+        maxChebyPoly = poly->nT;
     }
     // XXX: Add 1 since createChebyshevPolys() takes nTerms, not nOrder.
     chebPolys = createChebyshevPolys(maxChebyPoly + 1);
 
-    for (loop_x = 0; loop_x < (1 + poly->COOL_4D_nX); loop_x++) {
-        for (loop_y = 0; loop_y < (1 + poly->COOL_4D_nY); loop_y++) {
-            for (loop_z = 0; loop_z < (1 + poly->COOL_4D_nZ); loop_z++) {
-                for (loop_t = 0; loop_t < (1 + poly->COOL_4D_nT); loop_t++) {
+    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
+        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
+            for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
+                for (loop_t = 0; loop_t < (1 + poly->nT); loop_t++) {
                     if (poly->mask[loop_x][loop_y][loop_z][loop_t] == 0) {
                         polySum += poly->coeff[loop_x][loop_y][loop_z][loop_t] *
@@ -627,5 +627,5 @@
 
     newPoly->type = type;
-    newPoly->COOL_1D_n = n;
+    newPoly->nX = n;
     newPoly->coeff = psAlloc((n + 1) * sizeof(psF64));
     newPoly->coeffErr = psAlloc((n + 1) * sizeof(psF64));
@@ -655,6 +655,6 @@
 
     newPoly->type = type;
-    newPoly->COOL_2D_nX = nX;
-    newPoly->COOL_2D_nY = nY;
+    newPoly->nX = nX;
+    newPoly->nY = nY;
 
     newPoly->coeff = psAlloc((1 + nX) * sizeof(psF64 *));
@@ -695,7 +695,7 @@
 
     newPoly->type = type;
-    newPoly->COOL_3D_nX = nX;
-    newPoly->COOL_3D_nY = nY;
-    newPoly->COOL_3D_nZ = nZ;
+    newPoly->nX = nX;
+    newPoly->nY = nY;
+    newPoly->nZ = nZ;
 
     newPoly->coeff = psAlloc((nX + 1) * sizeof(psF64 **));
@@ -746,8 +746,8 @@
 
     newPoly->type = type;
-    newPoly->COOL_4D_nX = nX;
-    newPoly->COOL_4D_nY = nY;
-    newPoly->COOL_4D_nZ = nZ;
-    newPoly->COOL_4D_nT = nT;
+    newPoly->nX = nX;
+    newPoly->nY = nY;
+    newPoly->nZ = nZ;
+    newPoly->nT = nT;
 
     newPoly->coeff = psAlloc((nX + 1) * sizeof(psF64 ***));