Index: trunk/psLib/test/math/Makefile.am =================================================================== --- trunk/psLib/test/math/Makefile.am (revision 5823) +++ trunk/psLib/test/math/Makefile.am (revision 6099) @@ -41,6 +41,8 @@ tst_psSpline1D \ tst_psRandom \ - tst_psPolyFit1DCheby \ - tst_psPolyFit1DOrd \ + tst_psPolyFit1D \ + tst_psPolyFit2D \ + tst_psPolyFit3D \ + tst_psPolyFit4D \ tst_psPolyFit2DOrd \ tst_psPolyFit3DOrd \ @@ -83,6 +85,8 @@ 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_psPolyFit1D_SOURCES = tst_psPolyFit1D.c +tst_psPolyFit2D_SOURCES = tst_psPolyFit2D.c +tst_psPolyFit3D_SOURCES = tst_psPolyFit3D.c +tst_psPolyFit4D_SOURCES = tst_psPolyFit4D.c tst_psPolyFit2DOrd_SOURCES = tst_psPolyFit2DOrd.c tst_psPolyFit3DOrd_SOURCES = tst_psPolyFit3DOrd.c Index: trunk/psLib/test/math/tst_psMinimize05.c =================================================================== --- trunk/psLib/test/math/tst_psMinimize05.c (revision 5823) +++ trunk/psLib/test/math/tst_psMinimize05.c (revision 6099) @@ -7,7 +7,7 @@ *****************************************************************************/ #include -#include "pslib_strict.h" +#include +#include "pslib.h" #include "psTest.h" -#include #define N 5 #define MIN_VALUE 20.0 Index: trunk/psLib/test/math/tst_psPolyFit1D.c =================================================================== --- trunk/psLib/test/math/tst_psPolyFit1D.c (revision 6099) +++ trunk/psLib/test/math/tst_psPolyFit1D.c (revision 6099) @@ -0,0 +1,507 @@ +/***************************************************************************** +This routine must ensure that various psLib functions which fit 1D polynomials +to data work correctly. There is a function genericTest() which creates +vectors of data points (x and f), and populates them with the values from an +arbitrary function setData(). It then calls appropriate 1D fitting function. +It then evaluates the polynomial with the coefficients generated above and +determines if they are within an error tolerance of the expected values. + +XXX: Try null stats. + *****************************************************************************/ +#include +#include +#include "pslib.h" +#include "psTest.h" +#define NUM_DATA 35 +#define POLY_ORDER 4 +#define A 2.0 +#define B 3.0 +#define C 4.0 +#define D 5.0 +#define E 6.0 +#define ERROR_TOLERANCE 0.10 +#define YERR 10.0 +#define VERBOSE 0 +#define NUM_ITERATIONS 5 +#define CLIP_SIGMA 4.0 +#define OUTLIERS true +#define MASK_VALUE 1 + +#define TS00_F_NULL 0x00000001 +#define TS00_F_F32 0x00000002 +#define TS00_F_F64 0x00000004 +#define TS00_F_S32 0x00000008 +#define TS00_X_NULL 0x00000010 +#define TS00_X_F32 0x00000020 +#define TS00_X_F64 0x00000040 +#define TS00_X_S32 0x00000080 +#define TS00_FERR_NULL 0x00000100 +#define TS00_FERR_F32 0x00000200 +#define TS00_FERR_F64 0x00000400 +#define TS00_FERR_S32 0x00000800 +#define TS00_MASK_NULL 0x00001000 +#define TS00_MASK_U8 0x00002000 +#define TS00_MASK_S32 0x00004000 +#define TS00_POLY_ORD 0x00008000 +#define TS00_POLY_CHEB 0x00010000 +#define TS00_CLIP_FIT 0x00020000 + +psF32 setData(psF32 x) +{ + return(A + (B * x) + (C * x * x) + (D * x * x * x) + (E * x * x * x * x)); +} + +psS32 genericTest( + psU32 flags, + psS32 polyOrder, + psS32 numData, + psBool expectedRC) +{ + psS32 currentId = psMemGetId(); + psS32 testStatus = true; + psS32 memLeaks = 0; + psPolynomial1D *myPoly = NULL; + psVector *x = NULL; + psVector *f = NULL; + psVector *mask = NULL; + psVector *fErr = NULL; + psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + stats->clipSigma = CLIP_SIGMA; + stats->clipIter = NUM_ITERATIONS; + + printPositiveTestHeader(stdout, "psMinimize functions", "1D Polynomial Fitting Functions"); + + if (expectedRC == false) { + printf("This test should generate an error message, and return NULL.\n"); + } + + if (flags & TS00_CLIP_FIT) { + printf(" performing a clip-fit\n"); + } else { + printf(" performing a non clip-fit\n"); + } + + if (flags & TS00_POLY_ORD) { + printf(" using ordinary polynomials\n"); + myPoly = psPolynomial1DAlloc(polyOrder, PS_POLYNOMIAL_ORD); + } + + if (flags & TS00_POLY_CHEB) { + printf(" using chebyshev polynomials\n"); + myPoly = psPolynomial1DAlloc(polyOrder, PS_POLYNOMIAL_CHEB); + } + + if (flags & TS00_X_NULL) { + printf(" using a NULL x vector\n"); + } + + if (flags & TS00_X_F32) { + printf(" using a psF32 x vector\n"); + x = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = (psF32) i; + } + + if (flags & TS00_POLY_CHEB) { + p_psNormalizeVectorRangeF32(x, -1.0, 1.0); + } + } + + if (flags & TS00_X_S32) { + printf(" using a psS32 x vector\n"); + x = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) i; + } + + if (flags & TS00_POLY_CHEB) { + p_psNormalizeVectorRangeS32(x, -1, 1); + } + } + + if (flags & TS00_X_F64) { + printf(" using a psF64 x vector\n"); + x = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) i; + } + + if (flags & TS00_POLY_CHEB) { + p_psNormalizeVectorRangeF64(x, -1.0, 1.0); + } + } + + if (flags & TS00_F_NULL) { + printf(" using a NULL f vector\n"); + } + + if (flags & TS00_F_F32) { + printf(" using a psF32 f vector\n"); + f = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = setData((psF32) i); + } + // Set a few outliers in the data. + if (OUTLIERS && (flags & TS00_CLIP_FIT)) { + f->data.F32[numData/4]*= 2.0; + f->data.F32[numData/2]*= 2.0; + f->data.F32[3*numData/4]*= 2.0; + } + + if (VERBOSE) { + for (psS32 i=0;idata.F32[i]); + } + } + } + + if (flags & TS00_F_S32) { + printf(" using a psS32 f vector\n"); + f = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) setData((psF32) i); + } + // Set a few outliers in the data. + if (OUTLIERS && (flags & TS00_CLIP_FIT)) { + f->data.S32[numData/4]*= 2.0; + f->data.S32[numData/2]*= 2.0; + f->data.S32[3*numData/4]*= 2.0; + } + + if (VERBOSE) { + for (psS32 i=0;idata.S32[i]); + } + } + } + + if (flags & TS00_F_F64) { + printf(" using a psF64 f vector\n"); + f = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) setData((psF32) i); + } + // Set a few outliers in the data. + if (OUTLIERS && (flags & TS00_CLIP_FIT)) { + f->data.F64[numData/4]*= 2.0; + f->data.F64[numData/2]*= 2.0; + f->data.F64[3*numData/4]*= 2.0; + } + + if (VERBOSE) { + for (psS32 i=0;idata.F64[i]); + } + } + } + + if (flags & TS00_FERR_NULL) { + printf(" using a NULL fErr vector\n"); + } + + if (flags & TS00_FERR_F32) { + printf(" using a psF32 fErr vector\n"); + fErr = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = YERR; + } + } + + if (flags & TS00_FERR_S32) { + printf(" using a psS32 fErr vector\n"); + fErr = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) YERR; + } + } + + if (flags & TS00_FERR_F64) { + printf(" using a psF64 fErr vector\n"); + fErr = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = YERR; + } + } + + if (flags & TS00_MASK_NULL) { + printf(" using a NULL mask vector\n"); + } + + if (flags & TS00_MASK_U8) { + printf(" using a psU8 mask vector\n"); + mask = psVectorAlloc(numData, PS_TYPE_U8); + for (psS32 i=0;idata.U8[i] = 0; + } + } + + if (flags & TS00_MASK_S32) { + printf(" using a psS32 mask vector\n"); + mask = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = 0; + } + } + + psPolynomial1D *rc = NULL; + if (flags & TS00_CLIP_FIT) { + rc = psVectorClipFitPolynomial1D(myPoly, stats, mask, MASK_VALUE, f, fErr, x); + } else { + rc = psVectorFitPolynomial1D(myPoly, mask, MASK_VALUE, f, fErr, x); + } + + if (rc == NULL) { + if (expectedRC == true) { + printf("TEST ERROR: the 1D polynomial fitting function returned NULL.\n"); + testStatus = false; + } + } else { + if (expectedRC == false) { + printf("TEST ERROR: the 1D polynomial fitting function returned non-NULL.\n"); + testStatus = false; + } + + if (VERBOSE) { + for (psS32 i=0;icoeff[i]); + } + } + + for (psS32 i=0 ;idata.F32[i]; + } else if (flags & TS00_F_F64) { + expectData = (psF32) f->data.F64[i]; + } else if (flags & TS00_F_S32) { + expectData = (psF32) f->data.S32[i]; + } + + if (flags & TS00_X_F32) { + xData = x->data.F32[i]; + } else if (flags & TS00_X_F64) { + xData = (psF32) x->data.F64[i]; + } else if (flags & TS00_X_S32) { + xData = (psF32) x->data.S32[i]; + } else if (flags & TS00_X_NULL) { + if (flags & TS00_POLY_ORD) { + xData = (psF32) i; + } else if (flags & TS00_POLY_CHEB) { + xData = ((2.0 / ((psF32) (numData - 1))) * ((psF32) i)) - 1.0; + } + } + + psF32 actualData = psPolynomial1DEval(myPoly, xData); + + if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { + printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", + i, xData, actualData, expectData); + testStatus = false; + } else { + if (VERBOSE) { + printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", + i, xData, actualData, expectData); + } + } + } + } + + psMemCheckCorruption(1); + psFree(myPoly); + psFree(mask); + psFree(x); + psFree(f); + psFree(fErr); + psFree(stats); + psMemCheckCorruption(1); + memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); + if (0 != memLeaks) { + psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); + } + + printFooter(stdout, "psMinimize functions", "1D Polynomial Fitting Functions", testStatus); + + return (testStatus); +} + +/***************************************************************************** +We test a variety of polynomial fitting routines, types, and polynomial types +here: + F32 tests: Ordinary polys, non-clip fit + F64 tests: Ordinary polys, non-clip fit + F32 tests: Chebyshev polys, non-clip fit + F64 tests: Chebyshev polys, non-clip fit + F32 tests: Ordinary polys, clip fit + F64 tests: Ordinary polys, clip fit + F32 tests: Chebyshev polys, clip fit + F64 tests: Chebyshev polys, clip fit + *****************************************************************************/ +psS32 main() +{ + psBool testStatus = true; + psLogSetFormat("HLNM"); + psTraceSetLevel(".", 0); + psTraceSetLevel("psVectorClipFitPolynomial1D", 0); + psTraceSetLevel("VectorFitPolynomial1DOrd", 0); + psTraceSetLevel("VectorFitPolynomial1DCheb", 0); + psTraceSetLevel("vectorFitPolynomial1DChebSlow", 0); + psTraceSetLevel("vectorFitPolynomial1DChebFast", 0); + psTraceSetLevel("psVectorFitPolynomial1D", 0); + + printPositiveTestHeader(stdout, "psMinimize functions: 1D Polynomial Fitting Functions", ""); + + // + // F32 tests: Ordinary polys, non-clip fit + // + // All Vectors non-NULL + + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_NULL | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_NULL | TS00_X_NULL | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_NULL | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, false); + // Unallowable vector types + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_S32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_S32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_S32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, false); + + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + + // + // F64 tests: Ordinary polys, non-clip fit + // + // All Vectors non-NULL + + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F64 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_NULL | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_NULL | TS00_X_NULL | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_F_NULL | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F64 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER, NUM_DATA, true); + + + // + // F32 tests: Chebyshev polys, non-clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F32 | TS00_F_F32 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_NULL | TS00_F_F32 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_NULL | TS00_X_NULL | TS00_F_F32 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_NULL | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_F_F32 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + + + // + // F64 tests: Chebyshev polys, non-clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F64 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F64 | TS00_F_F64 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_NULL | TS00_F_F64 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_NULL | TS00_X_NULL | TS00_F_F64 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_F_NULL | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F64 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_F_F64 | TS00_POLY_CHEB, POLY_ORDER, NUM_DATA, true); + + // + // F32 tests: Ordinary polys, clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_NULL | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_NULL | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_NULL | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + + + // + // F64 tests: Ordinary polys, clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_NULL | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_F_NULL | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F64 | TS00_X_F64 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F64 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + + + // + // F32 tests: Chebyshev polys, clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F32 | TS00_F_F32 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_NULL | TS00_F_F32 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_NULL | TS00_F_F32 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_NULL | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F32 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_F_F32 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_F_F32 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + + + // + // F64 tests: Chebyshev polys, clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F64 | TS00_F_F64 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_NULL | TS00_F_F64 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, true); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_F_NULL | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F64 | TS00_X_F64 | TS00_F_F32 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F64 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_F_F64 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_F_F64 | TS00_POLY_CHEB | TS00_CLIP_FIT, POLY_ORDER, NUM_DATA, false); + + printFooter(stdout, "psMinimize functions: 1D Polynomial Fitting Functions", "", testStatus); +} + Index: trunk/psLib/test/math/tst_psPolyFit1DCheby.c =================================================================== --- trunk/psLib/test/math/tst_psPolyFit1DCheby.c (revision 5823) +++ (revision ) @@ -1,480 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psVectorFitPolynomial1D works correctly. - - We use Chebyshev polynomials here. - - We use psF32 and psF64 types here. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psMinimize.h" -#include -#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;idata.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;icoeff[i]); - } - } - - for (i=IGNORE;idata.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;idata.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;idata.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;idata.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;idata.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;idata.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;icoeff[i]); - } - } - - for (i=IGNORE;idata.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;idata.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;idata.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;idata.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;idata.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 5823) +++ (revision ) @@ -1,518 +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. - - 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 -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psMinimize.h" -#include -#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;idata.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;icoeff[i]); - } - } - - for (i=0;idata.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;idata.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;icoeff[i]); - } - } - - for (i=0;idata.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;idata.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;icoeff[i]); - } - } - - for (i=0;i 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;idata.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;icoeff[i]); - } - } - - for (i=0;idata.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;idata.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;icoeff[i]); - } - } - - for (i=0;idata.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;idata.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;icoeff[i]); - } - } - - for (i=0;i 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_psPolyFit2D.c =================================================================== --- trunk/psLib/test/math/tst_psPolyFit2D.c (revision 6099) +++ trunk/psLib/test/math/tst_psPolyFit2D.c (revision 6099) @@ -0,0 +1,460 @@ +/***************************************************************************** +This routine must ensure that various psLib functions which fit 2D polynomials +to data work correctly. There is a function genericTest() which creates +vectors of data points (x and f), and populates them with the values from an +arbitrary function setData(). It then calls appropriate 2D fitting function. +It then evaluates the polynomial with the coefficients generated above and +determines if they are within an error tolerance of the expected values. + *****************************************************************************/ +#include +#include +#include "pslib.h" +#include "psTest.h" +#define NUM_DATA 35 +#define POLY_ORDER_X 2 +#define POLY_ORDER_Y 3 +#define A 2.0 +#define B 3.0 +#define C 4.0 +#define D 5.0 +#define E 6.0 +#define F 4.0 +#define ERROR_TOLERANCE 0.10 +#define YERR 10.0 +#define VERBOSE 0 +#define NUM_ITERATIONS 5 +#define CLIP_SIGMA 4.0 +#define OUTLIERS true +#define MASK_VALUE 1 + +#define TS00_F_NULL 0x00000001 +#define TS00_F_F32 0x00000002 +#define TS00_F_F64 0x00000004 +#define TS00_F_S32 0x00000008 +#define TS00_X_NULL 0x00000010 +#define TS00_X_F32 0x00000020 +#define TS00_X_F64 0x00000040 +#define TS00_X_S32 0x00000080 +#define TS00_FERR_NULL 0x00000100 +#define TS00_FERR_F32 0x00000200 +#define TS00_FERR_F64 0x00000400 +#define TS00_FERR_S32 0x00000800 +#define TS00_MASK_NULL 0x00001000 +#define TS00_MASK_U8 0x00002000 +#define TS00_MASK_S32 0x00004000 +#define TS00_POLY_ORD 0x00008000 +#define TS00_POLY_CHEB 0x00010000 +#define TS00_CLIP_FIT 0x00020000 +#define TS00_Y_NULL 0x00100000 +#define TS00_Y_F32 0x00200000 +#define TS00_Y_F64 0x00400000 +#define TS00_Y_S32 0x00800000 + +psF32 setData(psF32 x, psF32 y) +{ + return(A + (B * x) + (C * x * x) + (D * y) + (E * y * y) + (F * x * y)); +} + +psS32 genericTest( + psU32 flags, + psS32 polyOrderX, + psS32 polyOrderY, + psS32 numData, + psBool expectedRC) +{ + psS32 currentId = psMemGetId(); + psS32 testStatus = true; + psS32 memLeaks = 0; + psPolynomial2D *myPoly = NULL; + psVector *x = NULL; + psVector *y = NULL; + psVector *f = NULL; + psVector *mask = NULL; + psVector *fErr = NULL; + psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + stats->clipSigma = CLIP_SIGMA; + stats->clipIter = NUM_ITERATIONS; + + printPositiveTestHeader(stdout, "psMinimize functions", "2D Polynomial Fitting Functions"); + + if (expectedRC == false) { + printf("This test should generate an error message, and return NULL.\n"); + } + + if (flags & TS00_CLIP_FIT) { + printf(" performing a clip-fit\n"); + } else { + printf(" performing a non clip-fit\n"); + } + + if (flags & TS00_POLY_ORD) { + printf(" using ordinary polynomials\n"); + myPoly = psPolynomial2DAlloc(polyOrderX, polyOrderY, PS_POLYNOMIAL_ORD); + } + + if (flags & TS00_X_NULL) { + printf(" using a NULL x vector\n"); + } + + if (flags & TS00_X_F32) { + printf(" using a psF32 x vector\n"); + x = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = (psF32) i; + } + } + + if (flags & TS00_X_S32) { + printf(" using a psS32 x vector\n"); + x = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) i; + } + } + + if (flags & TS00_X_F64) { + printf(" using a psF64 x vector\n"); + x = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) i; + } + } + + + if (flags & TS00_Y_NULL) { + printf(" using a NULL y vector\n"); + } + + if (flags & TS00_Y_F32) { + printf(" using a psF32 y vector\n"); + y = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = (psF32) i; + } + } + + if (flags & TS00_Y_S32) { + printf(" using a psS32 y vector\n"); + y = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) i; + } + } + + if (flags & TS00_Y_F64) { + printf(" using a psF64 y vector\n"); + y = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) i; + } + } + + if (flags & TS00_F_NULL) { + printf(" using a NULL f vector\n"); + } + + if (flags & TS00_F_F32) { + printf(" using a psF32 f vector\n"); + f = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = setData((psF32) i, (psF32) i); + } + // Set a few outliers in the data. + if (OUTLIERS && (flags & TS00_CLIP_FIT)) { + f->data.F32[numData/4]*= 2.0; + f->data.F32[numData/2]*= 2.0; + f->data.F32[3*numData/4]*= 2.0; + } + + if (VERBOSE) { + for (psS32 i=0;idata.F32[i]); + } + } + } + + if (flags & TS00_F_S32) { + printf(" using a psS32 f vector\n"); + f = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) setData((psF32) i, (psF32) i); + } + // Set a few outliers in the data. + if (OUTLIERS && (flags & TS00_CLIP_FIT)) { + f->data.S32[numData/4]*= 2.0; + f->data.S32[numData/2]*= 2.0; + f->data.S32[3*numData/4]*= 2.0; + } + + if (VERBOSE) { + for (psS32 i=0;idata.S32[i]); + } + } + } + + if (flags & TS00_F_F64) { + printf(" using a psF64 f vector\n"); + f = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) setData((psF32) i, (psF32) i); + } + // Set a few outliers in the data. + if (OUTLIERS && (flags & TS00_CLIP_FIT)) { + f->data.F64[numData/4]*= 2.0; + f->data.F64[numData/2]*= 2.0; + f->data.F64[3*numData/4]*= 2.0; + } + + if (VERBOSE) { + for (psS32 i=0;idata.F64[i]); + } + } + } + + if (flags & TS00_FERR_NULL) { + printf(" using a NULL fErr vector\n"); + } + + if (flags & TS00_FERR_F32) { + printf(" using a psF32 fErr vector\n"); + fErr = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = YERR; + } + } + + if (flags & TS00_FERR_S32) { + printf(" using a psS32 fErr vector\n"); + fErr = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) YERR; + } + } + + if (flags & TS00_FERR_F64) { + printf(" using a psF64 fErr vector\n"); + fErr = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = YERR; + } + } + + if (flags & TS00_MASK_NULL) { + printf(" using a NULL mask vector\n"); + } + + if (flags & TS00_MASK_U8) { + printf(" using a psU8 mask vector\n"); + mask = psVectorAlloc(numData, PS_TYPE_U8); + for (psS32 i=0;idata.U8[i] = 0; + } + } + + if (flags & TS00_MASK_S32) { + printf(" using a psS32 mask vector\n"); + mask = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = 0; + } + } + + psPolynomial2D *rc = NULL; + if (flags & TS00_CLIP_FIT) { + rc = psVectorClipFitPolynomial2D(myPoly, stats, mask, MASK_VALUE, f, fErr, x, y); + } else { + rc = psVectorFitPolynomial2D(myPoly, mask, MASK_VALUE, f, fErr, x, y); + } + + if (rc == NULL) { + if (expectedRC == true) { + printf("TEST ERROR: the 2D polynomial fitting function returned NULL.\n"); + testStatus = false; + } + } else { + if (expectedRC == false) { + printf("TEST ERROR: the 2D polynomial fitting function returned non-NULL.\n"); + testStatus = false; + } + + if (VERBOSE) { + for (psS32 i=0;icoeff[i][j]); + } + } + } + + for (psS32 i=0 ;idata.F32[i]; + } else if (flags & TS00_F_F64) { + expectData = (psF32) f->data.F64[i]; + } else if (flags & TS00_F_S32) { + expectData = (psF32) f->data.S32[i]; + } + + if (flags & TS00_X_F32) { + xData = x->data.F32[i]; + } else if (flags & TS00_X_F64) { + xData = (psF32) x->data.F64[i]; + } else if (flags & TS00_X_S32) { + xData = (psF32) x->data.S32[i]; + } else if (flags & TS00_X_NULL) { + xData = (psF32) i; + } + + if (flags & TS00_Y_F32) { + yData = y->data.F32[i]; + } else if (flags & TS00_Y_F64) { + yData = (psF32) y->data.F64[i]; + } else if (flags & TS00_Y_S32) { + yData = (psF32) y->data.S32[i]; + } else if (flags & TS00_Y_NULL) { + yData = (psF32) i; + } + + psF32 actualData = psPolynomial2DEval(myPoly, xData, yData); + + if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { + printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", + i, xData, actualData, expectData); + testStatus = false; + } else { + if (VERBOSE) { + printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", + i, xData, actualData, expectData); + } + } + } + } + + psMemCheckCorruption(1); + psFree(myPoly); + psFree(mask); + psFree(x); + psFree(y); + psFree(f); + psFree(fErr); + psFree(stats); + psMemCheckCorruption(1); + memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); + if (0 != memLeaks) { + psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); + } + + printFooter(stdout, "psMinimize functions", "2D Polynomial Fitting Functions", testStatus); + + return (testStatus); +} + +/***************************************************************************** +We test a variety of polynomial fitting routines, types, and polynomial types +here: + F32 tests: Ordinary polys, non-clip fit + F64 tests: Ordinary polys, non-clip fit + F32 tests: Chebyshev polys, non-clip fit + F64 tests: Chebyshev polys, non-clip fit + F32 tests: Ordinary polys, clip fit + F64 tests: Ordinary polys, clip fit + F32 tests: Chebyshev polys, clip fit + F64 tests: Chebyshev polys, clip fit + *****************************************************************************/ +psS32 main() +{ + psBool testStatus = true; + psLogSetFormat("HLNM"); + psTraceSetLevel(".", 0); + psTraceSetLevel("psVectorClipFitPolynomial2D", 0); + psTraceSetLevel("VectorFitPolynomial2DOrd", 0); + psTraceSetLevel("psVectorFitPolynomial2D", 0); + + printPositiveTestHeader(stdout, "psMinimize functions: 2D Polynomial Fitting Functions", ""); + + // + // F32 tests: Ordinary polys, non-clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F32 | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_NULL | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_NULL | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_F_NULL | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F64 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + + // + // F64 tests: Ordinary polys, non-clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F64 | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_NULL | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_NULL | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_F_NULL | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F32 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + + // + // F32 tests: Ordinary polys, clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F32 | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_NULL | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_NULL | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_F_NULL | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F64 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + + // + // F64 tests: Ordinary polys, clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F64 | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_NULL | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_NULL | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_F_NULL | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F32 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, NUM_DATA, false); + + printFooter(stdout, "psMinimize functions: 2D Polynomial Fitting Functions", "", testStatus); +} Index: trunk/psLib/test/math/tst_psPolyFit2DOrd.c =================================================================== --- trunk/psLib/test/math/tst_psPolyFit2DOrd.c (revision 5823) +++ (revision ) @@ -1,129 +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. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psMinimize.h" -#include -#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;idata.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;icoeff[i][j]); - } - } - } - - for (psS32 i=0;idata.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;idata.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_psPolyFit3D.c =================================================================== --- trunk/psLib/test/math/tst_psPolyFit3D.c (revision 6099) +++ trunk/psLib/test/math/tst_psPolyFit3D.c (revision 6099) @@ -0,0 +1,528 @@ +/***************************************************************************** +This routine must ensure that various psLib functions which fit 3D polynomials +to data work correctly. There is a function genericTest() which creates +vectors of data points (x and f), and populates them with the values from an +arbitrary function setData(). It then calls appropriate 3D fitting function. +It then evaluates the polynomial with the coefficients generated above and +determines if they are within an error tolerance of the expected values. + *****************************************************************************/ +#include +#include +#include "pslib.h" +#include "psTest.h" +#define NUM_DATA 35 +#define POLY_ORDER_X 2 +#define POLY_ORDER_Y 3 +#define POLY_ORDER_Z 2 +#define A 1.0 +#define B 2.0 +#define C 3.0 +#define D 4.0 +#define E 5.0 +#define F 4.0 +#define H 3.0 +#define J 3.0 +#define K 1.0 +#define L 5.0 +#define ERROR_TOLERANCE 0.10 +#define YERR 10.0 +#define VERBOSE 0 +#define NUM_ITERATIONS 5 +#define CLIP_SIGMA 4.0 +#define OUTLIERS true +#define MASK_VALUE 1 + +#define TS00_F_NULL 0x00000001 +#define TS00_F_F32 0x00000002 +#define TS00_F_F64 0x00000004 +#define TS00_F_S32 0x00000008 +#define TS00_X_NULL 0x00000010 +#define TS00_X_F32 0x00000020 +#define TS00_X_F64 0x00000040 +#define TS00_X_S32 0x00000080 +#define TS00_FERR_NULL 0x00000100 +#define TS00_FERR_F32 0x00000200 +#define TS00_FERR_F64 0x00000400 +#define TS00_FERR_S32 0x00000800 +#define TS00_MASK_NULL 0x00001000 +#define TS00_MASK_U8 0x00002000 +#define TS00_MASK_S32 0x00004000 +#define TS00_POLY_ORD 0x00008000 +#define TS00_POLY_CHEB 0x00010000 +#define TS00_CLIP_FIT 0x00020000 +#define TS00_Y_NULL 0x00100000 +#define TS00_Y_F32 0x00200000 +#define TS00_Y_F64 0x00400000 +#define TS00_Y_S32 0x00800000 +#define TS00_Z_NULL 0x01000000 +#define TS00_Z_F32 0x02000000 +#define TS00_Z_F64 0x04000000 +#define TS00_Z_S32 0x08000000 + +psF32 setData(psF32 x, psF32 y, psF32 z) +{ + if (0) { + // Linear case, for testing. + return(A + (B * x) + (D * y) + (H * z)); + } else { + return(A + (B * x) + (C * x * x) + (D * y) + (E * y * y) + (F * x * y) + (H * z) + + (J * z * z) + (K * x * z) + (L * y * z)); + } +} + +psS32 genericTest( + psU32 flags, + psS32 polyOrderX, + psS32 polyOrderY, + psS32 polyOrderZ, + psS32 numData, + psBool expectedRC) +{ + psS32 currentId = psMemGetId(); + psS32 testStatus = true; + psS32 memLeaks = 0; + psPolynomial3D *myPoly = NULL; + psVector *x = NULL; + psVector *y = NULL; + psVector *z = NULL; + psVector *f = NULL; + psVector *mask = NULL; + psVector *fErr = NULL; + psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + stats->clipSigma = CLIP_SIGMA; + stats->clipIter = NUM_ITERATIONS; + + printPositiveTestHeader(stdout, "psMinimize functions", "3D Polynomial Fitting Functions"); + + if (expectedRC == false) { + printf("This test should generate an error message, and return NULL.\n"); + } + + if (flags & TS00_CLIP_FIT) { + printf(" performing a clip-fit\n"); + } else { + printf(" performing a non clip-fit\n"); + } + + if (flags & TS00_POLY_ORD) { + printf(" using ordinary polynomials\n"); + myPoly = psPolynomial3DAlloc(polyOrderX, polyOrderY, polyOrderZ, PS_POLYNOMIAL_ORD); + } + + if (flags & TS00_X_NULL) { + printf(" using a NULL x vector\n"); + } + + if (flags & TS00_X_F32) { + printf(" using a psF32 x vector\n"); + x = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = (psF32) i; + } + } + + if (flags & TS00_X_S32) { + printf(" using a psS32 x vector\n"); + x = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) i; + } + } + + if (flags & TS00_X_F64) { + printf(" using a psF64 x vector\n"); + x = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) i; + } + } + + + if (flags & TS00_Y_NULL) { + printf(" using a NULL y vector\n"); + } + + if (flags & TS00_Y_F32) { + printf(" using a psF32 y vector\n"); + y = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = (psF32) i; + } + } + + if (flags & TS00_Y_S32) { + printf(" using a psS32 y vector\n"); + y = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) i; + } + } + + if (flags & TS00_Y_F64) { + printf(" using a psF64 y vector\n"); + y = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) i; + } + } + + if (flags & TS00_Z_NULL) { + printf(" using a NULL z vector\n"); + } + + if (flags & TS00_Z_F32) { + printf(" using a psF32 z vector\n"); + z = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = (psF32) i; + } + } + + if (flags & TS00_Z_S32) { + printf(" using a psS32 z vector\n"); + z = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) i; + } + } + + if (flags & TS00_Z_F64) { + printf(" using a psF64 z vector\n"); + z = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) i; + } + } + + + if (flags & TS00_F_NULL) { + printf(" using a NULL f vector\n"); + } + + if (flags & TS00_F_F32) { + printf(" using a psF32 f vector\n"); + f = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = setData((psF32) i, (psF32) i, (psF32) i); + } + // Set a few outliers in the data. + if (OUTLIERS && (flags & TS00_CLIP_FIT)) { + f->data.F32[numData/4]*= 2.0; + f->data.F32[numData/2]*= 2.0; + f->data.F32[3*numData/4]*= 2.0; + } + + if (VERBOSE) { + for (psS32 i=0;idata.F32[i]); + } + } + } + + if (flags & TS00_F_S32) { + printf(" using a psS32 f vector\n"); + f = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) setData((psF32) i, (psF32) i, (psF32) i); + } + // Set a few outliers in the data. + if (OUTLIERS && (flags & TS00_CLIP_FIT)) { + f->data.S32[numData/4]*= 2.0; + f->data.S32[numData/2]*= 2.0; + f->data.S32[3*numData/4]*= 2.0; + } + + if (VERBOSE) { + for (psS32 i=0;idata.S32[i]); + } + } + } + + if (flags & TS00_F_F64) { + printf(" using a psF64 f vector\n"); + f = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) setData((psF32) i, (psF32) i, (psF32) i); + } + // Set a few outliers in the data. + if (OUTLIERS && (flags & TS00_CLIP_FIT)) { + f->data.F64[numData/4]*= 2.0; + f->data.F64[numData/2]*= 2.0; + f->data.F64[3*numData/4]*= 2.0; + } + + if (VERBOSE) { + for (psS32 i=0;idata.F64[i]); + } + } + } + + if (flags & TS00_FERR_NULL) { + printf(" using a NULL fErr vector\n"); + } + + if (flags & TS00_FERR_F32) { + printf(" using a psF32 fErr vector\n"); + fErr = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = YERR; + } + } + + if (flags & TS00_FERR_S32) { + printf(" using a psS32 fErr vector\n"); + fErr = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) YERR; + } + } + + if (flags & TS00_FERR_F64) { + printf(" using a psF64 fErr vector\n"); + fErr = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = YERR; + } + } + + if (flags & TS00_MASK_NULL) { + printf(" using a NULL mask vector\n"); + } + + if (flags & TS00_MASK_U8) { + printf(" using a psU8 mask vector\n"); + mask = psVectorAlloc(numData, PS_TYPE_U8); + for (psS32 i=0;idata.U8[i] = 0; + } + } + + if (flags & TS00_MASK_S32) { + printf(" using a psS32 mask vector\n"); + mask = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = 0; + } + } + + psPolynomial3D *rc = NULL; + if (flags & TS00_CLIP_FIT) { + rc = psVectorClipFitPolynomial3D(myPoly, stats, mask, MASK_VALUE, f, fErr, x, y, z); + } else { + rc = psVectorFitPolynomial3D(myPoly, mask, MASK_VALUE, f, fErr, x, y, z); + } + + if (rc == NULL) { + if (expectedRC == true) { + printf("TEST ERROR: the 3D polynomial fitting function returned NULL.\n"); + testStatus = false; + } + } else { + if (expectedRC == false) { + printf("TEST ERROR: the 3D polynomial fitting function returned non-NULL.\n"); + testStatus = false; + } + + if (VERBOSE) { + for (psS32 i=0;icoeff[i][j][k]); + } + } + } + } + + for (psS32 i=0 ;idata.F32[i]; + } else if (flags & TS00_F_F64) { + expectData = (psF32) f->data.F64[i]; + } else if (flags & TS00_F_S32) { + expectData = (psF32) f->data.S32[i]; + } + + if (flags & TS00_X_F32) { + xData = x->data.F32[i]; + } else if (flags & TS00_X_F64) { + xData = (psF32) x->data.F64[i]; + } else if (flags & TS00_X_S32) { + xData = (psF32) x->data.S32[i]; + } else if (flags & TS00_X_NULL) { + xData = (psF32) i; + } + + if (flags & TS00_Y_F32) { + yData = y->data.F32[i]; + } else if (flags & TS00_Y_F64) { + yData = (psF32) y->data.F64[i]; + } else if (flags & TS00_Y_S32) { + yData = (psF32) y->data.S32[i]; + } else if (flags & TS00_Y_NULL) { + yData = (psF32) i; + } + + if (flags & TS00_Z_F32) { + zData = z->data.F32[i]; + } else if (flags & TS00_Z_F64) { + zData = (psF32) z->data.F64[i]; + } else if (flags & TS00_Z_S32) { + zData = (psF32) z->data.S32[i]; + } else if (flags & TS00_Z_NULL) { + zData = (psF32) i; + } + + psF32 actualData = psPolynomial3DEval(myPoly, xData, yData, zData); + + if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { + printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", + i, xData, actualData, expectData); + testStatus = false; + } else { + if (VERBOSE) { + printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", + i, xData, actualData, expectData); + } + } + } + } + + psMemCheckCorruption(1); + psFree(myPoly); + psFree(mask); + psFree(x); + psFree(y); + psFree(z); + psFree(f); + psFree(fErr); + psFree(stats); + psMemCheckCorruption(1); + memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); + if (0 != memLeaks) { + psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); + } + + printFooter(stdout, "psMinimize functions", "3D Polynomial Fitting Functions", testStatus); + + return (testStatus); +} + +/***************************************************************************** +We test a variety of polynomial fitting routines, types, and polynomial types +here: + F32 tests: Ordinary polys, non-clip fit + F64 tests: Ordinary polys, non-clip fit + F32 tests: Chebyshev polys, non-clip fit + F64 tests: Chebyshev polys, non-clip fit + F32 tests: Ordinary polys, clip fit + F64 tests: Ordinary polys, clip fit + F32 tests: Chebyshev polys, clip fit + F64 tests: Chebyshev polys, clip fit + *****************************************************************************/ +psS32 main() +{ + psBool testStatus = true; + psLogSetFormat("HLNM"); + psTraceSetLevel(".", 0); + psTraceSetLevel("psVectorClipFitPolynomial3D", 0); + psTraceSetLevel("VectorFitPolynomial3DOrd", 0); + psTraceSetLevel("psVectorFitPolynomial3D", 0); + + printPositiveTestHeader(stdout, "psMinimize functions: 3D Polynomial Fitting Functions", ""); + + // + // F32 tests: Ordinary polys, non-clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_NULL | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_NULL | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_NULL | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F64 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F64 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + + // + // F64 tests: Ordinary polys, non-clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_NULL | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_NULL | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_NULL | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F32 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F32 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + + // + // F32 tests: Ordinary polys, clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_NULL | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_NULL | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_NULL | TS00_Z_NULL | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_NULL | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F64 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F64 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + + // + // F64 tests: Ordinary polys, clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_NULL | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_NULL | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_NULL | TS00_Z_NULL | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_NULL | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F32 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F32 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, NUM_DATA, false); + + printFooter(stdout, "psMinimize functions: 3D Polynomial Fitting Functions", "", testStatus); +} Index: trunk/psLib/test/math/tst_psPolyFit3DOrd.c =================================================================== --- trunk/psLib/test/math/tst_psPolyFit3DOrd.c (revision 5823) +++ (revision ) @@ -1,261 +1,0 @@ -/***************************************************************************** -This routine must ensure that the psVectorFitPolynomial3D 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 -psVectorFitPolynomial3D() 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 -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psMinimize.h" -#include -#define NUM_DATA 10 -#define POLY_ORDER 3 -#define A 1.0 -#define B 2.0 -#define C 3.0 -#define D 4.0 -#define E 5.0 -#define F 4.0 -#define H 3.0 -#define J 3.0 -#define K 1.0 -#define L 5.0 -#define ERROR_TOLERANCE 0.10 -#define FERR 1.0 -#define VERBOSE 0 - -psF32 setDataF32(psF32 x, psF32 y, psF32 z) -{ - if (0) { - // Linear case, for testing. - return(A + (B * x) + (D * y) + (H * z)); - } else { - return(A + (B * x) + (C * x * x) + (D * y) + (E * y * y) + (F * x * y) + (H * z) + - (J * z * z) + (K * x * z) + (L * y * z)); - } -} - -psF64 setDataF64(psF64 x, psF64 y, psF64 z) -{ - if (0) { - // Linear case, for testing. - return(A + (B * x) + (D * y) + (H * z)); - } else { - return(A + (B * x) + (C * x * x) + (D * y) + (E * y * y) + (F * x * y) + (H * z) + - (J * z * z) + (K * x * z) + (L * y * z)); - } -} - -psS32 t00F32() -{ - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - psF64 expectData; - psF64 actualData; - - psPolynomial3D *myPoly = psPolynomial3DAlloc(POLY_ORDER, POLY_ORDER, POLY_ORDER, PS_POLYNOMIAL_ORD); - psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - psVector *z = 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;idata.F32[i] = (psF32) i; - y->data.F32[i] = (psF32) i; - z->data.F32[i] = (psF32) i; - f->data.F32[i] = setDataF32(x->data.F32[i], y->data.F32[i], z->data.F32[i]); - fErr->data.F32[i] = FERR; - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial3D(): psF32 data"); - - psVectorFitPolynomial3D(myPoly, NULL, 0, f, fErr, x, y, z); - - if (VERBOSE) { - for (psS32 i=0;icoeff[i][j][k]); - } - } - } - } - - for (psS32 i=0;idata.F32[i], y->data.F32[i], z->data.F32[i]); - actualData = psPolynomial3DEval(myPoly, x->data.F32[i], y->data.F32[i], z->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); - } - } - - if (1) { - printf("Running test with fErr set to NULL.\n"); - psVectorFitPolynomial3D(myPoly, NULL, 0, f, NULL, x, y, z); - for (psS32 i=0;idata.F32[i], y->data.F32[i], z->data.F32[i]); - actualData = psPolynomial3DEval(myPoly, x->data.F32[i], y->data.F32[i], z->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); - } - } - } - - if (1) { - psFree(myPoly); - printf("Running test with myPoly set to NULL. Should generate error.\n"); - myPoly = psVectorFitPolynomial3D(NULL, NULL, 0, f, fErr, NULL, NULL, NULL); - if (myPoly != NULL) { - printf("TEST ERROR: psVectorFitPolynomial3D() returned non-NULL.\n"); - testStatus = false; - } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psFree(z); - 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", - "psVectorFitPolynomial3D(): equal differences in variable fErr", - testStatus); - - return (!testStatus); -} - - -psS32 t00F64() -{ - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - psF64 expectData; - psF64 actualData; - - psPolynomial3D *myPoly = psPolynomial3DAlloc(POLY_ORDER, POLY_ORDER, POLY_ORDER, PS_POLYNOMIAL_ORD); - psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *z = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *f = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *fErr = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - - for (psS32 i=0;idata.F64[i] = (psF64) i; - y->data.F64[i] = (psF64) i; - z->data.F64[i] = (psF64) i; - f->data.F64[i] = setDataF64(x->data.F64[i], y->data.F64[i], z->data.F64[i]); - fErr->data.F64[i] = FERR; - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial3D(): psF64 data"); - - psVectorFitPolynomial3D(myPoly, NULL, 0, f, fErr, x, y, z); - - if (VERBOSE) { - for (psS32 i=0;icoeff[i][j][k]); - } - } - } - } - - for (psS32 i=0;idata.F64[i], y->data.F64[i], z->data.F64[i]); - actualData = psPolynomial3DEval(myPoly, x->data.F64[i], y->data.F64[i], z->data.F64[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.F64[i], y->data.F64[i], actualData, expectData); - testStatus = false; - } - if (VERBOSE) { - printf("GOOD: Data point [%d] is %f, should be %f.\n", i, actualData, expectData); - } - } - - if (1) { - printf("Running test with fErr set to NULL.\n"); - psVectorFitPolynomial3D(myPoly, NULL, 0, f, NULL, x, y, z); - for (psS32 i=0;idata.F64[i], y->data.F64[i], z->data.F64[i]); - actualData = psPolynomial3DEval(myPoly, x->data.F64[i], y->data.F64[i], z->data.F64[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.F64[i], y->data.F64[i], actualData, expectData); - testStatus = false; - } - if (VERBOSE) { - printf("GOOD: Data point [%d] is %f, should be %f.\n", i, actualData, expectData); - } - } - } - - if (1) { - psFree(myPoly); - printf("Running test with myPoly set to NULL. Should generate error.\n"); - myPoly = psVectorFitPolynomial3D(NULL, NULL, 0, f, fErr, NULL, NULL, NULL); - if (myPoly != NULL) { - printf("TEST ERROR: psVectorFitPolynomial3D() returned non-NULL.\n"); - testStatus = false; - } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psFree(z); - 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", - "psVectorFitPolynomial3D(): equal differences in variable fErr", - testStatus); - - return (!testStatus); -} - -psS32 main() -{ - psLogSetFormat("HLNM"); - t00F32(); - t00F64(); -} Index: trunk/psLib/test/math/tst_psPolyFit4D.c =================================================================== --- trunk/psLib/test/math/tst_psPolyFit4D.c (revision 6099) +++ trunk/psLib/test/math/tst_psPolyFit4D.c (revision 6099) @@ -0,0 +1,594 @@ +/***************************************************************************** +This routine must ensure that various psLib functions which fit 4D polynomials +to data work correctly. There is a function genericTest() which creates +vectors of data points (x and f), and populates them with the values from an +arbitrary function setData(). It then calls appropriate 4D fitting function. +It then evaluates the polynomial with the coefficients generated above and +determines if they are within an error tolerance of the expected values. + *****************************************************************************/ +#include +#include +#include "pslib.h" +#include "psTest.h" +#define NUM_DATA 35 +#define POLY_ORDER_X 2 +#define POLY_ORDER_Y 3 +#define POLY_ORDER_Z 2 +#define POLY_ORDER_T 2 +#define A 1.0 +#define B 2.0 +#define C 3.0 +#define D 4.0 +#define E 5.0 +#define F 4.0 +#define H 3.0 +#define J 3.0 +#define K 1.0 +#define L 5.0 +#define M 4.0 +#define N 3.0 +#define O 2.0 +#define P 1.0 +#define Q 5.0 +#define ERROR_TOLERANCE 0.10 +#define YERR 10.0 +#define VERBOSE 0 +#define NUM_ITERATIONS 5 +#define CLIP_SIGMA 4.0 +#define OUTLIERS true +#define MASK_VALUE 1 + +#define TS00_F_NULL 0x00000001 +#define TS00_F_F32 0x00000002 +#define TS00_F_F64 0x00000004 +#define TS00_F_S32 0x00000008 +#define TS00_X_NULL 0x00000010 +#define TS00_X_F32 0x00000020 +#define TS00_X_F64 0x00000040 +#define TS00_X_S32 0x00000080 +#define TS00_FERR_NULL 0x00000100 +#define TS00_FERR_F32 0x00000200 +#define TS00_FERR_F64 0x00000400 +#define TS00_FERR_S32 0x00000800 +#define TS00_MASK_NULL 0x00001000 +#define TS00_MASK_U8 0x00002000 +#define TS00_MASK_S32 0x00004000 +#define TS00_POLY_ORD 0x00008000 +#define TS00_POLY_CHEB 0x00010000 +#define TS00_CLIP_FIT 0x00020000 +#define TS00_Y_NULL 0x00100000 +#define TS00_Y_F32 0x00200000 +#define TS00_Y_F64 0x00400000 +#define TS00_Y_S32 0x00800000 +#define TS00_Z_NULL 0x01000000 +#define TS00_Z_F32 0x02000000 +#define TS00_Z_F64 0x04000000 +#define TS00_Z_S32 0x08000000 +#define TS00_T_NULL 0x10000000 +#define TS00_T_F32 0x20000000 +#define TS00_T_F64 0x40000000 +#define TS00_T_S32 0x80000000 + +psF32 setData(psF32 x, psF32 y, psF32 z, psF32 t) +{ + if (0) { + // Linear case, for testing. + return(A + (B * x) + (C * y) + (D * z) + (E * t)); + } else { + return(A + (B * x) + (C * y) + (D * z) + (E * t) + + (F * x * x) + (H * y * y) + (J * z * z) + (K * t * t) + + (L * x * y) + (M * x * z) + (N * x * t) + (O * y * z) + (P * y * t) + (Q * z * t)); + } +} + +psS32 genericTest( + psU32 flags, + psS32 polyOrderX, + psS32 polyOrderY, + psS32 polyOrderZ, + psS32 polyOrderT, + psS32 numData, + psBool expectedRC) +{ + psS32 currentId = psMemGetId(); + psS32 testStatus = true; + psS32 memLeaks = 0; + psPolynomial4D *myPoly = NULL; + psVector *x = NULL; + psVector *y = NULL; + psVector *z = NULL; + psVector *t = NULL; + psVector *f = NULL; + psVector *mask = NULL; + psVector *fErr = NULL; + psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); + stats->clipSigma = CLIP_SIGMA; + stats->clipIter = NUM_ITERATIONS; + + printPositiveTestHeader(stdout, "psMinimize functions", "4D Polynomial Fitting Functions"); + + if (expectedRC == false) { + printf("This test should generate an error message, and return NULL.\n"); + } + + if (flags & TS00_CLIP_FIT) { + printf(" performing a clip-fit\n"); + } else { + printf(" performing a non clip-fit\n"); + } + + if (flags & TS00_POLY_ORD) { + printf(" using ordinary polynomials\n"); + myPoly = psPolynomial4DAlloc(polyOrderX, polyOrderY, polyOrderZ, polyOrderT, PS_POLYNOMIAL_ORD); + } + + if (flags & TS00_X_NULL) { + printf(" using a NULL x vector\n"); + } + + if (flags & TS00_X_F32) { + printf(" using a psF32 x vector\n"); + x = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = (psF32) i; + } + } + + if (flags & TS00_X_S32) { + printf(" using a psS32 x vector\n"); + x = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) i; + } + } + + if (flags & TS00_X_F64) { + printf(" using a psF64 x vector\n"); + x = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) i; + } + } + + + if (flags & TS00_Y_NULL) { + printf(" using a NULL y vector\n"); + } + + if (flags & TS00_Y_F32) { + printf(" using a psF32 y vector\n"); + y = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = (psF32) i; + } + } + + if (flags & TS00_Y_S32) { + printf(" using a psS32 y vector\n"); + y = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) i; + } + } + + if (flags & TS00_Y_F64) { + printf(" using a psF64 y vector\n"); + y = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) i; + } + } + + if (flags & TS00_Z_NULL) { + printf(" using a NULL z vector\n"); + } + + if (flags & TS00_Z_F32) { + printf(" using a psF32 z vector\n"); + z = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = (psF32) i; + } + } + + if (flags & TS00_Z_S32) { + printf(" using a psS32 z vector\n"); + z = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) i; + } + } + + if (flags & TS00_Z_F64) { + printf(" using a psF64 z vector\n"); + z = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) i; + } + } + + if (flags & TS00_T_NULL) { + printf(" using a NULL t vector\n"); + } + + if (flags & TS00_T_F32) { + printf(" using a psF32 t vector\n"); + t = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = (psF32) i; + } + } + + if (flags & TS00_T_S32) { + printf(" using a psS32 t vector\n"); + t = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) i; + } + } + + if (flags & TS00_T_F64) { + printf(" using a psF64 t vector\n"); + t = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) i; + } + } + + + if (flags & TS00_F_NULL) { + printf(" using a NULL f vector\n"); + } + + if (flags & TS00_F_F32) { + printf(" using a psF32 f vector\n"); + f = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = setData((psF32) i, (psF32) i, (psF32) i, (psF32) i); + } + // Set a few outliers in the data. + if (OUTLIERS && (flags & TS00_CLIP_FIT)) { + f->data.F32[numData/4]*= 2.0; + f->data.F32[numData/2]*= 2.0; + f->data.F32[3*numData/4]*= 2.0; + } + + if (VERBOSE) { + for (psS32 i=0;idata.F32[i]); + } + } + } + + if (flags & TS00_F_S32) { + printf(" using a psS32 f vector\n"); + f = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) setData((psF32) i, (psF32) i, (psF32) i, (psF32) i); + } + // Set a few outliers in the data. + if (OUTLIERS && (flags & TS00_CLIP_FIT)) { + f->data.S32[numData/4]*= 2.0; + f->data.S32[numData/2]*= 2.0; + f->data.S32[3*numData/4]*= 2.0; + } + + if (VERBOSE) { + for (psS32 i=0;idata.S32[i]); + } + } + } + + if (flags & TS00_F_F64) { + printf(" using a psF64 f vector\n"); + f = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = (psF64) setData((psF32) i, (psF32) i, (psF32) i, (psF32) i); + } + // Set a few outliers in the data. + if (OUTLIERS && (flags & TS00_CLIP_FIT)) { + f->data.F64[numData/4]*= 2.0; + f->data.F64[numData/2]*= 2.0; + f->data.F64[3*numData/4]*= 2.0; + } + + if (VERBOSE) { + for (psS32 i=0;idata.F64[i]); + } + } + } + + if (flags & TS00_FERR_NULL) { + printf(" using a NULL fErr vector\n"); + } + + if (flags & TS00_FERR_F32) { + printf(" using a psF32 fErr vector\n"); + fErr = psVectorAlloc(numData, PS_TYPE_F32); + for (psS32 i=0;idata.F32[i] = YERR; + } + } + + if (flags & TS00_FERR_S32) { + printf(" using a psS32 fErr vector\n"); + fErr = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = (psS32) YERR; + } + } + + if (flags & TS00_FERR_F64) { + printf(" using a psF64 fErr vector\n"); + fErr = psVectorAlloc(numData, PS_TYPE_F64); + for (psS32 i=0;idata.F64[i] = YERR; + } + } + + if (flags & TS00_MASK_NULL) { + printf(" using a NULL mask vector\n"); + } + + if (flags & TS00_MASK_U8) { + printf(" using a psU8 mask vector\n"); + mask = psVectorAlloc(numData, PS_TYPE_U8); + for (psS32 i=0;idata.U8[i] = 0; + } + } + + if (flags & TS00_MASK_S32) { + printf(" using a psS32 mask vector\n"); + mask = psVectorAlloc(numData, PS_TYPE_S32); + for (psS32 i=0;idata.S32[i] = 0; + } + } + + psPolynomial4D *rc = NULL; + if (flags & TS00_CLIP_FIT) { + rc = psVectorClipFitPolynomial4D(myPoly, stats, mask, MASK_VALUE, f, fErr, x, y, z, t); + } else { + rc = psVectorFitPolynomial4D(myPoly, mask, MASK_VALUE, f, fErr, x, y, z, t); + } + + if (rc == NULL) { + if (expectedRC == true) { + printf("TEST ERROR: the 4D polynomial fitting function returned NULL.\n"); + testStatus = false; + } + } else { + if (expectedRC == false) { + printf("TEST ERROR: the 4D polynomial fitting function returned non-NULL.\n"); + testStatus = false; + } + + if (VERBOSE) { + for (psS32 i=0;icoeff[i][j][k][l]); + } + } + } + } + } + + for (psS32 i=0 ;idata.F32[i]; + } else if (flags & TS00_F_F64) { + expectData = (psF32) f->data.F64[i]; + } else if (flags & TS00_F_S32) { + expectData = (psF32) f->data.S32[i]; + } + + if (flags & TS00_X_F32) { + xData = x->data.F32[i]; + } else if (flags & TS00_X_F64) { + xData = (psF32) x->data.F64[i]; + } else if (flags & TS00_X_S32) { + xData = (psF32) x->data.S32[i]; + } else if (flags & TS00_X_NULL) { + xData = (psF32) i; + } + + if (flags & TS00_Y_F32) { + yData = y->data.F32[i]; + } else if (flags & TS00_Y_F64) { + yData = (psF32) y->data.F64[i]; + } else if (flags & TS00_Y_S32) { + yData = (psF32) y->data.S32[i]; + } else if (flags & TS00_Y_NULL) { + yData = (psF32) i; + } + + if (flags & TS00_Z_F32) { + zData = z->data.F32[i]; + } else if (flags & TS00_Z_F64) { + zData = (psF32) z->data.F64[i]; + } else if (flags & TS00_Z_S32) { + zData = (psF32) z->data.S32[i]; + } else if (flags & TS00_Z_NULL) { + zData = (psF32) i; + } + + if (flags & TS00_T_F32) { + tData = t->data.F32[i]; + } else if (flags & TS00_T_F64) { + tData = (psF32) t->data.F64[i]; + } else if (flags & TS00_T_S32) { + tData = (psF32) t->data.S32[i]; + } else if (flags & TS00_T_NULL) { + tData = (psF32) i; + } + + psF32 actualData = psPolynomial4DEval(myPoly, xData, yData, zData, tData); + + if (fabs(actualData-expectData) > fabs(ERROR_TOLERANCE * expectData)) { + printf("TEST ERROR: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", + i, xData, actualData, expectData); + testStatus = false; + } else { + if (VERBOSE) { + printf("GOOD: Fitted data %d: (%.1f %.1f), expected was (%.1f)\n", + i, xData, actualData, expectData); + } + } + } + } + + psMemCheckCorruption(1); + psFree(myPoly); + psFree(mask); + psFree(x); + psFree(y); + psFree(z); + psFree(t); + psFree(f); + psFree(fErr); + psFree(stats); + psMemCheckCorruption(1); + memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); + if (0 != memLeaks) { + psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); + } + + printFooter(stdout, "psMinimize functions", "4D Polynomial Fitting Functions", testStatus); + + return (testStatus); +} + +/***************************************************************************** +We test a variety of polynomial fitting routines, types, and polynomial types +here: + F32 tests: Ordinary polys, non-clip fit + F64 tests: Ordinary polys, non-clip fit + F32 tests: Chebyshev polys, non-clip fit + F64 tests: Chebyshev polys, non-clip fit + F32 tests: Ordinary polys, clip fit + F64 tests: Ordinary polys, clip fit + F32 tests: Chebyshev polys, clip fit + F64 tests: Chebyshev polys, clip fit + *****************************************************************************/ +psS32 main() +{ + psBool testStatus = true; + psLogSetFormat("HLNM"); + psTraceSetLevel(".", 0); + psTraceSetLevel("psVectorClipFitPolynomial4D", 0); + psTraceSetLevel("VectorFitPolynomial4DOrd", 0); + psTraceSetLevel("psVectorFitPolynomial4D", 0); + + printPositiveTestHeader(stdout, "psMinimize functions: 4D Polynomial Fitting Functions", ""); + + // + // F32 tests: Ordinary polys, non-clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_NULL | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_NULL | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_NULL | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_NULL | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_NULL | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F64 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F64 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F64 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + + // + // F64 tests: Ordinary polys, non-clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_NULL | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_NULL | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_NULL | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_NULL | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_NULL | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F32 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F32 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F32 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F32 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + + // + // F32 tests: Ordinary polys, clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_NULL | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_NULL | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_NULL | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_NULL | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_NULL | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F64 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F64 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F64 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F32 | TS00_X_F32 | TS00_Y_F32 | TS00_Z_F32 | TS00_T_F32 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + + // + // F64 tests: Ordinary polys, clip fit + // + // All Vectors non-NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + // Some Vectors NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_NULL | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, true); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_NULL | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_NULL | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_NULL | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_NULL | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + // F-vector NULL + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_NULL | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_NULL | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + // Mismatch vector types + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F32 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F32 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F32 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F32 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F32 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_U8 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F32 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + testStatus &= genericTest(TS00_MASK_S32 | TS00_FERR_F64 | TS00_X_F64 | TS00_Y_F64 | TS00_Z_F64 | TS00_T_F64 | TS00_F_F64 | TS00_POLY_ORD | TS00_CLIP_FIT, POLY_ORDER_X, POLY_ORDER_Y, POLY_ORDER_Z, POLY_ORDER_T, NUM_DATA, false); + + printFooter(stdout, "psMinimize functions: 4D Polynomial Fitting Functions", "", testStatus); +} + Index: trunk/psLib/test/math/tst_psPolyFit4DOrd.c =================================================================== --- trunk/psLib/test/math/tst_psPolyFit4DOrd.c (revision 5823) +++ (revision ) @@ -1,279 +1,0 @@ -/***************************************************************************** -This routine must ensure that the psVectorFitPolynomial4D 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 -psVectorFitPolynomial4D() 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 -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psVector.h" -#include "psImage.h" -#include "psMinimize.h" -#include -#define NUM_DATA 10 -#define POLY_ORDER 3 -#define A 1.0 -#define B 2.0 -#define C 3.0 -#define D 4.0 -#define E 5.0 -#define F 4.0 -#define H 3.0 -#define J 3.0 -#define K 1.0 -#define L 5.0 -#define M 4.0 -#define N 3.0 -#define O 2.0 -#define P 1.0 -#define Q 5.0 - -#define ERROR_TOLERANCE 0.10 -#define FERR 1.0 -#define VERBOSE 0 - -psF32 setDataF32(psF32 x, psF32 y, psF32 z, psF32 t) -{ - if (0) { - // Linear case, for testing. - return(A + (B * x) + (C * y) + (D * z) + (E * t)); - } else { - return(A + (B * x) + (C * y) + (D * z) + (E * t) + - (F * x * x) + (H * y * y) + (J * z * z) + (K * t * t) + - (L * x * y) + (M * x * z) + (N * x * t) + (O * y * z) + (P * y * t) + (Q * z * t)); - } -} - -psF64 setDataF64(psF64 x, psF64 y, psF64 z, psF64 t) -{ - if (0) { - // Linear case, for testing. - return(A + (B * x) + (C * y) + (D * z) + (E * t)); - } else { - return(A + (B * x) + (C * y) + (D * z) + (E * t) + - (F * x * x) + (H * y * y) + (J * z * z) + (K * t * t) + - (L * x * y) + (M * x * z) + (N * x * t) + (O * y * z) + (P * y * t) + (Q * z * t)); - } -} - -psS32 t00F32() -{ - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - psF64 expectData; - psF64 actualData; - - psPolynomial4D *myPoly = psPolynomial4DAlloc(POLY_ORDER, POLY_ORDER, POLY_ORDER, POLY_ORDER, PS_POLYNOMIAL_ORD); - psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - psVector *z = psVectorAlloc(NUM_DATA, PS_TYPE_F32); - psVector *t = 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;idata.F32[i] = (psF32) i; - y->data.F32[i] = (psF32) i; - z->data.F32[i] = (psF32) i; - t->data.F32[i] = (psF32) i; - f->data.F32[i] = setDataF32(x->data.F32[i], y->data.F32[i], z->data.F32[i], t->data.F32[i]); - fErr->data.F32[i] = FERR; - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial4D(): psF32 data"); - - psVectorFitPolynomial4D(myPoly, NULL, 0, f, fErr, x, y, y, t); - - if (VERBOSE) { - for (psS32 i=0;icoeff[i][j][k][m]); - } - } - } - } - } - - for (psS32 i=0;idata.F32[i], y->data.F32[i], z->data.F32[i], t->data.F32[i]); - actualData = psPolynomial4DEval(myPoly, x->data.F32[i], y->data.F32[i], z->data.F32[i], t->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); - } - } - - if (0) { - printf("Running test with fErr set to NULL.\n"); - psVectorFitPolynomial4D(myPoly, NULL, 0, f, NULL, x, y, z, t); - for (psS32 i=0;idata.F32[i], y->data.F32[i], z->data.F32[i], t->data.F32[i]); - actualData = psPolynomial4DEval(myPoly, x->data.F32[i], y->data.F32[i], z->data.F32[i], t->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); - } - } - } - - if (0) { - psFree(myPoly); - printf("Running test with myPoly set to NULL. Should generate error.\n"); - myPoly = psVectorFitPolynomial4D(NULL, NULL, 0, f, fErr, NULL, NULL, NULL, NULL); - if (myPoly != NULL) { - printf("TEST ERROR: psVectorFitPolynomial4D() returned non-NULL.\n"); - testStatus = false; - } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psFree(z); - psFree(t); - 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", - "psVectorFitPolynomial4D(): equal differences in variable fErr", - testStatus); - - return (!testStatus); -} - -psS32 t00F64() -{ - psS32 currentId = psMemGetId(); - psS32 testStatus = true; - psS32 memLeaks = 0; - psF64 expectData; - psF64 actualData; - - psPolynomial4D *myPoly = psPolynomial4DAlloc(POLY_ORDER, POLY_ORDER, POLY_ORDER, POLY_ORDER, PS_POLYNOMIAL_ORD); - psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *z = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *t = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *f = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - psVector *fErr = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - - for (psS32 i=0;idata.F64[i] = (psF64) i; - y->data.F64[i] = (psF64) i; - z->data.F64[i] = (psF64) i; - t->data.F64[i] = (psF64) i; - f->data.F64[i] = setDataF64(x->data.F64[i], y->data.F64[i], z->data.F64[i], t->data.F64[i]); - fErr->data.F64[i] = FERR; - } - - printPositiveTestHeader(stdout, - "psMinimize functions", - "psVectorFitPolynomial4D(): psF64 data"); - - psVectorFitPolynomial4D(myPoly, NULL, 0, f, fErr, x, y, y, t); - - if (VERBOSE) { - for (psS32 i=0;icoeff[i][j][k][m]); - } - } - } - } - } - - for (psS32 i=0;idata.F64[i], y->data.F64[i], z->data.F64[i], t->data.F64[i]); - actualData = psPolynomial4DEval(myPoly, x->data.F64[i], y->data.F64[i], z->data.F64[i], t->data.F64[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.F64[i], y->data.F64[i], actualData, expectData); - testStatus = false; - } - if (VERBOSE) { - printf("GOOD: Data point [%d] is %f, should be %f.\n", i, actualData, expectData); - } - } - - if (0) { - printf("Running test with fErr set to NULL.\n"); - psVectorFitPolynomial4D(myPoly, NULL, 0, f, NULL, x, y, z, t); - for (psS32 i=0;idata.F64[i], y->data.F64[i], z->data.F64[i], t->data.F64[i]); - actualData = psPolynomial4DEval(myPoly, x->data.F64[i], y->data.F64[i], z->data.F64[i], t->data.F64[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.F64[i], y->data.F64[i], actualData, expectData); - testStatus = false; - } - if (VERBOSE) { - printf("GOOD: Data point [%d] is %f, should be %f.\n", i, actualData, expectData); - } - } - } - - if (0) { - psFree(myPoly); - printf("Running test with myPoly set to NULL. Should generate error.\n"); - myPoly = psVectorFitPolynomial4D(NULL, NULL, 0, f, fErr, NULL, NULL, NULL, NULL); - if (myPoly != NULL) { - printf("TEST ERROR: psVectorFitPolynomial4D() returned non-NULL.\n"); - testStatus = false; - } - } - - psMemCheckCorruption(1); - psFree(myPoly); - psFree(x); - psFree(y); - psFree(z); - psFree(t); - 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", - "psVectorFitPolynomial4D(): equal differences in variable fErr", - testStatus); - - return (!testStatus); -} - - -psS32 main() -{ - psLogSetFormat("HLNM"); - t00F32(); - t00F64(); -}