Index: trunk/psLib/test/math/Makefile.am =================================================================== --- trunk/psLib/test/math/Makefile.am (revision 5117) +++ trunk/psLib/test/math/Makefile.am (revision 5155) @@ -7,9 +7,4 @@ tst_psFunc00 \ tst_psFunc01 \ - tst_psFunc02 \ - tst_psFunc03 \ - tst_psFunc04 \ - tst_psFunc05 \ - tst_psFunc07 \ tst_psFunc08 \ tst_psFunc09 \ @@ -48,13 +43,9 @@ tst_psStats08 \ tst_psStats09 \ + tst_psSpline1D \ tst_psRandom tst_psFunc00_SOURCES = tst_psFunc00.c tst_psFunc01_SOURCES = tst_psFunc01.c -tst_psFunc02_SOURCES = tst_psFunc02.c -tst_psFunc03_SOURCES = tst_psFunc03.c -tst_psFunc04_SOURCES = tst_psFunc04.c -tst_psFunc05_SOURCES = tst_psFunc05.c -tst_psFunc07_SOURCES = tst_psFunc07.c tst_psFunc08_SOURCES = tst_psFunc08.c tst_psFunc09_SOURCES = tst_psFunc09.c Index: trunk/psLib/test/math/tst_psFunc02.c =================================================================== --- trunk/psLib/test/math/tst_psFunc02.c (revision 5117) +++ (revision ) @@ -1,447 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psSpline1DAlloc() function properly - allocates the spline data structure. It allocates both linear and cubic - splines with a variety of min/max ranges. - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psSpline.h" - -#define N 4 -#define LINEAR 1 -#define CUBIC 3 - -psS32 main() -{ - psLogSetFormat("HLNM"); - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 i; - psS32 currentId = psMemGetId(); - psSpline1D *tmpSpline; - psVector* bounds; - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(): linear, normal"); - - tmpSpline = psSpline1DAlloc(N, LINEAR, 1.0, 10.0); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->COOL_1D_n != LINEAR) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->COOL_1D_n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;iknots->data.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAlloc(): linear, normal", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(): linear, min/max are equal"); - - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - tmpSpline = psSpline1DAlloc(N, LINEAR, 1.0, 1.0); - - if (tmpSpline != NULL) { - printf("ERROR: allocated psSpline1D data structure when min==max\n"); - testStatus = false; - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAlloc(): linear, min/max are equal", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(): linear, min > max."); - - tmpSpline = psSpline1DAlloc(N, LINEAR, 1.0, -1.0); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->COOL_1D_n != LINEAR) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->COOL_1D_n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;iknots->data.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAlloc(): linear, min > max.", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(), cubic, normal"); - - tmpSpline = psSpline1DAlloc(N, CUBIC, 1.0, 10.0); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->COOL_1D_n != CUBIC) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->COOL_1D_n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;idata.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAlloc(): cubic, normal", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(): cubic, min/max are equal"); - - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message"); - tmpSpline = psSpline1DAlloc(N, CUBIC, 1.0, 1.0); - - if (tmpSpline != NULL) { - printf("ERROR: allocated psSpline1D data structure when min==max\n"); - testStatus = false; - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAlloc(): cubic, min/max are equal", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(): cubic, min > max."); - - tmpSpline = psSpline1DAlloc(N, CUBIC, 1.0, -1.0); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->COOL_1D_n != CUBIC) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->COOL_1D_n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;iknots->data.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAlloc(): cubic, min > max.", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAllocGeneric(): linear, normal"); - - bounds = psVectorAlloc(5,PS_TYPE_F32); - bounds->n = bounds->nalloc; - for(psU32 n = 0; n < 5; n++ ) { - bounds->data.F32[n] = (n+1) * 2; - } - tmpSpline = psSpline1DAllocGeneric(bounds, LINEAR); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->COOL_1D_n != LINEAR) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->COOL_1D_n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;iknots->data.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - psFree(bounds); - psFree(tmpSpline); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psError(PS_ERR_UNKNOWN,true,"Memory Leaks! (%d leaks)", memLeaks); - testStatus = false; - } - printFooter(stdout, - "psSpline functions", - "psSpline1DAllocGeneric(): linear, normal", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - ///XXX: REMOVED FOLLOWING TEST AFTER CHANGING TO UNSIGNED INT/// - /* testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAllocGeneric(): negative order"); - - bounds = psVectorAlloc(5,PS_TYPE_F32); - bounds->n = bounds->nalloc; - for(psU32 n = 0; n < 5; n++ ) { - bounds->data.F32[n] = (n+1) * 2; - } - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - tmpSpline = psSpline1DAllocGeneric(bounds, -1); - if (tmpSpline != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return null for negative order"); - return 10; - } - psFree(bounds); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psError(PS_ERR_UNKNOWN,true,"Memory Leaks! (%d leaks)", memLeaks); - testStatus = false; - } - printFooter(stdout, - "psSpline functions", - "psSpline1DAllocGeneric(): negative order", - testStatus); - // XXX: Currently, if you free a psStructure twice, it seg faults. Why? - psFree(bounds); - */ - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAllocGeneric(): bound equal to NULL"); - - bounds = NULL; - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - tmpSpline = psSpline1DAllocGeneric(bounds, LINEAR); - if (tmpSpline != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return null for bounds equal to NULL"); - return 20; - } - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psError(PS_ERR_UNKNOWN,true,"Memory Leaks! (%d leaks)", memLeaks); - testStatus = false; - } - printFooter(stdout, - "psSpline functions", - "psSpline1DAllocGeneric(): bound equal to NULL", - testStatus); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAllocGeneric(): bounds with zero elements"); - - bounds = psVectorAlloc(5,PS_TYPE_F32); - bounds->n = 0; - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message."); - tmpSpline = psSpline1DAllocGeneric(bounds, LINEAR); - if (tmpSpline != NULL) { - psError(PS_ERR_UNKNOWN,true,"Did not return null for negative order"); - return 30; - } - psFree(bounds); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psError(PS_ERR_UNKNOWN,true,"Memory Leaks! (%d leaks)", memLeaks); - testStatus = false; - } - printFooter(stdout, - "psSpline functions", - "psSpline1DAllocGeneric(): bounds with zero elements", - testStatus); - - return (!testStatus); -} Index: trunk/psLib/test/math/tst_psFunc03.c =================================================================== --- trunk/psLib/test/math/tst_psFunc03.c (revision 5117) +++ (revision ) @@ -1,151 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psSpline1DAllocGeneric() function properly - allocates the spline data structure. - - XXX: test bounds? - *****************************************************************************/ -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psSpline.h" - -#define N 10 -#define LINEAR 1 -#define CUBIC 3 - -psS32 main() -{ - psLogSetFormat("HLNM"); - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 i; - psS32 currentId = psMemGetId(); - psSpline1D *tmpSpline; - psVector *bounds; - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAllocGeneric(): linear"); - bounds = psVectorAlloc(N+1, PS_TYPE_F32); - for (i=0;idata.F32[i] = (float) (3 * i); - } - - tmpSpline = psSpline1DAllocGeneric(bounds, LINEAR); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->COOL_1D_n != LINEAR) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->COOL_1D_n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;iknots->data.F32[i] != bounds->data.F32[i]) { - printf("ERROR: psSpline1D->knots->data.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - } - - psFree(tmpSpline); - psFree(bounds); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAllocGeneric(): linear", - testStatus); - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAllocGeneric(): cubic"); - bounds = psVectorAlloc(N+1, PS_TYPE_F32); - for (i=0;idata.F32[i] = (float) (3 * i); - } - - tmpSpline = psSpline1DAllocGeneric(bounds, CUBIC); - if (tmpSpline == NULL) { - printf("ERROR: Could not allocate psSpline1D data structure\n"); - testStatus = false; - } - if (tmpSpline->spline == NULL) { - printf("ERROR: Could not allocate psSpline1D->spline data structure\n"); - testStatus = false; - } - - if (tmpSpline->n != N) { - printf("ERROR: spline->n set incorrectly (%d)\n", tmpSpline->n); - testStatus = false; - } - - for (i=0;ispline[i] == NULL) { - printf("ERROR: Could not allocate spline %d\n", i); - testStatus = false; - } - if ((tmpSpline->spline[i])->COOL_1D_n != CUBIC) { - printf("ERROR: Spline created with order %d\n", (tmpSpline->spline[i])->COOL_1D_n); - testStatus = false; - } - } - - if (tmpSpline->knots == NULL) { - printf("ERROR: Could not allocate psSpline1D->knots data structure\n"); - testStatus = false; - } - - for (i=0;iknots->data.F32[i] != bounds->data.F32[i]) { - printf("ERROR: psSpline1D->knots->data.F32[%d] is %f\n", i, - tmpSpline->knots->data.F32[i]); - } - } - - psFree(tmpSpline); - psFree(bounds); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAllocGeneric(): cubic", - testStatus); - - return (!testStatus); -} Index: trunk/psLib/test/math/tst_psFunc04.c =================================================================== --- trunk/psLib/test/math/tst_psFunc04.c (revision 5117) +++ (revision ) @@ -1,135 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psSpline1DEval() function works - properly. It creates a spline with psSpline1DAlloc(), creates a set of - data values, sets the spline polynomials with psVectorFitSpline1D(), then - calls psSpline1DEval() on new data values and ensures that the results - are correct. - - XXX: figure out the memory deallocator - *****************************************************************************/ -#include -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psSpline.h" - -#define N 8 - -psS32 t00() -{ - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 i; - float x; - float y; - psS32 currentId = psMemGetId(); - psSpline1D *tmpSpline; - psVector *data; - - psTraceSetLevel(".", 0); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc()"); - data = psVectorAlloc(N+1, PS_TYPE_F32); - tmpSpline = psSpline1DAlloc(N, 1, 1.0, 10.0); - - for (i=0;idata.F32[i] = tmpSpline->knots->data.F32[i]; - } - psVectorFitSpline1D(tmpSpline, data, data, NULL); - - for (i=0;i FLT_EPSILON) { - printf("ERROR: f(%f) is %f\n", x, y); - testStatus = true; - } - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - psFree(data); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAlloc()", - testStatus); - - return (!testStatus); -} - -psS32 t01() -{ - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 i; - float x; - float y; - psS32 currentId = psMemGetId(); - psSpline1D *tmpSpline; - psVector *data; - - psTraceSetLevel(".", 0); - - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc()"); - data = psVectorAlloc(N+1, PS_TYPE_F32); - tmpSpline = psSpline1DAlloc(N, 1, 1.0, 10.0); - - for (i=0;idata.F32[i] = tmpSpline->knots->data.F32[i]; - } - psVectorFitSpline1D(tmpSpline, data, data, NULL); - - for (i=0;i FLT_EPSILON) { - printf("ERROR: f(%f) is %f\n", x, y); - testStatus = true; - } - } - - psFree(tmpSpline); - psMemCheckCorruption(1); - psFree(data); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAlloc()", - testStatus); - - return (!testStatus); -} - -psS32 main() -{ - psLogSetFormat("HLNM"); - t00(); - // XXX: Why is this commented? - // t01(); -} Index: trunk/psLib/test/math/tst_psFunc05.c =================================================================== --- trunk/psLib/test/math/tst_psFunc05.c (revision 5117) +++ (revision ) @@ -1,83 +1,0 @@ -/***************************************************************************** - This routine must ensure that the psSpline1DEvalVector() function works - properly. It creates a spline with psSpline1DAlloc(), (1-D functions - are used for the spline polynomials) creates a set of data values, sets - the spline polynomials with psVectorFitSpline1D(), then calls - psSpline1DEvalVector() on new data values and ensures that the results - are correct. - - XXX: Only F32 types are tested here. F64 types are tested elsewhere. - *****************************************************************************/ -#include -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psSpline.h" -#define N 8 -#define SPLINE_ORDER 1 - -psS32 main() -{ - psLogSetFormat("HLNM"); - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 i; - psS32 currentId = psMemGetId(); - psSpline1D *tmpSpline; - psVector *data; - psVector *x; - psVector *y; - - psTraceSetLevel(".", 0); - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc()"); - data = psVectorAlloc(N+1, PS_TYPE_F32); - x = psVectorAlloc(N+1, PS_TYPE_F32); - tmpSpline = psSpline1DAlloc(N, SPLINE_ORDER, 1.0, 10.0); - - for (i=0;idata.F32[i] = tmpSpline->knots->data.F32[i]; - } - - psVectorFitSpline1D(tmpSpline, data, data, NULL); - - for (i=0;idata.F32[i] = 0.5 + (float) i+1; - } - - y = psSpline1DEvalVector( - tmpSpline, - x - ); - - for (i=0;idata.F32[i]-y->data.F32[i]) > FLT_EPSILON) { - printf("ERROR: f(%f) is %f\n", x->data.F32[i], y->data.F32[i]); - testStatus = true; - } - } - - psFree(tmpSpline); - - psFree(x); - psFree(y); - psFree(data); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAlloc()", - testStatus); - - return (!testStatus); -} Index: trunk/psLib/test/math/tst_psFunc07.c =================================================================== --- trunk/psLib/test/math/tst_psFunc07.c (revision 5117) +++ (revision ) @@ -1,208 +1,0 @@ -/***************************************************************************** -This routine must ensure that the psVectorFitSpline1D() function works -properly. It creates a spline with psSpline1DAlloc(), creates a set of data -values, sets the spline polynomials with psVectorFitSpline1D(), then calls -psSpline1DEval() on new data values and ensures that the results are correct. - -F32 and F64 versions are used here. - -XXX: The spline eval functions are F32 only, while the spline fit functions -are F32 and F64. - -XXX: Must call the spline fit functions with unallowable input parameters. - *****************************************************************************/ -#include -#include -#include "pslib_strict.h" -#include "psTest.h" -#include "psMemory.h" -#include "psSpline.h" - -#define VERBOSE 0 -#define NUM_SPLINES 50 -#define A 4.0 -#define B -3.0 -#define C 0.2 -#define D 0.1 -#define MIN 1.0 -#define MAX 30 -#define ERROR_TOLERANCE 0.10 -#define OFFSET (NUM_SPLINES * ERROR_TOLERANCE) - -float myFunc(float x) -{ - return(A + x * (B + x * (C + x * (D)))); -} - -psS32 t00() -{ - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 currentId = psMemGetId(); - unsigned int i; - psSpline1D *tmpSpline = NULL; - psVector *x = NULL; - psVector *newX = NULL; - psVector *y = NULL; - psVector *newY = NULL; - - psTraceSetLevel(".", 0); - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - x = psVectorAlloc(NUM_SPLINES+1, PS_TYPE_F32); - newX = psVectorAlloc(NUM_SPLINES+1, PS_TYPE_F32); - y = psVectorAlloc(NUM_SPLINES+1, PS_TYPE_F32); - - - psF32 width = (MAX - MIN) / ((psF32) NUM_SPLINES); - x->data.F32[0] = MIN; - for (psS32 i=1;idata.F32[i] = MIN + (width * (psF32) i); - } - x->data.F32[NUM_SPLINES] = MAX; - - for (i=0;idata.F32[i] = myFunc(x->data.F32[i]); - } - - for (i=0;idata.F32[i]= ((x->data.F32[i] + x->data.F32[i+1])/2.0); - } - newX->data.F32[NUM_SPLINES] = x->data.F32[NUM_SPLINES]; - /****************************************************************************/ - /* psLib Code */ - /****************************************************************************/ - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(), psVectorFitSpline1D, psSpline1DEvalVector: F32 versions"); - - tmpSpline = psVectorFitSpline1DNEW(x, y, NUM_SPLINES); - if (tmpSpline == NULL) { - printf("TEST ERROR: psVectorFitSpline1DNEW() returned NULL.\n"); - testStatus = false; - } else { - newY = psSpline1DEvalVector(tmpSpline, newX); - - for (i=OFFSET;idata.F32[i] - myFunc(newX->data.F32[i]) ) > fabs( ERROR_TOLERANCE * myFunc(newX->data.F32[i]) ) ) { - printf("ERROR[%d]: f(%f) is %f. Should be %f\n", i, - newX->data.F32[i], newY->data.F32[i], myFunc(newX->data.F32[i])); - testStatus = false; - } else { - if (VERBOSE) { - printf("COOL[%d]: f(%f) is %f. Should be %f\n", i, - newX->data.F32[i], newY->data.F32[i], myFunc(newX->data.F32[i])); - } - } - } - psFree(tmpSpline); - psFree(newY); - } - psFree(x); - psFree(y); - psFree(newX); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAlloc(), psVectorFitSpline1D, psSpline1DEvalVector: F32 versions", - testStatus); - - return (!testStatus); -} - -// This is the F64 version of the above test code. -psS32 t01() -{ - psS32 testStatus = true; - psS32 memLeaks=0; - psS32 currentId = psMemGetId(); - psS32 i; - psSpline1D *tmpSpline = NULL; - psVector *x = NULL; - psVector *newX = NULL; - psVector *y = NULL; - psVector *newY = NULL; - - psTraceSetLevel(".", 0); - /****************************************************************************/ - /****************************************************************************/ - testStatus = true; - x = psVectorAlloc(NUM_SPLINES+1, PS_TYPE_F64); - newX = psVectorAlloc(NUM_SPLINES+1, PS_TYPE_F64); - y = psVectorAlloc(NUM_SPLINES+1, PS_TYPE_F64); - - psF64 width = (MAX - MIN) / ((psF32) NUM_SPLINES); - x->data.F64[0] = MIN; - for (psS32 i=1;idata.F64[i] = MIN + (width * (psF64) i); - } - x->data.F64[NUM_SPLINES] = MAX; - - for (i=0;idata.F64[i] = myFunc(x->data.F64[i]); - } - - for (i=0;idata.F64[i]= ((x->data.F64[i] + x->data.F64[i+1])/2.0); - } - newX->data.F64[NUM_SPLINES] = x->data.F64[NUM_SPLINES]; - /****************************************************************************/ - /* psLib Code */ - /****************************************************************************/ - printPositiveTestHeader(stdout, - "psFunction functions", - "psSpline1DAlloc(), psVectorFitSpline1D, psSpline1DEvalVector: F64 versions"); - - tmpSpline = psVectorFitSpline1DNEW(x, y, NUM_SPLINES); - if (tmpSpline == NULL) { - printf("TEST ERROR: psVectorFitSpline1DNEW() returned NULL.\n"); - testStatus = false; - } else { - newY = psSpline1DEvalVector(tmpSpline, newX); - - for (i=OFFSET;idata.F32[i] - myFunc(newX->data.F64[i]) ) > fabs( ERROR_TOLERANCE * myFunc((float)newX->data.F64[i]) ) ) { - printf("ERROR[%d]: f(%f) is %f. Should be %f\n", i, - newX->data.F64[i], newY->data.F32[i], myFunc((float)newX->data.F64[i])); - testStatus = false; - } else { - if (VERBOSE) { - printf("COOL[%d]: f(%f) is %f. Should be %f\n", i, - newX->data.F64[i], newY->data.F32[i], myFunc((float)newX->data.F64[i])); - } - } - } - psFree(tmpSpline); - psFree(newY); - } - psFree(x); - psFree(newX); - psFree(y); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psSpline functions", - "psSpline1DAlloc(), psVectorFitSpline1D, psSpline1DEvalVector: F64 versions", - testStatus); - - return (!testStatus); -} - -psS32 main() -{ - psLogSetFormat("HLNM"); - t00(); - t01(); -} Index: trunk/psLib/test/math/tst_psSpline1D.c =================================================================== --- trunk/psLib/test/math/tst_psSpline1D.c (revision 5155) +++ trunk/psLib/test/math/tst_psSpline1D.c (revision 5155) @@ -0,0 +1,660 @@ +/* @file tst_psImageManip.c +* +* @brief This file will contain tests for all of the public psLib functions +* that implement 1-D spline functionality: +* psSpline1DAlloc() +* psSpline1DEval() +* psSpline1DEvalVector() +* psVectorFitSpline1D() +* +* This file is composed of the tests formerly in tst_psFunc02.c, +* tst_psFunc03.c, tst_psFunc04.c, tst_psFunc05.c, and tst_psFunc07.c. +* +* @author GLG, MHPCC +* +* @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ +* @date $Date: 2005-09-27 23:19:47 $ +* +* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii +*/ + +#include "psTest.h" +#include "pslib_strict.h" + +static psS32 psSplineAllocTest( void ); +static psS32 psSplineEvalTest( void ); +static psS32 psSplineEvalVectorTest( void ); + +// {testFunction, testpointNumber, description, expected rc, boolean-ignore this test} +testDescription tests[] = { + {psSplineAllocTest, 0000, "(TEST A) psSplineAllocTest", true, false}, + {psSplineEvalTest, 0000, "(TEST B) psSplineEvalTest", true, false}, + {psSplineEvalVectorTest, 0000, "(TEST C) psSplineEvalVectorTest", true, false}, + {NULL} + }; + +#define ERROR_TOLERANCE_PERCENT 1.00 +/********************************************************************************* +CheckErrorF32(psF32 actual, psF32 expect): this routine returns FALSE if the +actual and expect arguments are with ERROR_TOLERANCE_PERCENT of each other, +otherwise it returns TRUE. + ********************************************************************************/ +psBool CheckErrorF32(psF32 actual, + psF32 expect) +{ + if ((fabs(actual - expect) / fabs(expect)) > ERROR_TOLERANCE_PERCENT) { + return(true); + } else { + return(false); + } +} + +psS32 main( psS32 argc, char* argv[] ) +{ + psLogSetFormat("HLNM"); + psLogSetLevel( PS_LOG_INFO ); + + return ( ! runTestSuite( stderr, "psSpline1D", tests, argc, argv ) ); +} + +psS32 psSplineAllocTest() +{ + psTraceSetLevel(".", 0); + psTraceSetLevel("spline1DFree", 0); + psTraceSetLevel("calculateSecondDerivs", 0); + psTraceSetLevel("vectorBinDisectF32", 0); + psTraceSetLevel("vectorBinDisectF64", 0); + psTraceSetLevel("p_psVectorBinDisect", 0); + psTraceSetLevel("fullInterpolate1DF32", 0); + psTraceSetLevel("fullInterpolate1DF64", 0); + psTraceSetLevel("interpolate1DF32", 0); + psTraceSetLevel("p_psVectorInterpolate", 0); + psTraceSetLevel("psSpline1DAlloc", 0); + psTraceSetLevel("psVectorFitSpline1D", 0); + psTraceSetLevel("psSpline1DEval", 0); + psTraceSetLevel("psSpline1DEvalVector", 0); + + psS32 testStatus = true; + psS32 currentId = psMemGetId(); + + printPositiveTestHeader(stdout, "psSpline functions", "psSpline1DAlloc()"); + + psSpline1D *tmpSpline = psSpline1DAlloc(); + if (tmpSpline == NULL) { + printf("TEST ERROR: Could not allocate psSpline1D data structure\n"); + testStatus = false; + } + + if (tmpSpline->n != 0) { + printf("TEST ERROR: psSpline1DAlloc() did not properly set the psSpline1D->n member.\n"); + testStatus = false; + } + + if (tmpSpline->spline != NULL) { + printf("TEST ERROR: psSpline1DAlloc() did not properly set the psSpline1D->spline member.\n"); + testStatus = false; + } + + if (tmpSpline->knots != NULL) { + printf("TEST ERROR: psSpline1DAlloc() did not properly set the psSpline1D->knots member.\n"); + testStatus = false; + } + + if (tmpSpline->p_psDeriv2 != NULL) { + printf("TEST ERROR: psSpline1DAlloc() did not properly set the psSpline1D->p_psDeriv2 member.\n"); + testStatus = false; + } + + psFree(tmpSpline); + psMemCheckCorruption(1); + psS32 memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); + if (0 != memLeaks) { + psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); + } + + printFooter(stdout, "psSpline functions", "psSpline1DAlloc()", testStatus); + return(testStatus); +} + + +/********************************************************************************* +t00(): We test the psVectorFitSpline1D, psSpline1DEval() functions with a very +simple x->y mapping (defined by myFunc00() below). We do this for both F32 +and F64 versions of the input x and y vectors. + ********************************************************************************/ +psF32 myFunc00(psF32 x) +{ + return(x); +} + +psS32 t00(psS32 NumSplines) +{ + printf("t00(): We test the psVectorFitSpline1D, psSpline1DEval() functions with a very\n"); + printf("simple x->y mapping (defined by myFunc00()). We do this for both F32\n"); + printf("and F64 versions of the input x and y vectors.\n"); + psS32 testStatus = true; + psS32 memLeaks=0; + psF32 x; + psF32 y; + psS32 currentId = psMemGetId(); + psVector *xF32 = NULL; + psVector *xF64 = NULL; + psVector *yF32 = NULL; + psVector *yF64 = NULL; + psSpline1D *tmpSpline = NULL; + + /****************************************************************************/ + /* PS_TYPE_F32, PS_TYPE_F32 test */ + /****************************************************************************/ + xF32 = psVectorAlloc(NumSplines+1, PS_TYPE_F32); + xF64 = psVectorAlloc(NumSplines+1, PS_TYPE_F64); + yF32 = psVectorAlloc(NumSplines+1, PS_TYPE_F32); + yF64 = psVectorAlloc(NumSplines+1, PS_TYPE_F64); + + for (psS32 i=0;idata.F32[i] = (psF32) i; + xF64->data.F64[i] = (psF64) i; + yF32->data.F32[i] = (psF32) myFunc00(xF32->data.F32[i]); + yF64->data.F64[i] = (psF64) myFunc00(xF32->data.F32[i]); + } + + printPositiveTestHeader(stdout, "psSpline functions", + "psVectorFitSpline1D, psSpline1DEval(), F32, F32"); + + tmpSpline = psVectorFitSpline1D(xF32, yF32); + if (tmpSpline == NULL) { + printf("TEST ERROR: Could not allocate psSpline1D data structure\n"); + testStatus = false; + } + + if (tmpSpline->n != NumSplines) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->n member.\n"); + printf(" psSpline1D->NumSplines was %d, should be %d.\n", tmpSpline->n, NumSplines); + testStatus = false; + } + + if (tmpSpline->spline == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->spline member.\n"); + testStatus = false; + } else { + for (psS32 i = 0 ; i < NumSplines ; i++) { + if (tmpSpline->spline[i] == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->spline[%d] member.\n", i); + testStatus = false; + } else { + if (psTraceGetLevel(__func__) >= 6) { + PS_POLY_PRINT_1D(tmpSpline->spline[i]); + } + } + } + } + + if (tmpSpline->knots == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->knots member.\n"); + testStatus = false; + } + + if (tmpSpline->p_psDeriv2 == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->p_psDeriv2 member.\n"); + testStatus = false; + } + + if (testStatus == true) { + for (psS32 i=0;idata.F32[i] = (psF32) i; + xF64->data.F64[i] = (psF64) i; + yF32->data.F32[i] = (psF32) myFunc00(xF32->data.F32[i]); + yF64->data.F64[i] = (psF64) myFunc00(xF32->data.F32[i]); + } + + printPositiveTestHeader(stdout, "psSpline functions", + "psVectorFitSpline1D, psSpline1DEval(), F64, F64"); + + tmpSpline = psVectorFitSpline1D(xF64, yF64); + if (tmpSpline == NULL) { + printf("TEST ERROR: Could not allocate psSpline1D data structure\n"); + testStatus = false; + } + + if (tmpSpline->n != NumSplines) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->n member.\n"); + printf(" psSpline1D->NumSplines was %d, should be %d.\n", tmpSpline->n, NumSplines); + testStatus = false; + } + + if (tmpSpline->spline == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->spline member.\n"); + testStatus = false; + } else { + for (psS32 i = 0 ; i < NumSplines ; i++) { + if (tmpSpline->spline[i] == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->spline[%d] member.\n", i); + testStatus = false; + } else { + if (psTraceGetLevel(__func__) >= 6) { + PS_POLY_PRINT_1D(tmpSpline->spline[i]); + } + } + } + } + + if (tmpSpline->knots == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->knots member.\n"); + testStatus = false; + } + + if (tmpSpline->p_psDeriv2 == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->p_psDeriv2 member.\n"); + testStatus = false; + } + + if (testStatus == true) { + for (psS32 i=0;iy mapping (defined by myFunc00b() below). We do this for +both F32 and F64 versions of the input x and y vectors. + ********************************************************************************/ +#define A 4.0 +#define B -3.0 +#define C 0.2 +#define D 0.1 +psF32 myFunc00b(psF32 x) +{ + return(A + x * (B + x * (C + x * (D)))); +} + +psS32 t00b(psS32 NumSplines) +{ + printf("t00b(): We test the psVectorFitSpline1D, psSpline1DEval() functions with a\n"); + printf("more complicated x->y mapping (defined by myFunc00b()). We do this for\n"); + printf("both F32 and F64 versions of the input x and y vectors.\n"); + psS32 testStatus = true; + psS32 memLeaks=0; + psF32 x; + psF32 y; + psS32 currentId = psMemGetId(); + psVector *xF32 = NULL; + psVector *xF64 = NULL; + psVector *yF32 = NULL; + psVector *yF64 = NULL; + psSpline1D *tmpSpline = NULL; + + /****************************************************************************/ + /* PS_TYPE_F32, PS_TYPE_F32 test */ + /****************************************************************************/ + xF32 = psVectorAlloc(NumSplines+1, PS_TYPE_F32); + xF64 = psVectorAlloc(NumSplines+1, PS_TYPE_F64); + yF32 = psVectorAlloc(NumSplines+1, PS_TYPE_F32); + yF64 = psVectorAlloc(NumSplines+1, PS_TYPE_F64); + + for (psS32 i=0;idata.F32[i] = (psF32) i; + xF64->data.F64[i] = (psF64) i; + yF32->data.F32[i] = (psF32) myFunc00b(xF32->data.F32[i]); + yF64->data.F64[i] = (psF64) myFunc00b(xF32->data.F32[i]); + } + + printPositiveTestHeader(stdout, "psSpline functions", + "psVectorFitSpline1D, psSpline1DEval(), F32, F32"); + + tmpSpline = psVectorFitSpline1D(xF32, yF32); + if (tmpSpline == NULL) { + printf("TEST ERROR: Could not allocate psSpline1D data structure\n"); + testStatus = false; + } + + if (tmpSpline->n != NumSplines) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->n member.\n"); + printf(" psSpline1D->NumSplines was %d, should be %d.\n", tmpSpline->n, NumSplines); + testStatus = false; + } + + if (tmpSpline->spline == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->spline member.\n"); + testStatus = false; + } else { + for (psS32 i = 0 ; i < NumSplines ; i++) { + if (tmpSpline->spline[i] == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->spline[%d] member.\n", i); + testStatus = false; + } else { + if (psTraceGetLevel(__func__) >= 6) { + PS_POLY_PRINT_1D(tmpSpline->spline[i]); + } + } + } + } + + if (tmpSpline->knots == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->knots member.\n"); + testStatus = false; + } + + if (tmpSpline->p_psDeriv2 == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->p_psDeriv2 member.\n"); + testStatus = false; + } + + if (testStatus == true) { + for (psS32 i=0;idata.F32[i] = (psF32) i; + xF64->data.F64[i] = (psF64) i; + yF32->data.F32[i] = (psF32) myFunc00b(xF32->data.F32[i]); + yF64->data.F64[i] = (psF64) myFunc00b(xF32->data.F32[i]); + } + + printPositiveTestHeader(stdout, "psSpline functions", + "psVectorFitSpline1D, psSpline1DEval(), F64, F64"); + + tmpSpline = psVectorFitSpline1D(xF64, yF64); + if (tmpSpline == NULL) { + printf("TEST ERROR: Could not allocate psSpline1D data structure\n"); + testStatus = false; + } + + if (tmpSpline->n != NumSplines) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->n member.\n"); + printf(" psSpline1D->NumSplines was %d, should be %d.\n", tmpSpline->n, NumSplines); + testStatus = false; + } + + if (tmpSpline->spline == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->spline member.\n"); + testStatus = false; + } else { + for (psS32 i = 0 ; i < NumSplines ; i++) { + if (tmpSpline->spline[i] == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->spline[%d] member.\n", i); + testStatus = false; + } else { + if (psTraceGetLevel(__func__) >= 6) { + PS_POLY_PRINT_1D(tmpSpline->spline[i]); + } + } + } + } + + if (tmpSpline->knots == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->knots member.\n"); + testStatus = false; + } + + if (tmpSpline->p_psDeriv2 == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->p_psDeriv2 member.\n"); + testStatus = false; + } + + if (testStatus == true) { + for (psS32 i=0;idata.F32[i] = (psF32) i; + yF32->data.F32[i] = (psF32) i; + } + + printPositiveTestHeader(stdout, "psSpline functions", + "psVectorFitSpline1D, psSpline1DEvalVector(), F32, F32"); + + tmpSpline = psVectorFitSpline1D(xF32, yF32); + if (tmpSpline == NULL) { + printf("TEST ERROR: Could not allocate psSpline1D data structure\n"); + testStatus = false; + } + + if (tmpSpline->n != NumSplines) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->n member.\n"); + printf(" psSpline1D->NumSplines was %d, should be %d.\n", tmpSpline->n, NumSplines); + testStatus = false; + } + + if (tmpSpline->spline == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->spline member.\n"); + testStatus = false; + } else { + for (psS32 i = 0 ; i < NumSplines ; i++) { + if (tmpSpline->spline[i] == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->spline[%d] member.\n", i); + testStatus = false; + } else { + if (psTraceGetLevel(__func__) >= 6) { + PS_POLY_PRINT_1D(tmpSpline->spline[i]); + } + } + } + } + + if (tmpSpline->knots == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->knots member.\n"); + testStatus = false; + } + + if (tmpSpline->p_psDeriv2 == NULL) { + printf("TEST ERROR: psVectorFitSpline1D() did not properly set the psSpline1D->p_psDeriv2 member.\n"); + testStatus = false; + } + + printf("Testing psSpline1DEvalVector() with an F32 vector.\n"); + if (testStatus == true) { + for (psS32 i=0;idata.F32[i] = 0.5 + (psF32) i; + } + yF32Test = psSpline1DEvalVector(tmpSpline, xF32Test); + + for (psS32 i=0;idata.F32[i], xF32Test->data.F32[i])) { + printf("TEST ERROR: f(%f) is %f\n", xF32Test->data.F32[i], yF32Test->data.F32[i]); + testStatus = false; + } + } + psFree(yF32Test); + } + + printf("Testing psSpline1DEvalVector() with an F64 vector.\n"); + if (testStatus == true) { + for (psS32 i=0;idata.F64[i] = 0.5 + (psF64) i; + } + yF32Test = psSpline1DEvalVector(tmpSpline, xF64Test); + + for (psS32 i=0;idata.F32[i], (psF32) xF64Test->data.F64[i])) { + printf("TEST ERROR: f(%f) is %f\n", (psF32) xF64Test->data.F64[i], yF32Test->data.F32[i]); + testStatus = false; + } + } + } + + psFree(tmpSpline); + psFree(xF32); + psFree(yF32); + psFree(xF32Test); + psFree(yF32Test); + psFree(xF64Test); + psMemCheckCorruption(1); + memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); + if (0 != memLeaks) { + psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); + } + printFooter(stdout, "psSpline functions", + "psVectorFitSpline1D, psSpline1DEvalVector(), F32, F32", testStatus); + + return (testStatus); +} + +psS32 psSplineEvalVectorTest() +{ + psTraceSetLevel(".", 0); + psTraceSetLevel("spline1DFree", 0); + psTraceSetLevel("calculateSecondDerivs", 0); + psTraceSetLevel("vectorBinDisectF32", 0); + psTraceSetLevel("vectorBinDisectF64", 0); + psTraceSetLevel("p_psVectorBinDisect", 0); + psTraceSetLevel("fullInterpolate1DF32", 0); + psTraceSetLevel("fullInterpolate1DF64", 0); + psTraceSetLevel("interpolate1DF32", 0); + psTraceSetLevel("p_psVectorInterpolate", 0); + psTraceSetLevel("psSpline1DAlloc", 0); + psTraceSetLevel("psVectorFitSpline1D", 0); + psTraceSetLevel("psSpline1DEval", 0); + psTraceSetLevel("psSpline1DEvalVector", 0); + + return(t01(10)); +} + + + +//is the way Index: trunk/psLib/test/math/tst_psStats07.c =================================================================== --- trunk/psLib/test/math/tst_psStats07.c (revision 5117) +++ trunk/psLib/test/math/tst_psStats07.c (revision 5155) @@ -44,4 +44,38 @@ /* Allocate and initialize data structures */ /*************************************************************************/ + maskVector = psVectorAlloc( N, PS_TYPE_U8 ); + maskVector->n = N; + myVector = p_psGaussianDev( MEAN, STDEV, N ); + // Set the mask vector and calculate the expected maximum. + for ( i = 0;i < N;i++ ) { + if ( i < ( N / 2 ) ) { + maskVector->data.U8[ i ] = 0; + count++; + } else { + maskVector->data.U8[ i ] = 1; + } + } + psStats *mySampleStats = psStatsAlloc( PS_STAT_SAMPLE_MEAN | + PS_STAT_SAMPLE_MEDIAN | + PS_STAT_SAMPLE_STDEV | + PS_STAT_SAMPLE_QUARTILE ); + mySampleStats = psVectorStats( mySampleStats, myVector, NULL, NULL, 0 ); + printf("The Sample Mean is %.2f\n", mySampleStats->sampleMean); + printf("The Sample Median is %.2f\n", mySampleStats->sampleMedian); + printf("The Sample stdev is %.2f\n", mySampleStats->sampleStdev); + printf("The Sample quartiles are (%.2f %.2f)\n", mySampleStats->sampleLQ, mySampleStats->sampleUQ); + psFree(mySampleStats); + + psStats *mySampleStatsWithMask = psStatsAlloc( PS_STAT_SAMPLE_MEAN | + PS_STAT_SAMPLE_MEDIAN | + PS_STAT_SAMPLE_STDEV | + PS_STAT_SAMPLE_QUARTILE ); + mySampleStatsWithMask = psVectorStats( mySampleStatsWithMask, myVector, NULL, maskVector, 1 ); + printf("The Sample Mean is %.2f\n", mySampleStatsWithMask->sampleMean); + printf("The Sample Median is %.2f\n", mySampleStatsWithMask->sampleMedian); + printf("The Sample stdev is %.2f\n", mySampleStatsWithMask->sampleStdev); + printf("The Sample quartiles are (%.2f %.2f)\n", mySampleStatsWithMask->sampleLQ, mySampleStatsWithMask->sampleUQ); + psFree(mySampleStatsWithMask); + myStats = psStatsAlloc( PS_STAT_ROBUST_MEAN | PS_STAT_ROBUST_MEDIAN | @@ -49,20 +83,7 @@ PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE ); - - maskVector = psVectorAlloc( N, PS_TYPE_U8 ); - maskVector->n = N; - myVector = p_psGaussianDev( MEAN, STDEV, N ); // Create a full outliers: myVector->data.F32[N/4] = -1000.0 * MEAN; myVector->data.F32[N/2] = 1000.0 * MEAN; - // Set the mask vector and calculate the expected maximum. - for ( i = 0;i < N;i++ ) { - if ( i < ( N / 2 ) ) { - maskVector->data.U8[ i ] = 0; - count++; - } else { - maskVector->data.U8[ i ] = 1; - } - } /*************************************************************************/ /* Call psVectorStats() with no vector mask. */ Index: trunk/psLib/test/math/verified/tst_psSpline1D.stderr =================================================================== --- trunk/psLib/test/math/verified/tst_psSpline1D.stderr (revision 5155) +++ trunk/psLib/test/math/verified/tst_psSpline1D.stderr (revision 5155) @@ -0,0 +1,27 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_psSpline1D.c * +* TestPoint: psSpline1D{(TEST A) psSplineAllocTest} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (psSpline1D{(TEST A) psSplineAllocTest} | tst_psSpline1D.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_psSpline1D.c * +* TestPoint: psSpline1D{(TEST B) psSplineEvalTest} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (psSpline1D{(TEST B) psSplineEvalTest} | tst_psSpline1D.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_psSpline1D.c * +* TestPoint: psSpline1D{(TEST C) psSplineEvalVectorTest} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (psSpline1D{(TEST C) psSplineEvalVectorTest} | tst_psSpline1D.c) + Index: trunk/psLib/test/math/verified/tst_psSpline1D.stdout =================================================================== --- trunk/psLib/test/math/verified/tst_psSpline1D.stdout (revision 5155) +++ trunk/psLib/test/math/verified/tst_psSpline1D.stdout (revision 5155) @@ -0,0 +1,62 @@ +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_psSpline1D.c * +* TestPoint: psSpline functions{psSpline1DAlloc()} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (psSpline functions{psSpline1DAlloc()} | tst_psSpline1D.c) + +t00(): We test the psVectorFitSpline1D, psSpline1DEval() functions with a very +simple x->y mapping (defined by myFunc00()). We do this for both F32 +and F64 versions of the input x and y vectors. +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_psSpline1D.c * +* TestPoint: psSpline functions{psVectorFitSpline1D, psSpline1DEval(), F32, F32} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (psSpline functions{psVectorFitSpline1D, psSpline1DEval(), F32, F32} | tst_psSpline1D.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_psSpline1D.c * +* TestPoint: psSpline functions{psVectorFitSpline1D, psSpline1DEval(), F64, F64} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (psSpline functions{psVectorFitSpline1D, psSpline1DEval(), F64, F64} | tst_psSpline1D.c) + +t00b(): We test the psVectorFitSpline1D, psSpline1DEval() functions with a +more complicated x->y mapping (defined by myFunc00b()). We do this for +both F32 and F64 versions of the input x and y vectors. +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_psSpline1D.c * +* TestPoint: psSpline functions{psVectorFitSpline1D, psSpline1DEval(), F32, F32} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (psSpline functions{psVectorFitSpline1D, psSpline1DEval(), F32, F32} | tst_psSpline1D.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_psSpline1D.c * +* TestPoint: psSpline functions{psVectorFitSpline1D, psSpline1DEval(), F64, F64} * +* TestType: Positive * +\**********************************************************************************/ + + +---> TESTPOINT PASSED (psSpline functions{psVectorFitSpline1D, psSpline1DEval(), F64, F64} | tst_psSpline1D.c) + +/***************************** TESTPOINT ******************************************\ +* TestFile: tst_psSpline1D.c * +* TestPoint: psSpline functions{psVectorFitSpline1D, psSpline1DEvalVector(), F32, F32} * +* TestType: Positive * +\**********************************************************************************/ + +Testing psSpline1DEvalVector() with an F32 vector. +Testing psSpline1DEvalVector() with an F64 vector. + +---> TESTPOINT PASSED (psSpline functions{psVectorFitSpline1D, psSpline1DEvalVector(), F32, F32} | tst_psSpline1D.c) +