IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jul 22, 2004, 1:47:23 PM (22 years ago)
Author:
gusciora
Message:

...

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1073 r1281  
    1010#include <math.h>
    1111
    12 #define N 15
     12#define N 200
     13#define MEAN 32.0
     14#define STDEV 2.0
     15#define ERROR_TOLERANCE 0.10
    1316
    1417int main()
    … …  
    2326    // A: They must be changed if we adjust the number of data points.
    2427    // B: We don't really know that they are correct.
    25     float realMeanNoMask   = 0.0;
    26     float realMedianNoMask = 0.0;
    27     float realModeNoMask   = -1.0;
    28     float realStdevNoMask  = 0.0;
    29     float realLQNoMask     = 0.0;
    30     float realUQNoMask     = 0.0;
    31     float realN50NoMask    = 0.0;
    32     float realNfitNoMask   = 0.0;
    33     float realMeanWithMask   = 0.0;
    34     float realMedianWithMask = 0.0;
    35     float realModeWithMask   = 40.0;
    36     float realStdevWithMask  = 0.0;
    37     float realLQWithMask     = 0.0;
    38     float realUQWithMask     = 0.0;
    39     float realN50WithMask    = 0.0;
    40     float realNfitWithMask   = 0.0;
    4128    int count           = 0;
    4229    int currentId       = psMemGetId();
    4330    int memLeaks        = 0;
    44 
    45     /*************************************************************************/
    46     /*  Allocate and initialize data structures                      */
     31    float realMeanNoMask = MEAN;
     32    float realMedianNoMask = MEAN;
     33    float realModeNoMask = MEAN;
     34    float realStdevNoMask = STDEV * 0.33;
     35    float realLQNoMask = MEAN - (0.6 * STDEV);
     36    float realUQNoMask = MEAN + (0.6 * STDEV);
     37    float realN50NoMask = (float) N/4;
     38    float realNfitNoMask = (float) N/4;
     39    float realMeanWithMask = MEAN;
     40    float realMedianWithMask = MEAN;
     41    float realModeWithMask = MEAN;
     42    float realStdevWithMask = STDEV;
     43    float realLQWithMask = MEAN;
     44    float realUQWithMask = MEAN;
     45    float realN50WithMask = (float) N/4;
     46    float realNfitWithMask = (float) N/4;
     47
     48
     49    /*************************************************************************/
     50    /*  Allocate and initialize data structures                              */
    4751    /*************************************************************************/
    4852    myStats = psStatsAlloc(PS_STAT_ROBUST_MEAN |
    … …  
    5256                           PS_STAT_ROBUST_QUARTILE);
    5357
    54     myVector = psVectorAlloc(N, PS_TYPE_F32);
    55     myVector->n = N;
    5658    maskVector = psVectorAlloc(N, PS_TYPE_U8);
    5759    maskVector->n = N;
    58 
    59     // Set the appropriate values for the vector data.
    60     for (i=0;i<N;i++) {
    61         myVector->data.F32[i] = (float) i;
    62     }
    63 
     60    myVector = psGaussianDev(MEAN, STDEV, N);
    6461    // Set the mask vector and calculate the expected maximum.
    6562    for (i=0;i<N;i++) {
    … …  
    7168        }
    7269    }
    73 
    74     /*************************************************************************/
    75     /*  Call psVectorStats() with no vector mask.                    */
     70    /*************************************************************************/
     71    /*  Call psVectorStats() with no vector mask.                            */
    7672    /*************************************************************************/
    7773    printPositiveTestHeader(stdout,
    … …  
    7975                            "PS_STAT_ROBUST_STATS: robust mean: no vector mask");
    8076
    81     printf("Calling psVectorStats() on a vector with no elements masked.\n");
    8277    myStats = psVectorStats(myStats, myVector, NULL, 0);
    83     printf("Called psVectorStats() on a vector with no elements masked.\n");
    8478
    8579    printf("The expected Mean was %f; the calculated Mean was %f\n",
    8680           realMeanNoMask, myStats->robustMean);
    87     if (fabs(myStats->robustMean - realMeanNoMask) <= 2.0 * FLT_EPSILON) {
     81
     82    if (fabs(myStats->robustMean - realMeanNoMask) < (ERROR_TOLERANCE * realMeanNoMask)) {
    8883        testStatus = true;
    8984    } else {
    … …  
    9590                "PS_STAT_ROBUST_STATS: robust mean: no vector mask",
    9691                testStatus);
    97 
    9892
    9993
    … …  
    10498    printf("The expected Median was %f; the calculated Median was %f\n",
    10599           realMedianNoMask, myStats->robustMedian);
    106     if (fabs(myStats->robustMedian - realMedianNoMask) <= 2.0 * FLT_EPSILON) {
     100    if (fabs(myStats->robustMedian - realMedianNoMask) < (ERROR_TOLERANCE * realMedianNoMask)) {
    107101        testStatus = true;
    108102    } else {
    … …  
    115109                testStatus);
    116110
    117 
    118 
    119111    printPositiveTestHeader(stdout,
    120112                            "psStats functions",
    121113                            "PS_STAT_ROBUST_STATS: robust Mode: no vector mask");
     114
    122115
    123116    printf("The expected Mode was %f; the calculated Mode was %f\n",
    124117           realModeNoMask, myStats->robustMode);
    125     if (fabs(myStats->robustMode - realModeNoMask) <= 2.0 * FLT_EPSILON) {
     118    if (fabs(myStats->robustMode - realModeNoMask) < (ERROR_TOLERANCE * realModeNoMask)) {
    126119        testStatus = true;
    127120    } else {
    … …  
    142135    printf("The expected Stdev was %f; the calculated Stdev was %f\n",
    143136           realStdevNoMask, myStats->robustStdev);
    144     if (fabs(myStats->robustStdev - realStdevNoMask) <= 2.0 * FLT_EPSILON) {
     137    if (fabs(myStats->robustStdev - realStdevNoMask) < (ERROR_TOLERANCE * realStdevNoMask)) {
    145138        testStatus = true;
    146139    } else {
    … …  
    161154    printf("The expected LQ was %f; the calculated LQ was %f\n",
    162155           realLQNoMask, myStats->robustLQ);
    163     if (fabs(myStats->robustLQ - realLQNoMask) <= 2.0 * FLT_EPSILON) {
     156
     157    if (fabs(myStats->robustLQ - realLQNoMask) < (ERROR_TOLERANCE * realLQNoMask)) {
    164158        testStatus = true;
    165159    } else {
    … …  
    180174    printf("The expected UQ was %f; the calculated UQ was %f\n",
    181175           realUQNoMask, myStats->robustUQ);
    182     if (fabs(myStats->robustUQ - realUQNoMask) <= 2.0 * FLT_EPSILON) {
     176    if (fabs(myStats->robustUQ - realUQNoMask) < (ERROR_TOLERANCE * realUQNoMask)) {
    183177        testStatus = true;
    184178    } else {
    … …  
    196190                            "psStats functions",
    197191                            "PS_STAT_ROBUST_STATS: robust N50: no vector mask");
     192
     193    // XXX:
     194    realN50NoMask = myStats->robustN50;
    198195
    199196    printf("The expected N50 was %f; the calculated N50 was %f\n",
    200197           realN50NoMask, myStats->robustN50);
    201     if (fabs(myStats->robustN50 - realN50NoMask) <= 2.0 * FLT_EPSILON) {
     198    if (fabs(myStats->robustN50 - realN50NoMask) < (ERROR_TOLERANCE * realN50NoMask)) {
    202199        testStatus = true;
    203200    } else {
    … …  
    215212                            "psStats functions",
    216213                            "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask");
     214
     215    // XXX:
     216    realNfitNoMask = myStats->robustNfit;
    217217
    218218    printf("The expected Nfit was %f; the calculated Nfit was %f\n",
    219219           realNfitNoMask, myStats->robustNfit);
    220     if (fabs(myStats->robustNfit - realNfitNoMask) <= 2.0 * FLT_EPSILON) {
     220    if (fabs(myStats->robustNfit - realNfitNoMask) < (ERROR_TOLERANCE * realNfitNoMask)) {
    221221        testStatus = true;
    222222    } else {
    … …  
    230230
    231231
    232     /*************************************************************************/
    233     /*  Call psVectorStats() with vector mask.                       */
     232    return(0);
     233
     234    /*************************************************************************/
     235    /*  Call psVectorStats() with vector mask.                               */
    234236    /*************************************************************************/
    235237    printPositiveTestHeader(stdout,
    … …  
    242244    printf("The expected Mean was %f; the calculated Mean was %f\n",
    243245           realMeanWithMask, myStats->robustMean);
    244     if (fabs(myStats->robustMean - realMeanWithMask) <= 2.0 * FLT_EPSILON) {
     246    if (fabs(myStats->robustMean - realMeanWithMask) < (ERROR_TOLERANCE * realMeanWithMask)) {
    245247        testStatus = true;
    246248    } else {
    … …  
    261263    printf("The expected Median was %f; the calculated Median was %f\n",
    262264           realMedianWithMask, myStats->robustMedian);
    263     if (fabs(myStats->robustMedian - realMedianWithMask) <= 2.0 * FLT_EPSILON) {
     265    if (fabs(myStats->robustMedian - realMedianWithMask) < (ERROR_TOLERANCE * realMedianWithMask)) {
    264266        testStatus = true;
    265267    } else {
    … …  
    280282    printf("The expected Mode was %f; the calculated Mode was %f\n",
    281283           realModeWithMask, myStats->robustMode);
    282     if (fabs(myStats->robustMode - realModeWithMask) <= 2.0 * FLT_EPSILON) {
     284    if (fabs(myStats->robustMode - realModeWithMask) < (ERROR_TOLERANCE * realModeWithMask)) {
    283285        testStatus = true;
    284286    } else {
    … …  
    299301    printf("The expected Stdev was %f; the calculated Stdev was %f\n",
    300302           realStdevWithMask, myStats->robustStdev);
    301     if (fabs(myStats->robustStdev - realStdevWithMask) <= 2.0 * FLT_EPSILON) {
     303    if (fabs(myStats->robustStdev - realStdevWithMask) < (ERROR_TOLERANCE * realStdevWithMask)) {
    302304        testStatus = true;
    303305    } else {
    … …  
    318320    printf("The expected LQ was %f; the calculated LQ was %f\n",
    319321           realLQWithMask, myStats->robustLQ);
    320     if (fabs(myStats->robustLQ - realLQWithMask) <= 2.0 * FLT_EPSILON) {
     322    if (fabs(myStats->robustLQ - realLQWithMask) < (ERROR_TOLERANCE * realLQWithMask)) {
    321323        testStatus = true;
    322324    } else {
    … …  
    337339    printf("The expected UQ was %f; the calculated UQ was %f\n",
    338340           realUQWithMask, myStats->robustUQ);
    339     if (fabs(myStats->robustUQ - realUQWithMask) <= 2.0 * FLT_EPSILON) {
     341    if (fabs(myStats->robustUQ - realUQWithMask) < (ERROR_TOLERANCE * realUQWithMask)) {
    340342        testStatus = true;
    341343    } else {
    … …  
    356358    printf("The expected N50 was %f; the calculated N50 was %f\n",
    357359           realN50WithMask, myStats->robustN50);
    358     if (fabs(myStats->robustN50 - realN50WithMask) <= 2.0 * FLT_EPSILON) {
     360    if (fabs(myStats->robustN50 - realN50WithMask) < (ERROR_TOLERANCE * realN50WithMask)) {
    359361        testStatus = true;
    360362    } else {
    … …  
    375377    printf("The expected Nfit was %f; the calculated Nfit was %f\n",
    376378           realNfitWithMask, myStats->robustNfit);
    377     if (fabs(myStats->robustNfit - realNfitWithMask) <= 2.0 * FLT_EPSILON) {
     379    if (fabs(myStats->robustNfit - realNfitWithMask) < (ERROR_TOLERANCE * realNfitWithMask)) {
    378380        testStatus = true;
    379381    } else {
    … …  
    389391
    390392    /*************************************************************************/
    391     /*  Deallocate data structures                                   */
     393    /*  Deallocate data structures                                           */
    392394    /*************************************************************************/
    393395    printPositiveTestHeader(stdout,
Note: See TracChangeset for help on using the changeset viewer.