Index: trunk/psLib/test/math/Makefile.am
===================================================================
--- trunk/psLib/test/math/Makefile.am	(revision 5647)
+++ trunk/psLib/test/math/Makefile.am	(revision 5813)
@@ -26,8 +26,4 @@
     tst_psMatrixVectorArithmetic03 \
     tst_psMatrixVectorArithmetic04 \
-    tst_psMinimize04 \
-    tst_psMinimize04_F32 \
-    tst_psMinimize04b \
-    tst_psMinimize04b_F32 \
     tst_psMinimize05 \
     tst_psMinimize06 \
@@ -44,5 +40,9 @@
     tst_psStats09 \
     tst_psSpline1D \
-    tst_psRandom
+    tst_psRandom \
+    tst_psPolyFit1DCheby \
+    tst_psPolyFit1DOrd \
+    tst_psPolyFit2DOrd
+
 
 tst_psFunc00_SOURCES =  tst_psFunc00.c
@@ -67,8 +67,4 @@
 tst_psMatrixVectorArithmetic03_SOURCES =  tst_psMatrixVectorArithmetic03.c
 tst_psMatrixVectorArithmetic04_SOURCES =  tst_psMatrixVectorArithmetic04.c
-tst_psMinimize04_SOURCES =  tst_psMinimize04.c
-tst_psMinimize04_F32_SOURCES =  tst_psMinimize04_F32.c
-tst_psMinimize04b_SOURCES =  tst_psMinimize04b.c
-tst_psMinimize04b_F32_SOURCES =  tst_psMinimize04b_F32.c
 tst_psMinimizeVector2D_F64_SOURCES = tst_psMinimizeVector2D_F64.c
 tst_psMinimizeVector2D_F32_SOURCES = tst_psMinimizeVector2D_F32.c
@@ -85,4 +81,7 @@
 tst_psStats09_SOURCES =  tst_psStats09.c
 tst_psRandom_SOURCES =  tst_psRandom.c
+tst_psPolyFit1DCheby_SOURCES = tst_psPolyFit1DCheby.c
+tst_psPolyFit1DOrd_SOURCES = tst_psPolyFit1DOrd.c
+tst_psPolyFit2DOrd_SOURCES = tst_psPolyFit2DOrd.c
 
 check_DATA =
Index: trunk/psLib/test/math/tst_psMinimize04.c
===================================================================
--- trunk/psLib/test/math/tst_psMinimize04.c	(revision 5647)
+++ 	(revision )
@@ -1,130 +1,0 @@
-/*****************************************************************************
-This routine must ensure that the psVectorFitPolynomial2D works correctly.
-We create a vectors of data points (x and y), and populate them with the
-values from an arbitrary function setData().  We then call
-psVectorFitPolynomial2D() with a regular polynomial data structure.  We then
-evaluate the polynomial with the coefficients generated above and determine
-if they are within an error tolerance of the expected values.
- 
-    t00(): all input vectors are non-NULL.
-    t01(): yErr is NULL.
-    t02(): x, yErr is NULL.
-    t03(): x, y, yErr is NULL.
- *****************************************************************************/
-#include <stdio.h>
-#include "pslib_strict.h"
-#include "psTest.h"
-#include "psMemory.h"
-#include "psVector.h"
-#include "psImage.h"
-#include "psMinimize.h"
-#include <math.h>
-#define NUM_DATA 10
-#define POLY_ORDER 5
-#define A 3.0
-#define B 2.0
-#define C 3.0
-#define D 3.0
-#define E 3.0
-#define F 3.0
-#define ERROR_TOLERANCE 0.10
-#define FERR 1.0
-#define PRINT_RESULTS 0
-
-double setData(double x, double y)
-{
-    return(A + (B * x) + (C * x * x) + (D * y) + (E * y * y) + (E * x * y));
-}
-
-psS32 t00()
-{
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-    double expectData;
-    double actualData;
-
-    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);
-    psVector *f = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-    psVector *fErr = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-
-    for (psS32 i=0;i<NUM_DATA;i++) {
-        x->data.F32[i] = (double) i;
-        y->data.F32[i] = (double) i;
-        f->data.F32[i] = setData(x->data.F32[i], y->data.F32[i]);
-        fErr->data.F32[i] = FERR;
-    }
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial2D(): equal difference in variable fErr");
-
-    psVectorFitPolynomial2D(myPoly, NULL, 0, f, fErr, x, y);
-
-    //    for (i=0;i<POLY_ORDER+1;i++) {
-    //        printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
-    //    }
-
-    for (psS32 i=0;i<NUM_DATA;i++) {
-        expectData = setData(x->data.F32[i],  y->data.F32[i]);
-        actualData = psPolynomial2DEval(myPoly, x->data.F32[i], y->data.F32[i]);
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f %.1f), expected was (%.1f)\n",
-                   i, x->data.F32[i], y->data.F32[i], actualData, expectData);
-            testStatus = false;
-        }
-        if (PRINT_RESULTS) {
-            printf("Data point [%d] is %f, should be %f.\n", i, actualData, expectData);
-        }
-    }
-
-
-    printf("Running test with fErr set to NULL.\n");
-    psVectorFitPolynomial2D(myPoly, NULL, 0, f, NULL, x, y);
-    for (psS32 i=0;i<NUM_DATA;i++) {
-        expectData = setData(x->data.F32[i],  y->data.F32[i]);
-        actualData = psPolynomial2DEval(myPoly, x->data.F32[i], y->data.F32[i]);
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f %.1f), expected was (%.1f)\n",
-                   i, x->data.F32[i], y->data.F32[i], actualData, expectData);
-            testStatus = false;
-        }
-        if (PRINT_RESULTS) {
-            printf("Data point [%d] is %f, should be %f.\n", i, actualData, expectData);
-        }
-    }
-    psFree(myPoly);
-
-    printf("Running test with x, y set to NULL.  Should generate error.\n");
-    myPoly = psVectorFitPolynomial2D(NULL, NULL, 0, f, fErr, NULL, NULL);
-    if (myPoly != NULL) {
-        printf("TEST ERROR: psVectorFitPolynomial2D() returned non-NULL.\n");
-        testStatus = false;
-    }
-
-    psMemCheckCorruption(1);
-    psFree(x);
-    psFree(y);
-    psFree(f);
-    psFree(fErr);
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial2D(): equal differences in variable fErr",
-                testStatus);
-
-    return (!testStatus);
-}
-
-psS32 main()
-{
-    psLogSetFormat("HLNM");
-    t00();
-}
Index: trunk/psLib/test/math/tst_psMinimize04_F32.c
===================================================================
--- trunk/psLib/test/math/tst_psMinimize04_F32.c	(revision 5647)
+++ 	(revision )
@@ -1,268 +1,0 @@
-/*****************************************************************************
-This routine must ensure that the psVectorFitPolynomial1D works correctly.
-We create a vectors of data points (x and y), and populate them with the
-values from an arbitrary function setData().  We then call
-psVectorFitPolynomial1D() with a regular polynomial data structure.  We then
-evaluate the polynomial with the coefficients generated above and determine
-if they are within an error tolerance of the expected values.
- 
-    t00(): all input vectors are non-NULL.
-    t01(): yErr is NULL.
-    t02(): x, yErr is NULL.
-    t03(): x, y, yErr is NULL.
- *****************************************************************************/
-#include <stdio.h>
-#include "pslib_strict.h"
-#include "psTest.h"
-#include "psMemory.h"
-#include "psVector.h"
-#include "psImage.h"
-#include "psMinimize.h"
-#include <math.h>
-#define NUM_DATA 10
-#define POLY_ORDER 5
-#define A 3.0
-#define B 2.0
-#define C 3.0
-#define ERROR_TOLERANCE 0.10
-#define YERR 10.0
-float setData(float x)
-{
-    return(A + (B * x) + (C * x * x));
-}
-
-psS32 t00()
-{
-    psPolynomial1D *myPoly = NULL;
-    psVector *x = NULL;
-    psVector *y = NULL;
-    psVector *yErr = NULL;
-    psS32 i = 0;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-    float expectData;
-    float actualData;
-
-    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
-    x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-    y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-    yErr = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-
-    for (i=0;i<NUM_DATA;i++) {
-        x->data.F32[i] = (float) i;
-        y->data.F32[i] = setData(x->data.F32[i]);
-        yErr->data.F32[i] = YERR;
-        //        printf("Original data %d: (%.1f %.1f)\n", i, x->data.F32[i], y->data.F32[i]);
-    }
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): equal errors in yErr");
-
-    psVectorFitPolynomial1D(myPoly, NULL, 0, y, yErr, x);
-
-    //    for (i=0;i<POLY_ORDER+1;i++) {
-    //        printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
-    //    }
-
-    for (i=0;i<NUM_DATA;i++) {
-        expectData = setData(x->data.F32[i]);
-        actualData = psPolynomial1DEval(
-                         myPoly,
-                         x->data.F32[i]
-                     );
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                   i, x->data.F32[i], actualData, expectData);
-            testStatus = false;
-            //        } else {
-            //            printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-            //                   i, x->data.F32[i], actualData, expectData);
-        }
-    }
-
-    psMemCheckCorruption(1);
-    psFree(myPoly);
-    psFree(x);
-    psFree(y);
-    psFree(yErr);
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): equal errors in yErr",
-                testStatus);
-
-    return (!testStatus);
-}
-
-psS32 t01()
-{
-    psPolynomial1D *myPoly = NULL;
-    psVector *x = NULL;
-    psVector *y = NULL;
-    psS32 i = 0;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-    float expectData;
-    float actualData;
-
-    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
-    x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-    y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-
-    for (i=0;i<NUM_DATA;i++) {
-        x->data.F32[i] = (float) i;
-        y->data.F32[i] = setData(x->data.F32[i]);
-        //        printf("Original data %d: (%.1f %.1f)\n", i, x->data.F32[i], y->data.F32[i]);
-    }
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): yErr is NULL");
-
-    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, x);
-
-    //    for (i=0;i<POLY_ORDER+1;i++) {
-    //        printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
-    //    }
-
-    for (i=0;i<NUM_DATA;i++) {
-        expectData = setData(x->data.F32[i]);
-        actualData = psPolynomial1DEval(
-                         myPoly,
-                         x->data.F32[i]
-                     );
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                   i, x->data.F32[i], actualData, expectData);
-            testStatus = false;
-            //        } else {
-            //            printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-            //                   i, x->data.F32[i], actualData, expectData);
-        }
-    }
-
-    psMemCheckCorruption(1);
-    psFree(myPoly);
-    psFree(x);
-    psFree(y);
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): yErr is NULL",
-                testStatus);
-
-    return (!testStatus);
-}
-
-psS32 t02()
-{
-    psPolynomial1D *myPoly = NULL;
-    psVector *y = NULL;
-    psS32 i = 0;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-    float expectData;
-    float actualData;
-
-    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
-    y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-
-    for (i=0;i<NUM_DATA;i++) {
-        y->data.F32[i] = setData((float) i);
-        //        printf("Original data %d: (%.1f)\n", i, y->data.F32[i]);
-    }
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): x, yErr is NULL");
-
-    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, NULL);
-
-    //    for (i=0;i<POLY_ORDER+1;i++) {
-    //        printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
-    //    }
-
-    for (i=0;i<NUM_DATA;i++) {
-        expectData = setData((float) i);
-        actualData = psPolynomial1DEval(
-                         myPoly,
-                         (float) i
-                     );
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                   i, (float) i, actualData, expectData);
-            testStatus = false;
-            //        } else {
-            //            printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-            //                   i, (float) i, actualData, expectData);
-        }
-    }
-
-    psMemCheckCorruption(1);
-    psFree(myPoly);
-    psFree(y);
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): x, yErr is NULL",
-                testStatus);
-
-    return (!testStatus);
-}
-
-psS32 t03()
-{
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): all inputs are NULL");
-
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error for null arguments.");
-
-    psVectorFitPolynomial1D(NULL, NULL, 0, NULL, NULL, NULL);
-
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): all inputs are NULL",
-                testStatus);
-
-    return (!testStatus);
-}
-
-
-psS32 main()
-{
-    psLogSetFormat("HLNM");
-    t00();
-    t01();
-    t02();
-    t03();
-}
Index: trunk/psLib/test/math/tst_psMinimize04b.c
===================================================================
--- trunk/psLib/test/math/tst_psMinimize04b.c	(revision 5647)
+++ 	(revision )
@@ -1,261 +1,0 @@
-/*****************************************************************************
-    This routine must ensure that the psVectorFitPolynomial1D works correctly.
- 
-    We use Chebyshev polynomials here.
- *****************************************************************************/
-#include <stdio.h>
-#include "pslib_strict.h"
-#include "psTest.h"
-#include "psMemory.h"
-#include "psVector.h"
-#include "psImage.h"
-#include "psMinimize.h"
-#include <math.h>
-#define NUM_DATA 21
-#define POLY_ORDER 10
-#define A 2.0
-#define B 3.0
-#define C 2.0
-#define D 4.0
-#define E 5.0
-#define ERROR_TOLERANCE 0.10
-#define IGNORE (ERROR_TOLERANCE * NUM_DATA)
-
-double setData(double x)
-{
-    return(A + (B * x) + (C * x * x) + (D * x * x * x) + (E * x * x * x * x));
-}
-
-psS32 t00()
-{
-    psPolynomial1D *myPoly = NULL;
-    psVector *x = NULL;
-    psVector *y = NULL;
-    psVector *yErr = NULL;
-    psS32 i = 0;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-
-    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
-    x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
-    y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
-    yErr = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
-
-    for (i=0;i<NUM_DATA;i++) {
-        x->data.F64[i] = (double) i;
-        y->data.F64[i] = setData(x->data.F64[i]);
-        yErr->data.F64[i] = 1.0;
-    }
-    p_psNormalizeVectorRangeF64(x, -1.0, 1.0);
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): CHEB, equal errors in yErr");
-
-    psVectorFitPolynomial1D(myPoly, NULL, 0, y, yErr, x);
-
-    //  Remove for testing since print out differs from platforms
-    //    for (i=0;i<POLY_ORDER+1;i++) {
-    //        printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
-    //    }
-
-    // We don't test the first or last few data items.
-    for (i=IGNORE;i<NUM_DATA-IGNORE;i++) {
-        double expectData = y->data.F64[i];
-        double actualData = psPolynomial1DEval(
-                                myPoly,
-                                x->data.F64[i]
-                            );
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                   i, x->data.F64[i], actualData, expectData);
-            testStatus = false;
-        }
-        //      Remove for testing since print out differs from platforms
-        //        } else {
-        //            printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-        //                   i, x->data.F64[i], actualData, expectData);
-        //        }
-    }
-
-    psMemCheckCorruption(1);
-    psFree(myPoly);
-    psFree(x);
-    psFree(y);
-    psFree(yErr);
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): CHEB, equal errors in yErr",
-                testStatus);
-    return (!testStatus);
-}
-
-
-psS32 t01()
-{
-    psPolynomial1D *myPoly = NULL;
-    psVector *x = NULL;
-    psVector *y = NULL;
-    psS32 i = 0;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-
-    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
-    x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
-    y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
-
-    for (i=0;i<NUM_DATA;i++) {
-        x->data.F64[i] = (double) i;
-        y->data.F64[i] = setData(x->data.F64[i]);
-    }
-    p_psNormalizeVectorRangeF64(x, -1.0, 1.0);
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): CHEB, yErr is NULL");
-
-    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, x);
-
-    // We don't test the first or last few data items.
-    for (i=IGNORE;i<NUM_DATA-IGNORE;i++) {
-        double expectData = y->data.F64[i];
-        double actualData = psPolynomial1DEval(
-                                myPoly,
-                                x->data.F64[i]
-                            );
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                   i, x->data.F64[i], actualData, expectData);
-            testStatus = false;
-        }
-        //      Remove for testing since print out differs from platforms
-        //        } else {
-        //            printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-        //                   i, x->data.F64[i], actualData, expectData);
-        //        }
-    }
-
-    psMemCheckCorruption(1);
-    psFree(myPoly);
-    psFree(x);
-    psFree(y);
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): CHEB, yErr is NULL",
-                testStatus);
-    return (!testStatus);
-}
-
-
-psS32 t02()
-{
-    psPolynomial1D *myPoly = NULL;
-    psVector *x = NULL;
-    psVector *y = NULL;
-    psS32 i = 0;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-
-    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
-    x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
-    y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
-
-    for (i=0;i<NUM_DATA;i++) {
-        x->data.F64[i] = (double) i;
-        y->data.F64[i] = setData(x->data.F64[i]);
-    }
-    p_psNormalizeVectorRangeF64(x, -1.0, 1.0);
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): CHEB, x, yErr is NULL");
-
-    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, NULL);
-    //    psVectorFitPolynomial1D(myPoly, x, y, NULL);
-
-    // We don't test the first or last few data items.
-    for (i=IGNORE;i<NUM_DATA-IGNORE;i++) {
-        double expectData = y->data.F64[i];
-        double actualData = psPolynomial1DEval(myPoly, x->data.F64[i]);
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.2f %.2f), expected was (%.2f)\n",
-                   i, x->data.F64[i], actualData, expectData);
-            testStatus = false;
-        }
-        //      Remove for testing since print out differs from platforms
-        //        } else {
-        //            printf("Fitted data %d: (%.2f %.2f), expected was (%.2f)\n",
-        //                   i, x->data.F64[i], actualData, expectData);
-        //        }
-    }
-
-    psMemCheckCorruption(1);
-    psFree(myPoly);
-    psFree(x);
-    psFree(y);
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): CHEB, x, yErr is NULL",
-                testStatus);
-    return (!testStatus);
-}
-
-psS32 t03()
-{
-    psPolynomial1D *myPoly = NULL;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): CHEB, yErr is NULL");
-
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error for null arguments.");
-    psVectorFitPolynomial1D(myPoly, NULL, 0, NULL, NULL, NULL);
-    if (myPoly != NULL) {
-        printf("ERROR: psVectorFitPolynomial1D() returned a non-NULL polynomial.\n");
-        testStatus = false;
-    }
-
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): CHEB, yErr is NULL",
-                testStatus);
-    return (!testStatus);
-}
-
-psS32 main()
-{
-    psLogSetFormat("HLNM");
-    t00();
-    t01();
-    t02();
-    t03();
-}
Index: trunk/psLib/test/math/tst_psMinimize04b_F32.c
===================================================================
--- trunk/psLib/test/math/tst_psMinimize04b_F32.c	(revision 5647)
+++ 	(revision )
@@ -1,263 +1,0 @@
-/*****************************************************************************
-    This routine must ensure that the psVectorFitPolynomial1D works correctly.
- 
-    We use Chebyshev polynomials here.
- *****************************************************************************/
-#include <stdio.h>
-#include "pslib_strict.h"
-#include "psTest.h"
-#include "psMemory.h"
-#include "psVector.h"
-#include "psImage.h"
-#include "psMinimize.h"
-#include <math.h>
-#define NUM_DATA 20
-#define POLY_ORDER 10
-#define A 2.0
-#define B 3.0
-#define C 2.0
-#define D 4.0
-#define E 5.0
-#define ERROR_TOLERANCE 0.10
-#define IGNORE (ERROR_TOLERANCE * NUM_DATA)
-
-float setData(float x)
-{
-    return(A + (B * x) + (C * x * x) + (D * x * x * x) + (E * x * x * x * x));
-}
-
-psS32 t00()
-{
-    psPolynomial1D *myPoly = NULL;
-    psVector *x = NULL;
-    psVector *y = NULL;
-    psVector *yErr = NULL;
-    psS32 i = 0;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-
-    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
-    x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-    y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-    yErr = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-
-    for (i=0;i<NUM_DATA;i++) {
-        x->data.F32[i] = (float) i;
-        y->data.F32[i] = setData(x->data.F32[i]);
-        yErr->data.F32[i] = 1.0;
-    }
-    p_psNormalizeVectorRangeF32(x, -1.0f, 1.0f);
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): CHEB, equal errors in yErr");
-
-    psVectorFitPolynomial1D(myPoly, NULL, 0, y, yErr, x);
-
-    //  Remove for testing since printout differs between platforms
-    //    for (i=0;i<POLY_ORDER+1;i++) {
-    //        printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
-    //    }
-
-    // We don't test the first or last few data items.
-    for (i=IGNORE;i<NUM_DATA-IGNORE;i++) {
-        float expectData = y->data.F32[i];
-        float actualData = psPolynomial1DEval(
-                               myPoly,
-                               x->data.F32[i]
-                           );
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                   i, x->data.F32[i], actualData, expectData);
-            testStatus = false;
-        }
-        //       REMOVE for testing since printout is different for different platforms
-        //        } else {
-        //            printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-        //                   i, x->data.F32[i], actualData, expectData);
-        //        }
-    }
-
-    psMemCheckCorruption(1);
-    psFree(myPoly);
-    psFree(x);
-    psFree(y);
-    psFree(yErr);
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): CHEB, equal errors in yErr",
-                testStatus);
-    return (!testStatus);
-}
-
-
-psS32 t01()
-{
-    psPolynomial1D *myPoly = NULL;
-    psVector *x = NULL;
-    psVector *y = NULL;
-    psS32 i = 0;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-
-    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
-    x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-    y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-
-    for (i=0;i<NUM_DATA;i++) {
-        x->data.F32[i] = (float) i;
-        y->data.F32[i] = setData(x->data.F32[i]);
-    }
-    p_psNormalizeVectorRangeF32(x, -1.0f, 1.0f);
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): CHEB, yErr is NULL");
-
-    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, x);
-
-    // We don't test the first or last few data items.
-    for (i=IGNORE;i<NUM_DATA-IGNORE;i++) {
-        float expectData = y->data.F32[i];
-        float actualData = psPolynomial1DEval(
-                               myPoly,
-                               x->data.F32[i]
-                           );
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                   i, x->data.F32[i], actualData, expectData);
-            testStatus = false;
-        }
-        //      Removed for testing since printout different on different platforms
-        //        } else {
-        //            printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-        //                   i, x->data.F32[i], actualData, expectData);
-        //        }
-    }
-
-    psMemCheckCorruption(1);
-    psFree(myPoly);
-    psFree(x);
-    psFree(y);
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): CHEB, yErr is NULL",
-                testStatus);
-    return (!testStatus);
-}
-
-
-psS32 t02()
-{
-    psPolynomial1D *myPoly = NULL;
-    psVector *x = NULL;
-    psVector *y = NULL;
-    psS32 i = 0;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-
-    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
-    x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-    y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
-
-    for (i=0;i<NUM_DATA;i++) {
-        x->data.F32[i] = (float) i;
-        y->data.F32[i] = setData(x->data.F32[i]);
-    }
-    p_psNormalizeVectorRangeF32(x, -1.0, 1.0);
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): CHEB, x, yErr is NULL");
-
-    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, NULL);
-
-    // We don't test the first or last few data items.
-    for (i=IGNORE;i<NUM_DATA-IGNORE;i++) {
-        float expectData = y->data.F32[i];
-        float  actualData = psPolynomial1DEval(
-                                myPoly,
-                                x->data.F32[i]
-                            );
-        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
-            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-                   i, x->data.F32[i], actualData, expectData);
-            testStatus = false;
-        }
-        //      Remove for testing since printout different for different platforms
-        //        } else {
-        //            printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
-        //                   i, x->data.F32[i], actualData, expectData);
-        //        }
-    }
-
-    psMemCheckCorruption(1);
-    psFree(myPoly);
-    psFree(x);
-    psFree(y);
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): CHEB, x, yErr is NULL",
-                testStatus);
-    return (!testStatus);
-}
-
-psS32 t03()
-{
-    psPolynomial1D *myPoly = NULL;
-    psS32 currentId = psMemGetId();
-    psS32 testStatus = true;
-    psS32 memLeaks = 0;
-
-    printPositiveTestHeader(stdout,
-                            "psMinimize functions",
-                            "psVectorFitPolynomial1D(): CHEB, yErr is NULL");
-
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error for null arguments.");
-    psVectorFitPolynomial1D(myPoly, NULL, 0, NULL, NULL, NULL);
-    if (myPoly != NULL) {
-        printf("ERROR: psVectorFitPolynomial1D() returned a non-NULL polynomial.\n");
-        testStatus = false;
-    }
-
-    psMemCheckCorruption(1);
-    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
-    if (0 != memLeaks) {
-        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
-    }
-    printFooter(stdout,
-                "psMinimize functions",
-                "psVectorFitPolynomial1D(): CHEB, yErr is NULL",
-                testStatus);
-    return (!testStatus);
-}
-
-psS32 main()
-{
-    psLogSetFormat("HLNM");
-    t00();
-    t01();
-    t02();
-    t03();
-}
Index: trunk/psLib/test/math/tst_psPolyFit1DCheby.c
===================================================================
--- trunk/psLib/test/math/tst_psPolyFit1DCheby.c	(revision 5813)
+++ trunk/psLib/test/math/tst_psPolyFit1DCheby.c	(revision 5813)
@@ -0,0 +1,480 @@
+/*****************************************************************************
+    This routine must ensure that the psVectorFitPolynomial1D works correctly.
+ 
+    We use Chebyshev polynomials here.
+ 
+    We use psF32 and psF64 types here.
+ *****************************************************************************/
+#include <stdio.h>
+#include "pslib_strict.h"
+#include "psTest.h"
+#include "psMemory.h"
+#include "psVector.h"
+#include "psImage.h"
+#include "psMinimize.h"
+#include <math.h>
+#define NUM_DATA 21
+#define POLY_ORDER 4
+#define A 2.0
+#define B 3.0
+#define C 5.0
+#define D 3.0
+#define E 2.0
+#define ERROR_TOLERANCE 0.10
+#define IGNORE (ERROR_TOLERANCE * NUM_DATA)
+#define VERBOSE 0
+
+psF64 setDataF64(psF64 x)
+{
+    return(A + (B * x) + (C * x * x) + (D * x * x * x) + (E * x * x * x * x));
+}
+
+psF32 setDataF32(psF32 x)
+{
+    return(A + (B * x) + (C * x * x) + (D * x * x * x) + (E * x * x * x * x));
+}
+
+psS32 t00F64()
+{
+    psS32 i = 0;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
+    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+    psVector *yErr = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+
+    for (i=0;i<NUM_DATA;i++) {
+        x->data.F64[i] = (psF64) i;
+        y->data.F64[i] = setDataF64(x->data.F64[i]);
+        yErr->data.F64[i] = 1.0;
+    }
+    p_psNormalizeVectorRangeF64(x, -1.0, 1.0);
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): CHEB, equal errors in yErr");
+
+    psVectorFitPolynomial1D(myPoly, NULL, 0, y, yErr, x);
+
+    if (VERBOSE) {
+        for (i=0;i<POLY_ORDER+1;i++) {
+            printf("Polynomial coefficient %d is %0.4f\n", i, myPoly->coeff[i]);
+        }
+    }
+
+    for (i=IGNORE;i<NUM_DATA-IGNORE;i++) {
+        psF64 expectData = y->data.F64[i];
+        psF64 actualData = psPolynomial1DEval(myPoly, x->data.F64[i]);
+
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F64[i], actualData, expectData);
+            testStatus = false;
+        } else {
+            if (VERBOSE) {
+                printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                       i, x->data.F64[i], actualData, expectData);
+            }
+        }
+    }
+
+    psMemCheckCorruption(1);
+    psFree(myPoly);
+    psFree(x);
+    psFree(y);
+    psFree(yErr);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): CHEB, equal errors in yErr",
+                testStatus);
+    return (testStatus);
+}
+
+
+psS32 t01F64()
+{
+    psS32 i = 0;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
+    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+
+    for (i=0;i<NUM_DATA;i++) {
+        x->data.F64[i] = (psF64) i;
+        y->data.F64[i] = setDataF64(x->data.F64[i]);
+    }
+    p_psNormalizeVectorRangeF64(x, -1.0, 1.0);
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): CHEB, yErr is NULL");
+
+    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, x);
+
+    for (i=IGNORE;i<NUM_DATA-IGNORE;i++) {
+        psF64 expectData = y->data.F64[i];
+        psF64 actualData = psPolynomial1DEval(
+                               myPoly,
+                               x->data.F64[i]
+                           );
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F64[i], actualData, expectData);
+            testStatus = false;
+        } else {
+            if (VERBOSE) {
+                printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                       i, x->data.F64[i], actualData, expectData);
+            }
+        }
+    }
+
+    psMemCheckCorruption(1);
+    psFree(myPoly);
+    psFree(x);
+    psFree(y);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): CHEB, yErr is NULL",
+                testStatus);
+    return (testStatus);
+}
+
+
+psS32 t02F64()
+{
+    psS32 i = 0;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
+    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+
+    for (i=0;i<NUM_DATA;i++) {
+        x->data.F64[i] = (psF64) i;
+        y->data.F64[i] = setDataF64(x->data.F64[i]);
+    }
+    p_psNormalizeVectorRangeF64(x, -1.0, 1.0);
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): CHEB, x, yErr is NULL");
+
+    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, NULL);
+    //    psVectorFitPolynomial1D(myPoly, x, y, NULL);
+
+    for (i=IGNORE;i<NUM_DATA-IGNORE;i++) {
+        psF64 expectData = y->data.F64[i];
+        psF64 actualData = psPolynomial1DEval(myPoly, x->data.F64[i]);
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("TEST ERROR: Fitted data %d: (%.2f %.2f), expected was (%.2f)\n",
+                   i, x->data.F64[i], actualData, expectData);
+            testStatus = false;
+        } else {
+            if (VERBOSE) {
+                printf("GOOD: Fitted data %d: (%.2f %.2f), expected was (%.2f)\n",
+                       i, x->data.F64[i], actualData, expectData);
+            }
+        }
+    }
+
+    psMemCheckCorruption(1);
+    psFree(myPoly);
+    psFree(x);
+    psFree(y);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): CHEB, x, yErr is NULL",
+                testStatus);
+    return (testStatus);
+}
+
+psS32 t03F64()
+{
+    psPolynomial1D *myPoly = NULL;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): CHEB, yErr is NULL");
+
+    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error for null arguments.");
+    psVectorFitPolynomial1D(myPoly, NULL, 0, NULL, NULL, NULL);
+    if (myPoly != NULL) {
+        printf("ERROR: psVectorFitPolynomial1D() returned a non-NULL polynomial.\n");
+        testStatus = false;
+    }
+
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): CHEB, yErr is NULL",
+                testStatus);
+    return (testStatus);
+}
+
+psS32 t00F32()
+{
+    psS32 i = 0;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
+    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+    psVector *yErr = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+
+    for (i=0;i<NUM_DATA;i++) {
+        x->data.F32[i] = (psF32) i;
+        y->data.F32[i] = setDataF32(x->data.F32[i]);
+        yErr->data.F32[i] = 1.0;
+    }
+    p_psNormalizeVectorRangeF32(x, -1.0f, 1.0f);
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): CHEB, equal errors in yErr");
+
+    psVectorFitPolynomial1D(myPoly, NULL, 0, y, yErr, x);
+
+    if (VERBOSE) {
+        for (i=0;i<POLY_ORDER+1;i++) {
+            printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
+        }
+    }
+
+    for (i=IGNORE;i<NUM_DATA-IGNORE;i++) {
+        psF32 expectData = y->data.F32[i];
+        psF32 actualData = psPolynomial1DEval(
+                               myPoly,
+                               x->data.F32[i]
+                           );
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F32[i], actualData, expectData);
+            testStatus = false;
+        } else {
+            if (VERBOSE) {
+                printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                       i, x->data.F32[i], actualData, expectData);
+            }
+        }
+    }
+
+    psMemCheckCorruption(1);
+    psFree(myPoly);
+    psFree(x);
+    psFree(y);
+    psFree(yErr);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): CHEB, equal errors in yErr",
+                testStatus);
+    return (testStatus);
+}
+
+
+psS32 t01F32()
+{
+    psS32 i = 0;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
+    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+
+    for (i=0;i<NUM_DATA;i++) {
+        x->data.F32[i] = (psF32) i;
+        y->data.F32[i] = setDataF32(x->data.F32[i]);
+    }
+    p_psNormalizeVectorRangeF32(x, -1.0f, 1.0f);
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): CHEB, yErr is NULL");
+
+    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, x);
+
+    for (i=IGNORE;i<NUM_DATA-IGNORE;i++) {
+        psF32 expectData = y->data.F32[i];
+        psF32 actualData = psPolynomial1DEval(
+                               myPoly,
+                               x->data.F32[i]
+                           );
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F32[i], actualData, expectData);
+            testStatus = false;
+        } else {
+            if (VERBOSE) {
+                printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                       i, x->data.F32[i], actualData, expectData);
+            }
+        }
+    }
+
+    psMemCheckCorruption(1);
+    psFree(myPoly);
+    psFree(x);
+    psFree(y);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): CHEB, yErr is NULL",
+                testStatus);
+    return (testStatus);
+}
+
+
+psS32 t02F32()
+{
+    psS32 i = 0;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
+    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+
+    for (i=0;i<NUM_DATA;i++) {
+        x->data.F32[i] = (psF32) i;
+        y->data.F32[i] = setDataF32(x->data.F32[i]);
+    }
+    p_psNormalizeVectorRangeF32(x, -1.0, 1.0);
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): CHEB, x, yErr is NULL");
+
+    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, NULL);
+
+    for (i=IGNORE;i<NUM_DATA-IGNORE;i++) {
+        psF32 expectData = y->data.F32[i];
+        psF32 actualData = psPolynomial1DEval(myPoly, x->data.F32[i]);
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F32[i], actualData, expectData);
+            testStatus = false;
+        } else {
+            if (VERBOSE) {
+                printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                       i, x->data.F32[i], actualData, expectData);
+            }
+        }
+    }
+
+    psMemCheckCorruption(1);
+    psFree(myPoly);
+    psFree(x);
+    psFree(y);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): CHEB, x, yErr is NULL",
+                testStatus);
+    return (testStatus);
+}
+
+psS32 t03F32()
+{
+    psPolynomial1D *myPoly = NULL;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): CHEB, yErr is NULL");
+
+    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error for null arguments.");
+    psVectorFitPolynomial1D(myPoly, NULL, 0, NULL, NULL, NULL);
+    if (myPoly != NULL) {
+        printf("ERROR: psVectorFitPolynomial1D() returned a non-NULL polynomial.\n");
+        testStatus = false;
+    }
+
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): CHEB, yErr is NULL",
+                testStatus);
+    return (testStatus);
+}
+
+
+
+
+psS32 main()
+{
+    psBool testStatus = true;
+
+    psLogSetFormat("HLNM");
+
+    printPositiveTestHeader(stdout, "psMinimize functions: testing the Chebyshev fitting routines.", "");
+    testStatus &= t00F64();
+    testStatus &= t01F64();
+    testStatus &= t02F64();
+    testStatus &= t03F64();
+    testStatus &= t00F32();
+    testStatus &= t01F32();
+    testStatus &= t02F32();
+    testStatus &= t03F32();
+
+    printFooter(stdout, "psMinimize functions: testing the Chebyshev fitting routines.", "", testStatus);
+}
Index: trunk/psLib/test/math/tst_psPolyFit1DOrd.c
===================================================================
--- trunk/psLib/test/math/tst_psPolyFit1DOrd.c	(revision 5813)
+++ trunk/psLib/test/math/tst_psPolyFit1DOrd.c	(revision 5813)
@@ -0,0 +1,518 @@
+/*****************************************************************************
+This routine must ensure that the psVectorFitPolynomial1D works correctly.
+We create a vectors of data points (x and y), and populate them with the
+values from an arbitrary function setData().  We then call
+psVectorFitPolynomial1D() with a regular polynomial data structure.  We then
+evaluate the polynomial with the coefficients generated above and determine
+if they are within an error tolerance of the expected values.
+ 
+    t00F32(): all input vectors are non-NULL.
+    t01F32(): yErr is NULL.
+    t02F32(): x, yErr is NULL.
+    t03F32(): x, y, yErr is NULL.
+ 
+    We use psF32 and psF64 types here.
+ *****************************************************************************/
+#include <stdio.h>
+#include "pslib_strict.h"
+#include "psTest.h"
+#include "psMemory.h"
+#include "psVector.h"
+#include "psImage.h"
+#include "psMinimize.h"
+#include <math.h>
+#define NUM_DATA 10
+#define POLY_ORDER 5
+#define A 2.0
+#define B 3.0
+#define C 4.0
+#define D 5.0
+#define E 2.0
+#define ERROR_TOLERANCE 0.10
+#define YERR 10.0
+#define VERBOSE 0
+
+
+psF32 setDataF32(psF32 x)
+{
+    return(A + (B * x) + (C * x * x) + (D * x * x * x) + (E * x * x * x * x));
+}
+
+psF64 setDataF64(psF64 x)
+{
+    return(A + (B * x) + (C * x * x) + (D * x * x * x) + (E * x * x * x * x));
+}
+
+psS32 t00F32()
+{
+    psS32 i = 0;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+    psF32 expectData;
+    psF32 actualData;
+
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
+    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+    psVector *yErr = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+
+    for (i=0;i<NUM_DATA;i++) {
+        x->data.F32[i] = (psF32) i;
+        y->data.F32[i] = setDataF32(x->data.F32[i]);
+        yErr->data.F32[i] = YERR;
+        if (VERBOSE) {
+            printf("Original data %d: (%.1f %.1f)\n", i, x->data.F32[i], y->data.F32[i]);
+        }
+    }
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): equal errors in yErr");
+
+    psVectorFitPolynomial1D(myPoly, NULL, 0, y, yErr, x);
+
+    if (VERBOSE) {
+        for (i=0;i<POLY_ORDER+1;i++) {
+            printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
+        }
+    }
+
+    for (i=0;i<NUM_DATA;i++) {
+        expectData = setDataF32(x->data.F32[i]);
+        actualData = psPolynomial1DEval(myPoly, x->data.F32[i]);
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F32[i], actualData, expectData);
+            testStatus = false;
+        } else {
+            if (VERBOSE) {
+                printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                       i, x->data.F32[i], actualData, expectData);
+            }
+        }
+    }
+
+    psMemCheckCorruption(1);
+    psFree(myPoly);
+    psFree(x);
+    psFree(y);
+    psFree(yErr);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): equal errors in yErr",
+                testStatus);
+
+    return (testStatus);
+}
+
+psS32 t01F32()
+{
+    psS32 i = 0;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+    psF32 expectData;
+    psF32 actualData;
+
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
+    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+
+    for (i=0;i<NUM_DATA;i++) {
+        x->data.F32[i] = (psF32) i;
+        y->data.F32[i] = setDataF32(x->data.F32[i]);
+        if (VERBOSE) {
+            printf("Original data %d: (%.1f %.1f)\n", i, x->data.F32[i], y->data.F32[i]);
+        }
+    }
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): yErr is NULL");
+
+    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, x);
+
+    if (VERBOSE) {
+        for (i=0;i<POLY_ORDER+1;i++) {
+            printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
+        }
+    }
+
+    for (i=0;i<NUM_DATA;i++) {
+        expectData = setDataF32(x->data.F32[i]);
+        actualData = psPolynomial1DEval(
+                         myPoly,
+                         x->data.F32[i]
+                     );
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F32[i], actualData, expectData);
+            testStatus = false;
+        } else {
+            if (VERBOSE) {
+                printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                       i, x->data.F32[i], actualData, expectData);
+            }
+        }
+    }
+
+    psMemCheckCorruption(1);
+    psFree(myPoly);
+    psFree(x);
+    psFree(y);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): yErr is NULL",
+                testStatus);
+
+    return (testStatus);
+}
+
+psS32 t02F32()
+{
+    psS32 i = 0;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+    psF32 expectData;
+    psF32 actualData;
+
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+
+    for (i=0;i<NUM_DATA;i++) {
+        y->data.F32[i] = setDataF32((psF32) i);
+        if (VERBOSE) {
+            printf("Original data %d: (%.1f)\n", i, y->data.F32[i]);
+        }
+    }
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): x, yErr is NULL");
+
+    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, NULL);
+
+    if (VERBOSE) {
+        for (i=0;i<POLY_ORDER+1;i++) {
+            printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
+        }
+    }
+
+    for (i=0;i<NUM_DATA;i++) {
+        expectData = setDataF32((psF32) i);
+        actualData = psPolynomial1DEval(myPoly, (psF32) i);
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                   i, (psF32) i, actualData, expectData);
+            testStatus = false;
+        } else {
+            if (VERBOSE) {
+                printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                       i, (psF32) i, actualData, expectData);
+            }
+        }
+    }
+
+    psMemCheckCorruption(1);
+    psFree(myPoly);
+    psFree(y);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout, "psMinimize functions",
+                "psVectorFitPolynomial1D(): x, yErr is NULL", testStatus);
+
+    return (testStatus);
+}
+
+psS32 t03F32()
+{
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): all inputs are NULL");
+
+    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error for null arguments.");
+
+    psVectorFitPolynomial1D(NULL, NULL, 0, NULL, NULL, NULL);
+
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): all inputs are NULL",
+                testStatus);
+
+    return(testStatus);
+}
+
+
+
+psS32 t00F64()
+{
+    psS32 i = 0;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+    psF64 expectData;
+    psF64 actualData;
+
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
+    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+    psVector *yErr = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+
+    for (i=0;i<NUM_DATA;i++) {
+        x->data.F64[i] = (psF64) i;
+        y->data.F64[i] = setDataF64(x->data.F64[i]);
+        yErr->data.F64[i] = YERR;
+        if (VERBOSE) {
+            printf("Original data %d: (%.1f %.1f)\n", i, x->data.F64[i], y->data.F64[i]);
+        }
+    }
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): equal errors in yErr");
+
+    psVectorFitPolynomial1D(myPoly, NULL, 0, y, yErr, x);
+
+    if (VERBOSE) {
+        for (i=0;i<POLY_ORDER+1;i++) {
+            printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
+        }
+    }
+
+    for (i=0;i<NUM_DATA;i++) {
+        expectData = setDataF64(x->data.F64[i]);
+        actualData = psPolynomial1DEval(myPoly, x->data.F64[i]);
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F64[i], actualData, expectData);
+            testStatus = false;
+        } else {
+            if (VERBOSE) {
+                printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                       i, x->data.F64[i], actualData, expectData);
+            }
+        }
+    }
+
+    psMemCheckCorruption(1);
+    psFree(myPoly);
+    psFree(x);
+    psFree(y);
+    psFree(yErr);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): equal errors in yErr",
+                testStatus);
+
+    return (testStatus);
+}
+
+psS32 t01F64()
+{
+    psS32 i = 0;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+    psF64 expectData;
+    psF64 actualData;
+
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
+    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+
+    for (i=0;i<NUM_DATA;i++) {
+        x->data.F64[i] = (psF64) i;
+        y->data.F64[i] = setDataF64(x->data.F64[i]);
+        if (VERBOSE) {
+            printf("Original data %d: (%.1f %.1f)\n", i, x->data.F64[i], y->data.F64[i]);
+        }
+    }
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): yErr is NULL");
+
+    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, x);
+
+    if (VERBOSE) {
+        for (i=0;i<POLY_ORDER+1;i++) {
+            printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
+        }
+    }
+
+    for (i=0;i<NUM_DATA;i++) {
+        expectData = setDataF64(x->data.F64[i]);
+        actualData = psPolynomial1DEval(
+                         myPoly,
+                         x->data.F64[i]
+                     );
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F64[i], actualData, expectData);
+            testStatus = false;
+        } else {
+            if (VERBOSE) {
+                printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                       i, x->data.F64[i], actualData, expectData);
+            }
+        }
+    }
+
+    psMemCheckCorruption(1);
+    psFree(myPoly);
+    psFree(x);
+    psFree(y);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): yErr is NULL",
+                testStatus);
+
+    return (testStatus);
+}
+
+psS32 t02F64()
+{
+    psS32 i = 0;
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+    psF64 expectData;
+    psF64 actualData;
+
+    psPolynomial1D *myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
+    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
+
+    for (i=0;i<NUM_DATA;i++) {
+        y->data.F64[i] = setDataF64((psF64) i);
+        if (VERBOSE) {
+            printf("Original data %d: (%.1f)\n", i, y->data.F64[i]);
+        }
+    }
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): x, yErr is NULL");
+
+    psVectorFitPolynomial1D(myPoly, NULL, 0, y, NULL, NULL);
+
+    if (VERBOSE) {
+        for (i=0;i<POLY_ORDER+1;i++) {
+            printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i]);
+        }
+    }
+
+    for (i=0;i<NUM_DATA;i++) {
+        expectData = setDataF64((psF64) i);
+        actualData = psPolynomial1DEval(myPoly, (psF64) i);
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                   i, (psF64) i, actualData, expectData);
+            testStatus = false;
+        } else {
+            if (VERBOSE) {
+                printf("Fitted data %d: (%.1f %.1f), expected was (%.1f)\n",
+                       i, (psF64) i, actualData, expectData);
+            }
+        }
+    }
+
+    psMemCheckCorruption(1);
+    psFree(myPoly);
+    psFree(y);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout, "psMinimize functions",
+                "psVectorFitPolynomial1D(): x, yErr is NULL", testStatus);
+
+    return (testStatus);
+}
+
+psS32 t03F64()
+{
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial1D(): all inputs are NULL");
+
+    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error for null arguments.");
+
+    psVectorFitPolynomial1D(NULL, NULL, 0, NULL, NULL, NULL);
+
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial1D(): all inputs are NULL",
+                testStatus);
+
+    return(testStatus);
+}
+
+psS32 main()
+{
+    psBool testStatus = true;
+    psLogSetFormat("HLNM");
+    printPositiveTestHeader(stdout, "psMinimize functions: testing the 1-D Polynomial fitting routines.", "");
+    testStatus &= t00F32();
+    testStatus &= t01F32();
+    testStatus &= t02F32();
+    testStatus &= t03F32();
+    testStatus &= t00F64();
+    testStatus &= t01F64();
+    testStatus &= t02F64();
+    testStatus &= t03F64();
+
+    printFooter(stdout, "psMinimize functions: testing the 1-D Polynomial fitting routines.", "", testStatus);
+}
+
Index: trunk/psLib/test/math/tst_psPolyFit2DOrd.c
===================================================================
--- trunk/psLib/test/math/tst_psPolyFit2DOrd.c	(revision 5813)
+++ trunk/psLib/test/math/tst_psPolyFit2DOrd.c	(revision 5813)
@@ -0,0 +1,129 @@
+/*****************************************************************************
+This routine must ensure that the psVectorFitPolynomial2D works correctly.
+We create a vectors of data points (x and y), and populate them with the
+values from an arbitrary function setData().  We then call
+psVectorFitPolynomial2D() with a regular polynomial data structure.  We then
+evaluate the polynomial with the coefficients generated above and determine
+if they are within an error tolerance of the expected values.
+     *****************************************************************************/
+#include <stdio.h>
+#include "pslib_strict.h"
+#include "psTest.h"
+#include "psMemory.h"
+#include "psVector.h"
+#include "psImage.h"
+#include "psMinimize.h"
+#include <math.h>
+#define NUM_DATA 10
+#define POLY_ORDER 3
+#define A 3.0
+#define B 2.0
+#define C 3.0
+#define D 3.0
+#define E 3.0
+#define F 3.0
+#define ERROR_TOLERANCE 0.10
+#define FERR 1.0
+#define VERBOSE 0
+
+double setData(double x, double y)
+{
+    return(A + (B * x) + (C * x * x) + (D * y) + (E * y * y) + (F * x * y));
+}
+
+psS32 t00()
+{
+    psS32 currentId = psMemGetId();
+    psS32 testStatus = true;
+    psS32 memLeaks = 0;
+    double expectData;
+    double actualData;
+
+    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);
+    psVector *f = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+    psVector *fErr = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
+
+    for (psS32 i=0;i<NUM_DATA;i++) {
+        x->data.F32[i] = (double) i;
+        y->data.F32[i] = (double) (2 * i);
+        f->data.F32[i] = setData(x->data.F32[i], y->data.F32[i]);
+        fErr->data.F32[i] = FERR;
+    }
+
+    printPositiveTestHeader(stdout,
+                            "psMinimize functions",
+                            "psVectorFitPolynomial2D(): equal difference in variable fErr");
+
+    psVectorFitPolynomial2D(myPoly, NULL, 0, f, fErr, x, y);
+
+    if (VERBOSE) {
+        for (psS32 i=0;i<POLY_ORDER+1;i++) {
+            for (psS32 j=0;j<POLY_ORDER+1;j++) {
+                printf("Polynomial coefficient %d is %0.1f\n", i, myPoly->coeff[i][j]);
+            }
+        }
+    }
+
+    for (psS32 i=0;i<NUM_DATA;i++) {
+        expectData = setData(x->data.F32[i],  y->data.F32[i]);
+        actualData = psPolynomial2DEval(myPoly, x->data.F32[i], y->data.F32[i]);
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("TEST ERROR: Fitted data %d: (%.1f %.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F32[i], y->data.F32[i], actualData, expectData);
+            testStatus = false;
+        }
+        if (VERBOSE) {
+            printf("GOOD: Data point [%d] is %f, should be %f.\n", i, actualData, expectData);
+        }
+    }
+
+
+    printf("Running test with fErr set to NULL.\n");
+    psVectorFitPolynomial2D(myPoly, NULL, 0, f, NULL, x, y);
+    for (psS32 i=0;i<NUM_DATA;i++) {
+        expectData = setData(x->data.F32[i],  y->data.F32[i]);
+        actualData = psPolynomial2DEval(myPoly, x->data.F32[i], y->data.F32[i]);
+        if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) {
+            printf("TEST ERROR: Fitted data %d: (%.1f %.1f %.1f), expected was (%.1f)\n",
+                   i, x->data.F32[i], y->data.F32[i], actualData, expectData);
+            testStatus = false;
+        }
+        if (VERBOSE) {
+            printf("Data point [%d] is %f, should be %f.\n", i, actualData, expectData);
+        }
+    }
+    psFree(myPoly);
+
+    printf("Running test with x, y set to NULL.  Should generate error.\n");
+    myPoly = psVectorFitPolynomial2D(NULL, NULL, 0, f, fErr, NULL, NULL);
+    if (myPoly != NULL) {
+        printf("TEST ERROR: psVectorFitPolynomial2D() returned non-NULL.\n");
+        testStatus = false;
+    }
+
+    psMemCheckCorruption(1);
+    psFree(x);
+    psFree(y);
+    psFree(f);
+    psFree(fErr);
+    psMemCheckCorruption(1);
+    memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
+    if (0 != memLeaks) {
+        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
+    }
+
+    printFooter(stdout,
+                "psMinimize functions",
+                "psVectorFitPolynomial2D(): equal differences in variable fErr",
+                testStatus);
+
+    return (!testStatus);
+}
+
+psS32 main()
+{
+    psLogSetFormat("HLNM");
+    t00();
+}
Index: trunk/psLib/test/math/tst_psStats07.c
===================================================================
--- trunk/psLib/test/math/tst_psStats07.c	(revision 5647)
+++ trunk/psLib/test/math/tst_psStats07.c	(revision 5813)
@@ -20,4 +20,5 @@
 psS32 t00()
 {
+
     psStats * myStats = NULL;
     psS32 testStatus = true;
@@ -510,4 +511,5 @@
 {
     psLogSetFormat("HLNM");
+    psLogSetLevel(PS_LOG_INFO);
     //
     // We list pertinent psStats.c functions here for debugging ease.