IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 660


Ignore:
Timestamp:
May 12, 2004, 9:42:51 PM (22 years ago)
Author:
gusciora
Message:

Added some tests and fixed some bugs in psArrayStats().

Location:
trunk/psLib
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r659 r660  
    174174    int i = 0;
    175175    float mean = 0.0;
     176    int count = 0;
    176177
    177178    if (maskVector != NULL) {
    178179        for (i=0;i<myVector->n;i++) {
    179180            if (!(maskVal & maskVector->vec.i[i])) {
    180                 mean+= maskVector->vec.i[i];
    181             }
    182         }
     181                mean+= myVector->vec.f[i];
     182                count++;
     183            }
     184        }
     185        mean/= (float) count;
     186        return(mean);
    183187    } else {
    184188        for (i=0;i<myVector->n;i++) {
    … …  
    348352    }
    349353
    350     switch (stats->options) {
    351     case PS_STAT_SAMPLE_MEAN:
    352         newStruct->sampleMean = p_psArraySampleMean(myVector, maskVector, maskVal);
    353         break;
    354     case PS_STAT_SAMPLE_MEDIAN:
     354    if (stats->options & PS_STAT_SAMPLE_MEAN) {
     355        newStruct->sampleMean = p_psArraySampleMean(myVector,
     356                                maskVector,
     357                                maskVal);
     358    }
     359
     360    if (stats->options & PS_STAT_MAX) {
     361        newStruct->max = p_psArrayMax(myVector, maskVector, maskVal);
     362    }
     363
     364    if (stats->options & PS_STAT_MIN) {
     365        newStruct->min = p_psArrayMin(myVector, maskVector, maskVal);
     366    }
     367
     368    if (stats->options & PS_STAT_NVALUES) {
     369        newStruct->nValues = p_psArrayNValues(myVector, maskVector, maskVal);
     370    }
     371
     372    if (stats->options & PS_STAT_SAMPLE_MEDIAN) {
    355373        newStruct->sampleMedian = p_psArrayXXX(myVector, maskVector, maskVal);
    356         break;
    357     case PS_STAT_SAMPLE_STDEV:
     374    }
     375
     376    if (stats->options & PS_STAT_SAMPLE_STDEV) {
    358377        newStruct->sampleStdev = p_psArrayXXX(myVector, maskVector, maskVal);
    359         break;
    360     case PS_STAT_SAMPLE_UQ:
     378    }
     379
     380    if (stats->options & PS_STAT_SAMPLE_UQ) {
    361381        newStruct->sampleUQ = p_psArrayXXX(myVector, maskVector, maskVal);
    362         break;
    363     case PS_STAT_SAMPLE_LQ:
     382    }
     383
     384    if (stats->options & PS_STAT_SAMPLE_LQ) {
    364385        newStruct->sampleLQ = p_psArrayXXX(myVector, maskVector, maskVal);
    365         break;
    366     case PS_STAT_ROBUST_MEAN:
     386    }
     387
     388    if (stats->options & PS_STAT_ROBUST_MEAN) {
    367389        newStruct->robustMean = p_psArrayXXX(myVector, maskVector, maskVal);
    368         break;
    369     case PS_STAT_ROBUST_MEAN_NVALUES:
     390    }
     391
     392    if (stats->options & PS_STAT_ROBUST_MEAN_NVALUES) {
    370393        newStruct->robustMeanNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
    371         break;
    372     case PS_STAT_ROBUST_MEDIAN:
     394    }
     395
     396    if (stats->options & PS_STAT_ROBUST_MEDIAN) {
    373397        newStruct->robustMedian = p_psArrayXXX(myVector, maskVector, maskVal);
    374         break;
    375     case PS_STAT_ROBUST_MEDIAN_NVALUES:
     398    }
     399
     400    if (stats->options & PS_STAT_ROBUST_MEDIAN_NVALUES) {
    376401        newStruct->robustMedianNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
    377         break;
    378     case PS_STAT_ROBUST_MODE:
     402    }
     403
     404    if (stats->options & PS_STAT_ROBUST_MODE) {
    379405        newStruct->robustMode = p_psArrayXXX(myVector, maskVector, maskVal);
    380         break;
    381     case PS_STAT_ROBUST_MODE_NVALUES:
     406    }
     407
     408    if (stats->options & PS_STAT_ROBUST_MODE_NVALUES) {
    382409        newStruct->robustModeNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
    383         break;
    384     case PS_STAT_ROBUST_STDEV:
     410    }
     411
     412    if (stats->options & PS_STAT_ROBUST_STDEV) {
    385413        newStruct->robustStdev = p_psArrayXXX(myVector, maskVector, maskVal);
    386         break;
    387     case PS_STAT_ROBUST_UQ:
     414    }
     415
     416    if (stats->options & PS_STAT_ROBUST_UQ) {
    388417        newStruct->robustUQ = p_psArrayXXX(myVector, maskVector, maskVal);
    389         break;
    390     case PS_STAT_ROBUST_LQ:
     418    }
     419
     420    if (stats->options & PS_STAT_ROBUST_LQ) {
    391421        newStruct->robustLQ = p_psArrayXXX(myVector, maskVector, maskVal);
    392         break;
    393     case PS_STAT_CLIPPED_MEAN:
     422    }
     423
     424    if (stats->options & PS_STAT_CLIPPED_MEAN) {
    394425        newStruct->clippedMean = p_psArrayXXX(myVector, maskVector, maskVal);
    395         break;
    396     case PS_STAT_CLIPPED_MEAN_NVALUES:
     426    }
     427
     428    if (stats->options & PS_STAT_CLIPPED_MEAN_NVALUES) {
    397429        newStruct->clippedMeanNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
    398         break;
    399     case PS_STAT_CLIPPED_MEAN_NSIGMA:
     430    }
     431
     432    if (stats->options & PS_STAT_CLIPPED_MEAN_NSIGMA) {
    400433        newStruct->clipSigma = p_psArrayXXX(myVector, maskVector, maskVal);
    401         break;
    402     case PS_STAT_CLIPPED_STDEV:
     434    }
     435
     436    if (stats->options & PS_STAT_CLIPPED_STDEV) {
    403437        newStruct->clippedStdev = p_psArrayXXX(myVector, maskVector, maskVal);
    404         break;
    405     case PS_STAT_MAX:
    406         newStruct->max = p_psArrayMax(myVector, maskVector, maskVal);
    407         break;
    408     case PS_STAT_MIN:
    409         newStruct->min = p_psArrayMin(myVector, maskVector, maskVal);
    410         break;
    411     case PS_STAT_NVALUES:
    412         newStruct->nValues = p_psArrayNValues(myVector, maskVector, maskVal);
    413         break;
    414     default:
    415         psError(__func__, "Unknown options 0x%x.\n", stats->options);
    416         break;
    417     }
     438    }
     439
     440
     441    //    OLD CODE: Should we check for an unknown option?
     442    //    default:
     443    //        psError(__func__, "Unknown options 0x%x.\n", stats->options);
    418444
    419445    return(newStruct);

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

    r659 r660  
    174174    int i = 0;
    175175    float mean = 0.0;
     176    int count = 0;
    176177
    177178    if (maskVector != NULL) {
    178179        for (i=0;i<myVector->n;i++) {
    179180            if (!(maskVal & maskVector->vec.i[i])) {
    180                 mean+= maskVector->vec.i[i];
    181             }
    182         }
     181                mean+= myVector->vec.f[i];
     182                count++;
     183            }
     184        }
     185        mean/= (float) count;
     186        return(mean);
    183187    } else {
    184188        for (i=0;i<myVector->n;i++) {
    … …  
    348352    }
    349353
    350     switch (stats->options) {
    351     case PS_STAT_SAMPLE_MEAN:
    352         newStruct->sampleMean = p_psArraySampleMean(myVector, maskVector, maskVal);
    353         break;
    354     case PS_STAT_SAMPLE_MEDIAN:
     354    if (stats->options & PS_STAT_SAMPLE_MEAN) {
     355        newStruct->sampleMean = p_psArraySampleMean(myVector,
     356                                maskVector,
     357                                maskVal);
     358    }
     359
     360    if (stats->options & PS_STAT_MAX) {
     361        newStruct->max = p_psArrayMax(myVector, maskVector, maskVal);
     362    }
     363
     364    if (stats->options & PS_STAT_MIN) {
     365        newStruct->min = p_psArrayMin(myVector, maskVector, maskVal);
     366    }
     367
     368    if (stats->options & PS_STAT_NVALUES) {
     369        newStruct->nValues = p_psArrayNValues(myVector, maskVector, maskVal);
     370    }
     371
     372    if (stats->options & PS_STAT_SAMPLE_MEDIAN) {
    355373        newStruct->sampleMedian = p_psArrayXXX(myVector, maskVector, maskVal);
    356         break;
    357     case PS_STAT_SAMPLE_STDEV:
     374    }
     375
     376    if (stats->options & PS_STAT_SAMPLE_STDEV) {
    358377        newStruct->sampleStdev = p_psArrayXXX(myVector, maskVector, maskVal);
    359         break;
    360     case PS_STAT_SAMPLE_UQ:
     378    }
     379
     380    if (stats->options & PS_STAT_SAMPLE_UQ) {
    361381        newStruct->sampleUQ = p_psArrayXXX(myVector, maskVector, maskVal);
    362         break;
    363     case PS_STAT_SAMPLE_LQ:
     382    }
     383
     384    if (stats->options & PS_STAT_SAMPLE_LQ) {
    364385        newStruct->sampleLQ = p_psArrayXXX(myVector, maskVector, maskVal);
    365         break;
    366     case PS_STAT_ROBUST_MEAN:
     386    }
     387
     388    if (stats->options & PS_STAT_ROBUST_MEAN) {
    367389        newStruct->robustMean = p_psArrayXXX(myVector, maskVector, maskVal);
    368         break;
    369     case PS_STAT_ROBUST_MEAN_NVALUES:
     390    }
     391
     392    if (stats->options & PS_STAT_ROBUST_MEAN_NVALUES) {
    370393        newStruct->robustMeanNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
    371         break;
    372     case PS_STAT_ROBUST_MEDIAN:
     394    }
     395
     396    if (stats->options & PS_STAT_ROBUST_MEDIAN) {
    373397        newStruct->robustMedian = p_psArrayXXX(myVector, maskVector, maskVal);
    374         break;
    375     case PS_STAT_ROBUST_MEDIAN_NVALUES:
     398    }
     399
     400    if (stats->options & PS_STAT_ROBUST_MEDIAN_NVALUES) {
    376401        newStruct->robustMedianNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
    377         break;
    378     case PS_STAT_ROBUST_MODE:
     402    }
     403
     404    if (stats->options & PS_STAT_ROBUST_MODE) {
    379405        newStruct->robustMode = p_psArrayXXX(myVector, maskVector, maskVal);
    380         break;
    381     case PS_STAT_ROBUST_MODE_NVALUES:
     406    }
     407
     408    if (stats->options & PS_STAT_ROBUST_MODE_NVALUES) {
    382409        newStruct->robustModeNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
    383         break;
    384     case PS_STAT_ROBUST_STDEV:
     410    }
     411
     412    if (stats->options & PS_STAT_ROBUST_STDEV) {
    385413        newStruct->robustStdev = p_psArrayXXX(myVector, maskVector, maskVal);
    386         break;
    387     case PS_STAT_ROBUST_UQ:
     414    }
     415
     416    if (stats->options & PS_STAT_ROBUST_UQ) {
    388417        newStruct->robustUQ = p_psArrayXXX(myVector, maskVector, maskVal);
    389         break;
    390     case PS_STAT_ROBUST_LQ:
     418    }
     419
     420    if (stats->options & PS_STAT_ROBUST_LQ) {
    391421        newStruct->robustLQ = p_psArrayXXX(myVector, maskVector, maskVal);
    392         break;
    393     case PS_STAT_CLIPPED_MEAN:
     422    }
     423
     424    if (stats->options & PS_STAT_CLIPPED_MEAN) {
    394425        newStruct->clippedMean = p_psArrayXXX(myVector, maskVector, maskVal);
    395         break;
    396     case PS_STAT_CLIPPED_MEAN_NVALUES:
     426    }
     427
     428    if (stats->options & PS_STAT_CLIPPED_MEAN_NVALUES) {
    397429        newStruct->clippedMeanNvalues = p_psArrayXXX(myVector, maskVector, maskVal);
    398         break;
    399     case PS_STAT_CLIPPED_MEAN_NSIGMA:
     430    }
     431
     432    if (stats->options & PS_STAT_CLIPPED_MEAN_NSIGMA) {
    400433        newStruct->clipSigma = p_psArrayXXX(myVector, maskVector, maskVal);
    401         break;
    402     case PS_STAT_CLIPPED_STDEV:
     434    }
     435
     436    if (stats->options & PS_STAT_CLIPPED_STDEV) {
    403437        newStruct->clippedStdev = p_psArrayXXX(myVector, maskVector, maskVal);
    404         break;
    405     case PS_STAT_MAX:
    406         newStruct->max = p_psArrayMax(myVector, maskVector, maskVal);
    407         break;
    408     case PS_STAT_MIN:
    409         newStruct->min = p_psArrayMin(myVector, maskVector, maskVal);
    410         break;
    411     case PS_STAT_NVALUES:
    412         newStruct->nValues = p_psArrayNValues(myVector, maskVector, maskVal);
    413         break;
    414     default:
    415         psError(__func__, "Unknown options 0x%x.\n", stats->options);
    416         break;
    417     }
     438    }
     439
     440
     441    //    OLD CODE: Should we check for an unknown option?
     442    //    default:
     443    //        psError(__func__, "Unknown options 0x%x.\n", stats->options);
    418444
    419445    return(newStruct);

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

    r659 r660  
    11/*****************************************************************************
    2     This code tests whether a hash table be allocated successfully.
     2    This routine must ensure that PS_STAT_SAMPLE_MEAN is correctly computed
     3    by the procedure psArrayStats().
    34 *****************************************************************************/
    45#include <stdio.h>
    … …  
    1415    int i               = 0;
    1516    psType dummyFloatType;
     17    psType dummyIntType;
    1618    psVector *myVector  = NULL;
     19    psVector *maskVector= NULL;
    1720    float mean          = 0.0;
    18     float realMean      = 0.0;
     21    float realMean1     = 0.0;
     22    float realMean2     = 0.0;
     23    int count           = 0;
    1924
    2025    printPositiveTestHeader(stdout,
    … …  
    2530    dummyFloatType.type = PS_TYPE_FLOAT;
    2631    dummyFloatType.dimen = PS_DIMEN_VECTOR;
     32    dummyIntType.type = PS_TYPE_INT;
     33    dummyIntType.dimen = PS_DIMEN_VECTOR;
    2734    myVector = psVectorAlloc(dummyFloatType, N);
    2835    myVector->n = N;
     36    maskVector = psVectorAlloc(dummyIntType, N);
     37    maskVector->n = N;
    2938
    3039    mean = 0.0;
    31     realMean = 0.0;
     40    realMean2 = 0.0;
    3241    for (i=0;i<N;i++) {
    3342        myVector->vec.f[i] = (float) i;
    34         realMean+= myVector->vec.f[i];
     43        if (i < (N/2)) {
     44            maskVector->vec.i[i] = 0;
     45            realMean2+= myVector->vec.f[i];
     46            count++;
     47        } else {
     48            printf("Masking element %d\n", i);
     49            maskVector->vec.i[i] = 1;
     50        }
     51        realMean1+= myVector->vec.f[i];
    3552    }
    36     realMean /= (float) N;
     53    realMean1 /= (float) N;
     54    realMean2 /= (float) count;
    3755
    3856    myStats2 = psArrayStats(myVector, NULL, 0, myStats);
    3957    mean = myStats2->sampleMean;
    4058
    41     if (mean == realMean) {
     59    printf("Called psArrayStats() on a vector with no elements masked.\n");
     60    printf("The expected mean was %f; the calculated mean was %f\n", realMean1, mean);
     61    if (mean == realMean1) {
    4262        testStatus = true;
    4363    } else {
    4464        testStatus = false;
    4565    }
     66
     67    myStats2 = psArrayStats(myVector, maskVector, 1, myStats);
     68    mean = myStats2->sampleMean;
     69    printf("Called psArrayStats() on a vector with last N/2 elements masked.\n");
     70    printf("The expected mean was %f; the calculated mean was %f\n", realMean2, mean);
    4671
    4772    printFooter(stdout,
Note: See TracChangeset for help on using the changeset viewer.