IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 2, 2004, 9:43:23 AM (22 years ago)
Author:
desonia
Message:

adjusted output precision to allow tests to pass on x86_64, etc.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1281 r1365  
    11/*****************************************************************************
    2     This routine must ensure that PS_STAT_ROBUST_QUARTILE is correctly computed
    3     by the procedure psArrayStats().
    4  *****************************************************************************/
     2   This routine must ensure that PS_STAT_ROBUST_QUARTILE is correctly computed
     3   by the procedure psArrayStats().
     4*****************************************************************************/
    55#include <stdio.h>
    66#include "pslib.h"
    … …  
    1717int main()
    1818{
    19     psStats *myStats    = NULL;
    20     int testStatus      = true;
     19    psStats * myStats = NULL;
     20    int testStatus = true;
    2121    int globalTestStatus = true;
    22     int i               = 0;
    23     psVector *myVector  = NULL;
    24     psVector *maskVector= NULL;
     22    int i = 0;
     23    psVector *myVector = NULL;
     24    psVector *maskVector = NULL;
    2525    // NOTE: These values were calculated by running the function on the data.
    2626    // A: They must be changed if we adjust the number of data points.
    2727    // B: We don't really know that they are correct.
    28     int count           = 0;
    29     int currentId       = psMemGetId();
    30     int memLeaks        = 0;
     28    int count = 0;
     29    int currentId = psMemGetId();
     30    int memLeaks = 0;
    3131    float realMeanNoMask = MEAN;
    3232    float realMedianNoMask = MEAN;
    3333    float realModeNoMask = MEAN;
    3434    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;
     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;
    3939    float realMeanWithMask = MEAN;
    4040    float realMedianWithMask = MEAN;
    … …  
    4343    float realLQWithMask = MEAN;
    4444    float realUQWithMask = MEAN;
    45     float realN50WithMask = (float) N/4;
    46     float realNfitWithMask = (float) N/4;
    47 
    48 
     45    float realN50WithMask = ( float ) N / 4;
     46    float realNfitWithMask = ( float ) N / 4;
     47   
     48   
    4949    /*************************************************************************/
    5050    /*  Allocate and initialize data structures                              */
    5151    /*************************************************************************/
    52     myStats = psStatsAlloc(PS_STAT_ROBUST_MEAN |
    53                            PS_STAT_ROBUST_MEDIAN |
    54                            PS_STAT_ROBUST_MODE |
    55                            PS_STAT_ROBUST_STDEV |
    56                            PS_STAT_ROBUST_QUARTILE);
    57 
    58     maskVector = psVectorAlloc(N, PS_TYPE_U8);
     52    myStats = psStatsAlloc( PS_STAT_ROBUST_MEAN |
     53                            PS_STAT_ROBUST_MEDIAN |
     54                            PS_STAT_ROBUST_MODE |
     55                            PS_STAT_ROBUST_STDEV |
     56                            PS_STAT_ROBUST_QUARTILE );
     57                           
     58    maskVector = psVectorAlloc( N, PS_TYPE_U8 );
    5959    maskVector->n = N;
    60     myVector = psGaussianDev(MEAN, STDEV, N);
     60    myVector = psGaussianDev( MEAN, STDEV, N );
    6161    // Set the mask vector and calculate the expected maximum.
    62     for (i=0;i<N;i++) {
    63         if (i < (N/2)) {
    64             maskVector->data.U8[i] = 0;
    65             count++;
    66         } else {
    67             maskVector->data.U8[i] = 1;
    68         }
    69     }
     62    for ( i = 0;i < N;i++ ) {
     63            if ( i < ( N / 2 ) ) {
     64                    maskVector->data.U8[ i ] = 0;
     65                    count++;
     66                } else {
     67                    maskVector->data.U8[ i ] = 1;
     68                }
     69        }
    7070    /*************************************************************************/
    7171    /*  Call psVectorStats() with no vector mask.                            */
    7272    /*************************************************************************/
    73     printPositiveTestHeader(stdout,
    74                             "psStats functions",
    75                             "PS_STAT_ROBUST_STATS: robust mean: no vector mask");
    76 
    77     myStats = psVectorStats(myStats, myVector, NULL, 0);
    78 
    79     printf("The expected Mean was %f; the calculated Mean was %f\n",
    80            realMeanNoMask, myStats->robustMean);
    81 
    82     if (fabs(myStats->robustMean - realMeanNoMask) < (ERROR_TOLERANCE * realMeanNoMask)) {
    83         testStatus = true;
    84     } else {
    85         testStatus = false;
    86         globalTestStatus = false;
    87     }
    88     printFooter(stdout,
    89                 "psVector functions",
    90                 "PS_STAT_ROBUST_STATS: robust mean: no vector mask",
    91                 testStatus);
    92 
    93 
    94     printPositiveTestHeader(stdout,
    95                             "psStats functions",
    96                             "PS_STAT_ROBUST_STATS: robust Median: no vector mask");
    97 
    98     printf("The expected Median was %f; the calculated Median was %f\n",
    99            realMedianNoMask, myStats->robustMedian);
    100     if (fabs(myStats->robustMedian - realMedianNoMask) < (ERROR_TOLERANCE * realMedianNoMask)) {
    101         testStatus = true;
    102     } else {
    103         testStatus = false;
    104         globalTestStatus = false;
    105     }
    106     printFooter(stdout,
    107                 "psVector functions",
    108                 "PS_STAT_ROBUST_STATS: robust Median: no vector mask",
    109                 testStatus);
    110 
    111     printPositiveTestHeader(stdout,
    112                             "psStats functions",
    113                             "PS_STAT_ROBUST_STATS: robust Mode: no vector mask");
    114 
    115 
    116     printf("The expected Mode was %f; the calculated Mode was %f\n",
    117            realModeNoMask, myStats->robustMode);
    118     if (fabs(myStats->robustMode - realModeNoMask) < (ERROR_TOLERANCE * realModeNoMask)) {
    119         testStatus = true;
    120     } else {
    121         testStatus = false;
    122         globalTestStatus = false;
    123     }
    124     printFooter(stdout,
    125                 "psVector functions",
    126                 "PS_STAT_ROBUST_STATS: robust Mode: no vector mask",
    127                 testStatus);
    128 
    129 
    130 
    131     printPositiveTestHeader(stdout,
    132                             "psStats functions",
    133                             "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask");
    134 
    135     printf("The expected Stdev was %f; the calculated Stdev was %f\n",
    136            realStdevNoMask, myStats->robustStdev);
    137     if (fabs(myStats->robustStdev - realStdevNoMask) < (ERROR_TOLERANCE * realStdevNoMask)) {
    138         testStatus = true;
    139     } else {
    140         testStatus = false;
    141         globalTestStatus = false;
    142     }
    143     printFooter(stdout,
    144                 "psVector functions",
    145                 "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask",
    146                 testStatus);
    147 
    148 
    149 
    150     printPositiveTestHeader(stdout,
    151                             "psStats functions",
    152                             "PS_STAT_ROBUST_STATS: lower quartile: no vector mask");
    153 
    154     printf("The expected LQ was %f; the calculated LQ was %f\n",
    155            realLQNoMask, myStats->robustLQ);
    156 
    157     if (fabs(myStats->robustLQ - realLQNoMask) < (ERROR_TOLERANCE * realLQNoMask)) {
    158         testStatus = true;
    159     } else {
    160         testStatus = false;
    161         globalTestStatus = false;
    162     }
    163     printFooter(stdout,
    164                 "psVector functions",
    165                 "PS_STAT_ROBUST_STATS: lower quartile: no vector mask",
    166                 testStatus);
    167 
    168 
    169 
    170     printPositiveTestHeader(stdout,
    171                             "psStats functions",
    172                             "PS_STAT_ROBUST_STATS: upper quartile: no vector mask");
    173 
    174     printf("The expected UQ was %f; the calculated UQ was %f\n",
    175            realUQNoMask, myStats->robustUQ);
    176     if (fabs(myStats->robustUQ - realUQNoMask) < (ERROR_TOLERANCE * realUQNoMask)) {
    177         testStatus = true;
    178     } else {
    179         testStatus = false;
    180         globalTestStatus = false;
    181     }
    182     printFooter(stdout,
    183                 "psVector functions",
    184                 "PS_STAT_ROBUST_STATS: lower quartile: no vector mask",
    185                 testStatus);
    186 
    187 
    188 
    189     printPositiveTestHeader(stdout,
    190                             "psStats functions",
    191                             "PS_STAT_ROBUST_STATS: robust N50: no vector mask");
    192 
     73    printPositiveTestHeader( stdout,
     74                             "psStats functions",
     75                             "PS_STAT_ROBUST_STATS: robust mean: no vector mask" );
     76                             
     77    myStats = psVectorStats( myStats, myVector, NULL, 0 );
     78   
     79    printf( "The expected Mean was %.2f; the calculated Mean was %.2f\n",
     80            realMeanNoMask, myStats->robustMean );
     81           
     82    if ( fabs( myStats->robustMean - realMeanNoMask ) < ( ERROR_TOLERANCE * realMeanNoMask ) ) {
     83            testStatus = true;
     84        } else {
     85            testStatus = false;
     86            globalTestStatus = false;
     87        }
     88    printFooter( stdout,
     89                 "psVector functions",
     90                 "PS_STAT_ROBUST_STATS: robust mean: no vector mask",
     91                 testStatus );
     92                 
     93                 
     94    printPositiveTestHeader( stdout,
     95                             "psStats functions",
     96                             "PS_STAT_ROBUST_STATS: robust Median: no vector mask" );
     97                             
     98    printf( "The expected Median was %.2f; the calculated Median was %.2f\n",
     99            realMedianNoMask, myStats->robustMedian );
     100    if ( fabs( myStats->robustMedian - realMedianNoMask ) < ( ERROR_TOLERANCE * realMedianNoMask ) ) {
     101            testStatus = true;
     102        } else {
     103            testStatus = false;
     104            globalTestStatus = false;
     105        }
     106    printFooter( stdout,
     107                 "psVector functions",
     108                 "PS_STAT_ROBUST_STATS: robust Median: no vector mask",
     109                 testStatus );
     110                 
     111    printPositiveTestHeader( stdout,
     112                             "psStats functions",
     113                             "PS_STAT_ROBUST_STATS: robust Mode: no vector mask" );
     114                             
     115                             
     116    printf( "The expected Mode was %.2f; the calculated Mode was %.2f\n",
     117            realModeNoMask, myStats->robustMode );
     118    if ( fabs( myStats->robustMode - realModeNoMask ) < ( ERROR_TOLERANCE * realModeNoMask ) ) {
     119            testStatus = true;
     120        } else {
     121            testStatus = false;
     122            globalTestStatus = false;
     123        }
     124    printFooter( stdout,
     125                 "psVector functions",
     126                 "PS_STAT_ROBUST_STATS: robust Mode: no vector mask",
     127                 testStatus );
     128                 
     129                 
     130                 
     131    printPositiveTestHeader( stdout,
     132                             "psStats functions",
     133                             "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask" );
     134                             
     135    printf( "The expected Stdev was %.2f; the calculated Stdev was %.2f\n",
     136            realStdevNoMask, myStats->robustStdev );
     137    if ( fabs( myStats->robustStdev - realStdevNoMask ) < ( ERROR_TOLERANCE * realStdevNoMask ) ) {
     138            testStatus = true;
     139        } else {
     140            testStatus = false;
     141            globalTestStatus = false;
     142        }
     143    printFooter( stdout,
     144                 "psVector functions",
     145                 "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask",
     146                 testStatus );
     147                 
     148                 
     149                 
     150    printPositiveTestHeader( stdout,
     151                             "psStats functions",
     152                             "PS_STAT_ROBUST_STATS: lower quartile: no vector mask" );
     153                             
     154    printf( "The expected LQ was %.2f; the calculated LQ was %.2f\n",
     155            realLQNoMask, myStats->robustLQ );
     156           
     157    if ( fabs( myStats->robustLQ - realLQNoMask ) < ( ERROR_TOLERANCE * realLQNoMask ) ) {
     158            testStatus = true;
     159        } else {
     160            testStatus = false;
     161            globalTestStatus = false;
     162        }
     163    printFooter( stdout,
     164                 "psVector functions",
     165                 "PS_STAT_ROBUST_STATS: lower quartile: no vector mask",
     166                 testStatus );
     167                 
     168                 
     169                 
     170    printPositiveTestHeader( stdout,
     171                             "psStats functions",
     172                             "PS_STAT_ROBUST_STATS: upper quartile: no vector mask" );
     173                             
     174    printf( "The expected UQ was %.2f; the calculated UQ was %.2f\n",
     175            realUQNoMask, myStats->robustUQ );
     176    if ( fabs( myStats->robustUQ - realUQNoMask ) < ( ERROR_TOLERANCE * realUQNoMask ) ) {
     177            testStatus = true;
     178        } else {
     179            testStatus = false;
     180            globalTestStatus = false;
     181        }
     182    printFooter( stdout,
     183                 "psVector functions",
     184                 "PS_STAT_ROBUST_STATS: lower quartile: no vector mask",
     185                 testStatus );
     186                 
     187                 
     188                 
     189    printPositiveTestHeader( stdout,
     190                             "psStats functions",
     191                             "PS_STAT_ROBUST_STATS: robust N50: no vector mask" );
     192                             
    193193    // XXX:
    194194    realN50NoMask = myStats->robustN50;
    195 
    196     printf("The expected N50 was %f; the calculated N50 was %f\n",
    197            realN50NoMask, myStats->robustN50);
    198     if (fabs(myStats->robustN50 - realN50NoMask) < (ERROR_TOLERANCE * realN50NoMask)) {
    199         testStatus = true;
    200     } else {
    201         testStatus = false;
    202         globalTestStatus = false;
    203     }
    204     printFooter(stdout,
    205                 "psVector functions",
    206                 "PS_STAT_ROBUST_STATS: robust N50: no vector mask",
    207                 testStatus);
    208 
    209 
    210 
    211     printPositiveTestHeader(stdout,
    212                             "psStats functions",
    213                             "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask");
    214 
     195   
     196    printf( "The expected N50 was %.2f; the calculated N50 was %.2f\n",
     197            realN50NoMask, myStats->robustN50 );
     198    if ( fabs( myStats->robustN50 - realN50NoMask ) < ( ERROR_TOLERANCE * realN50NoMask ) ) {
     199            testStatus = true;
     200        } else {
     201            testStatus = false;
     202            globalTestStatus = false;
     203        }
     204    printFooter( stdout,
     205                 "psVector functions",
     206                 "PS_STAT_ROBUST_STATS: robust N50: no vector mask",
     207                 testStatus );
     208                 
     209                 
     210                 
     211    printPositiveTestHeader( stdout,
     212                             "psStats functions",
     213                             "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask" );
     214                             
    215215    // XXX:
    216216    realNfitNoMask = myStats->robustNfit;
    217 
    218     printf("The expected Nfit was %f; the calculated Nfit was %f\n",
    219            realNfitNoMask, myStats->robustNfit);
    220     if (fabs(myStats->robustNfit - realNfitNoMask) < (ERROR_TOLERANCE * realNfitNoMask)) {
    221         testStatus = true;
    222     } else {
    223         testStatus = false;
    224         globalTestStatus = false;
    225     }
    226     printFooter(stdout,
    227                 "psVector functions",
    228                 "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask",
    229                 testStatus);
    230 
    231 
    232     return(0);
    233 
     217   
     218    printf( "The expected Nfit was %.2f; the calculated Nfit was %.2f\n",
     219            realNfitNoMask, myStats->robustNfit );
     220    if ( fabs( myStats->robustNfit - realNfitNoMask ) < ( ERROR_TOLERANCE * realNfitNoMask ) ) {
     221            testStatus = true;
     222        } else {
     223            testStatus = false;
     224            globalTestStatus = false;
     225        }
     226    printFooter( stdout,
     227                 "psVector functions",
     228                 "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask",
     229                 testStatus );
     230                 
     231                 
     232    return ( 0 );
     233   
    234234    /*************************************************************************/
    235235    /*  Call psVectorStats() with vector mask.                               */
    236236    /*************************************************************************/
    237     printPositiveTestHeader(stdout,
    238                             "psStats functions",
    239                             "PS_STAT_ROBUST_STATS: robust mean: with vector mask");
    240 
    241     printf("Calling psVectorStats() on a vector with elements masked.\n");
    242     myStats = psVectorStats(myStats, myVector, maskVector, 1);
    243     printf("Called psVectorStats() on a vector with elements masked.\n");
    244     printf("The expected Mean was %f; the calculated Mean was %f\n",
    245            realMeanWithMask, myStats->robustMean);
    246     if (fabs(myStats->robustMean - realMeanWithMask) < (ERROR_TOLERANCE * realMeanWithMask)) {
    247         testStatus = true;
    248     } else {
    249         testStatus = false;
    250         globalTestStatus = false;
    251     }
    252     printFooter(stdout,
    253                 "psVector functions",
    254                 "PS_STAT_ROBUST_STATS: robust mean: with vector mask",
    255                 testStatus);
    256 
    257 
    258 
    259     printPositiveTestHeader(stdout,
    260                             "psStats functions",
    261                             "PS_STAT_ROBUST_STATS: robust Median: with vector mask");
    262 
    263     printf("The expected Median was %f; the calculated Median was %f\n",
    264            realMedianWithMask, myStats->robustMedian);
    265     if (fabs(myStats->robustMedian - realMedianWithMask) < (ERROR_TOLERANCE * realMedianWithMask)) {
    266         testStatus = true;
    267     } else {
    268         testStatus = false;
    269         globalTestStatus = false;
    270     }
    271     printFooter(stdout,
    272                 "psVector functions",
    273                 "PS_STAT_ROBUST_STATS: robust Median: with vector mask",
    274                 testStatus);
    275 
    276 
    277 
    278     printPositiveTestHeader(stdout,
    279                             "psStats functions",
    280                             "PS_STAT_ROBUST_STATS: robust Mode: with vector mask");
    281 
    282     printf("The expected Mode was %f; the calculated Mode was %f\n",
    283            realModeWithMask, myStats->robustMode);
    284     if (fabs(myStats->robustMode - realModeWithMask) < (ERROR_TOLERANCE * realModeWithMask)) {
    285         testStatus = true;
    286     } else {
    287         testStatus = false;
    288         globalTestStatus = false;
    289     }
    290     printFooter(stdout,
    291                 "psVector functions",
    292                 "PS_STAT_ROBUST_STATS: robust Mode: with vector mask",
    293                 testStatus);
    294 
    295 
    296 
    297     printPositiveTestHeader(stdout,
    298                             "psStats functions",
    299                             "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask");
    300 
    301     printf("The expected Stdev was %f; the calculated Stdev was %f\n",
    302            realStdevWithMask, myStats->robustStdev);
    303     if (fabs(myStats->robustStdev - realStdevWithMask) < (ERROR_TOLERANCE * realStdevWithMask)) {
    304         testStatus = true;
    305     } else {
    306         testStatus = false;
    307         globalTestStatus = false;
    308     }
    309     printFooter(stdout,
    310                 "psVector functions",
    311                 "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask",
    312                 testStatus);
    313 
    314 
    315 
    316     printPositiveTestHeader(stdout,
    317                             "psStats functions",
    318                             "PS_STAT_ROBUST_STATS: lower quartile: with vector mask");
    319 
    320     printf("The expected LQ was %f; the calculated LQ was %f\n",
    321            realLQWithMask, myStats->robustLQ);
    322     if (fabs(myStats->robustLQ - realLQWithMask) < (ERROR_TOLERANCE * realLQWithMask)) {
    323         testStatus = true;
    324     } else {
    325         testStatus = false;
    326         globalTestStatus = false;
    327     }
    328     printFooter(stdout,
    329                 "psVector functions",
    330                 "PS_STAT_ROBUST_STATS: lower quartile: with vector mask",
    331                 testStatus);
    332 
    333 
    334 
    335     printPositiveTestHeader(stdout,
    336                             "psStats functions",
    337                             "PS_STAT_ROBUST_STATS: upper quartile: with vector mask");
    338 
    339     printf("The expected UQ was %f; the calculated UQ was %f\n",
    340            realUQWithMask, myStats->robustUQ);
    341     if (fabs(myStats->robustUQ - realUQWithMask) < (ERROR_TOLERANCE * realUQWithMask)) {
    342         testStatus = true;
    343     } else {
    344         testStatus = false;
    345         globalTestStatus = false;
    346     }
    347     printFooter(stdout,
    348                 "psVector functions",
    349                 "PS_STAT_ROBUST_STATS: lower quartile: with vector mask",
    350                 testStatus);
    351 
    352 
    353 
    354     printPositiveTestHeader(stdout,
    355                             "psStats functions",
    356                             "PS_STAT_ROBUST_STATS: robust N50: with vector mask");
    357 
    358     printf("The expected N50 was %f; the calculated N50 was %f\n",
    359            realN50WithMask, myStats->robustN50);
    360     if (fabs(myStats->robustN50 - realN50WithMask) < (ERROR_TOLERANCE * realN50WithMask)) {
    361         testStatus = true;
    362     } else {
    363         testStatus = false;
    364         globalTestStatus = false;
    365     }
    366     printFooter(stdout,
    367                 "psVector functions",
    368                 "PS_STAT_ROBUST_STATS: robust N50: with vector mask",
    369                 testStatus);
    370 
    371 
    372 
    373     printPositiveTestHeader(stdout,
    374                             "psStats functions",
    375                             "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask");
    376 
    377     printf("The expected Nfit was %f; the calculated Nfit was %f\n",
    378            realNfitWithMask, myStats->robustNfit);
    379     if (fabs(myStats->robustNfit - realNfitWithMask) < (ERROR_TOLERANCE * realNfitWithMask)) {
    380         testStatus = true;
    381     } else {
    382         testStatus = false;
    383         globalTestStatus = false;
    384     }
    385     printFooter(stdout,
    386                 "psVector functions",
    387                 "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask",
    388                 testStatus);
    389 
    390 
    391 
     237    printPositiveTestHeader( stdout,
     238                             "psStats functions",
     239                             "PS_STAT_ROBUST_STATS: robust mean: with vector mask" );
     240                             
     241    printf( "Calling psVectorStats() on a vector with elements masked.\n" );
     242    myStats = psVectorStats( myStats, myVector, maskVector, 1 );
     243    printf( "Called psVectorStats() on a vector with elements masked.\n" );
     244    printf( "The expected Mean was %.2f; the calculated Mean was %.2f\n",
     245            realMeanWithMask, myStats->robustMean );
     246    if ( fabs( myStats->robustMean - realMeanWithMask ) < ( ERROR_TOLERANCE * realMeanWithMask ) ) {
     247            testStatus = true;
     248        } else {
     249            testStatus = false;
     250            globalTestStatus = false;
     251        }
     252    printFooter( stdout,
     253                 "psVector functions",
     254                 "PS_STAT_ROBUST_STATS: robust mean: with vector mask",
     255                 testStatus );
     256                 
     257                 
     258                 
     259    printPositiveTestHeader( stdout,
     260                             "psStats functions",
     261                             "PS_STAT_ROBUST_STATS: robust Median: with vector mask" );
     262                             
     263    printf( "The expected Median was %.2f; the calculated Median was %.2f\n",
     264            realMedianWithMask, myStats->robustMedian );
     265    if ( fabs( myStats->robustMedian - realMedianWithMask ) < ( ERROR_TOLERANCE * realMedianWithMask ) ) {
     266            testStatus = true;
     267        } else {
     268            testStatus = false;
     269            globalTestStatus = false;
     270        }
     271    printFooter( stdout,
     272                 "psVector functions",
     273                 "PS_STAT_ROBUST_STATS: robust Median: with vector mask",
     274                 testStatus );
     275                 
     276                 
     277                 
     278    printPositiveTestHeader( stdout,
     279                             "psStats functions",
     280                             "PS_STAT_ROBUST_STATS: robust Mode: with vector mask" );
     281                             
     282    printf( "The expected Mode was %.2f; the calculated Mode was %.2f\n",
     283            realModeWithMask, myStats->robustMode );
     284    if ( fabs( myStats->robustMode - realModeWithMask ) < ( ERROR_TOLERANCE * realModeWithMask ) ) {
     285            testStatus = true;
     286        } else {
     287            testStatus = false;
     288            globalTestStatus = false;
     289        }
     290    printFooter( stdout,
     291                 "psVector functions",
     292                 "PS_STAT_ROBUST_STATS: robust Mode: with vector mask",
     293                 testStatus );
     294                 
     295                 
     296                 
     297    printPositiveTestHeader( stdout,
     298                             "psStats functions",
     299                             "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask" );
     300                             
     301    printf( "The expected Stdev was %.2f; the calculated Stdev was %.2f\n",
     302            realStdevWithMask, myStats->robustStdev );
     303    if ( fabs( myStats->robustStdev - realStdevWithMask ) < ( ERROR_TOLERANCE * realStdevWithMask ) ) {
     304            testStatus = true;
     305        } else {
     306            testStatus = false;
     307            globalTestStatus = false;
     308        }
     309    printFooter( stdout,
     310                 "psVector functions",
     311                 "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask",
     312                 testStatus );
     313                 
     314                 
     315                 
     316    printPositiveTestHeader( stdout,
     317                             "psStats functions",
     318                             "PS_STAT_ROBUST_STATS: lower quartile: with vector mask" );
     319                             
     320    printf( "The expected LQ was %.2f; the calculated LQ was %.2f\n",
     321            realLQWithMask, myStats->robustLQ );
     322    if ( fabs( myStats->robustLQ - realLQWithMask ) < ( ERROR_TOLERANCE * realLQWithMask ) ) {
     323            testStatus = true;
     324        } else {
     325            testStatus = false;
     326            globalTestStatus = false;
     327        }
     328    printFooter( stdout,
     329                 "psVector functions",
     330                 "PS_STAT_ROBUST_STATS: lower quartile: with vector mask",
     331                 testStatus );
     332                 
     333                 
     334                 
     335    printPositiveTestHeader( stdout,
     336                             "psStats functions",
     337                             "PS_STAT_ROBUST_STATS: upper quartile: with vector mask" );
     338                             
     339    printf( "The expected UQ was %.2f; the calculated UQ was %.2f\n",
     340            realUQWithMask, myStats->robustUQ );
     341    if ( fabs( myStats->robustUQ - realUQWithMask ) < ( ERROR_TOLERANCE * realUQWithMask ) ) {
     342            testStatus = true;
     343        } else {
     344            testStatus = false;
     345            globalTestStatus = false;
     346        }
     347    printFooter( stdout,
     348                 "psVector functions",
     349                 "PS_STAT_ROBUST_STATS: lower quartile: with vector mask",
     350                 testStatus );
     351                 
     352                 
     353                 
     354    printPositiveTestHeader( stdout,
     355                             "psStats functions",
     356                             "PS_STAT_ROBUST_STATS: robust N50: with vector mask" );
     357                             
     358    printf( "The expected N50 was %.2f; the calculated N50 was %.2f\n",
     359            realN50WithMask, myStats->robustN50 );
     360    if ( fabs( myStats->robustN50 - realN50WithMask ) < ( ERROR_TOLERANCE * realN50WithMask ) ) {
     361            testStatus = true;
     362        } else {
     363            testStatus = false;
     364            globalTestStatus = false;
     365        }
     366    printFooter( stdout,
     367                 "psVector functions",
     368                 "PS_STAT_ROBUST_STATS: robust N50: with vector mask",
     369                 testStatus );
     370                 
     371                 
     372                 
     373    printPositiveTestHeader( stdout,
     374                             "psStats functions",
     375                             "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask" );
     376                             
     377    printf( "The expected Nfit was %.2f; the calculated Nfit was %.2f\n",
     378            realNfitWithMask, myStats->robustNfit );
     379    if ( fabs( myStats->robustNfit - realNfitWithMask ) < ( ERROR_TOLERANCE * realNfitWithMask ) ) {
     380            testStatus = true;
     381        } else {
     382            testStatus = false;
     383            globalTestStatus = false;
     384        }
     385    printFooter( stdout,
     386                 "psVector functions",
     387                 "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask",
     388                 testStatus );
     389                 
     390                 
     391                 
    392392    /*************************************************************************/
    393393    /*  Deallocate data structures                                           */
    394394    /*************************************************************************/
    395     printPositiveTestHeader(stdout,
    396                             "psStats functions",
    397                             "psStats(): deallocating memory");
    398 
    399     psFree(myStats);
    400     psFree(myVector);
    401     psFree(maskVector);
    402 
    403     psMemCheckCorruption(1);
    404     memLeaks = psMemCheckLeaks(currentId,NULL,NULL);
    405     if (0 != memLeaks) {
    406         psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks);
    407     }
    408 
    409     printFooter(stdout,
    410                 "psVector functions",
    411                 "psStats(): deallocating memory",
    412                 testStatus);
    413 
    414     return (!globalTestStatus);
     395    printPositiveTestHeader( stdout,
     396                             "psStats functions",
     397                             "psStats(): deallocating memory" );
     398                             
     399    psFree( myStats );
     400    psFree( myVector );
     401    psFree( maskVector );
     402   
     403    psMemCheckCorruption( 1 );
     404    memLeaks = psMemCheckLeaks( currentId, NULL, NULL );
     405    if ( 0 != memLeaks ) {
     406            psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks );
     407        }
     408       
     409    printFooter( stdout,
     410                 "psVector functions",
     411                 "psStats(): deallocating memory",
     412                 testStatus );
     413                 
     414    return ( !globalTestStatus );
    415415}
Note: See TracChangeset for help on using the changeset viewer.