Index: unk/psLib/test/math/tst_psFunc00.c
===================================================================
--- /trunk/psLib/test/math/tst_psFunc00.c	(revision 6193)
+++ 	(revision )
@@ -1,346 +1,0 @@
-/** tst_Func00.c
-*
-*    This routine must ensure that the psPolynomial structures are
-*    allocated and deallocated by the psPolynomialXXXlloc() procedures.
-*    It also calls the various psPolynomialXXXEval() procedures.
-*
-*    The F32 and F64 polynomials are tested for all orders (1 - 4) and for
-*    both ordinary and chebyshev polynomials.
-*
-*    NOTE: This test code requries the stdout file to verify that the results
-*    are good.
-*
-*    XXX: Modify these tests so that polynomials with a variety of different
-*    orders are created.
-* 
-*    XXX: Compare to FLT_EPSILON
-* 
-*    @version $Revision: 1.6 $  $Name: not supported by cvs2svn $
-*    @date $Date: 2005-10-12 21:02:20 $
-*
-*  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
-*
-*****************************************************************************/
-#include <stdio.h>
-#include "pslib_strict.h"
-#include "psTest.h"
-
-// Defines
-#define ORDER    3
-
-static psS32 testPolynomial1DAlloc(void);
-static psS32 testPolynomial2DAlloc(void);
-static psS32 testPolynomial3DAlloc(void);
-static psS32 testPolynomial4DAlloc(void);
-
-testDescription tests[] = {
-                              {testPolynomial1DAlloc,578,"psPolynomial1DAlloc",0,false},
-                              {testPolynomial2DAlloc,578,"psPolynomial2DAlloc",0,false},
-                              {testPolynomial3DAlloc,578,"psPolynomial3DAlloc",0,false},
-                              {testPolynomial4DAlloc,578,"psPolynomial4DAlloc",0,false},
-                              {NULL}
-                          };
-
-
-psS32 main(psS32 argc, char* argv[])
-{
-    psLogSetFormat("HLNM");
-    psLogSetLevel(PS_LOG_INFO);
-
-    return !runTestSuite(stderr,"psPolynomialXD", tests, argc, argv);
-}
-
-
-// This test will allocate a 1D polynomial and verify the structure allocated
-psS32 testPolynomial1DAlloc(void)
-{
-    psPolynomial1D*  my1DPoly  = NULL;
-
-    // Allocate polynomial
-    my1DPoly = psPolynomial1DAlloc(ORDER,PS_POLYNOMIAL_ORD);
-    // Verify structure allocated
-    if(my1DPoly == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
-        return 1;
-    }
-    // Verify polynomial structure members set properly
-    if(my1DPoly->nX != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my1DPoly->nX, ORDER);
-        return 2;
-    }
-    if(my1DPoly->type != PS_POLYNOMIAL_ORD) {
-        psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
-                my1DPoly->type, PS_POLYNOMIAL_ORD);
-        return 3;
-    }
-    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",
-                    i, my1DPoly->coeff[i], 0.0);
-            return 4;
-        }
-        if(my1DPoly->coeffErr[i] != 0.0) {
-            psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d] %lg not as expected %lg",
-                    i, my1DPoly->coeffErr[i], 0.0);
-            return 5;
-        }
-        if(my1DPoly->mask[i] != 0) {
-            psError(PS_ERR_UNKNOWN,true,"Mask[%d] %d not as expected %d",
-                    i, my1DPoly->mask[i], 0);
-            return 6;
-        }
-    }
-    psFree(my1DPoly);
-
-    /*    // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psPolynomial1DAlloc(-1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 7;
-        }
-    */
-    return 0;
-}
-
-// This test will allocate a 2D polynomial and verify the structure allocated
-psS32 testPolynomial2DAlloc(void)
-{
-    psPolynomial2D* my2DPoly = NULL;
-
-    // Allocate polynomial
-    my2DPoly = psPolynomial2DAlloc(ORDER,ORDER+1,PS_POLYNOMIAL_ORD);
-    // Verify structure allocated
-    if(my2DPoly == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
-        return 1;
-    }
-    // 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);
-        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);
-        return 3;
-    }
-    if(my2DPoly->type != PS_POLYNOMIAL_ORD) {
-        psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
-                my2DPoly->type, PS_POLYNOMIAL_ORD);
-        return 4;
-    }
-
-    for(psS32 i = 0; i < ORDER+1; i++) {
-        for(psS32 j = 0; j < ORDER+2; j++) {
-            if(fabs(my2DPoly->coeff[i][j]) > FLT_EPSILON) {
-                psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d] %lg not as expected %lg",
-                        i, j, my2DPoly->coeff[i][j], 0.0);
-                return 5;
-            }
-            if(my2DPoly->coeffErr[i][j] != 0.0) {
-                psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d] %lg not as expected %lg",
-                        i, j, my2DPoly->coeffErr[i][j], 0.0);
-                return 6;
-            }
-            if(my2DPoly->mask[i][j] != 0) {
-                psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d] %d not as expected %d",
-                        i, j, my2DPoly->mask[i][j], 0);
-                return 7;
-            }
-        }
-    }
-    psFree(my2DPoly);
-
-    /*    // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psPolynomial2DAlloc(-1,1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 8;
-        }
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psPolynomial2DAlloc(1,-1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 9;
-        }
-    */
-    return 0;
-}
-
-// This test will allocate a 3D polynomial and verify the structure allocated
-psS32 testPolynomial3DAlloc(void)
-{
-    psPolynomial3D* my3DPoly = NULL;
-
-    // Allocate polynomial
-    my3DPoly = psPolynomial3DAlloc(ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_ORD);
-    // Verify structure allocated
-    if(my3DPoly == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
-        return 1;
-    }
-    // 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);
-        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);
-        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);
-        return 4;
-    }
-    if(my3DPoly->type != PS_POLYNOMIAL_ORD) {
-        psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
-                my3DPoly->type, PS_POLYNOMIAL_ORD);
-        return 5;
-    }
-    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",
-                            i, j, k, my3DPoly->coeff[i][j][k], 0.0);
-                    return 6;
-                }
-                if(my3DPoly->coeffErr[i][j][k] != 0.0) {
-                    psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d][%d] %lg not as expected %lg",
-                            i, j, k, my3DPoly->coeffErr[i][j][k], 0.0);
-                    return 7;
-                }
-                if(my3DPoly->mask[i][j][k] != 0) {
-                    psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d] %d not as expected %d",
-                            i, j, k, my3DPoly->mask[i][j][k], 0);
-                    return 8;
-                }
-            }
-        }
-    }
-    psFree(my3DPoly);
-
-    /*    // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psPolynomial3DAlloc(-1,1,1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 9;
-        }
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psPolynomial3DAlloc(1,-1,1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 10;
-        }
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psPolynomial3DAlloc(1,1,-1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 11;
-        }
-    */
-    return 0;
-}
-
-// This test will allocate a 4D polynomial and verify the structure allocated
-psS32 testPolynomial4DAlloc(void)
-{
-    psPolynomial4D* my4DPoly = NULL;
-
-    // Allocate polynomial
-    my4DPoly = psPolynomial4DAlloc(ORDER,ORDER+1,ORDER+2,ORDER+3,PS_POLYNOMIAL_ORD);
-    // Verify structure allocated
-    if(my4DPoly == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
-        return 1;
-    }
-    // Verify polynomial structure members set properly
-    if(my4DPoly->nX != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DPoly->nX, ORDER);
-        return 2;
-    }
-    // Verify polynomial structure members set properly
-    if(my4DPoly->nY != ORDER+1) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DPoly->nX, ORDER+1);
-        return 3;
-    }
-    // Verify polynomial structure members set properly
-    if(my4DPoly->nZ != ORDER+2) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DPoly->nZ, ORDER+2);
-        return 4;
-    }
-    // Verify polynomial structure members set properly
-    if(my4DPoly->nT != ORDER+3) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DPoly->nT, ORDER+3);
-        return 5;
-    }
-    if(my4DPoly->type != PS_POLYNOMIAL_ORD) {
-        psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
-                my4DPoly->type, PS_POLYNOMIAL_ORD);
-        return 6;
-    }
-    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",
-                                i, j, k, l, my4DPoly->coeff[i][j][k][l], 0.0);
-                        return 7;
-                    }
-                    if(my4DPoly->coeffErr[i][j][k][l] != 0.0) {
-                        psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d][%d][l] %lg not as expected %lg",
-                                i, j, k, l, my4DPoly->coeffErr[i][j][k][l], 0.0);
-                        return 8;
-                    }
-                    if(my4DPoly->mask[i][j][k][l] != 0) {
-                        psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d][%d][%d] %d not as expected %d",
-                                i, j, k, l, my4DPoly->mask[i][j][k][l], 0);
-                        return 9;
-                    }
-                }
-            }
-        }
-    }
-    psFree(my4DPoly);
-
-    /*    // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psPolynomial4DAlloc(-1,1,1,1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 10;
-        }
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psPolynomial4DAlloc(1,-1,1,1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 11;
-        }
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psPolynomial4DAlloc(1,1,-1,1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 12;
-        }
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psPolynomial4DAlloc(1,1,1,-1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 13;
-        }
-    */
-    return 0;
-}
-
Index: /trunk/psLib/test/math/tst_psPolyFit1D.c
===================================================================
--- /trunk/psLib/test/math/tst_psPolyFit1D.c	(revision 6193)
+++ /trunk/psLib/test/math/tst_psPolyFit1D.c	(revision 6194)
@@ -350,5 +350,5 @@
     psTraceSetLevel("VectorFitPolynomial1DOrd", 0);
     psTraceSetLevel("VectorFitPolynomial1DCheb", 0);
-    psTraceSetLevel("vectorFitPolynomial1DCheb", 10);
+    psTraceSetLevel("vectorFitPolynomial1DCheb", 0);
     psTraceSetLevel("vectorFitPolynomial1DChebSlow", 0);
     psTraceSetLevel("vectorFitPolynomial1DChebFast", 0);
@@ -505,8 +505,4 @@
     testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_F_F64 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false);
 
-
-    //    testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true);
-    //    testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true);
-
     printFooter(stdout, "psMinimize functions: 1D Polynomial Fitting Functions", "", testStatus);
 }