Index: trunk/psLib/test/math/tst_psFunc00.c
===================================================================
--- trunk/psLib/test/math/tst_psFunc00.c	(revision 4580)
+++ trunk/psLib/test/math/tst_psFunc00.c	(revision 4581)
@@ -4,19 +4,19 @@
 *    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.
-* 
-*    @version $Revision: 1.1 $  $Name: not supported by cvs2svn $
-*    @date $Date: 2005-07-13 02:47:00 $
+*
+*    @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
+*    @date $Date: 2005-07-20 01:21:13 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
-*   
+*
 *****************************************************************************/
 #include <stdio.h>
@@ -31,8 +31,4 @@
 static psS32 testPolynomial3DAlloc(void);
 static psS32 testPolynomial4DAlloc(void);
-static psS32 testDPolynomial1DAlloc(void);
-static psS32 testDPolynomial2DAlloc(void);
-static psS32 testDPolynomial3DAlloc(void);
-static psS32 testDPolynomial4DAlloc(void);
 
 testDescription tests[] = {
@@ -41,8 +37,4 @@
                               {testPolynomial3DAlloc,578,"psPolynomial3DAlloc",0,false},
                               {testPolynomial4DAlloc,578,"psPolynomial4DAlloc",0,false},
-                              {testDPolynomial1DAlloc,579,"psDPolynomial1DAlloc",0,false},
-                              {testDPolynomial2DAlloc,579,"psDPolynomial2DAlloc",0,false},
-                              {testDPolynomial3DAlloc,579,"psDPolynomial3DAlloc",0,false},
-                              {testDPolynomial4DAlloc,579,"psDPolynomial4DAlloc",0,false},
                               {NULL}
                           };
@@ -109,56 +101,4 @@
 }
 
-// This test will allocate a 1D polynomial and verify the structure allocated
-psS32 testDPolynomial1DAlloc(void)
-{
-    psDPolynomial1D*  my1DDPoly  = NULL;
-
-    // Allocate polynomial
-    my1DDPoly = psDPolynomial1DAlloc(ORDER,PS_POLYNOMIAL_CHEB);
-    // Verify structure allocated
-    if(my1DDPoly == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
-        return 1;
-    }
-    // Verify polynomial structure members set properly
-    if(my1DDPoly->n != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my1DDPoly->n, ORDER);
-        return 2;
-    }
-    if(my1DDPoly->type != PS_POLYNOMIAL_CHEB) {
-        psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
-                my1DDPoly->type, PS_POLYNOMIAL_CHEB);
-        return 3;
-    }
-    for(psS32 i = 0; i < ORDER; i++) {
-        if(my1DDPoly->coeff[i] != 0.0) {
-            psError(PS_ERR_UNKNOWN,true,"Coeff[%d] %lg not as expected %lg",
-                    i, my1DDPoly->coeff[i], 0.0);
-            return 4;
-        }
-        if(my1DDPoly->coeffErr[i] != 0.0) {
-            psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d] %lg not as expected %lg",
-                    i, my1DDPoly->coeffErr[i], 0.0);
-            return 5;
-        }
-        if(my1DDPoly->mask[i] != 0) {
-            psError(PS_ERR_UNKNOWN,true,"Mask[%d] %d not as expected %d",
-                    i, my1DDPoly->mask[i], 0);
-            return 6;
-        }
-    }
-    psFree(my1DDPoly);
-
-    /*    // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial1DAlloc(-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)
@@ -220,70 +160,4 @@
         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 2D polynomial and verify the structure allocated
-psS32 testDPolynomial2DAlloc(void)
-{
-    psDPolynomial2D* my2DDPoly = NULL;
-
-    // Allocate polynomial
-    my2DDPoly = psDPolynomial2DAlloc(ORDER,ORDER+1,PS_POLYNOMIAL_CHEB);
-    // Verify structure allocated
-    if(my2DDPoly == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
-        return 1;
-    }
-    // Verify polynomial structure members set properly
-    if(my2DDPoly->nX != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my2DDPoly->nX, ORDER);
-        return 2;
-    }
-    // Verify polynomial structure members set properly
-    if(my2DDPoly->nY != ORDER+1) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my2DDPoly->nY, ORDER+1);
-        return 3;
-    }
-    if(my2DDPoly->type != PS_POLYNOMIAL_CHEB) {
-        psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
-                my2DDPoly->type, PS_POLYNOMIAL_ORD);
-        return 4;
-    }
-    for(psS32 i = 0; i < ORDER; i++) {
-        for(psS32 j = 0; j < ORDER+1; j++) {
-            if(my2DDPoly->coeff[i][j] != 0.0) {
-                psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d] %lg not as expected %lg",
-                        i, j, my2DDPoly->coeff[i][j], 0.0);
-                return 5;
-            }
-            if(my2DDPoly->coeffErr[i][j] != 0.0) {
-                psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d] %lg not as expected %lg",
-                        i, j, my2DDPoly->coeffErr[i][j], 0.0);
-                return 6;
-            }
-            if(my2DDPoly->mask[i][j] != 0) {
-                psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d] %d not as expected %d",
-                        i, j, my2DDPoly->mask[i][j], 0);
-                return 7;
-            }
-        }
-    }
-    psFree(my2DDPoly);
-    /*
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial2DAlloc(-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(psDPolynomial2DAlloc(1,-1,PS_POLYNOMIAL_ORD) != NULL) {
             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
             return 9;
@@ -366,84 +240,4 @@
         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 3D polynomial and verify the structure allocated
-psS32 testDPolynomial3DAlloc(void)
-{
-    psDPolynomial3D* my3DDPoly = NULL;
-
-    // Allocate polynomial
-    my3DDPoly = psDPolynomial3DAlloc(ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_CHEB);
-    // Verify structure allocated
-    if(my3DDPoly == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
-        return 1;
-    }
-    // Verify polynomial structure members set properly
-    if(my3DDPoly->nX != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my3DDPoly->nX, ORDER);
-        return 2;
-    }
-    // Verify polynomial structure members set properly
-    if(my3DDPoly->nY != ORDER+1) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my3DDPoly->nY, ORDER+1);
-        return 3;
-    }
-    // Verify polynomial structure members set properly
-    if(my3DDPoly->nZ != ORDER+2) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my3DDPoly->nZ, ORDER+2);
-        return 4;
-    }
-    if(my3DDPoly->type != PS_POLYNOMIAL_CHEB) {
-        psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
-                my3DDPoly->type, PS_POLYNOMIAL_ORD);
-        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++) {
-                if(my3DDPoly->coeff[i][j][k] != 0.0) {
-                    psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d] %lg not as expected %lg",
-                            i, j, k, my3DDPoly->coeff[i][j][k], 0.0);
-                    return 6;
-                }
-                if(my3DDPoly->coeffErr[i][j][k] != 0.0) {
-                    psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d][%d] %lg not as expected %lg",
-                            i, j, k, my3DDPoly->coeffErr[i][j][k], 0.0);
-                    return 7;
-                }
-                if(my3DDPoly->mask[i][j][k] != 0) {
-                    psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d] %d not as expected %d",
-                            i, j, k, my3DDPoly->mask[i][j][k], 0);
-                    return 8;
-                }
-            }
-        }
-    }
-    psFree(my3DDPoly);
-
-    /*    // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial3DAlloc(-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(psDPolynomial3DAlloc(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(psDPolynomial3DAlloc(1,1,-1,PS_POLYNOMIAL_ORD) != NULL) {
             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
             return 11;
@@ -547,96 +341,2 @@
 }
 
-// This test will allocate a 4D polynomial and verify the structure allocated
-psS32 testDPolynomial4DAlloc(void)
-{
-    psDPolynomial4D* my4DDPoly = NULL;
-
-    // Allocate polynomial
-    my4DDPoly = psDPolynomial4DAlloc(ORDER+3,ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_ORD);
-    // Verify structure allocated
-    if(my4DDPoly == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
-        return 1;
-    }
-    // Verify polynomial structure members set properly
-    if(my4DDPoly->nY != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DDPoly->nY, ORDER);
-        return 2;
-    }
-    // Verify polynomial structure members set properly
-    if(my4DDPoly->nZ != ORDER+1) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DDPoly->nZ, ORDER+1);
-        return 3;
-    }
-    // Verify polynomial structure members set properly
-    if(my4DDPoly->nT != ORDER+2) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DDPoly->nT, ORDER+2);
-        return 4;
-    }
-    // Verify polynomial structure members set properly
-    if(my4DDPoly->nX != ORDER+3) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DDPoly->nX, ORDER+3);
-        return 5;
-    }
-    if(my4DDPoly->type != PS_POLYNOMIAL_ORD) {
-        psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
-                my4DDPoly->type, PS_POLYNOMIAL_ORD);
-        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++) {
-                    if(my4DDPoly->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, my4DDPoly->coeff[i][j][k][l], 0.0);
-                        return 7;
-                    }
-                    if(my4DDPoly->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, my4DDPoly->coeffErr[i][j][k][l], 0.0);
-                        return 8;
-                    }
-                    if(my4DDPoly->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, my4DDPoly->mask[i][j][k][l], 0);
-                        return 9;
-                    }
-                }
-            }
-        }
-    }
-    psFree(my4DDPoly);
-
-    /*    // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial4DAlloc(-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(psDPolynomial4DAlloc(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(psDPolynomial4DAlloc(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(psDPolynomial4DAlloc(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_psFunc08.c
===================================================================
--- trunk/psLib/test/math/tst_psFunc08.c	(revision 4580)
+++ trunk/psLib/test/math/tst_psFunc08.c	(revision 4581)
@@ -4,6 +4,6 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-07-13 02:47:00 $
+*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-07-20 01:21:13 $
 *
 *  XXX: Probably should test single- and multi-dimensional polynomials in
@@ -22,13 +22,9 @@
 
 static psS32 testPoly1DEval(void);
-static psS32 testDPoly1DEval(void);
 static psS32 testPoly1DEvalVector(void);
-static psS32 testDPoly1DEvalVector(void);
 
 testDescription tests[] = {
                               {testPoly1DEval,000,"psPolynomial1DEval",0,false},
-                              {testDPoly1DEval,000,"psDPolynomial1DEval",0,false},
                               {testPoly1DEvalVector,000,"psPolynomial1DEvalVector",0,false},
-                              {testDPoly1DEvalVector,000,"psDPolynomial1DEvalVector",0,false},
                               {NULL}
                           };
@@ -58,6 +54,6 @@
 psS32 testPoly1DEval(void)
 {
-    psF32  result;
-    psF32  resultCheb;
+    psF64  result;
+    psF64  resultCheb;
 
     // Allocate polynomial structure
@@ -103,51 +99,4 @@
 }
 
-// This test will verify operation of 1D polynomial evaluation
-psS32 testDPoly1DEval(void)
-{
-    psF64  result;
-    psF64  resultCheb;
-
-    // Allocate polynomial structure
-    psDPolynomial1D*  polyOrd = psDPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_ORD);
-    psDPolynomial1D*  polyCheb = psDPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_CHEB);
-    // Set polynomial members
-    for(psS32 i = 0; i < TERMS; i++) {
-        polyOrd->coeff[i] = Dpoly1DCoeff[i];
-        polyOrd->mask[i]  = poly1DMask[i];
-        polyCheb->coeff[i] = 1.0;
-        polyCheb->mask[i]  = poly1DMask[i];
-    }
-    // Evaluate test points and verify results
-    for(psS32 i = 0; i < TESTPOINTS; i++) {
-        result = psDPolynomial1DEval(polyOrd,Dpoly1DXValue[i]);
-        if(fabs(Dpoly1DXResult[i]-result) > ERROR_TOL ) {
-            psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
-                    result, Dpoly1DXResult[i]);
-            return i;
-        }
-        resultCheb = psDPolynomial1DEval(polyCheb,Dpoly1DXChebValue[i]);
-        if(fabs(Dpoly1DXChebResult[i]-resultCheb) > ERROR_TOL ) {
-            psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
-                    resultCheb, Dpoly1DXChebResult[i]);
-            return 5*i;
-        }
-    }
-    psFree(polyOrd);
-    psFree(polyCheb);
-
-    // Allocate polynomial with invalid type
-    polyOrd = psDPolynomial1DAlloc(TERMS, 99);
-    // Attempt to evaluation invalid polynomial type
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
-    result = psDPolynomial1DEval(polyOrd,0.0);
-    if ( !isnan(result) ) {
-        psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
-        return 20;
-    }
-    psFree(polyOrd);
-
-    return 0;
-}
 
 psS32 testPoly1DEvalVector(void)
@@ -156,95 +105,4 @@
     psPolynomial1D* polyOrd = psPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_ORD);
     psPolynomial1D* polyCheb = psPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_CHEB);
-
-    // Set polynomial members
-    for(psS32 i = 0; i < TERMS; i++) {
-        polyOrd->coeff[i] = poly1DCoeff[i];
-        polyOrd->mask[i]  = poly1DMask[i];
-        polyCheb->coeff[i] = 1.0;
-        polyCheb->mask[i]  = poly1DMask[i];
-    }
-
-    // Create input vectors
-    psVector* inputOrd = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
-    psVector* inputCheb = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
-    for(psS32 i = 0; i < TESTPOINTS; i++) {
-        inputOrd->data.F32[i] = poly1DXValue[i];
-        inputCheb->data.F32[i] = poly1DXChebValue[i];
-    }
-
-    // Evaluate the vectors
-    psVector* outputOrd = psPolynomial1DEvalVector(polyOrd, inputOrd);
-    if(outputOrd == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
-        return 1;
-    }
-    if(outputOrd->type.type != PS_TYPE_F32) {
-        psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
-                outputOrd->type.type, PS_TYPE_F32);
-        return 2;
-    }
-    psVector* outputCheb = psPolynomial1DEvalVector(polyCheb, inputCheb);
-    if(outputCheb == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
-        return 1;
-    }
-    if(outputCheb->type.type != PS_TYPE_F32) {
-        psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
-                outputCheb->type.type, PS_TYPE_F32);
-        return 2;
-    }
-
-    // Verify the results
-    for(psS32 i = 0; i < TESTPOINTS; i++) {
-        if(fabs(poly1DXResult[i]-outputOrd->data.F32[i]) > ERROR_TOL) {
-            psError(PS_ERR_UNKNOWN,true,"Result[%d] %g not equal to expected %g",
-                    i, outputOrd->data.F32[i], poly1DXResult[i]);
-            return i*5;
-        }
-        if(fabs(poly1DXChebResult[i]-outputCheb->data.F32[i]) > ERROR_TOL) {
-            psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %g not equal to expected %g",
-                    i, outputCheb->data.F32[i], poly1DXChebResult[i]);
-            return i*10;
-        }
-    }
-
-    // Attempt to invoke function with null polynomial
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
-    if(psPolynomial1DEvalVector(NULL, inputOrd) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
-        return 60;
-    }
-
-    // Attempt to invoke function with null input vector
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psPolynomial1DEvalVector(polyOrd,NULL) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
-        return 61;
-    }
-
-    // Attempt to invoke function with a non F32 type input vector
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
-    inputOrd->type.type = PS_TYPE_U8;
-    if(psPolynomial1DEvalVector(polyOrd,inputOrd) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector");
-        return 62;
-    }
-    inputOrd->type.type = PS_TYPE_F32;
-
-    psFree(inputOrd);
-    psFree(inputCheb);
-    psFree(outputOrd);
-    psFree(outputCheb);
-    psFree(polyOrd);
-    psFree(polyCheb);
-
-    return 0;
-}
-
-psS32 testDPoly1DEvalVector(void)
-{
-    // Allocate polynomial
-    psDPolynomial1D* polyOrd = psDPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_ORD);
-    psDPolynomial1D* polyCheb = psDPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_CHEB);
 
     // Set polynomial members
@@ -265,5 +123,5 @@
 
     // Evaluate the vectors
-    psVector* outputOrd = psDPolynomial1DEvalVector(polyOrd, inputOrd);
+    psVector* outputOrd = psPolynomial1DEvalVector(polyOrd, inputOrd);
     if(outputOrd == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -275,5 +133,5 @@
         return 2;
     }
-    psVector* outputCheb = psDPolynomial1DEvalVector(polyCheb, inputCheb);
+    psVector* outputCheb = psPolynomial1DEvalVector(polyCheb, inputCheb);
     if(outputCheb == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -302,5 +160,5 @@
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
-    if(psDPolynomial1DEvalVector(NULL, inputOrd) != NULL) {
+    if(psPolynomial1DEvalVector(NULL, inputOrd) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
         return 60;
@@ -309,5 +167,5 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial1DEvalVector(polyOrd,NULL) != NULL) {
+    if(psPolynomial1DEvalVector(polyOrd,NULL) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 61;
@@ -317,5 +175,5 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrd->type.type = PS_TYPE_U8;
-    if(psDPolynomial1DEvalVector(polyOrd,inputOrd) != NULL) {
+    if(psPolynomial1DEvalVector(polyOrd,inputOrd) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 62;
Index: trunk/psLib/test/math/tst_psFunc09.c
===================================================================
--- trunk/psLib/test/math/tst_psFunc09.c	(revision 4580)
+++ trunk/psLib/test/math/tst_psFunc09.c	(revision 4581)
@@ -4,6 +4,6 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-07-13 02:47:00 $
+*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-07-20 01:21:13 $
 *
 * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -19,13 +19,9 @@
 
 static psS32 testPoly2DEval(void);
-static psS32 testDPoly2DEval(void);
 static psS32 testPoly2DEvalVector(void);
-static psS32 testDPoly2DEvalVector(void);
 
 testDescription tests[] = {
                               {testPoly2DEval,583,"psPolynomial2DEval",0,false},
-                              {testDPoly2DEval,582,"psDPolynomial2DEval",0,false},
                               {testPoly2DEvalVector,000,"psPolynomial2DEvalVector",0,false},
-                              {testDPoly2DEvalVector,000,"psDPolynomial2DEvalVector",0,false},
                               {NULL}
                           };
@@ -85,9 +81,9 @@
 
 // This test will verify operation of 1D polynomial evaluation
-psS32 testPoly2DEval(void)
+/*psS32 testPoly2DEval(void)
 {
     psF32  result;
     psF32  resultCheb;
-
+ 
     // Allocate polynomial structure
     psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
@@ -119,5 +115,5 @@
     psFree(polyOrd);
     psFree(polyCheb);
-
+ 
     // Allocate polynomial with invalid type
     polyOrd = psPolynomial2DAlloc(TERMS, TERMS, 99);
@@ -130,10 +126,10 @@
     }
     psFree(polyOrd);
-
+ 
     return 0;
 }
-
+*/
 // This test will verify operation of 1D polynomial evaluation
-psS32 testDPoly2DEval(void)
+psS32 testPoly2DEval(void)
 {
     psF64  result;
@@ -141,6 +137,6 @@
 
     // Allocate polynomial structure
-    psDPolynomial2D*  polyOrd = psDPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
-    psDPolynomial2D*  polyCheb = psDPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_CHEB);
+    psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
+    psPolynomial2D*  polyCheb = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -154,5 +150,5 @@
     // Evaluate test points and verify results
     for(psS32 i = 0; i < TESTPOINTS; i++) {
-        result = psDPolynomial2DEval(polyOrd,Dpoly2DXYValue[i][0],Dpoly2DXYValue[i][1]);
+        result = psPolynomial2DEval(polyOrd,Dpoly2DXYValue[i][0],Dpoly2DXYValue[i][1]);
         if(fabs(Dpoly2DResult[i]-result) > ERROR_TOL ) {
             psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
@@ -160,5 +156,5 @@
             return i;
         }
-        resultCheb = psDPolynomial2DEval(polyCheb,Dpoly2DXYChebValue[i][0],Dpoly2DXYChebValue[i][1]);
+        resultCheb = psPolynomial2DEval(polyCheb,Dpoly2DXYChebValue[i][0],Dpoly2DXYChebValue[i][1]);
         if(fabs(Dpoly2DChebResult[i]-resultCheb) > ERROR_TOL ) {
             psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
@@ -171,8 +167,8 @@
 
     // Allocate polynomial with invalid type
-    polyOrd = psDPolynomial2DAlloc(TERMS, TERMS, 99);
+    polyOrd = psPolynomial2DAlloc(TERMS, TERMS, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
-    result = psDPolynomial2DEval(polyOrd,0.0, 0.0);
+    result = psPolynomial2DEval(polyOrd,0.0, 0.0);
     if ( !isnan(result) ) {
         psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
@@ -184,10 +180,10 @@
 }
 
-psS32 testPoly2DEvalVector(void)
+/*psS32 testPoly2DEvalVector(void)
 {
     // Allocate polynomial
     psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
     psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
-
+ 
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -199,5 +195,5 @@
         }
     }
-
+ 
     // Create input vectors
     psVector* inputOrdX  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
@@ -211,5 +207,5 @@
         inputChebY->data.F32[i] = poly2DXYChebValue[i][1];
     }
-
+ 
     // Evaluate the vectors
     psVector* outputOrd = psPolynomial2DEvalVector(polyOrd, inputOrdX, inputOrdY);
@@ -233,5 +229,5 @@
         return 2;
     }
-
+ 
     // Verify the results
     for(psS32 i = 0; i < TESTPOINTS; i++) {
@@ -247,5 +243,5 @@
         }
     }
-
+ 
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
@@ -254,5 +250,5 @@
         return 60;
     }
-
+ 
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
@@ -267,5 +263,5 @@
         return 62;
     }
-
+ 
     // Attempt to invoke function with a non F32 type input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
@@ -284,5 +280,5 @@
     }
     inputOrdY->type.type = PS_TYPE_F32;
-
+ 
     psFree(inputOrdX);
     psFree(inputOrdY);
@@ -293,13 +289,13 @@
     psFree(polyOrd);
     psFree(polyCheb);
-
+ 
     return 0;
 }
-
-psS32 testDPoly2DEvalVector(void)
+*/
+psS32 testPoly2DEvalVector(void)
 {
     // Allocate polynomial
-    psDPolynomial2D* polyOrd = psDPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psDPolynomial2D* polyCheb = psDPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
+    psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
 
     // Set polynomial members
@@ -326,5 +322,5 @@
 
     // Evaluate the vectors
-    psVector* outputOrd = psDPolynomial2DEvalVector(polyOrd, inputOrdX, inputOrdY);
+    psVector* outputOrd = psPolynomial2DEvalVector(polyOrd, inputOrdX, inputOrdY);
     if(outputOrd == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -336,5 +332,5 @@
         return 2;
     }
-    psVector* outputCheb = psDPolynomial2DEvalVector(polyCheb, inputChebX, inputChebY);
+    psVector* outputCheb = psPolynomial2DEvalVector(polyCheb, inputChebX, inputChebY);
     if(outputCheb == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -363,5 +359,5 @@
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
-    if(psDPolynomial2DEvalVector(NULL, inputOrdX, inputOrdY) != NULL) {
+    if(psPolynomial2DEvalVector(NULL, inputOrdX, inputOrdY) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
         return 60;
@@ -370,5 +366,5 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial2DEvalVector(polyOrd,NULL,inputOrdY) != NULL) {
+    if(psPolynomial2DEvalVector(polyOrd,NULL,inputOrdY) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 61;
@@ -376,5 +372,5 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial2DEvalVector(polyOrd,inputOrdX,NULL) != NULL) {
+    if(psPolynomial2DEvalVector(polyOrd,inputOrdX,NULL) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 62;
@@ -384,5 +380,5 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdX->type.type = PS_TYPE_U8;
-    if(psDPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) {
+    if(psPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 63;
@@ -392,5 +388,5 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdY->type.type = PS_TYPE_U8;
-    if(psDPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) {
+    if(psPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 64;
Index: trunk/psLib/test/math/tst_psFunc10.c
===================================================================
--- trunk/psLib/test/math/tst_psFunc10.c	(revision 4580)
+++ trunk/psLib/test/math/tst_psFunc10.c	(revision 4581)
@@ -4,6 +4,6 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-07-13 02:47:00 $
+*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-07-20 01:21:13 $
 *
 * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -19,13 +19,9 @@
 
 static psS32 testPoly3DEval(void);
-static psS32 testDPoly3DEval(void);
 static psS32 testPoly3DEvalVector(void);
-static psS32 testDPoly3DEvalVector(void);
 
 testDescription tests[] = {
                               {testPoly3DEval,583,"psPolynomial3DEval",0,false},
-                              {testDPoly3DEval,582,"psDPolynomial3DEval",0,false},
                               {testPoly3DEvalVector,000,"psPolynomial3DEvalVector",0,false},
-                              {testDPoly3DEvalVector,000,"psDPolynomial3DEvalVector",0,false},
                               {NULL}
                           };
@@ -136,9 +132,9 @@
 
 // This test will verify operation of 1D polynomial evaluation
-psS32 testPoly3DEval(void)
+/*psS32 testPoly3DEval(void)
 {
     psF32  result;
     psF32  resultCheb;
-
+ 
     // Allocate polynomial structure
     psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, PS_POLYNOMIAL_ORD);
@@ -174,5 +170,5 @@
     psFree(polyOrd);
     psFree(polyCheb);
-
+ 
     // Allocate polynomial with invalid type
     polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
@@ -185,10 +181,10 @@
     }
     psFree(polyOrd);
-
+ 
     return 0;
 }
-
+*/
 // This test will verify operation of 1D polynomial evaluation
-psS32 testDPoly3DEval(void)
+psS32 testPoly3DEval(void)
 {
     psF64  result;
@@ -196,6 +192,6 @@
 
     // Allocate polynomial structure
-    psDPolynomial3D*  polyOrd = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psDPolynomial3D*  polyCheb = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
+    psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -211,6 +207,6 @@
     // Evaluate test points and verify results
     for(psS32 i = 0; i < TESTPOINTS; i++) {
-        result = psDPolynomial3DEval(polyOrd,Dpoly3DXYZValue[i][0],Dpoly3DXYZValue[i][1],
-                                     Dpoly3DXYZValue[i][2]);
+        result = psPolynomial3DEval(polyOrd,Dpoly3DXYZValue[i][0],Dpoly3DXYZValue[i][1],
+                                    Dpoly3DXYZValue[i][2]);
         if(fabs(Dpoly3DResult[i]-result) > ERROR_TOL ) {
             psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
@@ -218,6 +214,6 @@
             return i;
         }
-        resultCheb = psDPolynomial3DEval(polyCheb,Dpoly3DXYZChebValue[i][0],Dpoly3DXYZChebValue[i][1],
-                                         Dpoly3DXYZChebValue[i][2]);
+        resultCheb = psPolynomial3DEval(polyCheb,Dpoly3DXYZChebValue[i][0],Dpoly3DXYZChebValue[i][1],
+                                        Dpoly3DXYZChebValue[i][2]);
         if(fabs(Dpoly3DChebResult[i]-resultCheb) > ERROR_TOL ) {
             psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
@@ -230,8 +226,8 @@
 
     // Allocate polynomial with invalid type
-    polyOrd = psDPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
+    polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
-    result = psDPolynomial3DEval(polyOrd,0.0, 0.0, 0.0);
+    result = psPolynomial3DEval(polyOrd,0.0, 0.0, 0.0);
     if ( !isnan(result) ) {
         psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
@@ -243,10 +239,10 @@
 }
 
-psS32 testPoly3DEvalVector(void)
+/*psS32 testPoly3DEvalVector(void)
 {
     // Allocate polynomial
     psPolynomial3D* polyOrd  = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
     psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
-
+ 
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -260,5 +256,5 @@
         }
     }
-
+ 
     // Create input vectors
     psVector* inputOrdX  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
@@ -276,5 +272,5 @@
         inputChebZ->data.F32[i] = poly3DXYZChebValue[i][2];
     }
-
+ 
     // Evaluate the vectors
     psVector* outputOrd = psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ);
@@ -298,5 +294,5 @@
         return 2;
     }
-
+ 
     // Verify the results
     for(psS32 i = 0; i < TESTPOINTS; i++) {
@@ -312,5 +308,5 @@
         }
     }
-
+ 
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
@@ -319,5 +315,5 @@
         return 60;
     }
-
+ 
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
@@ -338,5 +334,5 @@
         return 63;
     }
-
+ 
     // Attempt to invoke function with a non F32 type input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
@@ -363,5 +359,5 @@
     }
     inputOrdZ->type.type = PS_TYPE_F32;
-
+ 
     psFree(inputOrdX);
     psFree(inputOrdY);
@@ -374,13 +370,13 @@
     psFree(polyOrd);
     psFree(polyCheb);
-
+ 
     return 0;
 }
-
-psS32 testDPoly3DEvalVector(void)
+*/
+psS32 testPoly3DEvalVector(void)
 {
     // Allocate polynomial
-    psDPolynomial3D* polyOrd = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psDPolynomial3D* polyCheb = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial3D* polyOrd = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
+    psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
 
     // Set polynomial members
@@ -413,5 +409,5 @@
 
     // Evaluate the vectors
-    psVector* outputOrd = psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ);
+    psVector* outputOrd = psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ);
     if(outputOrd == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -423,5 +419,5 @@
         return 2;
     }
-    psVector* outputCheb = psDPolynomial3DEvalVector(polyCheb,inputChebX,inputChebY,inputChebZ);
+    psVector* outputCheb = psPolynomial3DEvalVector(polyCheb,inputChebX,inputChebY,inputChebZ);
     if(outputCheb == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -450,5 +446,5 @@
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
-    if(psDPolynomial3DEvalVector(NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial3DEvalVector(NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
         return 60;
@@ -457,5 +453,5 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial3DEvalVector(polyOrd,NULL,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial3DEvalVector(polyOrd,NULL,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 61;
@@ -463,5 +459,5 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,NULL,inputOrdZ) != NULL) {
+    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,NULL,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 62;
@@ -469,5 +465,5 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,NULL) != NULL) {
+    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,NULL) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 63;
@@ -477,5 +473,5 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdX->type.type = PS_TYPE_U8;
-    if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 64;
@@ -485,5 +481,5 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdY->type.type = PS_TYPE_U8;
-    if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 65;
@@ -493,5 +489,5 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdZ->type.type = PS_TYPE_U8;
-    if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 66;
Index: trunk/psLib/test/math/tst_psFunc11.c
===================================================================
--- trunk/psLib/test/math/tst_psFunc11.c	(revision 4580)
+++ trunk/psLib/test/math/tst_psFunc11.c	(revision 4581)
@@ -4,6 +4,6 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-07-13 02:47:00 $
+*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-07-20 01:21:13 $
 *
 * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -19,13 +19,9 @@
 
 static psS32 testPoly4DEval(void);
-static psS32 testDPoly4DEval(void);
 static psS32 testPoly4DEvalVector(void);
-static psS32 testDPoly4DEvalVector(void);
 
 testDescription tests[] = {
                               {testPoly4DEval,583,"psPolynomial4DEval",0,false},
-                              {testDPoly4DEval,582,"psDPolynomial4DEval",0,false},
                               {testPoly4DEvalVector,000,"psPolynomial4DEvalVector",0,false},
-                              {testDPoly4DEvalVector,000,"psDPolynomial4DEvalVector",0,false},
                               {NULL}
                           };
@@ -378,9 +374,9 @@
 
 // This test will verify operation of 1D polynomial evaluation
-psS32 testPoly4DEval(void)
+/*psS32 testPoly4DEval(void)
 {
     psF32  result;
     psF32  resultCheb;
-
+ 
     // Allocate polynomial structure
     psPolynomial4D*  polyOrd  = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
@@ -418,5 +414,5 @@
     psFree(polyOrd);
     psFree(polyCheb);
-
+ 
     // Allocate polynomial with invalid type
     polyOrd = psPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
@@ -429,10 +425,10 @@
     }
     psFree(polyOrd);
-
+ 
     return 0;
 }
-
+*/
 // This test will verify operation of 1D polynomial evaluation
-psS32 testDPoly4DEval(void)
+psS32 testPoly4DEval(void)
 {
     psF64  result;
@@ -440,6 +436,6 @@
 
     // Allocate polynomial structure
-    psDPolynomial4D*  polyOrd = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psDPolynomial4D*  polyCheb = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial4D*  polyOrd = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
+    psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -457,6 +453,6 @@
     // Evaluate test points and verify results
     for(psS32 i = 0; i < TESTPOINTS; i++) {
-        result = psDPolynomial4DEval(polyOrd,Dpoly4DWXYZValue[i][0],Dpoly4DWXYZValue[i][1],
-                                     Dpoly4DWXYZValue[i][2],Dpoly4DWXYZValue[i][3]);
+        result = psPolynomial4DEval(polyOrd,Dpoly4DWXYZValue[i][0],Dpoly4DWXYZValue[i][1],
+                                    Dpoly4DWXYZValue[i][2],Dpoly4DWXYZValue[i][3]);
         if(fabs(Dpoly4DResult[i]-result) > ERROR_TOL ) {
             psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
@@ -464,6 +460,6 @@
             return i;
         }
-        resultCheb = psDPolynomial4DEval(polyCheb,Dpoly4DWXYZChebValue[i][0],Dpoly4DWXYZChebValue[i][1],
-                                         Dpoly4DWXYZChebValue[i][2],Dpoly4DWXYZChebValue[i][3]);
+        resultCheb = psPolynomial4DEval(polyCheb,Dpoly4DWXYZChebValue[i][0],Dpoly4DWXYZChebValue[i][1],
+                                        Dpoly4DWXYZChebValue[i][2],Dpoly4DWXYZChebValue[i][3]);
         if(fabs(Dpoly4DChebResult[i]-resultCheb) > ERROR_TOL ) {
             psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
@@ -476,8 +472,8 @@
 
     // Allocate polynomial with invalid type
-    polyOrd = psDPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
+    polyOrd = psPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
-    result = psDPolynomial4DEval(polyOrd,0.0, 0.0, 0.0, 0.0);
+    result = psPolynomial4DEval(polyOrd,0.0, 0.0, 0.0, 0.0);
     if ( !isnan(result) ) {
         psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
@@ -489,10 +485,10 @@
 }
 
-psS32 testPoly4DEvalVector(void)
+/*psS32 testPoly4DEvalVector(void)
 {
     // Allocate polynomial
     psPolynomial4D* polyOrd  = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
     psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
-
+ 
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -508,5 +504,5 @@
         }
     }
-
+ 
     // Create input vectors
     psVector* inputOrdW  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
@@ -528,5 +524,5 @@
         inputChebZ->data.F32[i] = poly4DWXYZChebValue[i][3];
     }
-
+ 
     // Evaluate the vectors
     psVector* outputOrd = psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ);
@@ -550,5 +546,5 @@
         return 2;
     }
-
+ 
     // Verify the results
     for(psS32 i = 0; i < TESTPOINTS; i++) {
@@ -564,5 +560,5 @@
         }
     }
-
+ 
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
@@ -571,5 +567,5 @@
         return 60;
     }
-
+ 
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
@@ -596,5 +592,5 @@
         return 64;
     }
-
+ 
     // Attempt to invoke function with a non F32 type input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
@@ -629,5 +625,5 @@
     }
     inputOrdW->type.type = PS_TYPE_F32;
-
+ 
     psFree(inputOrdW);
     psFree(inputOrdX);
@@ -642,13 +638,13 @@
     psFree(polyOrd);
     psFree(polyCheb);
-
+ 
     return 0;
 }
-
-psS32 testDPoly4DEvalVector(void)
+*/
+psS32 testPoly4DEvalVector(void)
 {
     // Allocate polynomial
-    psDPolynomial4D* polyOrd = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psDPolynomial4D* polyCheb = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial4D* polyOrd = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
+    psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
 
     // Set polynomial members
@@ -687,5 +683,5 @@
 
     // Evaluate the vectors
-    psVector* outputOrd = psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ);
+    psVector* outputOrd = psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ);
     if(outputOrd == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -697,5 +693,5 @@
         return 2;
     }
-    psVector* outputCheb = psDPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ);
+    psVector* outputCheb = psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ);
     if(outputCheb == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -724,5 +720,5 @@
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
-    if(psDPolynomial4DEvalVector(NULL,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(NULL,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
         return 60;
@@ -731,5 +727,5 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial4DEvalVector(polyOrd,NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 61;
@@ -737,5 +733,5 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,NULL,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,NULL,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 62;
@@ -743,5 +739,5 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,NULL,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,NULL,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 63;
@@ -749,5 +745,5 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,NULL) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,NULL) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 64;
@@ -757,5 +753,5 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdX->type.type = PS_TYPE_U8;
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 65;
@@ -765,5 +761,5 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdY->type.type = PS_TYPE_U8;
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 66;
@@ -773,5 +769,5 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdZ->type.type = PS_TYPE_U8;
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 67;
@@ -781,5 +777,5 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdW->type.type = PS_TYPE_U8;
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 68;
Index: trunk/psLib/test/math/verified/tst_psFunc00.stderr
===================================================================
--- trunk/psLib/test/math/verified/tst_psFunc00.stderr	(revision 4580)
+++ trunk/psLib/test/math/verified/tst_psFunc00.stderr	(revision 4581)
@@ -35,38 +35,2 @@
 ---> TESTPOINT PASSED (psPolynomialXD{psPolynomial4DAlloc} | tst_psFunc00.c)
 
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc00.c                                             *
-*            TestPoint: psPolynomialXD{psDPolynomial1DAlloc}                       *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psPolynomialXD{psDPolynomial1DAlloc} | tst_psFunc00.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc00.c                                             *
-*            TestPoint: psPolynomialXD{psDPolynomial2DAlloc}                       *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psPolynomialXD{psDPolynomial2DAlloc} | tst_psFunc00.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc00.c                                             *
-*            TestPoint: psPolynomialXD{psDPolynomial3DAlloc}                       *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psPolynomialXD{psDPolynomial3DAlloc} | tst_psFunc00.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc00.c                                             *
-*            TestPoint: psPolynomialXD{psDPolynomial4DAlloc}                       *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psPolynomialXD{psDPolynomial4DAlloc} | tst_psFunc00.c)
-
Index: trunk/psLib/test/math/verified/tst_psFunc08.stderr
===================================================================
--- trunk/psLib/test/math/verified/tst_psFunc08.stderr	(revision 4580)
+++ trunk/psLib/test/math/verified/tst_psFunc08.stderr	(revision 4581)
@@ -11,17 +11,4 @@
 
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial1DEval} | tst_psFunc08.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc08.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial1DEval}                    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly1DEval
-    Following should generate error message invalid type
-<DATE><TIME>|<HOST>|E|psDPolynomial1DEval (FILE:LINENO)
-    Unknown polynomial type 0x63 found.  Evaluation failed.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial1DEval} | tst_psFunc08.c)
 
 /***************************** TESTPOINT ******************************************\
@@ -46,23 +33,2 @@
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial1DEvalVector} | tst_psFunc08.c)
 
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc08.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial1DEvalVector}              *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly1DEvalVector
-    Following should generate an error message for NULL polynomial
-<DATE><TIME>|<HOST>|E|psDPolynomial1DEvalVector (FILE:LINENO)
-    Unallowable operation: polynomial poly or its coeffs is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly1DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial1DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly1DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial1DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x has incorrect type.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial1DEvalVector} | tst_psFunc08.c)
-
Index: trunk/psLib/test/math/verified/tst_psFunc09.stderr
===================================================================
--- trunk/psLib/test/math/verified/tst_psFunc09.stderr	(revision 4580)
+++ trunk/psLib/test/math/verified/tst_psFunc09.stderr	(revision 4581)
@@ -11,17 +11,4 @@
 
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial2DEval} | tst_psFunc09.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc09.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial2DEval}                    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly2DEval
-    Following should generate error message invalid type
-<DATE><TIME>|<HOST>|E|psDPolynomial2DEval (FILE:LINENO)
-    Unknown polynomial type 0x63 found.  Evaluation failed.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial2DEval} | tst_psFunc09.c)
 
 /***************************** TESTPOINT ******************************************\
@@ -54,31 +41,2 @@
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial2DEvalVector} | tst_psFunc09.c)
 
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc09.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial2DEvalVector}              *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
-    Following should generate an error message for NULL polynomial
-<DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
-    Unallowable operation: polynomial poly or its coeffs is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector y or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x has incorrect type.
-<DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector y has incorrect type.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial2DEvalVector} | tst_psFunc09.c)
-
Index: trunk/psLib/test/math/verified/tst_psFunc10.stderr
===================================================================
--- trunk/psLib/test/math/verified/tst_psFunc10.stderr	(revision 4580)
+++ trunk/psLib/test/math/verified/tst_psFunc10.stderr	(revision 4581)
@@ -11,17 +11,4 @@
 
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial3DEval} | tst_psFunc10.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc10.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial3DEval}                    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly3DEval
-    Following should generate error message invalid type
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEval (FILE:LINENO)
-    Unknown polynomial type 0x63 found.  Evaluation failed.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial3DEval} | tst_psFunc10.c)
 
 /***************************** TESTPOINT ******************************************\
@@ -62,39 +49,2 @@
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial3DEvalVector} | tst_psFunc10.c)
 
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc10.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial3DEvalVector}              *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for NULL polynomial
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: polynomial poly or its coeffs is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector y or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector z or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x has incorrect type.
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector y has incorrect type.
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector z has incorrect type.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial3DEvalVector} | tst_psFunc10.c)
-
Index: trunk/psLib/test/math/verified/tst_psFunc11.stderr
===================================================================
--- trunk/psLib/test/math/verified/tst_psFunc11.stderr	(revision 4580)
+++ trunk/psLib/test/math/verified/tst_psFunc11.stderr	(revision 4581)
@@ -11,17 +11,4 @@
 
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial4DEval} | tst_psFunc11.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc11.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial4DEval}                    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly4DEval
-    Following should generate error message invalid type
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEval (FILE:LINENO)
-    Unknown polynomial type 0x63 found.  Evaluation failed.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial4DEval} | tst_psFunc11.c)
 
 /***************************** TESTPOINT ******************************************\
@@ -70,47 +57,2 @@
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial4DEvalVector} | tst_psFunc11.c)
 
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc11.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial4DEvalVector}              *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for NULL polynomial
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: polynomial poly or its coeffs is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector y or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector z or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector t or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector y has incorrect type.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector z has incorrect type.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector t has incorrect type.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x has incorrect type.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial4DEvalVector} | tst_psFunc11.c)
-