Index: /trunk/psLib/src/astro/psCoord.c
===================================================================
--- /trunk/psLib/src/astro/psCoord.c	(revision 5089)
+++ /trunk/psLib/src/astro/psCoord.c	(revision 5090)
@@ -10,6 +10,6 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.86 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-11 22:18:40 $
+*  @version $Revision: 1.87 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-09-22 02:47:16 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -90,15 +90,15 @@
 
     A = transform->x->coeff[0][0];
-    if (transform->x->nX >= 2) {
+    if (transform->x->COOL_2D_nX >= 1) {
         B = transform->x->coeff[1][0];
     }
-    if (transform->x->nY >= 2) {
+    if (transform->x->COOL_2D_nY >= 1) {
         C = transform->x->coeff[0][1];
     }
     D = transform->y->coeff[0][0];
-    if (transform->y->nX >= 2) {
+    if (transform->y->COOL_2D_nX >= 1) {
         E = transform->y->coeff[1][0];
     }
-    if (transform->y->nY >= 2) {
+    if (transform->y->COOL_2D_nY >= 1) {
         F = transform->y->coeff[0][1];
     }
@@ -154,6 +154,6 @@
     PS_ASSERT_PTR_NON_NULL(transform->y, 0);
 
-    for (psS32 i=0;i<(transform->x->nX);i++) {
-        for (psS32 j=0;j<(transform->x->nY);j++) {
+    for (psS32 i=0;i<(1 + transform->x->COOL_2D_nX);i++) {
+        for (psS32 j=0;j<(1 + transform->x->COOL_2D_nY);j++) {
             if (transform->x->coeff[i][j] != 0.0) {
                 if (!(((i == 0) && (j == 0)) ||
@@ -166,6 +166,6 @@
     }
 
-    for (psS32 i=0;i<(transform->y->nX);i++) {
-        for (psS32 j=0;j<(transform->y->nY);j++) {
+    for (psS32 i=0;i<(1 + transform->y->COOL_2D_nX);i++) {
+        for (psS32 j=0;j<(1 + transform->y->COOL_2D_nY);j++) {
             if (transform->y->coeff[i][j] != 0.0) {
                 if (!(((i == 0) && (j == 0)) ||
@@ -208,4 +208,5 @@
 }
 
+// XXX: Verify the order/nterms poly changes
 psPlaneTransform* psPlaneTransformAlloc(int n1, int n2)
 {
@@ -214,6 +215,6 @@
 
     psPlaneTransform *pt = psAlloc(sizeof(psPlaneTransform));
-    pt->x = psPolynomial2DAlloc(n1, n2, PS_POLYNOMIAL_ORD);
-    pt->y = psPolynomial2DAlloc(n1, n2, PS_POLYNOMIAL_ORD);
+    pt->x = psPolynomial2DAlloc(n1-1, n2-1, PS_POLYNOMIAL_ORD);
+    pt->y = psPolynomial2DAlloc(n1-1, n2-1, PS_POLYNOMIAL_ORD);
 
     psMemSetDeallocator(pt, (psFreeFunc) planeTransformFree);
@@ -276,4 +277,5 @@
 }
 
+// XXX: Verify the order/nterms poly changes
 psPlaneDistort* psPlaneDistortAlloc(int n1, int n2, int n3, int n4)
 {
@@ -284,6 +286,6 @@
 
     psPlaneDistort *pt = psAlloc(sizeof(psPlaneDistort));
-    pt->x = psPolynomial4DAlloc(n1, n2, n3, n4, PS_POLYNOMIAL_ORD);
-    pt->y = psPolynomial4DAlloc(n1, n2, n3, n4, PS_POLYNOMIAL_ORD);
+    pt->x = psPolynomial4DAlloc(n1-1, n2-1, n3-1, n4-1, PS_POLYNOMIAL_ORD);
+    pt->y = psPolynomial4DAlloc(n1-1, n2-1, n3-1, n4-1, PS_POLYNOMIAL_ORD);
 
     psMemSetDeallocator(pt, (psFreeFunc) planeDistortFree);
@@ -499,12 +501,15 @@
                                        psPolynomial2D *trans2)
 {
-    //TRACE: printf("multiplyDPoly2D(%d %d: %d %d)\n", trans1->nX, trans1->nY, trans2->nX, trans2->nY);
-    psS32 orderX = (trans1->nX + trans2->nX) - 1;
-    psS32 orderY = (trans1->nY + trans2->nY) - 1;
-
-    psPolynomial2D *out = psPolynomial2DAlloc(orderX, orderY, PS_POLYNOMIAL_ORD);
+    //TRACE: printf("multiplyDPoly2D(%d %d: %d %d)\n", trans1->COOL_2D_nX, trans1->COOL_2D_nY, trans2->COOL_2D_nX, trans2->COOL_2D_nY);
+    // XXX: OLD:  psS32 orderX = (trans1->nX + trans2->nX) - 1;
+    // XXX: Verify this (the poly order change)
+    psS32 orderX = trans1->COOL_2D_nX + trans2->COOL_2D_nX + 1;
+    psS32 orderY = trans1->COOL_2D_nY + trans2->COOL_2D_nY + 1;
+
+    // XXX: Verify this (the poly order change)
+    psPolynomial2D *out = psPolynomial2DAlloc(orderX-1, orderY-1, PS_POLYNOMIAL_ORD);
     //TRACE: printf("Creating poly (%d, %d)\n", orderX, orderY);
-    for (psS32 i = 0 ; i < out->nX; i++) {
-        for (psS32 j = 0 ; j < out->nY; j++) {
+    for (psS32 i = 0 ; i < (1 + out->COOL_2D_nX); i++) {
+        for (psS32 j = 0 ; j < (1 + out->COOL_2D_nY); j++) {
             out->coeff[i][j] = 0.0;
             out->mask[i][j] = 0;
@@ -512,9 +517,9 @@
     }
 
-    for (psS32 t1x = 0 ; t1x < trans1->nX ; t1x++) {
-        for (psS32 t1y = 0 ; t1y < trans1->nY ; t1y++) {
+    for (psS32 t1x = 0 ; t1x < (1 + trans1->COOL_2D_nX) ; t1x++) {
+        for (psS32 t1y = 0 ; t1y < (1 + trans1->COOL_2D_nY) ; t1y++) {
             if (0.0 != trans1->coeff[t1x][t1y]) {
-                for (psS32 t2x = 0 ; t2x < trans2->nX ; t2x++) {
-                    for (psS32 t2y = 0 ; t2y < trans2->nY ; t2y++) {
+                for (psS32 t2x = 0 ; t2x < (1 + trans2->COOL_2D_nX) ; t2x++) {
+                    for (psS32 t2y = 0 ; t2y < (1 + trans2->COOL_2D_nY) ; t2y++) {
                         /* Possible debug-only macro which checks these coords?
                         if ((t1x+t2x) >= orderX)
@@ -547,5 +552,5 @@
     PS_ASSERT_PTR_NON_NULL(trans1, NULL);
     PS_ASSERT_PTR_NON_NULL(trans2, NULL);
-    //TRACE: printf("psPlaneTransformCombine(%d, %d, %d, %d: %d, %d, %d, %d)\n", trans1->x->nX, trans1->x->nY, trans1->y->nX, trans1->y->nY, trans2->x->nX, trans2->x->nY, trans2->y->nX, trans2->y->nY);
+    //TRACE: printf("psPlaneTransformCombine(%d, %d, %d, %d: %d, %d, %d, %d)\n", trans1->x->COOL_2D_nX, trans1->x->COOL_2D_nY, trans1->y->COOL_2D_nX, trans1->y->COOL_2D_nY, trans2->x->COOL_2D_nX, trans2->x->COOL_2D_nY, trans2->y->COOL_2D_nX, trans2->y->COOL_2D_nY);
     //
     // Determine the size of the new psPlaneTransform.
@@ -553,13 +558,13 @@
     // PS_MAX(  Number of x terms in T2->x * number of x terms in T1->x,
     //          Number of y terms in T2->x * number of x terms in T1->y,
-    psS32 orderXnX = PS_MAX((trans2->x->nX * trans1->x->nX),
-                            (trans2->x->nY * trans1->y->nX));
-    psS32 orderXnY = PS_MAX((trans2->x->nX * trans1->x->nY),
-                            (trans2->x->nY * trans1->y->nY));
-
-    psS32 orderYnX = PS_MAX((trans2->y->nX * trans1->x->nX),
-                            (trans2->y->nY * trans1->y->nX));
-    psS32 orderYnY = PS_MAX((trans2->y->nX * trans1->x->nY),
-                            (trans2->y->nY * trans1->y->nY));
+    psS32 orderXnX = PS_MAX(((1 + trans2->x->COOL_2D_nX) * (1 + trans1->x->COOL_2D_nX)),
+                            ((1 + trans2->x->COOL_2D_nY) * (1 + trans1->y->COOL_2D_nX)));
+    psS32 orderXnY = PS_MAX(((1 + trans2->x->COOL_2D_nX) * (1 + trans1->x->COOL_2D_nY)),
+                            ((1 + trans2->x->COOL_2D_nY) * (1 + trans1->y->COOL_2D_nY)));
+
+    psS32 orderYnX = PS_MAX(((1 + trans2->y->COOL_2D_nX) * (1 + trans1->x->COOL_2D_nX)),
+                            ((1 + trans2->y->COOL_2D_nY) * (1 + trans1->y->COOL_2D_nX)));
+    psS32 orderYnY = PS_MAX(((1 + trans2->y->COOL_2D_nX) * (1 + trans1->x->COOL_2D_nY)),
+                            ((1 + trans2->y->COOL_2D_nY) * (1 + trans1->y->COOL_2D_nY)));
     psS32 orderX = PS_MAX(orderXnX, orderYnX);
     psS32 orderY = PS_MAX(orderXnY, orderYnY);
@@ -568,10 +573,11 @@
     // Allocate the new psPlaneTransform, if necessary.
     //
+    // XXX: rename, or verify, or recode, after the poly norder/nterm change.
     psPlaneTransform *myPT = NULL;
     if (out == NULL) {
         myPT = psPlaneTransformAlloc(orderX, orderY);
     } else {
-        if ((out->x->nX == orderX) && (out->x->nY == orderY) &&
-                (out->y->nX == orderX) && (out->y->nY == orderY)) {
+        if (((1 + out->x->COOL_2D_nX) == orderX) && ((1 + out->x->COOL_2D_nY) == orderY) &&
+                ((1 + out->y->COOL_2D_nX) == orderX) && ((1 + out->y->COOL_2D_nY) == orderY)) {
             myPT = out;
         } else {
@@ -603,7 +609,8 @@
     //
 
-    for (psS32 t2x = 0 ; t2x < trans2->x->nX ; t2x++) {
-        for (psS32 t2y = 0 ; t2y < trans2->x->nY ; t2y++) {
-            psPolynomial2D *currPoly = psPolynomial2DAlloc(1, 1, PS_POLYNOMIAL_ORD);
+    for (psS32 t2x = 0 ; t2x < (1 + trans2->x->COOL_2D_nX) ; t2x++) {
+        for (psS32 t2y = 0 ; t2y < (1 + trans2->x->COOL_2D_nX) ; t2y++) {
+            // XXX: Verify this (poly order/nterm change)
+            psPolynomial2D *currPoly = psPolynomial2DAlloc(1-1, 1-1, PS_POLYNOMIAL_ORD);
 
             currPoly->coeff[0][0] = 1.0;
@@ -627,6 +634,6 @@
 
                 // Set the appropriate coeffs in myPT->x
-                for (psS32 i = 0 ; i < currPoly->nX ; i++) {
-                    for (psS32 j = 0 ; j < currPoly->nY ; j++) {
+                for (psS32 i = 0 ; i < (1 + currPoly->COOL_2D_nX) ; i++) {
+                    for (psS32 j = 0 ; j < (1 + currPoly->COOL_2D_nY) ; j++) {
                         myPT->x->coeff[i][j]+= currPoly->coeff[i][j] * trans2->x->coeff[t2x][t2y];
                     }
@@ -638,7 +645,8 @@
 
 
-    for (psS32 t2x = 0 ; t2x < trans2->y->nX ; t2x++) {
-        for (psS32 t2y = 0 ; t2y < trans2->y->nY ; t2y++) {
-            psPolynomial2D *currPoly = psPolynomial2DAlloc(1, 1, PS_POLYNOMIAL_ORD);
+    for (psS32 t2x = 0 ; t2x < (1 + trans2->y->COOL_2D_nX) ; t2x++) {
+        for (psS32 t2y = 0 ; t2y < (1 + trans2->y->COOL_2D_nY) ; t2y++) {
+            // XXX: Verify this (poly order/nterm change)
+            psPolynomial2D *currPoly = psPolynomial2DAlloc(1-1, 1-1, PS_POLYNOMIAL_ORD);
             currPoly->coeff[0][0] = 1.0;
             currPoly->mask[0][0] = 0;
@@ -662,6 +670,6 @@
 
                 // Set the appropriate coeffs in myPT->x
-                for (psS32 i = 0 ; i < currPoly->nX ; i++) {
-                    for (psS32 j = 0 ; j < currPoly->nY ; j++) {
+                for (psS32 i = 0 ; i < (1 + currPoly->COOL_2D_nX) ; i++) {
+                    for (psS32 j = 0 ; j < (1 + currPoly->COOL_2D_nY) ; j++) {
                         myPT->y->coeff[i][j]+= currPoly->coeff[i][j] * trans2->y->coeff[t2x][t2y];
                     }
@@ -694,12 +702,15 @@
 
     psS32 numCoords = PS_MIN(source->n, dest->n);
-    psS32 order = PS_MAX(trans->x->nX, trans->x->nY);
-    order = PS_MAX(order, trans->y->nX);
-    order = PS_MAX(order, trans->y->nY);
+    psS32 order = PS_MAX(trans->x->COOL_2D_nX, trans->x->COOL_2D_nY);
+    order = PS_MAX(order, trans->y->COOL_2D_nX);
+    order = PS_MAX(order, trans->y->COOL_2D_nY);
+    // XXX: Verify, or recode, after the poly norder/nterm change.
+    order++;
 
     //
     // Create fake polynomial to use in evaluation
     //
-    psPolynomial2D *fakePoly = psPolynomial2DAlloc(order, order, PS_POLYNOMIAL_ORD);
+    // XXX: Verify this (poly order/nterm change)
+    psPolynomial2D *fakePoly = psPolynomial2DAlloc(order-1, order-1, PS_POLYNOMIAL_ORD);
     for (int i = 0; i < order; i++) {
         for (int j = 0; j < order; j++) {
@@ -811,10 +822,11 @@
 
     // Ensure that the input transformation is symmetrical.
-    if ((in->x->nX != in->x->nY) ||
-            (in->y->nX != in->y->nY) ||
-            (in->x->nX != in->y->nX)) {
+    if ((in->x->COOL_2D_nX != in->x->COOL_2D_nY) ||
+            (in->y->COOL_2D_nX != in->y->COOL_2D_nY) ||
+            (in->x->COOL_2D_nX != in->y->COOL_2D_nX)) {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Input transformation must have same nX==nY.");
     }
-    psS32 order = in->x->nX;
+    // XXX: recode or verify after poly changes
+    psS32 order = 1 + in->x->COOL_2D_nX;
 
     psPlaneTransform *myPT = NULL;
@@ -826,8 +838,10 @@
     //
     if (out == NULL) {
+        // XXX: Verify this (poly order/nterm change)
         myPT = psPlaneTransformAlloc(order, order);
     } else {
-        if ((out->x->nX == order) && (out->x->nY == order) &&
-                (out->y->nX == order) && (out->y->nY == order)) {
+        // XXX: recode or verify after poly changes
+        if (((1 + out->x->COOL_2D_nX) == order) && ((1 + out->x->COOL_2D_nY) == order) &&
+                ((1 + out->y->COOL_2D_nX) == order) && ((1 + out->y->COOL_2D_nX) == order)) {
             myPT = out;
         } else {
@@ -840,11 +854,11 @@
     // Copy the input transform to myPT.
     //
-    for (psS32 i = 0 ; i < in->x->nX ; i++) {
-        for (psS32 j = 0 ; j < in->x->nY ; j++) {
+    for (psS32 i = 0 ; i < (1 + in->x->COOL_2D_nX) ; i++) {
+        for (psS32 j = 0 ; j < (1 + in->x->COOL_2D_nY) ; j++) {
             myPT->x->coeff[i][j] = in->x->coeff[i][j];
         }
     }
-    for (psS32 i = 0 ; i < in->y->nX ; i++) {
-        for (psS32 j = 0 ; j < in->y->nY ; j++) {
+    for (psS32 i = 0 ; i < (1 + in->y->COOL_2D_nX) ; i++) {
+        for (psS32 j = 0 ; j < (1 + in->y->COOL_2D_nY) ; j++) {
             myPT->y->coeff[i][j] = in->y->coeff[i][j];
         }
@@ -926,7 +940,7 @@
 
     // This loop starts at loop_x=1 since the derivative of the loop_x=0 terms are all 0.0
-    for (psS32 loop_x = 1; loop_x < xPoly->nX; loop_x++) {
+    for (psS32 loop_x = 1; loop_x < (1 + xPoly->COOL_2D_nX); loop_x++) {
         ySum = 1.0;
-        for (psS32 loop_y = 0; loop_y < xPoly->nY; loop_y++) {
+        for (psS32 loop_y = 0; loop_y < (1 + xPoly->COOL_2D_nY); loop_y++) {
             //
             // For each iteration of the loop, we multiple the (x, y) coefficient
@@ -946,7 +960,7 @@
 
     // This loop starts at loop_y=1 since the derivative of the loop_y=0 terms are all 0.0
-    for (psS32 loop_x = 0; loop_x < yPoly->nX; loop_x++) {
+    for (psS32 loop_x = 0; loop_x < (1 + yPoly->COOL_2D_nX); loop_x++) {
         ySum = 1.0;
-        for (psS32 loop_y = 1; loop_y < yPoly->nY; loop_y++) {
+        for (psS32 loop_y = 1; loop_y < (1 + yPoly->COOL_2D_nY); loop_y++) {
             //
             // For each iteration of the loop, we multiple the (x, y) coefficient
Index: /trunk/psLib/src/imageops/psImageStats.c
===================================================================
--- /trunk/psLib/src/imageops/psImageStats.c	(revision 5089)
+++ /trunk/psLib/src/imageops/psImageStats.c	(revision 5090)
@@ -9,6 +9,6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.78 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-22 02:32:00 $
+ *  @version $Revision: 1.79 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-09-22 02:47:16 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -224,5 +224,6 @@
     chebPolys = (psPolynomial1D **) psAlloc(maxChebyPoly * sizeof(psPolynomial1D *));
     for (i = 0; i < maxChebyPoly; i++) {
-        chebPolys[i] = psPolynomial1DAlloc(i + 1, PS_POLYNOMIAL_ORD);
+        // XXX: verify this, poly nOrder/nTerms change.
+        chebPolys[i] = psPolynomial1DAlloc(i, PS_POLYNOMIAL_ORD);
     }
 
@@ -232,8 +233,8 @@
     chebPolys[1]->coeff[1] = 1;
     for (i = 2; i < maxChebyPoly; i++) {
-        for (j = 0; j < chebPolys[i - 1]->n; j++) {
+        for (j = 0; j < (1 + chebPolys[i - 1]->COOL_1D_n); j++) {
             chebPolys[i]->coeff[j + 1] = 2 * chebPolys[i - 1]->coeff[j];
         }
-        for (j = 0; j < chebPolys[i - 2]->n; j++) {
+        for (j = 0; j < (1 + chebPolys[i - 2]->COOL_1D_n); j++) {
             chebPolys[i]->coeff[j] -= chebPolys[i - 2]->coeff[j];
         }
@@ -290,7 +291,7 @@
     // 29 in the ADD: sums[k][l] = SUM {
     // image(x,y) * Tk(x) * Tl(y) }
-    sums = (double **)psAlloc(coeffs->nX * sizeof(double *));
-    for (i = 0; i < coeffs->nX; i++) {
-        sums[i] = (double *)psAlloc(coeffs->nY * sizeof(double));
+    sums = (double **)psAlloc((1 + coeffs->COOL_2D_nX) * sizeof(double *));
+    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
+        sums[i] = (double *)psAlloc((1 + coeffs->COOL_2D_nY) * sizeof(double));
     }
     // We scale the pixel positions to values
@@ -301,13 +302,14 @@
     // Determine how many Chebyshev polynomials
     // are needed, then create them.
-    maxChebyPoly = coeffs->nX;
-    if (coeffs->nY > coeffs->nX) {
-        maxChebyPoly = coeffs->nY;
-    }
-    chebPolys = p_psCreateChebyshevPolys(maxChebyPoly);
+    // XXX: recorde or verify the poly order/nterm change
+    maxChebyPoly = coeffs->COOL_2D_nX;
+    if (coeffs->COOL_2D_nY > coeffs->COOL_2D_nX) {
+        maxChebyPoly = coeffs->COOL_2D_nY;
+    }
+    chebPolys = p_psCreateChebyshevPolys(maxChebyPoly + 1);
 
     // Compute the sums[][] data structure.
-    for (i = 0; i < coeffs->nX; i++) {
-        for (j = 0; j < coeffs->nY; j++) {
+    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
+        for (j = 0; j < (1 + coeffs->COOL_2D_nY); j++) {
             sums[i][j] = 0.0;
             for (x = 0; x < input->numRows; x++) {
@@ -330,6 +332,6 @@
     }
 
-    for (i = 0; i < coeffs->nX; i++) {
-        for (j = 0; j < coeffs->nY; j++) {
+    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
+        for (j = 0; j < (1 + coeffs->COOL_2D_nY); j++) {
             coeffs->coeff[i][j] = sums[i][j];
             coeffs->coeff[i][j] /= (double)(input->numRows * input->numCols);
@@ -353,5 +355,5 @@
 
     // Free some data
-    for (i = 0; i < coeffs->nX; i++) {
+    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
         psFree(sums[i]);
     }
@@ -436,7 +438,7 @@
     // 29 in the ADD: sums[k][l] = SUM {
     // image(x,y) * Tk(x) * Tl(y) }
-    sums = (double **)psAlloc(coeffs->nX * sizeof(double *));
-    for (i = 0; i < coeffs->nX; i++) {
-        sums[i] = (double *)psAlloc(coeffs->nY * sizeof(double));
+    sums = (double **)psAlloc((1 + coeffs->COOL_2D_nX) * sizeof(double *));
+    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
+        sums[i] = (double *)psAlloc((1 + coeffs->COOL_2D_nY) * sizeof(double));
     }
     // We scale the pixel positions to values
@@ -447,13 +449,13 @@
     // Determine how many Chebyshev polynomials
     // are needed, then create them.
-    maxChebyPoly = coeffs->nX;
-    if (coeffs->nY > coeffs->nX) {
-        maxChebyPoly = coeffs->nY;
-    }
-    chebPolys = p_psCreateChebyshevPolys(maxChebyPoly);
+    maxChebyPoly = coeffs->COOL_2D_nX;
+    if (coeffs->COOL_2D_nY > coeffs->COOL_2D_nX) {
+        maxChebyPoly = coeffs->COOL_2D_nY;
+    }
+    chebPolys = 1 + p_psCreateChebyshevPolys(maxChebyPoly);
 
     // Compute the sums[][] data structure.
-    for (i = 0; i < coeffs->nX; i++) {
-        for (j = 0; j < coeffs->nY; j++) {
+    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
+        for (j = 0; j < (1 + coeffs->COOL_2D_nY); j++) {
             sums[i][j] = 0.0;
             for (x = 0; x < input->numRows; x++) {
@@ -479,6 +481,6 @@
     }
 
-    for (i = 0; i < coeffs->nX; i++) {
-        for (j = 0; j < coeffs->nY; j++) {
+    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
+        for (j = 0; j < (1 + coeffs->COOL_2D_nY); j++) {
             coeffs->coeff[i][j] = sums[i][j];
             coeffs->coeff[i][j] /= (double)(input->numRows * input->numCols);
@@ -502,5 +504,5 @@
 
     // Free some data
-    for (i = 0; i < coeffs->nX; i++) {
+    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
         psFree(sums[i]);
     }
@@ -538,16 +540,16 @@
     // Determine how many Chebyshev polynomials
     // are needed, then create them.
-    maxChebyPoly = coeffs->nX;
-    if (coeffs->nY > coeffs->nX) {
-        maxChebyPoly = coeffs->nY;
-    }
-
-    chebPolys = p_psCreateChebyshevPolys(maxChebyPoly);
+    maxChebyPoly = coeffs->COOL_2D_nX;
+    if (coeffs->COOL_2D_nY > coeffs->COOL_2D_nX) {
+        maxChebyPoly = coeffs->COOL_2D_nY;
+    }
+
+    chebPolys = 1 + p_psCreateChebyshevPolys(maxChebyPoly);
 
     for (x = 0; x < input->numRows; x++) {
         for (y = 0; y < input->numCols; y++) {
             polySum = 0.0;
-            for (i = 0; i < coeffs->nX; i++) {
-                for (j = 0; j < coeffs->nY; j++) {
+            for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
+                for (j = 0; j < (1 + coeffs->COOL_2D_nY); j++) {
                     polySum +=
                         psPolynomial1DEval(chebPolys[i], rScalingFactors[x]) *
Index: /trunk/psLib/src/math/psMinimize.c
===================================================================
--- /trunk/psLib/src/math/psMinimize.c	(revision 5089)
+++ /trunk/psLib/src/math/psMinimize.c	(revision 5090)
@@ -10,6 +10,6 @@
  *  @author EAM, IfA
  *
- *  @version $Revision: 1.138 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-13 21:43:47 $
+ *  @version $Revision: 1.139 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-09-22 02:47:16 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -1459,5 +1459,5 @@
     // XXX: these ASSERTS are redundant.
     PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(myPoly->n, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_1D_n, NULL);
     PS_ASSERT_VECTOR_NON_NULL(y, NULL);
     PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
@@ -1523,5 +1523,5 @@
     fac = 2.0/((psF32) n);
     // XXX: is this loop bound correct?
-    for (j=0;j<myPoly->n;j++) {
+    for (j=0;j<myPoly->COOL_1D_n+1;j++) {
         sum = 0.0;
         for (k=0;k<n;k++) {
@@ -1552,5 +1552,5 @@
     // XXX: these ASSERTS are redundant.
     PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(myPoly->n, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_1D_n, NULL);
     PS_ASSERT_VECTOR_NON_NULL(f, NULL);
     PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F64, NULL);
@@ -1597,5 +1597,5 @@
     }
 
-    nTerm = myPoly->n;
+    nTerm = 1 + myPoly->COOL_1D_n;
     nOrder = nTerm - 1;
 
@@ -1697,5 +1697,5 @@
 
     PS_ASSERT_POLY_NON_NULL(poly, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(poly->n, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(poly->COOL_1D_n, NULL);
     PS_ASSERT_VECTOR_NON_NULL(f, NULL);
     PS_ASSERT_VECTOR_NON_EMPTY(f, NULL);
@@ -1837,6 +1837,6 @@
     // These ASSERTS are redundant.
     PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(myPoly->nX, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(myPoly->nY, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_2D_nX, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_2D_nY, NULL);
 
     PS_ASSERT_VECTOR_NON_NULL(f, NULL);
@@ -1865,6 +1865,6 @@
 
     // XXX:Watch for changes to the psPolys: nTerm != nOrder.
-    psS32 nXterm = myPoly->nX;
-    psS32 nYterm = myPoly->nY;
+    psS32 nXterm = 1 + myPoly->COOL_2D_nX;
+    psS32 nYterm = 1 + myPoly->COOL_2D_nY;
     nTerm = nXterm * nYterm;
 
@@ -2264,7 +2264,7 @@
     // These ASSERTS are redundant.
     PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(myPoly->nX, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(myPoly->nY, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(myPoly->nZ, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_3D_nX, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_3D_nY, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_3D_nZ, NULL);
 
     PS_ASSERT_VECTOR_NON_NULL(f, NULL);
@@ -2527,8 +2527,8 @@
     // These ASSERTS are redundant.
     PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(myPoly->nX, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(myPoly->nY, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(myPoly->nZ, NULL);
-    PS_ASSERT_INT_NONNEGATIVE(myPoly->nT, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_4D_nX, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_4D_nY, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_4D_nZ, NULL);
+    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_4D_nT, NULL);
     PS_ASSERT_VECTOR_NON_NULL(f, NULL);
     PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F64, NULL);
Index: /trunk/psLib/src/math/psPolynomial.c
===================================================================
--- /trunk/psLib/src/math/psPolynomial.c	(revision 5089)
+++ /trunk/psLib/src/math/psPolynomial.c	(revision 5090)
@@ -7,6 +7,6 @@
 *  polynomials.  It also contains a Gaussian functions.
 *
-*  @version $Revision: 1.122 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-20 20:48:35 $
+*  @version $Revision: 1.123 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-09-22 02:47:16 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -95,5 +95,5 @@
     unsigned int x = 0;
 
-    for (x = 0; x < poly->nX; x++) {
+    for (x = 0; x < poly->COOL_2D_nX; x++) {
         psFree(poly->coeff[x]);
         psFree(poly->coeffErr[x]);
@@ -110,6 +110,6 @@
     unsigned int y = 0;
 
-    for (x = 0; x < poly->nX; x++) {
-        for (y = 0; y < poly->nY; y++) {
+    for (x = 0; x < poly->COOL_3D_nX; x++) {
+        for (y = 0; y < poly->COOL_3D_nY; y++) {
             psFree(poly->coeff[x][y]);
             psFree(poly->coeffErr[x][y]);
@@ -132,7 +132,7 @@
     unsigned int z = 0;
 
-    for (x = 0; x < poly->nX; x++) {
-        for (y = 0; y < poly->nY; y++) {
-            for (z = 0; z < poly->nZ; z++) {
+    for (x = 0; x < poly->COOL_4D_nX; x++) {
+        for (y = 0; y < poly->COOL_4D_nY; y++) {
+            for (z = 0; z < poly->COOL_4D_nZ; z++) {
                 psFree(poly->coeff[x][y][z]);
                 psFree(poly->coeffErr[x][y][z]);
@@ -170,5 +170,5 @@
     chebPolys = (psPolynomial1D **) psAlloc(maxChebyPoly * sizeof(psPolynomial1D *));
     for (unsigned int i = 0; i < maxChebyPoly; i++) {
-        chebPolys[i] = psPolynomial1DAlloc(i + 1, PS_POLYNOMIAL_ORD);
+        chebPolys[i] = psPolynomial1DAlloc(i, PS_POLYNOMIAL_ORD);
     }
 
@@ -182,8 +182,8 @@
 
         for (psS32 i = 2; i < maxChebyPoly; i++) {
-            for (psS32 j = 0; j < chebPolys[i - 1]->n; j++) {
+            for (psS32 j = 0; j < chebPolys[i - 1]->COOL_1D_n; j++) {
                 chebPolys[i]->coeff[j + 1] = 2 * chebPolys[i - 1]->coeff[j];
             }
-            for (psS32 j = 0; j < chebPolys[i - 2]->n; j++) {
+            for (psS32 j = 0; j < chebPolys[i - 2]->COOL_1D_n; j++) {
                 chebPolys[i]->coeff[j] -= chebPolys[i - 2]->coeff[j];
             }
@@ -210,11 +210,11 @@
             "---- Calling ordPolynomial1DEval(%lf)\n", x);
     psTrace(".psLib.dataManip.psPolynomial.ordPolynomial1DEval", 4,
-            "Polynomial order is %u\n", poly->n);
-    for (loop_x = 0; loop_x < poly->n; loop_x++) {
+            "Polynomial order is %u\n", poly->COOL_1D_n);
+    for (loop_x = 0; loop_x < poly->COOL_1D_n+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->n; loop_x++) {
+    for (loop_x = 0; loop_x < poly->COOL_1D_n+1; loop_x++) {
         if (poly->mask[loop_x] == 0) {
             // XXX: If you set the tracelevel to 10 here, and later set the tracelevel to
@@ -238,10 +238,11 @@
     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 %u.", poly->n);
+    if (poly->COOL_1D_n < 1) {
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Error: Chebyshev polynomial is order %u.", poly->COOL_1D_n);
         return(NAN);
     }
     psVector *d;
-    unsigned int n = poly->n;
+    // XXX: n should be nTerms here (for clarity).  Or get rid of the variable.
+    unsigned int n = 1 + poly->COOL_1D_n;
     unsigned int i;
     psF64 tmp = 0.0;
@@ -302,9 +303,9 @@
     psPolynomial1D **chebPolys = NULL;
 
-    n = poly->n;
+    n = 1 + poly->COOL_1D_n;
     chebPolys = createChebyshevPolys(n);
 
     tmp = 0.0;
-    for (i=0;i<poly->n;i++) {
+    for (i=0;i<(1 + poly->COOL_1D_n);i++) {
         tmp+= (poly->coeff[i] * psPolynomial1DEval(x, chebPolys[i]));
     }
@@ -328,7 +329,7 @@
     psF64 ySum = 1.0;
 
-    for (loop_x = 0; loop_x < poly->nX; loop_x++) {
+    for (loop_x = 0; loop_x < (1 + poly->COOL_2D_nX); loop_x++) {
         ySum = xSum;
-        for (loop_y = 0; loop_y < poly->nY; loop_y++) {
+        for (loop_y = 0; loop_y < (1 + poly->COOL_2D_nY); loop_y++) {
             if (poly->mask[loop_x][loop_y] == 0) {
                 polySum += ySum * poly->coeff[loop_x][loop_y];
@@ -359,12 +360,12 @@
     // Determine how many Chebyshev polynomials
     // are needed, then create them.
-    maxChebyPoly = poly->nX;
-    if (poly->nY > maxChebyPoly) {
-        maxChebyPoly = poly->nY;
+    maxChebyPoly = 1 + poly->COOL_2D_nX;
+    if ((1 + poly->COOL_2D_nY) > maxChebyPoly) {
+        maxChebyPoly = (1 + poly->COOL_2D_nY);
     }
     chebPolys = createChebyshevPolys(maxChebyPoly);
 
-    for (loop_x = 0; loop_x < poly->nX; loop_x++) {
-        for (loop_y = 0; loop_y < poly->nY; loop_y++) {
+    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++) {
             if (poly->mask[loop_x][loop_y] == 0) {
                 polySum += poly->coeff[loop_x][loop_y] *
@@ -394,9 +395,9 @@
     psF64 zSum = 1.0;
 
-    for (loop_x = 0; loop_x < poly->nX; loop_x++) {
+    for (loop_x = 0; loop_x < (1 + poly->COOL_3D_nX); loop_x++) {
         ySum = xSum;
-        for (loop_y = 0; loop_y < poly->nY; loop_y++) {
+        for (loop_y = 0; loop_y < (1 + poly->COOL_3D_nY); loop_y++) {
             zSum = ySum;
-            for (loop_z = 0; loop_z < poly->nZ; loop_z++) {
+            for (loop_z = 0; loop_z < (1 + poly->COOL_3D_nZ); loop_z++) {
                 if (poly->mask[loop_x][loop_y][loop_z] == 0) {
                     polySum += zSum * poly->coeff[loop_x][loop_y][loop_z];
@@ -430,16 +431,16 @@
     // Determine how many Chebyshev polynomials
     // are needed, then create them.
-    maxChebyPoly = poly->nX;
-    if (poly->nY > maxChebyPoly) {
-        maxChebyPoly = poly->nY;
-    }
-    if (poly->nZ > maxChebyPoly) {
-        maxChebyPoly = poly->nZ;
-    }
-    chebPolys = createChebyshevPolys(maxChebyPoly);
-
-    for (loop_x = 0; loop_x < poly->nX; loop_x++) {
-        for (loop_y = 0; loop_y < poly->nY; loop_y++) {
-            for (loop_z = 0; loop_z < poly->nZ; loop_z++) {
+    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;
+    }
+    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++) {
                 if (poly->mask[loop_x][loop_y][loop_z] == 0) {
                     polySum += poly->coeff[loop_x][loop_y][loop_z] *
@@ -475,11 +476,11 @@
     psF64 tSum = 1.0;
 
-    for (loop_x = 0; loop_x < poly->nX; loop_x++) {
+    for (loop_x = 0; loop_x < (1 + poly->COOL_4D_nX); loop_x++) {
         ySum = xSum;
-        for (loop_y = 0; loop_y < poly->nY; loop_y++) {
+        for (loop_y = 0; loop_y < (1 + poly->COOL_4D_nY); loop_y++) {
             zSum = ySum;
-            for (loop_z = 0; loop_z < poly->nZ; loop_z++) {
+            for (loop_z = 0; loop_z < (1 + poly->COOL_4D_nZ); loop_z++) {
                 tSum = zSum;
-                for (loop_t = 0; loop_t < poly->nT; loop_t++) {
+                for (loop_t = 0; loop_t < (1 + poly->COOL_4D_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];
@@ -518,20 +519,20 @@
     // Determine how many Chebyshev polynomials
     // are needed, then create them.
-    maxChebyPoly = poly->nX;
-    if (poly->nY > maxChebyPoly) {
-        maxChebyPoly = poly->nY;
-    }
-    if (poly->nZ > maxChebyPoly) {
-        maxChebyPoly = poly->nZ;
-    }
-    if (poly->nT > maxChebyPoly) {
-        maxChebyPoly = poly->nT;
+    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;
     }
     chebPolys = createChebyshevPolys(maxChebyPoly);
 
-    for (loop_x = 0; loop_x < poly->nX; loop_x++) {
-        for (loop_y = 0; loop_y < poly->nY; loop_y++) {
-            for (loop_z = 0; loop_z < poly->nZ; loop_z++) {
-                for (loop_t = 0; loop_t < poly->nT; loop_t++) {
+    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_nZ); 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] *
@@ -610,4 +611,7 @@
 /*****************************************************************************
     This routine must allocate memory for the polynomial structures.
+    XXX: replaces nterms variables with nOrder.  Lots of potential for bugs
+         here.  Probably should create separately named private variables
+         in these functions.
  *****************************************************************************/
 psPolynomial1D* psPolynomial1DAlloc(unsigned int n,
@@ -623,9 +627,9 @@
 
     newPoly->type = type;
-    newPoly->n = n;
+    newPoly->COOL_1D_n = n;
     newPoly->coeff = psAlloc(n * sizeof(psF64));
     newPoly->coeffErr = psAlloc(n * sizeof(psF64));
-    newPoly->mask = (psMaskType *)psAlloc(n * sizeof(psMaskType));
-    for (i = 0; i < n; i++) {
+    newPoly->mask = (psMaskType *)psAlloc((n + 1) * sizeof(psMaskType));
+    for (i = 0; i < (n + 1); i++) {
         newPoly->coeff[i] = 0.0;
         newPoly->coeffErr[i] = 0.0;
@@ -651,17 +655,17 @@
 
     newPoly->type = type;
-    newPoly->nX = nX;
-    newPoly->nY = nY;
-
-    newPoly->coeff = psAlloc(nX * sizeof(psF64 *));
-    newPoly->coeffErr = psAlloc(nX * sizeof(psF64 *));
-    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] = (psMaskType *)psAlloc(nY * sizeof(psMaskType));
-    }
-    for (x = 0; x < nX; x++) {
-        for (y = 0; y < nY; y++) {
+    newPoly->COOL_2D_nX = nX;
+    newPoly->COOL_2D_nY = nY;
+
+    newPoly->coeff = psAlloc((1 + nX) * sizeof(psF64 *));
+    newPoly->coeffErr = psAlloc((1 + nX) * sizeof(psF64 *));
+    newPoly->mask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
+    for (x = 0; x < (1 + nX); x++) {
+        newPoly->coeff[x] = psAlloc((1 + nY) * sizeof(psF64));
+        newPoly->coeffErr[x] = psAlloc((1 + nY) * sizeof(psF64));
+        newPoly->mask[x] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
+    }
+    for (x = 0; x < (1 + nX); x++) {
+        for (y = 0; y < (1 + nY); y++) {
             newPoly->coeff[x][y] = 0.0;
             newPoly->coeffErr[x][y] = 0.0;
@@ -691,24 +695,24 @@
 
     newPoly->type = type;
-    newPoly->nX = nX;
-    newPoly->nY = nY;
-    newPoly->nZ = nZ;
-
-    newPoly->coeff = psAlloc(nX * sizeof(psF64 **));
-    newPoly->coeffErr = psAlloc(nX * sizeof(psF64 **));
-    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] = (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] = (psMaskType *)psAlloc(nZ * sizeof(psMaskType));
-        }
-    }
-    for (x = 0; x < nX; x++) {
-        for (y = 0; y < nY; y++) {
-            for (z = 0; z < nZ; z++) {
+    newPoly->COOL_3D_nX = nX;
+    newPoly->COOL_3D_nY = nY;
+    newPoly->COOL_3D_nZ = nZ;
+
+    newPoly->coeff = psAlloc((nX + 1) * sizeof(psF64 **));
+    newPoly->coeffErr = psAlloc((nX + 1) * sizeof(psF64 **));
+    newPoly->mask = (psMaskType ***)psAlloc((nX + 1) * sizeof(psMaskType **));
+    for (x = 0; x < (1 + nX); x++) {
+        newPoly->coeff[x] = psAlloc((nY + 1) * sizeof(psF64 *));
+        newPoly->coeffErr[x] = psAlloc((nY + 1) * sizeof(psF64 *));
+        newPoly->mask[x] = (psMaskType **)psAlloc((nY + 1) * sizeof(psMaskType *));
+        for (y = 0; y < (nY + 1); y++) {
+            newPoly->coeff[x][y] = psAlloc((nZ + 1) * sizeof(psF64));
+            newPoly->coeffErr[x][y] = psAlloc((nZ + 1) * sizeof(psF64));
+            newPoly->mask[x][y] = (psMaskType *)psAlloc((nZ + 1) * sizeof(psMaskType));
+        }
+    }
+    for (x = 0; x < (nX + 1); x++) {
+        for (y = 0; y < (nY + 1); y++) {
+            for (z = 0; z < (nZ + 1); z++) {
                 newPoly->coeff[x][y][z] = 0.0;
                 newPoly->coeffErr[x][y][z] = 0.0;
@@ -742,31 +746,31 @@
 
     newPoly->type = type;
-    newPoly->nX = nX;
-    newPoly->nY = nY;
-    newPoly->nZ = nZ;
-    newPoly->nT = nT;
-
-    newPoly->coeff = psAlloc(nX * sizeof(psF64 ***));
-    newPoly->coeffErr = psAlloc(nX * sizeof(psF64 ***));
-    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] = (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] = (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] = (psMaskType *)psAlloc(nT * sizeof(psMaskType));
-            }
-        }
-    }
-    for (x = 0; x < nX; x++) {
-        for (y = 0; y < nY; y++) {
-            for (z = 0; z < nZ; z++) {
-                for (t = 0; t < nT; t++) {
+    newPoly->COOL_4D_nX = nX;
+    newPoly->COOL_4D_nY = nY;
+    newPoly->COOL_4D_nZ = nZ;
+    newPoly->COOL_4D_nT = nT;
+
+    newPoly->coeff = psAlloc((nX + 1) * sizeof(psF64 ***));
+    newPoly->coeffErr = psAlloc((nX + 1) * sizeof(psF64 ***));
+    newPoly->mask = (psMaskType ****)psAlloc((nX + 1) * sizeof(psMaskType ***));
+    for (x = 0; x < (nX + 1); x++) {
+        newPoly->coeff[x] = psAlloc((nY + 1) * sizeof(psF64 **));
+        newPoly->coeffErr[x] = psAlloc((nY + 1) * sizeof(psF64 **));
+        newPoly->mask[x] = (psMaskType ***)psAlloc((nY + 1) * sizeof(psMaskType **));
+        for (y = 0; y < (nY + 1); y++) {
+            newPoly->coeff[x][y] = psAlloc((nZ + 1) * sizeof(psF64 *));
+            newPoly->coeffErr[x][y] = psAlloc((nZ + 1) * sizeof(psF64 *));
+            newPoly->mask[x][y] = (psMaskType **)psAlloc((nZ + 1) * sizeof(psMaskType *));
+            for (z = 0; z < (nZ + 1); z++) {
+                newPoly->coeff[x][y][z] = psAlloc((nT + 1) * sizeof(psF64));
+                newPoly->coeffErr[x][y][z] = psAlloc((nT + 1) * sizeof(psF64));
+                newPoly->mask[x][y][z] = (psMaskType *)psAlloc((nT + 1) * sizeof(psMaskType));
+            }
+        }
+    }
+    for (x = 0; x < (nX + 1); x++) {
+        for (y = 0; y < (nY + 1); y++) {
+            for (z = 0; z < (nZ + 1); z++) {
+                for (t = 0; t < (nT + 1); t++) {
                     newPoly->coeff[x][y][z][t] = 0.0;
                     newPoly->coeffErr[x][y][z][t] = 0.0;
@@ -972,5 +976,5 @@
     }
 
-    // Allocate output vector
+    // Allocoutput vector
     tmp = psVectorAlloc(vecLen, PS_TYPE_F64);
 
Index: /trunk/psLib/src/math/psPolynomial.h
===================================================================
--- /trunk/psLib/src/math/psPolynomial.h	(revision 5089)
+++ /trunk/psLib/src/math/psPolynomial.h	(revision 5090)
@@ -11,6 +11,6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.56 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-19 19:53:13 $
+ *  @version $Revision: 1.57 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-09-22 02:47:16 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -64,56 +64,68 @@
  */
 typedef enum {
-    PS_POLYNOMIAL_ORD,                 ///< Ordinary Polynomial
-    PS_POLYNOMIAL_CHEB                 ///< Chebyshev Polynomial
+    PS_POLYNOMIAL_ORD,                  ///< Ordinary Polynomial
+    PS_POLYNOMIAL_CHEB                  ///< Chebyshev Polynomial
 }
 psPolynomialType;
 
+// XXX: These are incorrect names for the order of the polynomial.  We
+// keep them here temporarily so we can later sed replace them with the
+// correct names.
 /** One-dimensional polynomial */
 typedef struct
 {
-    psPolynomialType type;             ///< Polynomial type
-    unsigned int n;                    ///< Number of terms
-    psF64 *coeff;                      ///< Coefficients
-    psF64 *coeffErr;                   ///< Error in coefficients
-    psMaskType *mask;                  ///< Coefficient mask
+    psPolynomialType type;              ///< Polynomial type
+    unsigned int COOL_1D_n;             ///< Polynomial order
+    psF64 *coeff;                       ///< Coefficients
+    psF64 *coeffErr;                    ///< Error in coefficients
+    psMaskType *mask;                   ///< Coefficient mask
 }
 psPolynomial1D;
 
+// XXX: These are incorrect names for the order of the polynomial.  We
+// keep them here temporarily so we can later sed replace them with the
+// correct names.
 /** Two-dimensional polynomial */
 typedef struct
 {
-    psPolynomialType type;             ///< Polynomial type
-    unsigned int nX;                   ///< Number of terms in x
-    unsigned int nY;                   ///< Number of terms in y
-    psF64 **coeff;                     ///< Coefficients
-    psF64 **coeffErr;                  ///< Error in coefficients
-    psMaskType **mask;                 ///< Coefficients mask
+    psPolynomialType type;              ///< Polynomial type
+    unsigned int COOL_2D_nX;            ///< Polynomial order in x
+    unsigned int COOL_2D_nY;            ///< Polynomial order in y
+    psF64 **coeff;                      ///< Coefficients
+    psF64 **coeffErr;                   ///< Error in coefficients
+    psMaskType **mask;                  ///< Coefficients mask
 }
 psPolynomial2D;
 
+// XXX: These are incorrect names for the order of the polynomial.  We
+// keep them here temporarily so we can later sed replace them with the
+// correct names.
 /** Three-dimensional polynomial */
 typedef struct
 {
-    psPolynomialType type;             ///< Polynomial type
-    unsigned int nX;                   ///< Number of terms in x
-    unsigned int nY;                   ///< Number of terms in y
-    unsigned int nZ;                   ///< Number of terms in z
-    psF64 ***coeff;                    ///< Coefficients
-    psF64 ***coeffErr;                 ///< Error in coefficients
-    psMaskType ***mask;                ///< Coefficients mask
+    psPolynomialType type;              ///< Polynomial type
+    unsigned int COOL_3D_nX;            ///< Polynomial order in x
+    unsigned int COOL_3D_nY;            ///< Polynomial order in y
+    unsigned int COOL_3D_nZ;            ///< Polynomial order in z
+    psF64 ***coeff;                     ///< Coefficients
+    psF64 ***coeffErr;                  ///< Error in coefficients
+    psMaskType ***mask;                 ///< Coefficients mask
 }
 psPolynomial3D;
 
+// XXX: These are incorrect names for the order of the polynomial.  We
+// keep them here temporarily so we can later sed replace them with the
+// correct names.
 /** Four-dimensional polynomial */
 typedef struct
 {
-    psPolynomialType type;             ///< Polynomial type
-    unsigned int nX;                   ///< Number of terms in x
-    unsigned int nY;                   ///< Number of terms in y
-    unsigned int nZ;                   ///< Number of terms in z
-    unsigned int nT;                   ///< Number of terms in t
-    psF64 ****coeff;                   ///< Coefficients
-    psF64 ****coeffErr;                ///< Error in coefficients
-    psMaskType ****mask;               ///< Coefficients mask
+    psPolynomialType type;              ///< Polynomial type
+    unsigned int COOL_4D_nX;            ///< Polynomial order in x
+    unsigned int COOL_4D_nY;            ///< Polynomial order in y
+    unsigned int COOL_4D_nZ;            ///< Polynomial order in z
+    unsigned int COOL_4D_nT;            ///< Polynomial order in t
+    psF64 ****coeff;                    ///< Coefficients
+    psF64 ****coeffErr;                 ///< Error in coefficients
+    psMaskType ****mask;                ///< Coefficients mask
 }
 psPolynomial4D;
Index: /trunk/psLib/src/math/psSpline.c
===================================================================
--- /trunk/psLib/src/math/psSpline.c	(revision 5089)
+++ /trunk/psLib/src/math/psSpline.c	(revision 5090)
@@ -7,6 +7,6 @@
 *  splines.
 *
-*  @version $Revision: 1.126 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-20 02:43:53 $
+*  @version $Revision: 1.127 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-09-22 02:47:16 $
 *
 *
@@ -383,5 +383,5 @@
     // If these are linear splines, which means their polynomials will have
     // two coefficients, then we do the simple calculation.
-    if (2 == (spline->spline[0])->n) {
+    if (1 == (spline->spline[0])->COOL_1D_n) {
         for (i=0;i<spline->n;i++) {
             slope = (y32->data.F32[i+1] - y32->data.F32[i]) /
@@ -402,8 +402,8 @@
 
     // Check if these are cubic splines (n==4).  If not, psError.
-    if (4 != (spline->spline[0])->n) {
+    if (3 != (spline->spline[0])->COOL_1D_n) {
         psError(PS_ERR_BAD_PARAMETER_SIZE, true,
                 "Don't know how to generate %u-order splines.",
-                (spline->spline[0])->n-1);
+                (spline->spline[0])->COOL_1D_n);
         return(NULL);
     }
@@ -745,5 +745,5 @@
     tmpSpline->spline = (psPolynomial1D **) psAlloc(numSplines * sizeof(psPolynomial1D *));
     for (unsigned int i=0;i<numSplines;i++) {
-        (tmpSpline->spline)[i] = psPolynomial1DAlloc(order+1, PS_POLYNOMIAL_ORD);
+        (tmpSpline->spline)[i] = psPolynomial1DAlloc(order, PS_POLYNOMIAL_ORD);
     }
 
@@ -809,5 +809,5 @@
     tmpSpline->spline = (psPolynomial1D **) psAlloc(numSplines * sizeof(psPolynomial1D *));
     for (unsigned int i=0;i<numSplines;i++) {
-        (tmpSpline->spline)[i] = psPolynomial1DAlloc(order+1, PS_POLYNOMIAL_ORD);
+        (tmpSpline->spline)[i] = psPolynomial1DAlloc(order, PS_POLYNOMIAL_ORD);
     }
 
Index: /trunk/psLib/src/math/psStats.c
===================================================================
--- /trunk/psLib/src/math/psStats.c	(revision 5089)
+++ /trunk/psLib/src/math/psStats.c	(revision 5090)
@@ -17,6 +17,6 @@
  *
  *
- *  @version $Revision: 1.145 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-11 22:18:40 $
+ *  @version $Revision: 1.146 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-09-22 02:47:16 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -1502,4 +1502,5 @@
     psVector *y = psVectorAlloc(3, PS_TYPE_F64);
     psVector *yErr = psVectorAlloc(3, PS_TYPE_F64);
+    // XXX: Why was this 2 when the alloc function specified number of terms?  Note: it's correct now.
     psPolynomial1D *myPoly = psPolynomial1DAlloc(2, PS_POLYNOMIAL_ORD);
 
@@ -1552,5 +1553,4 @@
 
         // Determine the coefficients of the polynomial.
-        //        myPoly = psVectorFitPolynomial1D(myPoly, x, y, yErr);
         myPoly = psVectorFitPolynomial1D(myPoly, NULL, 0, y, yErr, x);
         if (myPoly == NULL) {
@@ -1827,5 +1827,5 @@
         }
 
-        psPolynomial1D *tmpPoly = psPolynomial1DAlloc(3, PS_POLYNOMIAL_ORD);
+        psPolynomial1D *tmpPoly = psPolynomial1DAlloc(2, PS_POLYNOMIAL_ORD);
         // XXX: What about the NULL x argument?
         tmpPoly = psVectorFitPolynomial1D(tmpPoly, NULL, 0, y, NULL, NULL);
Index: /trunk/psLib/test/astro/tst_psCoord.c
===================================================================
--- /trunk/psLib/test/astro/tst_psCoord.c	(revision 5089)
+++ /trunk/psLib/test/astro/tst_psCoord.c	(revision 5090)
@@ -6,6 +6,6 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-07-23 02:44:09 $
+*  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-09-22 02:47:16 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -51,22 +51,22 @@
 
     // Verify returned transform has members set properly
-    if (myPT->x->nX != NX_TERMS) {
-        psError(PS_ERR_UNKNOWN,true,"myPT->x->nX is %d, should be %d",
-                myPT->x->nX, NX_TERMS);
+    if ((1 + myPT->x->COOL_2D_nX) != NX_TERMS) {
+        psError(PS_ERR_UNKNOWN,true,"myPT->x->COOL_2D_nX is %d, should be %d",
+                myPT->x->COOL_2D_nX, NX_TERMS-1);
         return 2;
     }
-    if (myPT->y->nX != NX_TERMS) {
-        psError(PS_ERR_UNKNOWN,true,"myPT->y->nX is %d, should be %d",
-                myPT->y->nX, NX_TERMS);
+    if ((1 + myPT->y->COOL_2D_nX) != NX_TERMS) {
+        psError(PS_ERR_UNKNOWN,true,"myPT->y->COOL_2D_nX is %d, should be %d",
+                myPT->y->COOL_2D_nX, NX_TERMS-1);
         return 3;
     }
-    if (myPT->x->nY != NY_TERMS) {
-        psError(PS_ERR_UNKNOWN,true,"myPT->x->nY is %d, should be %d",
-                myPT->x->nY, NY_TERMS);
+    if ((1 + myPT->x->COOL_2D_nY) != NY_TERMS) {
+        psError(PS_ERR_UNKNOWN,true,"myPT->x->COOL_2D_nY is %d, should be %d",
+                myPT->x->COOL_2D_nY, NY_TERMS-1);
         return 4;
     }
-    if (myPT->y->nY != NY_TERMS) {
-        psError(PS_ERR_UNKNOWN,true,"myPT->y->nY is %d, should be %d",
-                myPT->y->nY, NY_TERMS);
+    if ((1 + myPT->y->COOL_2D_nY) != NY_TERMS) {
+        psError(PS_ERR_UNKNOWN,true,"myPT->y->COOL_2D_nY is %d, should be %d",
+                myPT->y->COOL_2D_nY, NY_TERMS-1);
         return 5;
     }
@@ -108,42 +108,42 @@
     }
     // Verify the terms are properly set after allocation
-    if (myPD->x->nX != NX_TERMS) {
-        psError(PS_ERR_UNKNOWN,true,"myPD->x->nX is %d, should be %d",
-                myPD->x->nX, NX_TERMS);
+    if ((1 + myPD->x->COOL_4D_nX) != NX_TERMS) {
+        psError(PS_ERR_UNKNOWN,true,"myPD->x->COOL_4D_nX is %d, should be %d",
+                myPD->x->COOL_4D_nX, NX_TERMS-1);
         return 2;
     }
-    if (myPD->y->nX != NX_TERMS) {
-        psError(PS_ERR_UNKNOWN,true,"myPD->y->nX is %d, should be %d",
-                myPD->y->nX, NX_TERMS);
+    if ((1 + myPD->y->COOL_4D_nX) != NX_TERMS) {
+        psError(PS_ERR_UNKNOWN,true,"myPD->y->COOL_4D_nX is %d, should be %d",
+                myPD->y->COOL_4D_nX, NX_TERMS-1);
         return 3;
     }
-    if (myPD->x->nY != NY_TERMS) {
-        psError(PS_ERR_UNKNOWN,true,"myPD->x->nY is %d, should be %d",
-                myPD->x->nY, NY_TERMS);
+    if ((1 + myPD->x->COOL_4D_nY) != NY_TERMS) {
+        psError(PS_ERR_UNKNOWN,true,"myPD->x->COOL_4D_nY is %d, should be %d",
+                myPD->x->COOL_4D_nY, NY_TERMS-1);
         return 4;
     }
-    if (myPD->y->nY != NY_TERMS) {
-        psError(PS_ERR_UNKNOWN,true,"myPD->y->nY is %d, should be %d",
-                myPD->y->nY, NY_TERMS);
+    if ((1 + myPD->y->COOL_4D_nY) != NY_TERMS) {
+        psError(PS_ERR_UNKNOWN,true,"myPD->y->COOL_4D_nY is %d, should be %d",
+                myPD->y->COOL_4D_nY, NY_TERMS-1);
         return 5;
     }
-    if (myPD->x->nZ != NZ_TERMS) {
-        psError(PS_ERR_UNKNOWN,true,"myPD->x->nZ is %d, should be %d",
-                myPD->x->nZ, NZ_TERMS);
+    if ((1 + myPD->x->COOL_4D_nZ) != NZ_TERMS) {
+        psError(PS_ERR_UNKNOWN,true,"myPD->x->COOL_4D_nZ is %d, should be %d",
+                myPD->x->COOL_4D_nX, NZ_TERMS-1);
         return 6;
     }
-    if (myPD->y->nZ != NZ_TERMS) {
-        psError(PS_ERR_UNKNOWN,true,"myPD->y->nZ is %d, should be %d",
-                myPD->y->nZ, NZ_TERMS);
+    if ((1 + myPD->y->COOL_4D_nZ) != NZ_TERMS) {
+        psError(PS_ERR_UNKNOWN,true,"myPD->y->COOL_4D_nZ is %d, should be %d",
+                myPD->y->COOL_4D_nZ, NZ_TERMS-1);
         return 7;
     }
-    if (myPD->x->nT != NT_TERMS) {
-        psError(PS_ERR_UNKNOWN,true,"myPD->x->nT is %d, should be %d",
-                myPD->x->nT, NT_TERMS);
+    if ((1 + myPD->x->COOL_4D_nT) != NT_TERMS) {
+        psError(PS_ERR_UNKNOWN,true,"myPD->x->COOL_4D_nT is %d, should be %d",
+                myPD->x->COOL_4D_nT, NT_TERMS-1);
         return 8;
     }
-    if (myPD->y->nT != NT_TERMS) {
-        psError(PS_ERR_UNKNOWN,true,"myPD->y->nT is %d, should be %d",
-                myPD->y->nT, NT_TERMS);
+    if ((1 + myPD->y->COOL_4D_nT) != NT_TERMS) {
+        psError(PS_ERR_UNKNOWN,true,"myPD->y->COOL_4D_nT is %d, should be %d",
+                myPD->y->COOL_4D_nT, NT_TERMS-1);
         return 9;
     }
Index: /trunk/psLib/test/math/tst_psFunc00.c
===================================================================
--- /trunk/psLib/test/math/tst_psFunc00.c	(revision 5089)
+++ /trunk/psLib/test/math/tst_psFunc00.c	(revision 5090)
@@ -14,6 +14,6 @@
 *    orders are created.
 * 
-*    @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
-*    @date $Date: 2005-08-08 21:44:09 $
+*    @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
+*    @date $Date: 2005-09-22 02:47:16 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -63,7 +63,7 @@
     }
     // Verify polynomial structure members set properly
-    if(my1DPoly->n != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my1DPoly->n, ORDER);
+    if(my1DPoly->COOL_1D_n != ORDER) {
+        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
+                my1DPoly->COOL_1D_n, ORDER);
         return 2;
     }
@@ -73,5 +73,5 @@
         return 3;
     }
-    for(psS32 i = 0; i < ORDER; i++) {
+    for(psS32 i = 0; i < ORDER+1; i++) {
         if(my1DPoly->coeff[i] != 0.0) {
             psError(PS_ERR_UNKNOWN,true,"Coeff[%d] %lg not as expected %lg",
@@ -115,13 +115,13 @@
     }
     // Verify polynomial structure members set properly
-    if(my2DPoly->nX != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my2DPoly->nX, ORDER);
+    if(my2DPoly->COOL_2D_nX != ORDER) {
+        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
+                my2DPoly->COOL_2D_nX, ORDER);
         return 2;
     }
     // Verify polynomial structure members set properly
-    if(my2DPoly->nY != ORDER+1) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my2DPoly->nY, ORDER+1);
+    if(my2DPoly->COOL_2D_nY != ORDER+1) {
+        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
+                my2DPoly->COOL_2D_nY, ORDER+1);
         return 3;
     }
@@ -131,6 +131,6 @@
         return 4;
     }
-    for(psS32 i = 0; i < ORDER; i++) {
-        for(psS32 j = 0; j < ORDER+1; j++) {
+    for(psS32 i = 0; i < ORDER+1; i++) {
+        for(psS32 j = 0; j < ORDER+2; j++) {
             if(my2DPoly->coeff[i][j] != 0.0) {
                 psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d] %lg not as expected %lg",
@@ -181,19 +181,19 @@
     }
     // Verify polynomial structure members set properly
-    if(my3DPoly->nX != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my3DPoly->nX, ORDER);
+    if(my3DPoly->COOL_3D_nX != ORDER) {
+        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
+                my3DPoly->COOL_3D_nX, ORDER);
         return 2;
     }
     // Verify polynomial structure members set properly
-    if(my3DPoly->nY != ORDER+1) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my3DPoly->nY, ORDER+1);
+    if(my3DPoly->COOL_3D_nY != ORDER+1) {
+        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
+                my3DPoly->COOL_3D_nY, ORDER+1);
         return 3;
     }
     // Verify polynomial structure members set properly
-    if(my3DPoly->nZ != ORDER+2) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my3DPoly->nZ, ORDER+2);
+    if(my3DPoly->COOL_3D_nZ != ORDER+2) {
+        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
+                my3DPoly->COOL_3D_nZ, ORDER+2);
         return 4;
     }
@@ -203,7 +203,7 @@
         return 5;
     }
-    for(psS32 i = 0; i < ORDER; i++) {
-        for(psS32 j = 0; j < ORDER+1; j++) {
-            for(psS32 k = 0; k < ORDER+2; k++) {
+    for(psS32 i = 0; i < ORDER+1; i++) {
+        for(psS32 j = 0; j < ORDER+2; j++) {
+            for(psS32 k = 0; k < ORDER+3; k++) {
                 if(my3DPoly->coeff[i][j][k] != 0.0) {
                     psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d] %lg not as expected %lg",
@@ -254,5 +254,5 @@
 
     // Allocate polynomial
-    my4DPoly = psPolynomial4DAlloc(ORDER+3,ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_ORD);
+    my4DPoly = psPolynomial4DAlloc(ORDER,ORDER+1,ORDER+2,ORDER+3,PS_POLYNOMIAL_ORD);
     // Verify structure allocated
     if(my4DPoly == NULL) {
@@ -261,25 +261,25 @@
     }
     // Verify polynomial structure members set properly
-    if(my4DPoly->nY != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DPoly->nY, ORDER);
+    if(my4DPoly->COOL_4D_nX != ORDER) {
+        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
+                my4DPoly->COOL_4D_nX, ORDER);
         return 2;
     }
     // Verify polynomial structure members set properly
-    if(my4DPoly->nZ != ORDER+1) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DPoly->nZ, ORDER+1);
+    if(my4DPoly->COOL_4D_nY != ORDER+1) {
+        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
+                my4DPoly->COOL_4D_nX, ORDER+1);
         return 3;
     }
     // Verify polynomial structure members set properly
-    if(my4DPoly->nT != ORDER+2) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DPoly->nT, ORDER+2);
+    if(my4DPoly->COOL_4D_nZ != ORDER+2) {
+        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
+                my4DPoly->COOL_4D_nZ, ORDER+2);
         return 4;
     }
     // Verify polynomial structure members set properly
-    if(my4DPoly->nX != ORDER+3) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DPoly->nX, ORDER+3);
+    if(my4DPoly->COOL_4D_nT != ORDER+3) {
+        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
+                my4DPoly->COOL_4D_nT, ORDER+3);
         return 5;
     }
@@ -289,8 +289,8 @@
         return 6;
     }
-    for(psS32 i = 0; i < ORDER+3; i++) {
-        for(psS32 j = 0; j < ORDER; j++) {
-            for(psS32 k = 0; k < ORDER+1; k++) {
-                for(psS32 l = 0; l < ORDER+2; l++) {
+    for(psS32 i = 0; i < ORDER+1; i++) {
+        for(psS32 j = 0; j < ORDER+2; j++) {
+            for(psS32 k = 0; k < ORDER+3; k++) {
+                for(psS32 l = 0; l < ORDER+4; l++) {
                     if(my4DPoly->coeff[i][j][k][l] != 0.0) {
                         psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d][%d] %lg not as expected %lg",
Index: /trunk/psLib/test/math/tst_psFunc08.c
===================================================================
--- /trunk/psLib/test/math/tst_psFunc08.c	(revision 5089)
+++ /trunk/psLib/test/math/tst_psFunc08.c	(revision 5090)
@@ -4,6 +4,6 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.3 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-08-08 21:44:09 $
+*  @version  $Revision: 1.4 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-09-22 02:47:16 $
 *
 *  XXX: Probably should test single- and multi-dimensional polynomials in
@@ -59,6 +59,6 @@
 
     // Allocate polynomial structure
-    psPolynomial1D*  polyOrd = psPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_ORD);
-    psPolynomial1D*  polyCheb = psPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_CHEB);
+    psPolynomial1D*  polyOrd = psPolynomial1DAlloc(TERMS-1, PS_POLYNOMIAL_ORD);
+    psPolynomial1D*  polyCheb = psPolynomial1DAlloc(TERMS-1, PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -87,5 +87,5 @@
 
     // Allocate polynomial with invalid type
-    polyOrd = psPolynomial1DAlloc(TERMS, 99);
+    polyOrd = psPolynomial1DAlloc(TERMS-1, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
@@ -104,6 +104,6 @@
 {
     // Allocate polynomial
-    psPolynomial1D* polyOrd = psPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_ORD);
-    psPolynomial1D* polyCheb = psPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial1D* polyOrd = psPolynomial1DAlloc(TERMS-1,PS_POLYNOMIAL_ORD);
+    psPolynomial1D* polyCheb = psPolynomial1DAlloc(TERMS-1,PS_POLYNOMIAL_CHEB);
 
     // Set polynomial members
Index: /trunk/psLib/test/math/tst_psFunc09.c
===================================================================
--- /trunk/psLib/test/math/tst_psFunc09.c	(revision 5089)
+++ /trunk/psLib/test/math/tst_psFunc09.c	(revision 5090)
@@ -4,6 +4,6 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.3 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-08-08 21:44:09 $
+*  @version  $Revision: 1.4 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-09-22 02:47:16 $
 *
 * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -88,6 +88,6 @@
  
     // Allocate polynomial structure
-    psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
-    psPolynomial2D*  polyCheb = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_CHEB);
+    psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
+    psPolynomial2D*  polyCheb = psPolynomial2DAlloc(TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -118,5 +118,5 @@
  
     // Allocate polynomial with invalid type
-    polyOrd = psPolynomial2DAlloc(TERMS, TERMS, 99);
+    polyOrd = psPolynomial2DAlloc(TERMS-1, TERMS-1, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
@@ -138,6 +138,6 @@
 
     // Allocate polynomial structure
-    psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
-    psPolynomial2D*  polyCheb = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_CHEB);
+    psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
+    psPolynomial2D*  polyCheb = psPolynomial2DAlloc(TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -168,5 +168,5 @@
 
     // Allocate polynomial with invalid type
-    polyOrd = psPolynomial2DAlloc(TERMS, TERMS, 99);
+    polyOrd = psPolynomial2DAlloc(TERMS-1, TERMS-1, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
@@ -184,6 +184,6 @@
 {
     // Allocate polynomial
-    psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS-1,TERMS-1,PS_POLYNOMIAL_ORD);
+    psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS-1,TERMS-1,PS_POLYNOMIAL_CHEB);
  
     // Set polynomial members
@@ -297,6 +297,6 @@
 {
     // Allocate polynomial
-    psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS-1,TERMS-1,PS_POLYNOMIAL_ORD);
+    psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS-1,TERMS-1,PS_POLYNOMIAL_CHEB);
 
     // Set polynomial members
Index: /trunk/psLib/test/math/tst_psFunc10.c
===================================================================
--- /trunk/psLib/test/math/tst_psFunc10.c	(revision 5089)
+++ /trunk/psLib/test/math/tst_psFunc10.c	(revision 5090)
@@ -4,6 +4,6 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.3 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-08-08 21:44:09 $
+*  @version  $Revision: 1.4 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-09-22 02:47:16 $
 *
 * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -139,6 +139,6 @@
  
     // Allocate polynomial structure
-    psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, PS_POLYNOMIAL_ORD);
-    psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS, TERMS, TERMS, PS_POLYNOMIAL_CHEB);
+    psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
+    psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -173,5 +173,5 @@
  
     // Allocate polynomial with invalid type
-    polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
+    polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
@@ -193,6 +193,6 @@
 
     // Allocate polynomial structure
-    psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_ORD);
+    psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -227,5 +227,5 @@
 
     // Allocate polynomial with invalid type
-    polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
+    polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
@@ -243,6 +243,6 @@
 {
     // Allocate polynomial
-    psPolynomial3D* polyOrd  = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial3D* polyOrd  = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_ORD);
+    psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_CHEB);
  
     // Set polynomial members
@@ -378,6 +378,6 @@
 {
     // Allocate polynomial
-    psPolynomial3D* polyOrd = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial3D* polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_ORD);
+    psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_CHEB);
 
     // Set polynomial members
Index: /trunk/psLib/test/math/tst_psFunc11.c
===================================================================
--- /trunk/psLib/test/math/tst_psFunc11.c	(revision 5089)
+++ /trunk/psLib/test/math/tst_psFunc11.c	(revision 5090)
@@ -4,6 +4,6 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.3 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-08-08 21:44:09 $
+*  @version  $Revision: 1.4 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-09-22 02:47:16 $
 *
 * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -381,6 +381,6 @@
  
     // Allocate polynomial structure
-    psPolynomial4D*  polyOrd  = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial4D*  polyOrd  = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
+    psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -417,5 +417,5 @@
  
     // Allocate polynomial with invalid type
-    polyOrd = psPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
+    polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
@@ -437,6 +437,6 @@
 
     // Allocate polynomial structure
-    psPolynomial4D*  polyOrd = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial4D*  polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
+    psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -473,5 +473,5 @@
 
     // Allocate polynomial with invalid type
-    polyOrd = psPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
+    polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
@@ -489,6 +489,6 @@
 {
     // Allocate polynomial
-    psPolynomial4D* polyOrd  = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial4D* polyOrd  = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
+    psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
  
     // Set polynomial members
@@ -646,6 +646,6 @@
 {
     // Allocate polynomial
-    psPolynomial4D* polyOrd = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial4D* polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
+    psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
 
     // Set polynomial members
Index: /trunk/psLib/test/math/tst_psMinimize04.c
===================================================================
--- /trunk/psLib/test/math/tst_psMinimize04.c	(revision 5089)
+++ /trunk/psLib/test/math/tst_psMinimize04.c	(revision 5090)
@@ -45,5 +45,5 @@
     double actualData;
 
-    psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER+1, POLY_ORDER+1, PS_POLYNOMIAL_ORD);
+    psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER, POLY_ORDER, PS_POLYNOMIAL_ORD);
     psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
     psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
Index: /trunk/psLib/test/math/tst_psMinimize04_F32.c
===================================================================
--- /trunk/psLib/test/math/tst_psMinimize04_F32.c	(revision 5089)
+++ /trunk/psLib/test/math/tst_psMinimize04_F32.c	(revision 5090)
@@ -45,5 +45,5 @@
     float actualData;
 
-    myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD);
+    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
     x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
     y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
@@ -114,5 +114,5 @@
     float actualData;
 
-    myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD);
+    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
     x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
     y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
@@ -179,5 +179,5 @@
     float actualData;
 
-    myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD);
+    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
     y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
 
Index: /trunk/psLib/test/math/tst_psMinimize04b.c
===================================================================
--- /trunk/psLib/test/math/tst_psMinimize04b.c	(revision 5089)
+++ /trunk/psLib/test/math/tst_psMinimize04b.c	(revision 5090)
@@ -38,5 +38,5 @@
     psS32 memLeaks = 0;
 
-    myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB);
+    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
     x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
@@ -109,5 +109,5 @@
     psS32 memLeaks = 0;
 
-    myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB);
+    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
     x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
@@ -172,5 +172,5 @@
     psS32 memLeaks = 0;
 
-    myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB);
+    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
     x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
Index: /trunk/psLib/test/math/tst_psMinimize04b_F32.c
===================================================================
--- /trunk/psLib/test/math/tst_psMinimize04b_F32.c	(revision 5089)
+++ /trunk/psLib/test/math/tst_psMinimize04b_F32.c	(revision 5090)
@@ -38,5 +38,5 @@
     psS32 memLeaks = 0;
 
-    myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB);
+    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
     x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
     y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
@@ -109,5 +109,5 @@
     psS32 memLeaks = 0;
 
-    myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB);
+    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
     x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
     y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
@@ -172,5 +172,5 @@
     psS32 memLeaks = 0;
 
-    myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB);
+    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
     x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
     y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
Index: /trunk/psLib/test/math/tst_psMinimizeVector2D_F32.c
===================================================================
--- /trunk/psLib/test/math/tst_psMinimizeVector2D_F32.c	(revision 5089)
+++ /trunk/psLib/test/math/tst_psMinimizeVector2D_F32.c	(revision 5090)
@@ -45,5 +45,5 @@
     double actualData;
 
-    psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER+1, POLY_ORDER+1, PS_POLYNOMIAL_ORD);
+    psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER, POLY_ORDER, PS_POLYNOMIAL_ORD);
     psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
     psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
Index: /trunk/psLib/test/math/tst_psMinimizeVector2D_F64.c
===================================================================
--- /trunk/psLib/test/math/tst_psMinimizeVector2D_F64.c	(revision 5089)
+++ /trunk/psLib/test/math/tst_psMinimizeVector2D_F64.c	(revision 5090)
@@ -45,5 +45,5 @@
     double actualData;
 
-    psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER+1, POLY_ORDER+1, PS_POLYNOMIAL_ORD);
+    psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER, POLY_ORDER, PS_POLYNOMIAL_ORD);
     psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
     psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);