IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 8, 2006, 4:26:44 PM (20 years ago)
Author:
jhoblitt
Message:

normalize psTrace() facility names

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r7766 r8245  
    1111 *  NOTE: XXX: The SDR is silent about data types.  F32 is implemented here.
    1212 *
    13  *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2006-06-30 02:20:06 $
     13 *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2006-08-09 02:26:44 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    117117    psBool boolLineIsNull = true;
    118118
    119     psTrace(__func__, 4, "---- p_psDetermineBracket() begin ----\n");
     119    psTrace("psLib.math", 4, "---- p_psDetermineBracket() begin ----\n");
    120120
    121121    // If the line vector is zero, then return NULL.
    122122    PS_VECTOR_WITH_MASK_F32_CHECK_ZERO_VECTOR(params, paramMask, boolLineIsNull);
    123123    if (boolLineIsNull == true) {
    124         psTrace(__func__, 2, "p_psDetermineBracket() called with zero line vector.\n");
    125         psTrace(__func__, 4, "---- p_psDetermineBracket() end (NULL) ----\n");
     124        psTrace("psLib.math", 2, "p_psDetermineBracket() called with zero line vector.\n");
     125        psTrace("psLib.math", 4, "---- p_psDetermineBracket() end (NULL) ----\n");
    126126        psFree(bracket);
    127127        return(NULL);
    … …  
    155155    }
    156156
    157     psTrace(__func__, 6, "(a, b, c) is (%f %f %f) (fa, fb, fc) is (%f %f %f)\n", a, b, c, fa, fb, fc);
     157    psTrace("psLib.math", 6, "(a, b, c) is (%f %f %f) (fa, fb, fc) is (%f %f %f)\n", a, b, c, fa, fb, fc);
    158158
    159159    while (iter > 0) {
    160         psTrace(__func__, 6, "psDetermineBracket(): iteration %d\n", iter);
     160        psTrace("psLib.math", 6, "psDetermineBracket(): iteration %d\n", iter);
    161161        if ((fb < fa) && (fb < fc)) {
    162162            bracket->data.F32[0] = a;
    … …  
    164164            bracket->data.F32[2] = c;
    165165            psFree(tmp);
    166             psTrace(__func__, 6, "---- p_psDetermineBracket() end ----\n");
     166            psTrace("psLib.math", 6, "---- p_psDetermineBracket() end ----\n");
    167167            return(bracket);
    168168        }
    … …  
    177177        fc = func(tmp, coords);
    178178
    179         psTrace(__func__, 6, "Iter(%d): (a, b, c) is (%f %f %f) (fa, fb, fc) is (%f %f %f)\n", iter, a, b, c, fa, fb, fc);
     179        psTrace("psLib.math", 6, "Iter(%d): (a, b, c) is (%f %f %f) (fa, fb, fc) is (%f %f %f)\n", iter, a, b, c, fa, fb, fc);
    180180
    181181        if (fa < fb) {
    … …  
    195195            bracket->data.F32[2] = c;
    196196            psFree(tmp);
    197             psTrace(__func__, 4, "---- p_psDetermineBracket() end ----\n");
     197            psTrace("psLib.math", 4, "---- p_psDetermineBracket() end ----\n");
    198198            return(bracket);
    199199        }
    … …  
    204204            bracket->data.F32[2] = c;
    205205            psFree(tmp);
    206             psTrace(__func__, 4, "---- p_psDetermineBracket() end ----\n");
     206            psTrace("psLib.math", 4, "---- p_psDetermineBracket() end ----\n");
    207207            return(bracket);
    208208        }
    … …  
    213213    psFree(tmp);
    214214    psFree(bracket);
    215     psTrace(__func__, 4, "---- p_psDetermineBracket() end (NULL) ----\n");
     215    psTrace("psLib.math", 4, "---- p_psDetermineBracket() end (NULL) ----\n");
    216216    return(NULL);
    217217}
    … …  
    228228    bracket->data.F32[2] = a; \
    229229} \
    230 psTrace(__func__, 4, "Final bracket (a, b, c) is (%f %f %f) (fa, fb, fc) is (%f %f %f)\n", a, b, c, fa, fb, fc); \
    231 psTrace(__func__, 4, "---- p_psDetermineBracket() end ----\n"); \
     230psTrace("psLib.math", 4, "Final bracket (a, b, c) is (%f %f %f) (fa, fb, fc) is (%f %f %f)\n", a, b, c, fa, fb, fc); \
     231psTrace("psLib.math", 4, "---- p_psDetermineBracket() end ----\n"); \
    232232psFree(tmp); \
    233233return(bracket); \
    … …  
    253253    psS32 countMin = 0;
    254254
    255     psTrace(__func__, 4, "---- p_psDetermineBracket() begin ----\n");
     255    psTrace("psLib.math", 4, "---- p_psDetermineBracket() begin ----\n");
    256256
    257257    // If the line vector is zero, then return NULL.
    258258    PS_VECTOR_WITH_MASK_F32_CHECK_ZERO_VECTOR(params, paramMask, boolLineIsNull);
    259259    if (boolLineIsNull == true) {
    260         psTrace(__func__, 2, "p_psDetermineBracket() called with zero line vector.\n");
    261         psTrace(__func__, 4, "---- p_psDetermineBracket() end (NULL) ----\n");
     260        psTrace("psLib.math", 2, "p_psDetermineBracket() called with zero line vector.\n");
     261        psTrace("psLib.math", 4, "---- p_psDetermineBracket() end (NULL) ----\n");
    262262        psFree(tmp);
    263263        return(NULL);
    … …  
    289289    iter = 0;
    290290    while (iter < PS_DETERMINE_BRACKET_MAX_ITERATIONS) {
    291         psTrace(__func__, 6, "psDetermineBracket(): iterationA %d\n", iter);
     291        psTrace("psLib.math", 6, "psDetermineBracket(): iterationA %d\n", iter);
    292292        c+= (1.0 + PS_DETERMINE_BRACKET_STEP_SIZE) * (c - a);
    293293
    … …  
    295295        fc = func(tmp, coords);
    296296
    297         psTrace(__func__, 6, "Iteration(%d) (bracket): (a, b, c) is (%f %f %f) (fa, fb, fc) is (%f %f %f)\n", iter, a, b, c, fa, fb, fc);
     297        psTrace("psLib.math", 6, "Iteration(%d) (bracket): (a, b, c) is (%f %f %f) (fa, fb, fc) is (%f %f %f)\n", iter, a, b, c, fa, fb, fc);
    298298
    299299        if ((fb < fa) && (fb < fc)) {
    … …  
    320320
    321321    psFree(bracket);
    322     psTrace(__func__, 4, "---- p_psDetermineBracket() end (NULL) (BAD) ----\n");
     322    psTrace("psLib.math", 4, "---- p_psDetermineBracket() end (NULL) (BAD) ----\n");
    323323    return(NULL);
    324324}
    … …  
    371371    psS32 numIterations = 0;
    372372
    373     psTrace(__func__, 4, "---- LineMin() begin ----\n");
     373    psTrace("psLib.math", 4, "---- LineMin() begin ----\n");
    374374    PS_VECTOR_F32_CHECK_ZERO_VECTOR(line, boolLineIsNull);
    375375
    376376    if (boolLineIsNull == true) {
    377377        min->value = func(params, coords);
    378         psTrace(__func__, 2, "LineMin() called with zero line vector.  Return 0.0.  Function value is %f\n", min->value);
     378        psTrace("psLib.math", 2, "LineMin() called with zero line vector.  Return 0.0.  Function value is %f\n", min->value);
    379379        return(0.0);
    380380    }
    … …  
    382382    if (6 <= psTraceGetLevel(__func__)) {
    383383        for (i=0;i<params->n;i++) {
    384             psTrace(__func__, 6, "(params, paramMask, line)[%d] is (%f %d %f)\n", i,
     384            psTrace("psLib.math", 6, "(params, paramMask, line)[%d] is (%f %d %f)\n", i,
    385385                    params->data.F32[i], paramMask->data.U8[i], line->data.F32[i]);
    386386        }
    … …  
    402402    while (numIterations < PS_LINEMIN_MAX_ITERATIONS) {
    403403        numIterations++;
    404         psTrace(__func__, 6, "LineMin(): iteration %d\n", numIterations);
     404        psTrace("psLib.math", 6, "LineMin(): iteration %d\n", numIterations);
    405405
    406406        a = bracket->data.F32[0];
    … …  
    413413        fb = func(tmpb, coords);
    414414        fc = func(tmpc, coords);
    415         psTrace(__func__, 6, "LineMin: f(%f %f %f) is (%f %f %f)\n", a, b, c, fa, fb, fc);
     415        psTrace("psLib.math", 6, "LineMin: f(%f %f %f) is (%f %f %f)\n", a, b, c, fa, fb, fc);
    416416
    417417        // We determine which is the biggest segment in [a,b,c] then split
    … …  
    449449            }
    450450        }
    451         psTrace(__func__, 6, "LineMin: new bracket is (%f %f %f)\n", bracket->data.F32[0], bracket->data.F32[1], bracket->data.F32[2]);
     451        psTrace("psLib.math", 6, "LineMin: new bracket is (%f %f %f)\n", bracket->data.F32[0], bracket->data.F32[1], bracket->data.F32[2]);
    452452
    453453        mul = bracket->data.F32[1];
    … …  
    456456            min->value = func(params, coords);
    457457            psFree(bracket);
    458             psTrace(__func__, 4, "---- LineMin() end.a (%f) (%f) ----\n", mul, min->value);
     458            psTrace("psLib.math", 4, "---- LineMin() end.a (%f) (%f) ----\n", mul, min->value);
    459459            psFree(tmpa);
    460460            psFree(tmpb);
    … …  
    468468    PS_VECTOR_ADD_MULTIPLE(params, paramMask, line, params, mul);
    469469    min->value = func(params, coords);
    470     psTrace(__func__, 4, "---- LineMin() end.b (%f) %f ----\n", mul, min->value);
     470    psTrace("psLib.math", 4, "---- LineMin() end.b (%f) %f ----\n", mul, min->value);
    471471
    472472    psFree(bracket);
    … …  
    517517    psS32 iterationNumber = 0;
    518518
    519     psTrace(__func__, 4, "---- psMinimizePowell() begin ----\n");
    520     psTrace(__func__, 6, "min->maxIter is %d\n", min->maxIter);
    521     psTrace(__func__, 6, "min->tol is %f\n", min->tol);
     519    psTrace("psLib.math", 4, "---- psMinimizePowell() begin ----\n");
     520    psTrace("psLib.math", 6, "min->maxIter is %d\n", min->maxIter);
     521    psTrace("psLib.math", 6, "min->tol is %f\n", min->tol);
    522522
    523523    if (paramMask == NULL) {
    … …  
    562562    while (iterationNumber < min->maxIter) {
    563563        iterationNumber++;
    564         psTrace(__func__, 6, "psMinimizePowell() iteration %d\n", iterationNumber);
     564        psTrace("psLib.math", 6, "psMinimizePowell() iteration %d\n", iterationNumber);
    565565
    566566        // 3: For each dimension in params, move Q only in the vector v[i] to
    … …  
    569569        baseFuncVal = func(Q, coords);
    570570        currFuncVal = baseFuncVal;
    571         psTrace(__func__, 6, "Current function value is %f\n", currFuncVal);
     571        psTrace("psLib.math", 6, "Current function value is %f\n", currFuncVal);
    572572
    573573        biggestDiff = 0;
    … …  
    588588                    return(false);
    589589                }
    590                 psTrace(__func__, 6, "LineMin along dimension %d has multiple %f\n", i, mul);
     590                psTrace("psLib.math", 6, "LineMin along dimension %d has multiple %f\n", i, mul);
    591591
    592592                if (fabs(dummyMin.value - currFuncVal) > biggestDiff) {
    … …  
    598598            // XXX: how can it be that we are not saving mul anywhere?
    599599        }
    600         psTrace(__func__, 6, "New function value is %f\n", currFuncVal);
     600        psTrace("psLib.math", 6, "New function value is %f\n", currFuncVal);
    601601        // XXX: There must be a bug here.  How can currFuncVal be the current function value?
    602602        // It is simply the minimum along one of the parameter dimensions.
    … …  
    608608                u->n++;
    609609
    610                 psTrace(__func__, 6, "u[i]=Q[i]-P[i] (%f = %f - %f)\n", u->data.F32[i],
     610                psTrace("psLib.math", 6, "u[i]=Q[i]-P[i] (%f = %f - %f)\n", u->data.F32[i],
    611611                        Q->data.F32[i],
    612612                        params->data.F32[i]);
    … …  
    620620        // 5: Move Q only in the direction u, and minimize the function.
    621621        for (i=0;i<numDims;i++) {
    622             psTrace(__func__, 6, "u[i] is %f\n", u->data.F32[i]);
     622            psTrace("psLib.math", 6, "u[i] is %f\n", u->data.F32[i]);
    623623        }
    624624
    … …  
    643643            min->value = currFuncVal;
    644644            min->lastDelta = 0.0;
    645             psTrace(__func__, 4, "---- psMinimizePowell() end (1)(true) ----\n");
     645            psTrace("psLib.math", 4, "---- psMinimizePowell() end (1)(true) ----\n");
    646646            return(true);
    647647        }
    … …  
    685685            min->iter = iterationNumber;
    686686            min->lastDelta = currFuncVal - baseFuncVal;
    687             psTrace(__func__, 4, "---- psMinimizePowell() end (2) (true) ----\n");
     687            psTrace("psLib.math", 4, "---- psMinimizePowell() end (2) (true) ----\n");
    688688            return(true);
    689689        }
    … …  
    695695    psFree(Q);
    696696    min->iter = iterationNumber;
    697     psTrace(__func__, 4, "---- psMinimizePowell() end (0) (false) ----\n");
     697    psTrace("psLib.math", 4, "---- psMinimizePowell() end (0) (false) ----\n");
    698698    return(false);
    699699}
    … …  
    712712    const psArray *coords)
    713713{
    714     psTrace(__func__, 4, "---- myPowellChi2Func() begin ----\n");
     714    psTrace("psLib.math", 4, "---- myPowellChi2Func() begin ----\n");
    715715    PS_ASSERT_VECTOR_NON_NULL(params, NAN);
    716716    PS_ASSERT_VECTOR_NON_EMPTY(params, NAN);
    … …  
    750750    }
    751751    psFree(tmp);
    752     psTrace(__func__, 4, "---- myPowellChi2Func() end (chi2 is %f) ----\n", chi2);
     752    psTrace("psLib.math", 4, "---- myPowellChi2Func() end (chi2 is %f) ----\n", chi2);
    753753    return(chi2);
    754754}
Note: See TracChangeset for help on using the changeset viewer.