Index: /trunk/psLib/test/math/tst_psMinimizeLMM.c =================================================================== --- /trunk/psLib/test/math/tst_psMinimizeLMM.c (revision 6291) +++ /trunk/psLib/test/math/tst_psMinimizeLMM.c (revision 6291) @@ -0,0 +1,259 @@ +/***************************************************************************** + This routine must ensure that psMinimizeLM() works correctly. + + XXX: This code needs a lot of additional test case work. + XXX: Use the tst_template. + XXX: Print headers and footers. + XXX: Why are we flushing stdout? + *****************************************************************************/ +#include +#include "pslib_strict.h" +#include "psTest.h" +#include +#define NUM_ITERATIONS 100 +#define ERR_TOL 0.1 +#define NUM_DATA_POINTS 20 +#define NUM_PARAMS 5 +float expectedParm[NUM_PARAMS]; + +/***************************************************************************** +myFunc(): + sum = param[0] + x[0] * x[1] + + param[1] * x[0] + + param[2] * x[0]^2 + + param[3] * x[1] + + param[4] * x[1]^2 + + *****************************************************************************/ +psF32 myFunc(psVector *deriv, + psVector *params, + psVector *x) +{ + if ((deriv == NULL) || (params == NULL) || (x == NULL)) { + psError(PS_ERR_UNKNOWN, true, "deriv or params or x is NULL.\n"); + } + + psF32 sum = (params->data.F32[0] * x->data.F32[0] * x->data.F32[1]) + + (params->data.F32[1] * x->data.F32[0]) + + (params->data.F32[2] * PS_SQR(x->data.F32[0])) + + (params->data.F32[3] * x->data.F32[1]) + + (params->data.F32[4] * PS_SQR(x->data.F32[1])); + + deriv->data.F32[0] = x->data.F32[0] * x->data.F32[1]; + deriv->data.F32[1] = x->data.F32[0]; + deriv->data.F32[2] = PS_SQR(x->data.F32[0]); + deriv->data.F32[3] = x->data.F32[1]; + deriv->data.F32[4] = PS_SQR(x->data.F32[1]); + + return(sum); +} + +psS32 t01() +{ + psS32 currentId = psMemGetId(); + psBool testStatus = true; + + psMinimization *min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL); + psImage *myCovar = psImageAlloc(NUM_PARAMS, NUM_PARAMS, PS_TYPE_F32); + psVector *myParams = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); + psVector *myDerivs = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32); + psArray *myCoords = psArrayAlloc(NUM_DATA_POINTS); + psVector *y = psVectorAlloc(NUM_DATA_POINTS, PS_TYPE_F32); + + for (psS32 i=0;idata[i] = (psPtr *) psVectorAlloc(2, PS_TYPE_F32); + ((psVector *) (myCoords->data[i]))->data.F32[0] = (float) (i+10); + ((psVector *) (myCoords->data[i]))->data.F32[1] = (float) (i+3); + psTrace(__func__, 5, "x[%d] is vector (%f, %f)\n", i, ((psVector *) (myCoords->data[i]))->data.F32[0], + ((psVector *) (myCoords->data[i]))->data.F32[1]); + y->data.F32[i] = (float) i; + } + for (psS32 i=0;idata.F32[i] = (float) (2 * i); + } + + psBool rc = psMinimizeLMChi2(min, NULL, myParams, NULL, myCoords, y, NULL, + (psMinimizeLMChi2Func) myFunc); + if (rc == false) { + printf("TEST ERROR: psMinimizeLMChi2() returned FALSE.\n"); + fflush(stdout); + testStatus = false; + } else { + printf("\nThe value of the function at the minimum is %f\n", min->value); + for (psS32 i=0;idata[i])); + fflush(stdout); + } + + for (psS32 i=0;idata.F32[i], expectedParm[i]); + fflush(stdout); + } + } + + psFree(min); + psFree(myCovar); + psFree(myParams); + psFree(myDerivs); + psFree(myCoords); + psFree(y); + psMemCheckCorruption(1); + psS32 memLeaks = psMemCheckLeaks(currentId, NULL, NULL, false); + if (0 != memLeaks) { + printf("TEST ERROR: Memory Leaks! (%d leaks).\n", memLeaks); + fflush(stdout); + // XXX: This is causing a seg fault + psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); + } + + return (testStatus); +} + +#define NUM_ITER 10 +#define TOL 20.0 +psS32 tst_psMinimizationAlloc() +{ + psS32 currentId = psMemGetId(); + psBool testStatus = true; + + psMinimization *tmp = psMinimizationAlloc(NUM_ITER, TOL); + if (tmp == NULL) { + printf("TEST ERROR: psMinimizationAlloc() returned FALSE.\n"); + testStatus = false; + } else { + if (tmp->maxIter != NUM_ITER) { + printf("TEST ERROR: psMinimizationAlloc() did not properly set ->maxIter.\n"); + testStatus = false; + } + + if (tmp->tol != TOL) { + printf("TEST ERROR: psMinimizationAlloc() did not properly set ->tol.\n"); + testStatus = false; + } + + if (tmp->value != 0.0) { + printf("TEST ERROR: psMinimizationAlloc() did not properly set ->value.\n"); + testStatus = false; + } + + if (tmp->iter != 0) { + printf("TEST ERROR: psMinimizationAlloc() did not properly set ->iter.\n"); + testStatus = false; + } + + if (!isnan(tmp->lastDelta)) { + printf("TEST ERROR: psMinimizationAlloc() did not properly set ->lastDelta.\n"); + testStatus = false; + } + psFree(tmp); + } + + psMemCheckCorruption(1); + psS32 memLeaks = psMemCheckLeaks(currentId, NULL, NULL, false); + if (0 != memLeaks) { + printf("TEST ERROR: Memory Leaks! (%d leaks).\n", memLeaks); + testStatus = false; + } + + return(testStatus); +} + + +#define NUM_ITER 10 +#define TOL 20.0 +psS32 tst_psMinConstrainAlloc() +{ + psS32 currentId = psMemGetId(); + psBool testStatus = true; + + psMinConstrain *tmp = psMinConstrainAlloc(NUM_ITER, TOL); + if (tmp == NULL) { + printf("TEST ERROR: psMinConstrainAlloc() returned FALSE.\n"); + testStatus = false; + } else { + if (tmp->paramMask != NULL) { + printf("TEST ERROR: psMinConstrainAlloc() did not properly set ->paramMask.\n"); + testStatus = false; + } + + if (tmp->paramMax != NULL) { + printf("TEST ERROR: psMinConstrainAlloc() did not properly set ->paramMax.\n"); + testStatus = false; + } + + if (tmp->paramMin != NULL) { + printf("TEST ERROR: psMinConstrainAlloc() did not properly set ->paramMin.\n"); + testStatus = false; + } + + if (tmp->paramDelta != NULL) { + printf("TEST ERROR: psMinConstrainAlloc() did not properly set ->paramDelta.\n"); + testStatus = false; + } + + psFree(tmp); + } + + psMemCheckCorruption(1); + psS32 memLeaks = psMemCheckLeaks(currentId, NULL, NULL, false); + if (0 != memLeaks) { + printf("TEST ERROR: Memory Leaks! (%d leaks).\n", memLeaks); + testStatus = false; + } + + return(testStatus); +} + + +psS32 main() +{ + psLogSetFormat("HLNM"); + psTraceSetDestination(1); + psTraceSetLevel(".", 0); + psTraceSetLevel(__func__, 0); + psTraceSetLevel("t01", 0); + psTraceSetLevel("psMinimizeLMChi2_OLD", 0); + psTraceSetLevel("psMinimizeLMChi2", 0); + psTraceSetLevel("psMinimizeGaussNewtonDelta", 0); + psTraceSetLevel("psMinimizeGaussNewtonDelta_EAM", 0); + psTraceSetLevel("p_psMinLM_GuessABP", 0); + psTraceSetLevel("p_psMinLM_GuessABP_EAM", 0); + psTraceSetLevel("p_psMinLM_SetABX", 0); + psTraceSetLevel("psGaussJordan", 0); + psTraceSetLevel("psMinimizationAlloc", 0); + psTraceSetLevel("psMinConstrainAlloc", 0); + psTraceSetLevel("psMemCheckMinimization", 0); + psTraceSetLevel("p_psDetermineBracket", 0); + psTraceSetLevel("p_psDetermineBracket2", 0); + psTraceSetLevel("p_psLineMin", 0); + psTraceSetLevel("psMinimizePowell", 0); + psTraceSetLevel("myPowellChi2Func", 0); + psTraceSetLevel("psMinimizeChi2Powell", 0); + psTraceSetLevel("BuildSums1D", 0); + psTraceSetLevel("BuildSums2D", 0); + psTraceSetLevel("Polynomial2DEvalVectorD", 0); + psTraceSetLevel("vectorFitPolynomial1DCheby", 0); + psTraceSetLevel("VectorFitPolynomial1DOrd", 0); + psTraceSetLevel("psVectorFitPolynomial1D", 0); + psTraceSetLevel("psVectorClipFitPolynomial1D", 0); + + psTrace(__func__, 2, "Calling new psMinimize().\n"); + psS32 testStatus = true; + + + testStatus &= t01(); + testStatus &= tst_psMinimizationAlloc(); + testStatus &= tst_psMinConstrainAlloc(); + if (testStatus == true) { + printf("The LMM minimization tests PASSED.\n"); + } else { + printf("The LMM minimization tests FAILED.\n"); + } + printf("DONE\n"); + fflush(stdout); +} + + Index: /trunk/psLib/test/math/verified/tst_psMinimizeLMM.stdout =================================================================== --- /trunk/psLib/test/math/verified/tst_psMinimizeLMM.stdout (revision 6291) +++ /trunk/psLib/test/math/verified/tst_psMinimizeLMM.stdout (revision 6291) @@ -0,0 +1,29 @@ + +The value of the function at the minimum is 0.000000 +The minimum for data point number 0: f is 0.00 +The minimum for data point number 1: f is 1.00 +The minimum for data point number 2: f is 2.00 +The minimum for data point number 3: f is 3.00 +The minimum for data point number 4: f is 4.00 +The minimum for data point number 5: f is 5.00 +The minimum for data point number 6: f is 6.00 +The minimum for data point number 7: f is 7.00 +The minimum for data point number 8: f is 8.00 +The minimum for data point number 9: f is 9.00 +The minimum for data point number 10: f is 10.00 +The minimum for data point number 11: f is 11.00 +The minimum for data point number 12: f is 12.00 +The minimum for data point number 13: f is 13.00 +The minimum for data point number 14: f is 14.00 +The minimum for data point number 15: f is 15.00 +The minimum for data point number 16: f is 16.00 +The minimum for data point number 17: f is 17.00 +The minimum for data point number 18: f is 18.00 +The minimum for data point number 19: f is 19.00 +Parameter 0 at the minimum is -3.391722 (expected: 2.420000) +Parameter 1 at the minimum is -14.965391 (expected: 4.420000) +Parameter 2 at the minimum is 2.076689 (expected: 6.420000) +Parameter 3 at the minimum is 10.633801 (expected: 8.420000) +Parameter 4 at the minimum is 1.315034 (expected: 10.420000) +The LMM minimization tests PASSED. +DONE