IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 1991


Ignore:
Timestamp:
Oct 6, 2004, 1:29:16 PM (22 years ago)
Author:
gusciora
Message:

Tests for NULL paramaters in the MinimizePowell functions.

Location:
trunk/psLib
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/dataManip/psMinimize.c

    r1982 r1991  
    99 *  @author GLF, MHPCC
    1010 *
    11  *  @version $Revision: 1.55 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2004-10-06 21:30:53 $
     11 *  @version $Revision: 1.56 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2004-10-06 23:29:16 $
    1313 *
    1414 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    12971297 
    12981298XXX: Define constants for default dummy number of iterations and tolerance.
     1299 
     1300XXX: Must define behavior on various NULL inputs.
    12991301 *****************************************************************************/
    13001302bool psMinimizePowell(psMinimization *min,
    … …  
    13041306                      psMinimizePowellFunc func)
    13051307{
     1308    PS_CHECK_NULL_VECTOR_RETURN_NULL(params);
     1309    PS_CHECK_EMPTY_VECTOR_RETURN_NULL(params);
     1310    PS_CHECK_NULL_PTR_RETURN_NULL(min);
     1311    PS_CHECK_NULL_PTR_RETURN_NULL(coords);
     1312    PS_CHECK_NULL_PTR_RETURN_NULL(func);
     1313
    13061314    int numDims = params->n;
    13071315    int i = 0;
    … …  
    13111319    psVector *Q = NULL;
    13121320    psVector *u = NULL;
     1321    psVector *myParamMask = NULL;  // XXX: Use a recylced vector here.
    13131322    psMinimization dummyMin;
    13141323    float mul = 0.0;
    … …  
    13331342    Q = psVectorAlloc(numDims, PS_TYPE_F32);
    13341343
     1344    if (paramMask == NULL) {
     1345        myParamMask = psVectorAlloc(params->n, PS_TYPE_U8);
     1346        for (i=0;i<myParamMask->n;i++) {
     1347            myParamMask->data.U8[i] = 0;
     1348        }
     1349    } else {
     1350        myParamMask = (psVector *) paramMask;
     1351    }
     1352    PS_CHECK_VECTOR_SIZE_EQUAL_RETURN_NULL(params, myParamMask);
     1353
    13351354    // 1: Set v[i] to be the unit vectors for each dimension in params
    13361355    v = (psVector **) psAlloc(params->n * sizeof(psVector **));
    … …  
    13481367    // 2: Set Q to be the initial params (P in the ADD)
    13491368    for (i=0;i<numDims;i++) {
    1350         if (paramMask->data.U8[i] == 0) {
     1369        if (myParamMask->data.U8[i] == 0) {
    13511370            Q->data.F32[i] = params->data.F32[i];
    13521371        }
    … …  
    13681387        biggestIter = 0;
    13691388        for (i=0;i<numDims;i++) {
    1370             if (paramMask->data.U8[i] == 0) {
     1389            if (myParamMask->data.U8[i] == 0) {
    13711390                dummyMin.maxIter = 100;
    13721391                dummyMin.tol = 0.01;
    1373                 mul = p_psLineMin(&dummyMin, Q, v[i], paramMask, coords, func);
     1392                mul = p_psLineMin(&dummyMin, Q, v[i], myParamMask, coords, func);
    13741393                if (fabs(dummyMin.value - currFuncVal) > biggestDiff) {
    13751394                    biggestDiff = fabs(dummyMin.value - currFuncVal);
    … …  
    13821401        // 4: Set the vector u = Q - P
    13831402        for (i=0;i<numDims;i++) {
    1384             if (paramMask->data.U8[i] == 0) {
     1403            if (myParamMask->data.U8[i] == 0) {
    13851404                u->data.F32[i] = Q->data.F32[i] - params->data.F32[i];
    13861405
    … …  
    14021421        }
    14031422
    1404         mul = p_psLineMin(min, params, u, paramMask, coords, func);
     1423        mul = p_psLineMin(min, params, u, myParamMask, coords, func);
    14051424
    14061425        // 6:
    … …  
    14131432            psFree(pQP);
    14141433            psFree(Q);
     1434            if (paramMask == NULL) {
     1435                psFree(myParamMask);
     1436            }
    14151437            psTrace(".psLib.dataManip.psMinimizePowell", 4,
    14161438                    "---- psMinimizePowell() end (true) ----\n");
    … …  
    14191441
    14201442        for (i=0;i<numDims;i++) {
    1421             if (paramMask->data.U8[i] == 0) {
     1443            if (myParamMask->data.U8[i] == 0) {
    14221444                pQP->data.F32[i] = (2 * Q->data.F32[i]) - params->data.F32[i];
    14231445            } else {
    … …  
    14341456        if (term1 < term2) {
    14351457            for (i=0;i<numDims;i++) {
    1436                 if (paramMask->data.U8[i] == 0) {
     1458                if (myParamMask->data.U8[i] == 0) {
    14371459                    v[biggestIter]->data.F32[i] = u->data.F32[i];
    14381460                }
    … …  
    14421464        // 7: Set P to Q
    14431465        for (i=0;i<numDims;i++) {
    1444             if (paramMask->data.U8[i] == 0) {
     1466            if (myParamMask->data.U8[i] == 0) {
    14451467                params->data.F32[i] = Q->data.F32[i];
    14461468            }
    … …  
    14581480            psTrace(".psLib.dataManip.psMinimizePowell", 4,
    14591481                    "---- psMinimizePowell() end (true) ----\n");
     1482            if (paramMask == NULL) {
     1483                psFree(myParamMask);
     1484            }
    14601485            return(true);
    14611486        }
    14621487    }
    14631488
     1489    if (paramMask == NULL) {
     1490        psFree(myParamMask);
     1491    }
    14641492    for (i=0;i<numDims;i++) {
    14651493        psFree(v[i]);

  • trunk/psLib/src/math/psMinimize.c

    r1982 r1991  
    99 *  @author GLF, MHPCC
    1010 *
    11  *  @version $Revision: 1.55 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2004-10-06 21:30:53 $
     11 *  @version $Revision: 1.56 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2004-10-06 23:29:16 $
    1313 *
    1414 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    12971297 
    12981298XXX: Define constants for default dummy number of iterations and tolerance.
     1299 
     1300XXX: Must define behavior on various NULL inputs.
    12991301 *****************************************************************************/
    13001302bool psMinimizePowell(psMinimization *min,
    … …  
    13041306                      psMinimizePowellFunc func)
    13051307{
     1308    PS_CHECK_NULL_VECTOR_RETURN_NULL(params);
     1309    PS_CHECK_EMPTY_VECTOR_RETURN_NULL(params);
     1310    PS_CHECK_NULL_PTR_RETURN_NULL(min);
     1311    PS_CHECK_NULL_PTR_RETURN_NULL(coords);
     1312    PS_CHECK_NULL_PTR_RETURN_NULL(func);
     1313
    13061314    int numDims = params->n;
    13071315    int i = 0;
    … …  
    13111319    psVector *Q = NULL;
    13121320    psVector *u = NULL;
     1321    psVector *myParamMask = NULL;  // XXX: Use a recylced vector here.
    13131322    psMinimization dummyMin;
    13141323    float mul = 0.0;
    … …  
    13331342    Q = psVectorAlloc(numDims, PS_TYPE_F32);
    13341343
     1344    if (paramMask == NULL) {
     1345        myParamMask = psVectorAlloc(params->n, PS_TYPE_U8);
     1346        for (i=0;i<myParamMask->n;i++) {
     1347            myParamMask->data.U8[i] = 0;
     1348        }
     1349    } else {
     1350        myParamMask = (psVector *) paramMask;
     1351    }
     1352    PS_CHECK_VECTOR_SIZE_EQUAL_RETURN_NULL(params, myParamMask);
     1353
    13351354    // 1: Set v[i] to be the unit vectors for each dimension in params
    13361355    v = (psVector **) psAlloc(params->n * sizeof(psVector **));
    … …  
    13481367    // 2: Set Q to be the initial params (P in the ADD)
    13491368    for (i=0;i<numDims;i++) {
    1350         if (paramMask->data.U8[i] == 0) {
     1369        if (myParamMask->data.U8[i] == 0) {
    13511370            Q->data.F32[i] = params->data.F32[i];
    13521371        }
    … …  
    13681387        biggestIter = 0;
    13691388        for (i=0;i<numDims;i++) {
    1370             if (paramMask->data.U8[i] == 0) {
     1389            if (myParamMask->data.U8[i] == 0) {
    13711390                dummyMin.maxIter = 100;
    13721391                dummyMin.tol = 0.01;
    1373                 mul = p_psLineMin(&dummyMin, Q, v[i], paramMask, coords, func);
     1392                mul = p_psLineMin(&dummyMin, Q, v[i], myParamMask, coords, func);
    13741393                if (fabs(dummyMin.value - currFuncVal) > biggestDiff) {
    13751394                    biggestDiff = fabs(dummyMin.value - currFuncVal);
    … …  
    13821401        // 4: Set the vector u = Q - P
    13831402        for (i=0;i<numDims;i++) {
    1384             if (paramMask->data.U8[i] == 0) {
     1403            if (myParamMask->data.U8[i] == 0) {
    13851404                u->data.F32[i] = Q->data.F32[i] - params->data.F32[i];
    13861405
    … …  
    14021421        }
    14031422
    1404         mul = p_psLineMin(min, params, u, paramMask, coords, func);
     1423        mul = p_psLineMin(min, params, u, myParamMask, coords, func);
    14051424
    14061425        // 6:
    … …  
    14131432            psFree(pQP);
    14141433            psFree(Q);
     1434            if (paramMask == NULL) {
     1435                psFree(myParamMask);
     1436            }
    14151437            psTrace(".psLib.dataManip.psMinimizePowell", 4,
    14161438                    "---- psMinimizePowell() end (true) ----\n");
    … …  
    14191441
    14201442        for (i=0;i<numDims;i++) {
    1421             if (paramMask->data.U8[i] == 0) {
     1443            if (myParamMask->data.U8[i] == 0) {
    14221444                pQP->data.F32[i] = (2 * Q->data.F32[i]) - params->data.F32[i];
    14231445            } else {
    … …  
    14341456        if (term1 < term2) {
    14351457            for (i=0;i<numDims;i++) {
    1436                 if (paramMask->data.U8[i] == 0) {
     1458                if (myParamMask->data.U8[i] == 0) {
    14371459                    v[biggestIter]->data.F32[i] = u->data.F32[i];
    14381460                }
    … …  
    14421464        // 7: Set P to Q
    14431465        for (i=0;i<numDims;i++) {
    1444             if (paramMask->data.U8[i] == 0) {
     1466            if (myParamMask->data.U8[i] == 0) {
    14451467                params->data.F32[i] = Q->data.F32[i];
    14461468            }
    … …  
    14581480            psTrace(".psLib.dataManip.psMinimizePowell", 4,
    14591481                    "---- psMinimizePowell() end (true) ----\n");
     1482            if (paramMask == NULL) {
     1483                psFree(myParamMask);
     1484            }
    14601485            return(true);
    14611486        }
    14621487    }
    14631488
     1489    if (paramMask == NULL) {
     1490        psFree(myParamMask);
     1491    }
    14641492    for (i=0;i<numDims;i++) {
    14651493        psFree(v[i]);

  • trunk/psLib/test/dataManip/tst_psFunc05.c

    r1946 r1991  
    66    psSpline1DEvalVector() on new data values and ensures that the results
    77    are correct.
     8 
     9    XXX: Only F32 types are tested here.  F64 types are tested elsewhere.
    810 *****************************************************************************/
    911#include <stdio.h>

  • trunk/psLib/test/dataManip/tst_psMinimize04.c

    r1976 r1991  
    2727#define C 3.0
    2828#define ERROR_TOLERANCE 0.10
    29 #define YERR 10.0
     29#define YERR 1.0
    3030double setData(double x)
    3131{

  • trunk/psLib/test/dataManip/tst_psMinimize05.c

    r1810 r1991  
    11/*****************************************************************************
    22    This routine must ensure that psMinimizePowell() works correctly.
     3 
     4    We test with a NULL and non-NULL paramMask.
     5 
     6    XXX: Must verify the stderr for the NULL parameter tests.
    37 *****************************************************************************/
    48#include <stdio.h>
    … …  
    913#define MIN_VALUE 20.0
    1014#define NUM_PARAMS 10
     15#define ERROR_TOLERANCE 0.10
    1116float expectedParm[NUM_PARAMS];
    1217int testStatus = true;
    … …  
    5762
    5863
    59 int main()
     64int t00()
    6065{
    6166    int currentId = psMemGetId();
    … …  
    8691    }
    8792
    88     psMinimizePowell(min, myParams, myParamMask, myCoords, (psMinimizePowellFunc) myFunc);
     93    printPositiveTestHeader(stdout,
     94                            "psMinimize functions",
     95                            "psMinimizePowell()");
     96
     97    psMinimizePowell(min,
     98                     myParams,
     99                     myParamMask,
     100                     myCoords,
     101                     (psMinimizePowellFunc) myFunc);
     102
    89103    printf("\nThe minimum is %f (expected: %f)\n", min->value, MIN_VALUE);
     104
    90105    for (i=0;i<NUM_PARAMS;i++) {
    91106        printf("Parameter %d at the minimum is %f (expected: %f)\n", i,
    92107               myParams->data.F32[i], expectedParm[i]);
    93     }
     108
     109        if (fabs(myParams->data.F32[i] - expectedParm[i]) > fabs(ERROR_TOLERANCE * expectedParm[i])) {
     110            printf("ERROR: Parameter %d: (%.1f), expected was (%.1f)\n",
     111                   i, myParams->data.F32[i], expectedParm[i]);
     112            testStatus = false;
     113        } else {
     114            printf("Parameter %d: (%.1f), expected was (%.1f)\n",
     115                   i, myParams->data.F32[i], expectedParm[i]);
     116        }
     117    }
     118
    94119
    95120    psFree(myCoords);
    … …  
    103128        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
    104129    }
     130    printFooter(stdout,
     131                "psMinimize functions",
     132                "psMinimizePowell()",
     133                testStatus);
     134
     135
    105136    return (!testStatus);
    106137}
     138
     139int t01()
     140{
     141    int currentId = psMemGetId();
     142    int memLeaks = 0;
     143    int i = 0;
     144    psArray *myCoords;
     145    psVector *myParams;
     146    psMinimization *min;
     147
     148    psTraceSetLevel(".psLib", 0);
     149    /**************************************************************************
     150     *************************************************************************/
     151    myParams = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32);
     152    min = psMinimizationAlloc(100, 0.01);
     153
     154    myCoords = psArrayAlloc(N);
     155    for (i=0;i<N;i++) {
     156        myCoords->data[i] = (psPTR *) psVectorAlloc(2, PS_TYPE_F32);
     157        ((psVector *) (myCoords->data[i]))->data.F32[0] = (float) (i+10);
     158        ((psVector *) (myCoords->data[i]))->data.F32[1] = (float) (i+3);
     159    }
     160    for (i=0;i<NUM_PARAMS;i++) {
     161        expectedParm[i] = 2.32 + (float) (2 * i);
     162        myParams->data.F32[i] = 0.0;
     163    }
     164
     165    printPositiveTestHeader(stdout,
     166                            "psMinimize functions",
     167                            "psMinimizePowell()");
     168
     169    psMinimizePowell(min,
     170                     myParams,
     171                     NULL,
     172                     myCoords,
     173                     (psMinimizePowellFunc) myFunc);
     174
     175    printf("\nThe minimum is %f (expected: %f)\n", min->value, MIN_VALUE);
     176
     177    for (i=0;i<NUM_PARAMS;i++) {
     178        printf("Parameter %d at the minimum is %f (expected: %f)\n", i,
     179               myParams->data.F32[i], expectedParm[i]);
     180
     181        if (fabs(myParams->data.F32[i] - expectedParm[i]) > fabs(ERROR_TOLERANCE * expectedParm[i])) {
     182            printf("ERROR: Parameter %d: (%.1f), expected was (%.1f)\n",
     183                   i, myParams->data.F32[i], expectedParm[i]);
     184            testStatus = false;
     185        } else {
     186            printf("Parameter %d: (%.1f), expected was (%.1f)\n",
     187                   i, myParams->data.F32[i], expectedParm[i]);
     188        }
     189    }
     190
     191
     192    psFree(myCoords);
     193    psFree(myParams);
     194    psFree(min);
     195
     196    psMemCheckCorruption(1);
     197    memLeaks = psMemCheckLeaks(currentId,NULL,stderr);
     198    if (0 != memLeaks) {
     199        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     200    }
     201    printFooter(stdout,
     202                "psMinimize functions",
     203                "psMinimizePowell()",
     204                testStatus);
     205
     206
     207    return (!testStatus);
     208}
     209
     210int t02()
     211{
     212    int currentId = psMemGetId();
     213    int memLeaks = 0;
     214    int i = 0;
     215    psArray *myCoords;
     216    psVector *myParams;
     217    psVector *myParamMask;
     218    psMinimization *min;
     219
     220    psTraceSetLevel(".psLib", 0);
     221    /**************************************************************************
     222     *************************************************************************/
     223    myParams = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32);
     224    myParamMask = psVectorAlloc(NUM_PARAMS, PS_TYPE_F32);
     225    min = psMinimizationAlloc(100, 0.01);
     226
     227    myCoords = psArrayAlloc(N);
     228    for (i=0;i<N;i++) {
     229        myCoords->data[i] = (psPTR *) psVectorAlloc(2, PS_TYPE_F32);
     230        ((psVector *) (myCoords->data[i]))->data.F32[0] = (float) (i+10);
     231        ((psVector *) (myCoords->data[i]))->data.F32[1] = (float) (i+3);
     232    }
     233    for (i=0;i<NUM_PARAMS;i++) {
     234        expectedParm[i] = 2.32 + (float) (2 * i);
     235        myParams->data.F32[i] = 0.0;
     236        myParamMask->data.U8[i] = 0;
     237    }
     238
     239    printPositiveTestHeader(stdout,
     240                            "psMinimize functions",
     241                            "psMinimizePowell(): various NULL inputs");
     242
     243    psMinimizePowell(NULL, myParams, myParamMask, myCoords, (psMinimizePowellFunc) myFunc);
     244    psMinimizePowell(min, NULL, myParamMask, myCoords,(psMinimizePowellFunc) myFunc);
     245    psMinimizePowell(min, myParams, myParamMask, NULL, (psMinimizePowellFunc) myFunc);
     246    psMinimizePowell(min, myParams, myParamMask, myCoords, NULL);
     247
     248    psFree(myCoords);
     249    psFree(myParams);
     250    psFree(myParamMask);
     251    psFree(min);
     252
     253    psMemCheckCorruption(1);
     254    memLeaks = psMemCheckLeaks(currentId,NULL,stderr);
     255    if (0 != memLeaks) {
     256        psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
     257    }
     258    printFooter(stdout,
     259                "psMinimize functions",
     260                "psMinimizePowell(): various NULL inputs",
     261                testStatus);
     262
     263
     264    return (!testStatus);
     265}
     266
     267int main()
     268{
     269    t00();
     270    t01();
     271    t02();
     272}
Note: See TracChangeset for help on using the changeset viewer.