IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 6215 for trunk/psLib/test/math


Ignore:
Timestamp:
Jan 26, 2006, 1:49:11 PM (20 years ago)
Author:
gusciora
Message:

Made the requested changes to the psStats structure and added the fitted
statistics.

Location:
trunk/psLib/test/math
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/math/tst_psStats00.c

    r5117 r6215  
    66*  do a much simpler test with data types PS_TYPE_U8, PS_TYPE_U16, PS_TYPE_F64.
    77*
    8 *  If the psStats,c code every changes such that vectors of different type
     8*  If the psStats,c code ever changes such that vectors of different type
    99*  are handled by different routines, then these tests must be extended.
    1010*
    1111*  @author GLG, MHPCC
    1212*
    13 *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
    14 *  @date $Date: 2005-09-24 01:10:00 $
     13*  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
     14*  @date $Date: 2006-01-26 23:49:11 $
    1515*
    1616*  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    2222#define ERROR_TOL  0.0001
    2323#define N 15
    24 
     24#define VERBOSE 1
    2525static psS32 testStatsSampleMeanF32(void);
    2626static psS32 testStatsSampleMeanS8(void);
    … …  
    7171    psTraceSetLevel(".", 0);
    7272    psTraceSetLevel("p_psGetStatValue", 0);
    73     psTraceSetLevel("p_psVectorSampleMean", 0);
     73    psTraceSetLevel("p_psVectorSampleMean", 10);
    7474    psTraceSetLevel("p_psVectorMax", 0);
    7575    psTraceSetLevel("p_psVectorMin", 0);
    … …  
    119119    }
    120120
     121    printf("HMMM: myStats->options is (0x%x)\n", myStats->options);
    121122    /*************************************************************************/
    122123    /*  Call psVectorStats() with no vector mask.                    */
    … …  
    125126    mean = myStats->sampleMean;
    126127    // Verify return value is as expected
    127     if ( fabs(mean - expectedMeanNoMaskF32) > ERROR_TOL ) {
     128    if (VERBOSE) {
     129        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedMeanNoMaskF32);
     130    }
     131    if (isnan(myStats->sampleMean) || (fabs(mean - expectedMeanNoMaskF32) > ERROR_TOL)) {
    128132        psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f",
    129133                mean, expectedMeanNoMaskF32);
    … …  
    135139    mean = myStats->sampleMean;
    136140    // Verify return value is as expected
    137     if ( fabs(mean - expectedWeightMeanNoMaskF32) > ERROR_TOL ) {
     141    if (VERBOSE) {
     142        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedWeightMeanNoMaskF32);
     143    }
     144    if (isnan(myStats->sampleMean) || (fabs(mean - expectedWeightMeanNoMaskF32) > ERROR_TOL)) {
    138145        psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f",
    139146                mean, expectedWeightMeanNoMaskF32);
    … …  
    148155    mean = myStats->sampleMean;
    149156    // Verify return value is as expected
     157    if (VERBOSE) {
     158        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedMeanRangeNoMaskF32);
     159    }
    150160    if ( fabs(mean - expectedMeanRangeNoMaskF32) > ERROR_TOL ) {
    151161        psError(PS_ERR_UNKNOWN,true,"Return value %f not as expected %f",
    … …  
    158168    mean = myStats->sampleMean;
    159169    // Verify return value is as expected
     170    if (VERBOSE) {
     171        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedWeightMeanNoMaskRangeF32);
     172    }
    160173    if ( fabs(mean - expectedWeightMeanNoMaskRangeF32) > ERROR_TOL) {
    161174        psError(PS_ERR_UNKNOWN,true,"Return value %f not as expected %f",
    … …  
    170183    myStats = psVectorStats(myStats, myVector, NULL, maskVector, 1);
    171184    mean = myStats->sampleMean;
     185    if (VERBOSE) {
     186        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedMeanWithMaskF32);
     187    }
    172188    if ( fabs(mean - expectedMeanWithMaskF32) > ERROR_TOL ) {
    173189        psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f",
    … …  
    179195    myStats = psVectorStats(myStats, myVector, myErrors, maskVector, 1);
    180196    mean = myStats->sampleMean;
     197    if (VERBOSE) {
     198        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedWeightMeanWithMaskF32);
     199    }
    181200    if ( fabs(mean - expectedWeightMeanWithMaskF32) > ERROR_TOL ) {
    182201        psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f",
    … …  
    190209    mean = myStats->sampleMean;
    191210    // Verify return value is as expected
     211    if (VERBOSE) {
     212        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedMeanRangeWithMaskF32);
     213    }
    192214    if ( fabs(mean - expectedMeanRangeWithMaskF32) > ERROR_TOL ) {
    193215        psError(PS_ERR_UNKNOWN,true,"Return value %f not as expected %f",
    … …  
    200222    mean = myStats->sampleMean;
    201223    // Verify return value is as expected
     224    if (VERBOSE) {
     225        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedWeightMeanWithMaskRangeF32);
     226    }
    202227    if ( fabs(mean - expectedWeightMeanWithMaskRangeF32) > ERROR_TOL ) {
    203228        psError(PS_ERR_UNKNOWN,true,"Return value %f not as expected %f",
    … …  
    219244    myStats = psVectorStats(myStats, myVector, NULL, maskVector, 2);
    220245    mean = myStats->sampleMean;
     246    if (VERBOSE) {
     247        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedMeanWithMaskF32);
     248    }
    221249    if (fabs(mean - expectedMeanWithMaskF32) > ERROR_TOL )  {
    222250        psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f",
    … …  
    237265    myStats = psVectorStats(myStats, myVector, NULL, maskVector, 4);
    238266    mean = myStats->sampleMean;
     267    if (VERBOSE) {
     268        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedMeanNoMaskF32);
     269    }
    239270    if (fabs(mean - expectedMeanNoMaskF32) > ERROR_TOL ) {
    240271        psError(PS_ERR_UNKNOWN,true,"Return value %f not as expected %f",
    … …  
    307338    mean = myStats->sampleMean;
    308339    // Verify return value is as expected
     340    if (VERBOSE) {
     341        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedMeanNoMaskS8);
     342    }
    309343    if ( fabs(mean - expectedMeanNoMaskS8) > ERROR_TOL ) {
    310344        psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f",
    … …  
    347381    mean = myStats->sampleMean;
    348382    // Verify return value is as expected
     383    if (VERBOSE) {
     384        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedMeanNoMaskU16);
     385    }
    349386    if ( fabs(mean - expectedMeanNoMaskU16) > ERROR_TOL ) {
    350387        psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f",
    … …  
    387424    mean = myStats->sampleMean;
    388425    // Verify return value is as expected
     426    if (VERBOSE) {
     427        printf("psVectorStats() returned %.2f: expected was %.2f\n", mean, expectedMeanNoMaskF64);
     428    }
    389429    if ( fabs(mean - expectedMeanNoMaskF64) > ERROR_TOL ) {
    390430        psError(PS_ERR_UNKNOWN,true,"Returned value %f not as expected %f",

  • trunk/psLib/test/math/tst_psStats03.c

    r5117 r6215  
    1818    // We list pertinent psStats.c functions here for debugging ease.
    1919    //
    20     psTraceSetLevel(".", 0);
    21     psTraceSetLevel("p_psGetStatValue", 0);
    22     psTraceSetLevel("p_psVectorSampleMean", 0);
    23     psTraceSetLevel("p_psVectorCheckNonEmpty", 0);
    24     psTraceSetLevel("p_psVectorNValues", 0);
    25     psTraceSetLevel("p_psVectorSampleMedian", 0);
    26     psTraceSetLevel("psStatsAlloc", 0);
    27     psTraceSetLevel("p_psConvertToF32", 0);
    28     psTraceSetLevel("psVectorStats", 0);
     20    psTraceSetLevel(".", 10);
     21    psTraceSetLevel("p_psGetStatValue", 10);
     22    psTraceSetLevel("p_psVectorSampleMean", 10);
     23    psTraceSetLevel("p_psVectorCheckNonEmpty", 10);
     24    psTraceSetLevel("p_psVectorNValues", 10);
     25    psTraceSetLevel("p_psVectorSampleMedian", 10);
     26    psTraceSetLevel("psStatsAlloc", 10);
     27    psTraceSetLevel("p_psConvertToF32", 10);
     28    psTraceSetLevel("psVectorStats", 10);
    2929
    3030    psStats *myStats    = NULL;

  • trunk/psLib/test/math/tst_psStats07.c

    r6204 r6215  
    4040    float realUQNoMask = MEAN + ( 0.6 * STDEV );
    4141    psS32 realN50NoMask = N / 4;
    42     psS32 realNfitNoMask = N / 4;
    4342
    4443    /*************************************************************************/
    … …  
    7978    psFree(mySampleStatsWithMask);
    8079
    81     myStats = psStatsAlloc( PS_STAT_ROBUST_MEAN |
    82                             PS_STAT_ROBUST_MEDIAN |
    83                             PS_STAT_ROBUST_MODE |
    84                             PS_STAT_ROBUST_STDEV |
    85                             PS_STAT_ROBUST_QUARTILE );
     80    myStats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN |
     81                           PS_STAT_ROBUST_STDEV |
     82                           PS_STAT_ROBUST_QUARTILE |
     83                           PS_STAT_FITTED_MEAN |
     84                           PS_STAT_FITTED_STDEV);
    8685    // Create a full outliers:
    8786    myVector->data.F32[N/4] = -1000.0 * MEAN;
    … …  
    101100
    102101    printf( "The expected Mean was %.2f; the calculated Mean was %.2f\n",
    103             realMeanNoMask, myStats->robustMean );
    104 
    105     if ( fabs( myStats->robustMean - realMeanNoMask ) < ( ERROR_TOLERANCE * realMeanNoMask ) ) {
     102            realMeanNoMask, myStats->fittedMean );
     103
     104    if ( fabs( myStats->fittedMean - realMeanNoMask ) < ( ERROR_TOLERANCE * realMeanNoMask ) ) {
    106105        testStatus = true;
    107106    } else {
    … …  
    157156
    158157    printf( "The expected Stdev was %.2f; the calculated Stdev was %.2f\n",
    159             realStdevNoMask, myStats->robustStdev );
    160     if ( fabs( myStats->robustStdev - realStdevNoMask ) < ( ERROR_TOLERANCE * realStdevNoMask ) ) {
     158            realStdevNoMask, myStats->fittedStdev );
     159    if ( fabs( myStats->fittedStdev - realStdevNoMask ) < ( ERROR_TOLERANCE * realStdevNoMask ) ) {
    161160        testStatus = true;
    162161    } else {
    … …  
    208207                             "psStats functions",
    209208                             "PS_STAT_ROBUST_STATS: robust N50: no vector mask" );
    210 
    211209    // XXX:
    212210    realN50NoMask = myStats->robustN50;
    … …  
    227225                 testStatus );
    228226
    229     printPositiveTestHeader( stdout,
    230                              "psStats functions",
    231                              "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask" );
    232 
    233     // XXX:
    234     realNfitNoMask = myStats->robustNfit;
    235 
    236     printf( "The expected Nfit was %d; the calculated Nfit was %d\n",
    237             realNfitNoMask, myStats->robustNfit );
    238     /* XXX: fix
    239         if ( fabs( myStats->robustNfit - realNfitNoMask ) < ( ERROR_TOLERANCE * realNfitNoMask ) ) {
    240             testStatus = true;
    241         } else {
    242             testStatus = false;
    243             globalTestStatus = false;
    244         }
    245     */
    246     printFooter( stdout,
    247                  "psVector functions",
    248                  "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask",
    249                  testStatus );
    250227
    251228    /*************************************************************************/
    … …  
    296273    float realUQWithMask = MEAN;
    297274    psS32 realN50WithMask = N / 4;
    298     psS32 realNfitWithMask = N / 4;
    299275    /*************************************************************************/
    300276    /*  Allocate and initialize data structures                              */
    301277    /*************************************************************************/
    302     myStats = psStatsAlloc( PS_STAT_ROBUST_MEAN |
    303                             PS_STAT_ROBUST_MEDIAN |
    304                             PS_STAT_ROBUST_MODE |
    305                             PS_STAT_ROBUST_STDEV |
    306                             PS_STAT_ROBUST_QUARTILE );
     278    myStats = psStatsAlloc(PS_STAT_ROBUST_MEDIAN |
     279                           PS_STAT_ROBUST_STDEV |
     280                           PS_STAT_ROBUST_QUARTILE |
     281                           PS_STAT_FITTED_MEAN |
     282                           PS_STAT_FITTED_STDEV);
    307283
    308284    maskVector = psVectorAlloc( N, PS_TYPE_U8 );
    … …  
    334310    printf( "Called psVectorStats() on a vector with elements masked.\n" );
    335311    printf( "The expected Mean was %.2f; the calculated Mean was %.2f\n",
    336             realMeanWithMask, myStats->robustMean );
    337     if ( fabs( myStats->robustMean - realMeanWithMask ) < ( ERROR_TOLERANCE * realMeanWithMask ) ) {
     312            realMeanWithMask, myStats->fittedMean );
     313    if ( fabs( myStats->fittedMean - realMeanWithMask ) < ( ERROR_TOLERANCE * realMeanWithMask ) ) {
    338314        testStatus = true;
    339315    } else {
    … …  
    389365
    390366    printf( "The expected Stdev was %.2f; the calculated Stdev was %.2f\n",
    391             realStdevWithMask, myStats->robustStdev );
    392     if ( fabs( myStats->robustStdev - realStdevWithMask ) < ( ERROR_TOLERANCE * realStdevWithMask ) ) {
     367            realStdevWithMask, myStats->fittedStdev );
     368    if ( fabs( myStats->fittedStdev - realStdevWithMask ) < ( ERROR_TOLERANCE * realStdevWithMask ) ) {
    393369        testStatus = true;
    394370    } else {
    … …  
    459435                 "PS_STAT_ROBUST_STATS: robust N50: with vector mask",
    460436                 testStatus );
    461 
    462 
    463 
    464     printPositiveTestHeader( stdout,
    465                              "psStats functions",
    466                              "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask" );
    467 
    468     printf( "The expected Nfit was %d; the calculated Nfit was %d\n",
    469             realNfitWithMask, myStats->robustNfit );
    470     /* XXX: fix
    471         if ( fabs( myStats->robustNfit - realNfitWithMask ) < ( ERROR_TOLERANCE * realNfitWithMask ) ) {
    472             testStatus = true;
    473         } else {
    474             testStatus = false;
    475             globalTestStatus = false;
    476         }
    477     */
    478     printFooter( stdout,
    479                  "psVector functions",
    480                  "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask",
    481                  testStatus );
    482 
    483437
    484438
Note: See TracChangeset for help on using the changeset viewer.