IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Dec 8, 2006, 1:38:54 AM (20 years ago)
Author:
magnier
Message:
  • moved psHistogram functions to psHistogram.c,h (pslib_strict.h, MAkefile.am, psMemory.c)
  • changed psVectorStats return value to bool (psImageGeomManip.c, psImagePixelExtract.c, psImageStats.c, psMinPoly.c,
  • added FITTED_MEAN,STDEV_V2 (quadratic fit to log-peak)
  • added stats->results
  • set stats->results when stats are measured
  • return stats calculated even if not requested
  • moved vectorFittedStats call out of vectorRobustStats to psVectorStats
  • internal calls to private stats function XXX now tests stats->results for the corresponding flag, NOT if value of stats->XXX == NAN.
  • dropped unused function NonEmpty (commented out)
  • rolled up vectorSampleMedian with if tests in the loop
  • rolled up vectorSampleStdev with if tests in the loop
  • call psError on failure for any internal stats call (the user should call psErrorClear if they ignore errors from psVectorStats)
Location:
trunk/psLib/test/math
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed

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

    r10166 r10550  
    99// ok(condition, "condition succeeded");
    1010// skip_start(condition, Nskip, "Skipping tests because of failure");
     11
     12# define DTIME(A,B) ((A.tv_sec - B.tv_sec) + 1e-6*(A.tv_usec - B.tv_usec))
     13struct timeval start, mark;
    1114
    1215int main (void)
    … …  
    2225        rnd->data.F32[i] = psRandomGaussian (seed);
    2326    }
    24     psTimerStart ("test");
    25 
    26     /********** fitted stats ***********/
    27     // test FITTED timing
    28     {
    29         // psMemId id = psMemGetId();
    30 
    31         diag ("check fitted mean speed : 1000 pts / 1000 loops");
     27
     28    diag ("timing for sample mean");
     29    /********** SAMPLE MEAN ***********/
     30    // test stat sample mean (no mask, no range)
     31    {
     32        psMemId id = psMemGetId();
     33
     34        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN);
     35
     36        gettimeofday (&start, NULL);
     37        for (int i = 0; i < 10000; i++)
     38        {
     39            psVectorStats (stats, rnd, NULL, NULL, 0);
     40        }
     41        gettimeofday (&mark, NULL);
     42        psF64 delta = DTIME(mark, start);
     43        ok (delta < 0.1, "sample mean %f (mask: 0, range: 0): %.3f sec", stats->sampleMean, delta);
     44        psFree (stats);
     45
     46        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     47    }
     48
     49    // test stat sample mean (mask, no range)
     50    {
     51        psMemId id = psMemGetId();
     52
     53        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN);
     54        psVector *mask = psVectorAlloc (1000, PS_TYPE_U8);
     55        psVectorInit (mask, 0);
     56        mask->data.U8[100] = 1;
     57        mask->data.U8[200] = 1;
     58        mask->data.U8[300] = 1;
     59
     60        gettimeofday (&start, NULL);
     61        for (int i = 0; i < 10000; i++)
     62        {
     63            psVectorStats (stats, rnd, NULL, mask, 1);
     64        }
     65        gettimeofday (&mark, NULL);
     66        psF64 delta = DTIME(mark, start);
     67        ok (delta < 0.12, "sample mean %f (mask: 1, range: 0): %.3f sec", stats->sampleMean, delta);
     68        psFree (stats);
     69        psFree (mask);
     70
     71        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     72    }
     73
     74    // test stat sample mean (no mask, range)
     75    {
     76        psMemId id = psMemGetId();
     77
     78        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_USE_RANGE);
     79        stats->min = -10;
     80        stats->max = +10;
     81
     82        gettimeofday (&start, NULL);
     83        for (int i = 0; i < 10000; i++)
     84        {
     85            psVectorStats (stats, rnd, NULL, NULL, 0);
     86        }
     87        gettimeofday (&mark, NULL);
     88        psF64 delta = DTIME(mark, start);
     89        ok (delta < 0.18, "sample mean %f (mask: 0, range: 1): %.3f sec", stats->sampleMean, delta);
     90        psFree (stats);
     91
     92        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     93    }
     94
     95    // test stat sample mean (mask, range)
     96    {
     97        psMemId id = psMemGetId();
     98
     99        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_USE_RANGE);
     100        stats->min = -10;
     101        stats->max = +10;
     102        psVector *mask = psVectorAlloc (1000, PS_TYPE_U8);
     103        psVectorInit (mask, 0);
     104        mask->data.U8[100] = 1;
     105        mask->data.U8[200] = 1;
     106        mask->data.U8[300] = 1;
     107
     108        gettimeofday (&start, NULL);
     109        for (int i = 0; i < 10000; i++)
     110        {
     111            psVectorStats (stats, rnd, NULL, mask, 1);
     112        }
     113        gettimeofday (&mark, NULL);
     114        psF64 delta = DTIME(mark, start);
     115        ok (delta < 0.2, "sample mean %f (mask: 1, range: 1): %.3f sec", stats->sampleMean, delta);
     116        psFree (stats);
     117        psFree (mask);
     118
     119        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     120    }
     121
     122    diag ("timing for sample median");
     123    /********** SAMPLE MEDIAN ***********/
     124    // test stat sample median (no mask, no range)
     125    {
     126        psMemId id = psMemGetId();
     127
     128        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN);
     129
     130        gettimeofday (&start, NULL);
     131        for (int i = 0; i < 10000; i++)
     132        {
     133            psVectorStats (stats, rnd, NULL, NULL, 0);
     134        }
     135        gettimeofday (&mark, NULL);
     136        psF64 delta = DTIME(mark, start);
     137        ok (delta < 2.8, "sample median %f (mask: 0, range: 0): %.3f sec", stats->sampleMedian, delta);
     138        psFree (stats);
     139
     140        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     141    }
     142
     143    // test stat sample median (mask, no range)
     144    {
     145        psMemId id = psMemGetId();
     146
     147        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN);
     148        psVector *mask = psVectorAlloc (1000, PS_TYPE_U8);
     149        psVectorInit (mask, 0);
     150        mask->data.U8[100] = 1;
     151        mask->data.U8[200] = 1;
     152        mask->data.U8[300] = 1;
     153
     154        gettimeofday (&start, NULL);
     155        for (int i = 0; i < 10000; i++)
     156        {
     157            psVectorStats (stats, rnd, NULL, mask, 1);
     158        }
     159        gettimeofday (&mark, NULL);
     160        psF64 delta = DTIME(mark, start);
     161        ok (delta < 2.8, "sample median %f (mask: 1, range: 0): %.3f sec", stats->sampleMedian, delta);
     162        psFree (stats);
     163        psFree (mask);
     164
     165        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     166    }
     167
     168    // test stat sample median (no mask, range)
     169    {
     170        psMemId id = psMemGetId();
     171
     172        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN | PS_STAT_USE_RANGE);
     173        stats->min = -10;
     174        stats->max = +10;
     175
     176        gettimeofday (&start, NULL);
     177        for (int i = 0; i < 10000; i++)
     178        {
     179            psVectorStats (stats, rnd, NULL, NULL, 0);
     180        }
     181        gettimeofday (&mark, NULL);
     182        psF64 delta = DTIME(mark, start);
     183        ok (delta < 2.8, "sample median %f (mask: 0, range: 1): %.3f sec", stats->sampleMedian, delta);
     184        psFree (stats);
     185
     186        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     187    }
     188
     189    // test stat sample median (mask, range)
     190    {
     191        psMemId id = psMemGetId();
     192
     193        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN | PS_STAT_USE_RANGE);
     194        stats->min = -10;
     195        stats->max = +10;
     196        psVector *mask = psVectorAlloc (1000, PS_TYPE_U8);
     197        psVectorInit (mask, 0);
     198        mask->data.U8[100] = 1;
     199        mask->data.U8[200] = 1;
     200        mask->data.U8[300] = 1;
     201
     202        gettimeofday (&start, NULL);
     203        for (int i = 0; i < 10000; i++)
     204        {
     205            psVectorStats (stats, rnd, NULL, mask, 1);
     206        }
     207        gettimeofday (&mark, NULL);
     208        psF64 delta = DTIME(mark, start);
     209        ok (delta < 2.8, "sample median %f (mask: 1, range: 1): %.3f sec", stats->sampleMedian, delta);
     210        psFree (stats);
     211        psFree (mask);
     212
     213        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     214    }
     215
     216    diag ("timing for sample stdev");
     217    /********** SAMPLE STDEV ***********/
     218    // test stat sample stdev (no mask, no range)
     219    {
     220        psMemId id = psMemGetId();
     221
     222        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_STDEV);
     223
     224        gettimeofday (&start, NULL);
     225        for (int i = 0; i < 10000; i++)
     226        {
     227            psVectorStats (stats, rnd, NULL, NULL, 0);
     228        }
     229        gettimeofday (&mark, NULL);
     230        psF64 delta = DTIME(mark, start);
     231        ok (delta < 0.2, "sample stdev %f (mask: 0, range: 0): %.3f sec", stats->sampleStdev, delta);
     232        psFree (stats);
     233
     234        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     235    }
     236
     237    // test stat sample stdev (mask, no range)
     238    {
     239        psMemId id = psMemGetId();
     240
     241        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_STDEV);
     242        psVector *mask = psVectorAlloc (1000, PS_TYPE_U8);
     243        psVectorInit (mask, 0);
     244        mask->data.U8[100] = 1;
     245        mask->data.U8[200] = 1;
     246        mask->data.U8[300] = 1;
     247
     248        gettimeofday (&start, NULL);
     249        for (int i = 0; i < 10000; i++)
     250        {
     251            psVectorStats (stats, rnd, NULL, mask, 1);
     252        }
     253        gettimeofday (&mark, NULL);
     254        psF64 delta = DTIME(mark, start);
     255        ok (delta < 0.27, "sample stdev %f (mask: 1, range: 0): %.3f sec", stats->sampleStdev, delta);
     256        psFree (stats);
     257        psFree (mask);
     258
     259        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     260    }
     261
     262    // test stat sample stdev (no mask, range)
     263    {
     264        psMemId id = psMemGetId();
     265
     266        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_STDEV | PS_STAT_USE_RANGE);
     267        stats->min = -10;
     268        stats->max = +10;
     269
     270        gettimeofday (&start, NULL);
     271        for (int i = 0; i < 10000; i++)
     272        {
     273            psVectorStats (stats, rnd, NULL, NULL, 0);
     274        }
     275        gettimeofday (&mark, NULL);
     276        psF64 delta = DTIME(mark, start);
     277        ok (delta < 0.36, "sample stdev %f (mask: 0, range: 1): %.3f sec", stats->sampleStdev, delta);
     278        psFree (stats);
     279
     280        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     281    }
     282
     283    // test stat sample stdev (mask, range)
     284    {
     285        psMemId id = psMemGetId();
     286
     287        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_STDEV | PS_STAT_USE_RANGE);
     288        stats->min = -10;
     289        stats->max = +10;
     290        psVector *mask = psVectorAlloc (1000, PS_TYPE_U8);
     291        psVectorInit (mask, 0);
     292        mask->data.U8[100] = 1;
     293        mask->data.U8[200] = 1;
     294        mask->data.U8[300] = 1;
     295
     296        gettimeofday (&start, NULL);
     297        for (int i = 0; i < 10000; i++)
     298        {
     299            psVectorStats (stats, rnd, NULL, mask, 1);
     300        }
     301        gettimeofday (&mark, NULL);
     302        psF64 delta = DTIME(mark, start);
     303        ok (delta < 0.42, "sample stdev %f (mask: 1, range: 1): %.3f sec", stats->sampleStdev, delta);
     304        psFree (stats);
     305        psFree (mask);
     306
     307        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     308    }
     309
     310    diag ("timing for sample min,max");
     311    /*************** MIN,MAX ******************/
     312    // test stat min,max (no mask, no range)
     313    {
     314        psMemId id = psMemGetId();
     315
     316        psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX);
     317        gettimeofday (&start, NULL);
     318        for (int i = 0; i < 10000; i++)
     319        {
     320            psVectorStats (stats, rnd, NULL, NULL, 1);
     321        }
     322        gettimeofday (&mark, NULL);
     323        psF64 delta = DTIME(mark, start);
     324        ok (delta < 0.17, "sample min,max %f,%f (mask: 0, range: 0): %.3f sec", stats->min, stats->max, delta);
     325        psFree (stats);
     326
     327        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     328    }
     329    // test stat min,max (no mask, no range)
     330    {
     331        psMemId id = psMemGetId();
     332
     333        psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX);
     334        psVector *mask = psVectorAlloc (1000, PS_TYPE_U8);
     335        psVectorInit (mask, 0);
     336        mask->data.U8[100] = 1;
     337        mask->data.U8[200] = 1;
     338        mask->data.U8[300] = 1;
     339
     340        gettimeofday (&start, NULL);
     341        for (int i = 0; i < 10000; i++)
     342        {
     343            psVectorStats (stats, rnd, NULL, mask, 1);
     344        }
     345        gettimeofday (&mark, NULL);
     346        psF64 delta = DTIME(mark, start);
     347        ok (delta < 0.18, "sample min,max %f,%f (mask: 1, range: 0): %.3f sec", stats->min, stats->max, delta);
     348        psFree (stats);
     349        psFree (mask);
     350
     351        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     352    }
     353    // test stat min,max (no mask, no range)
     354    {
     355        psMemId id = psMemGetId();
     356
     357        psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX | PS_STAT_USE_RANGE);
     358        stats->min = -10;
     359        stats->max = +10;
     360
     361        gettimeofday (&start, NULL);
     362        for (int i = 0; i < 10000; i++)
     363        {
     364            psVectorStats (stats, rnd, NULL, NULL, 1);
     365        }
     366        gettimeofday (&mark, NULL);
     367        psF64 delta = DTIME(mark, start);
     368        ok (delta < 0.22, "sample min,max %f,%f (mask: 0, range: 1): %.3f sec", stats->min, stats->max, delta);
     369        psFree (stats);
     370
     371        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     372    }
     373    // test stat min,max (no mask, no range)
     374    {
     375        psMemId id = psMemGetId();
     376
     377        psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX | PS_STAT_USE_RANGE);
     378        stats->min = -10;
     379        stats->max = +10;
     380        psVector *mask = psVectorAlloc (1000, PS_TYPE_U8);
     381        psVectorInit (mask, 0);
     382        mask->data.U8[100] = 1;
     383        mask->data.U8[200] = 1;
     384        mask->data.U8[300] = 1;
     385
     386        gettimeofday (&start, NULL);
     387        for (int i = 0; i < 10000; i++)
     388        {
     389            psVectorStats (stats, rnd, NULL, mask, 1);
     390        }
     391        gettimeofday (&mark, NULL);
     392        psF64 delta = DTIME(mark, start);
     393        ok (delta < 0.26, "sample min,max %f,%f (mask: 1, range: 1): %.3f sec", stats->min, stats->max, delta);
     394        psFree (stats);
     395        psFree (mask);
     396
     397        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     398    }
     399
     400    diag ("timing for clipped stats");
     401    /********** CLIPPED STATS ***********/
     402    {
     403        psMemId id = psMemGetId();
     404
     405        psStats *stats = psStatsAlloc (PS_STAT_CLIPPED_MEAN | PS_STAT_CLIPPED_STDEV);
     406        psVector *rnd2 = psVectorAlloc (1000, PS_TYPE_F32);
     407        for (int i = 0; i < rnd2->n; i++)
     408        {
     409            rnd2->data.F32[i] = psRandomGaussian (seed);
     410        }
     411
     412        gettimeofday (&start, NULL);
     413        for (int i = 0; i < 1000; i++)
     414        {
     415            psVectorStats (stats, rnd2, NULL, NULL, 1);
     416        }
     417        gettimeofday (&mark, NULL);
     418        psF64 delta = DTIME(mark, start);
     419        ok (delta < 0.3, "clipped mean %f, stdev %f (mask: 0, range: 0): %.3f sec (1000 pts / 1000 loops)", stats->clippedMean, stats->clippedStdev, delta);
     420        psFree (stats);
     421        psFree (rnd2);
     422
     423        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     424    }
     425    {
     426        psMemId id = psMemGetId();
     427
     428        psStats *stats = psStatsAlloc (PS_STAT_CLIPPED_MEAN | PS_STAT_CLIPPED_STDEV);
     429        psVector *rnd2 = psVectorAlloc (3000, PS_TYPE_F32);
     430        for (int i = 0; i < rnd2->n; i++)
     431        {
     432            rnd2->data.F32[i] = psRandomGaussian (seed);
     433        }
     434
     435        gettimeofday (&start, NULL);
     436        for (int i = 0; i < 1000; i++)
     437        {
     438            psVectorStats (stats, rnd2, NULL, NULL, 1);
     439        }
     440        gettimeofday (&mark, NULL);
     441        psF64 delta = DTIME(mark, start);
     442        ok (delta < 0.5, "clipped mean %f, stdev %f (mask: 0, range: 0): %.3f sec (3000 pts / 1000 loops)", stats->clippedMean, stats->clippedStdev, delta);
     443        psFree (stats);
     444        psFree (rnd2);
     445
     446        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     447    }
     448    {
     449        psMemId id = psMemGetId();
     450
     451        psStats *stats = psStatsAlloc (PS_STAT_CLIPPED_MEAN | PS_STAT_CLIPPED_STDEV);
     452        psVector *rnd2 = psVectorAlloc (10000, PS_TYPE_F32);
     453        for (int i = 0; i < rnd2->n; i++)
     454        {
     455            rnd2->data.F32[i] = psRandomGaussian (seed);
     456        }
     457
     458        gettimeofday (&start, NULL);
     459        for (int i = 0; i < 1000; i++)
     460        {
     461            psVectorStats (stats, rnd2, NULL, NULL, 1);
     462        }
     463        gettimeofday (&mark, NULL);
     464        psF64 delta = DTIME(mark, start);
     465        ok (delta < 1.2, "clipped mean %f, stdev %f (mask: 0, range: 0): %.3f sec (10000 pts / 1000 loops)", stats->clippedMean, stats->clippedStdev, delta);
     466        psFree (stats);
     467        psFree (rnd2);
     468
     469        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     470    }
     471
     472    diag ("timing for robust stats");
     473    /********** ROBUST STATS ***********/
     474    {
     475        psMemId id = psMemGetId();
     476
     477        psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE);
     478        psVector *rnd2 = psVectorAlloc (1000, PS_TYPE_F32);
     479        for (int i = 0; i < rnd2->n; i++)
     480        {
     481            rnd2->data.F32[i] = psRandomGaussian (seed);
     482        }
     483
     484        gettimeofday (&start, NULL);
     485        for (int i = 0; i < 1000; i++)
     486        {
     487            psVectorStats (stats, rnd2, NULL, NULL, 1);
     488        }
     489        gettimeofday (&mark, NULL);
     490        psF64 delta = DTIME(mark, start);
     491        ok (delta < 0.3, "robust mean %f, stdev %f (mask: 0, range: 0): %.3f sec (1000 pts / 1000 loops)", stats->robustMedian, stats->robustStdev, delta);
     492        psFree (stats);
     493        psFree (rnd2);
     494
     495        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     496    }
     497    {
     498        psMemId id = psMemGetId();
     499
     500        psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE);
     501        psVector *rnd2 = psVectorAlloc (3000, PS_TYPE_F32);
     502        for (int i = 0; i < rnd2->n; i++)
     503        {
     504            rnd2->data.F32[i] = psRandomGaussian (seed);
     505        }
     506
     507        gettimeofday (&start, NULL);
     508        for (int i = 0; i < 1000; i++)
     509        {
     510            psVectorStats (stats, rnd2, NULL, NULL, 1);
     511        }
     512        gettimeofday (&mark, NULL);
     513        psF64 delta = DTIME(mark, start);
     514        ok (delta < 0.5, "robust mean %f, stdev %f (mask: 0, range: 0): %.3f sec (3000 pts / 1000 loops)", stats->robustMedian, stats->robustStdev, delta);
     515        psFree (stats);
     516        psFree (rnd2);
     517
     518        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     519    }
     520    {
     521        psMemId id = psMemGetId();
     522
     523        psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE);
     524        psVector *rnd2 = psVectorAlloc (10000, PS_TYPE_F32);
     525        for (int i = 0; i < rnd2->n; i++)
     526        {
     527            rnd2->data.F32[i] = psRandomGaussian (seed);
     528        }
     529
     530        gettimeofday (&start, NULL);
     531        for (int i = 0; i < 1000; i++)
     532        {
     533            psVectorStats (stats, rnd2, NULL, NULL, 1);
     534        }
     535        gettimeofday (&mark, NULL);
     536        psF64 delta = DTIME(mark, start);
     537        ok (delta < 1.2, "robust mean %f, stdev %f (mask: 0, range: 0): %.3f sec (10000 pts / 1000 loops)", stats->robustMedian, stats->robustStdev, delta);
     538        psFree (stats);
     539        psFree (rnd2);
     540
     541        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     542    }
     543
     544    diag ("timing for fitted stats");
     545    /********** FITTED TIMING ***********/
     546    {
     547        psMemId id = psMemGetId();
    32548
    33549        psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV);
    … …  
    38554        }
    39555
    40         psTimerClear ("test");
    41         for (int i = 0; i < 1000; i++)
    42         {
    43             psVectorStats (stats, rnd2, NULL, NULL, 1);
    44         }
    45         psF64 delta = psTimerMark("test");
    46         ok (delta < 0.5, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec", stats->fittedMean, stats->fittedStdev, delta);
    47         psFree (stats);
    48 
    49         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    50     }
    51     // test FITTED timing
    52     {
    53         // psMemId id = psMemGetId();
    54 
    55         diag ("check fitted mean speed : 3000 pts / 1000 loops");
     556        gettimeofday (&start, NULL);
     557        for (int i = 0; i < 1000; i++)
     558        {
     559            psVectorStats (stats, rnd2, NULL, NULL, 1);
     560
     561        }
     562        gettimeofday (&mark, NULL);
     563        psF64 delta = DTIME(mark, start);
     564        ok (delta < 0.7, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec (1000 pts / 1000 loops)", stats->fittedMean, stats->fittedStdev, delta);
     565        psFree (stats);
     566        psFree (rnd2);
     567
     568        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     569    }
     570    {
     571        psMemId id = psMemGetId();
    56572
    57573        psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV);
    … …  
    62578        }
    63579
    64         psTimerClear ("test");
    65         for (int i = 0; i < 1000; i++)
    66         {
    67             psVectorStats (stats, rnd2, NULL, NULL, 1);
    68         }
    69         psF64 delta = psTimerMark("test");
    70         ok (delta < 0.8, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec", stats->fittedMean, stats->fittedStdev, delta);
    71         psFree (stats);
    72 
    73         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    74     }
    75     // test FITTED timing
    76     {
    77         // psMemId id = psMemGetId();
    78 
    79         diag ("check fitted mean speed : 10000 pts / 1000 loops");
     580        gettimeofday (&start, NULL);
     581        for (int i = 0; i < 1000; i++)
     582        {
     583            psVectorStats (stats, rnd2, NULL, NULL, 1);
     584        }
     585        gettimeofday (&mark, NULL);
     586        psF64 delta = DTIME(mark, start);
     587        ok (delta < 0.8, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec (3000 pts / 1000 loops)", stats->fittedMean, stats->fittedStdev, delta);
     588        psFree (stats);
     589        psFree (rnd2);
     590
     591        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     592    }
     593    {
     594        psMemId id = psMemGetId();
    80595
    81596        psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV);
    … …  
    86601        }
    87602
    88         psTimerClear ("test");
    89         for (int i = 0; i < 1000; i++)
    90         {
    91             psVectorStats (stats, rnd2, NULL, NULL, 1);
    92         }
    93         psF64 delta = psTimerMark("test");
    94         ok (delta < 2.2, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec", stats->fittedMean, stats->fittedStdev, delta);
    95         psFree (stats);
    96 
    97         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    98     }
    99     // test stat min,max (no mask, no range)
    100     {
    101         // psMemId id = psMemGetId();
    102 
    103         diag ("check fitted mean speed (and value)");
    104 
    105         psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV | PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV);
    106         psVector *sample = psVectorAlloc (1000, PS_TYPE_F32);
    107         psVector *fitted = psVectorAlloc (1000, PS_TYPE_F32);
    108 
    109         for (int i = 0; i < 1000; i++)
    110         {
    111             // generate a new sample
    112             for (int j = 0; j < rnd->n; j++) {
    113                 rnd->data.F32[j] = psRandomGaussian (seed);
    114             }
    115             // measure the stats
    116             psVectorStats (stats, rnd, NULL, NULL, 1);
    117             sample->data.F32[i] = stats->sampleMean;
    118             fitted->data.F32[i] = stats->fittedMean;
    119         }
    120         psFree (stats);
    121 
    122         stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV);
    123         psVectorStats (stats, sample, NULL, NULL, 1);
    124         ok (stats->sampleStdev < 2/sqrt(1000), "sample mean %f, stdev %f", stats->sampleMean, stats->sampleStdev);
    125         psVectorStats (stats, fitted, NULL, NULL, 1);
    126         ok (stats->sampleStdev < 2/sqrt(1000), "fitted mean %f, stdev %f", stats->sampleMean, stats->sampleStdev);
    127         psFree (stats);
    128 
    129         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    130     }
    131 
    132     /********** robust stats ***********/
    133     // test ROBUST timing
    134     {
    135         // psMemId id = psMemGetId();
    136 
    137         diag ("check robust mean speed : 1000 pts / 1000 loops");
    138 
    139         psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE);
     603        gettimeofday (&start, NULL);
     604        for (int i = 0; i < 1000; i++)
     605        {
     606            psVectorStats (stats, rnd2, NULL, NULL, 1);
     607        }
     608        gettimeofday (&mark, NULL);
     609        psF64 delta = DTIME(mark, start);
     610        ok (delta < 2.2, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec (10000 pts / 1000 loops)", stats->fittedMean, stats->fittedStdev, delta);
     611        psFree (stats);
     612        psFree (rnd2);
     613
     614        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     615    }
     616
     617    diag ("timing for fitted (v2) stats");
     618    /********** FITTED (v2) TIMING ***********/
     619    {
     620        psMemId id = psMemGetId();
     621
     622        psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2);
    140623        psVector *rnd2 = psVectorAlloc (1000, PS_TYPE_F32);
    141624        for (int i = 0; i < rnd2->n; i++)
    … …  
    144627        }
    145628
    146         psTimerClear ("test");
    147         for (int i = 0; i < 1000; i++)
    148         {
    149             psVectorStats (stats, rnd2, NULL, NULL, 1);
    150         }
    151         psF64 delta = psTimerMark("test");
    152         ok (delta < 0.2, "robust mean %f, stdev %f (mask: 0, range: 0): %.3f sec", stats->robustMedian, stats->robustStdev, delta);
    153         psFree (stats);
    154 
    155         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    156     }
    157     // test ROBUST timing
    158     {
    159         // psMemId id = psMemGetId();
    160 
    161         diag ("check robust mean speed : 3000 pts / 1000 loops");
    162 
    163         psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE);
     629        gettimeofday (&start, NULL);
     630        for (int i = 0; i < 1000; i++)
     631        {
     632            psVectorStats (stats, rnd2, NULL, NULL, 1);
     633
     634        }
     635        gettimeofday (&mark, NULL);
     636        psF64 delta = DTIME(mark, start);
     637        ok (delta < 0.7, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec (1000 pts / 1000 loops)", stats->fittedMean, stats->fittedStdev, delta);
     638        psFree (stats);
     639        psFree (rnd2);
     640
     641        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     642    }
     643    {
     644        psMemId id = psMemGetId();
     645
     646        psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2);
    164647        psVector *rnd2 = psVectorAlloc (3000, PS_TYPE_F32);
    165648        for (int i = 0; i < rnd2->n; i++)
    … …  
    168651        }
    169652
    170         psTimerClear ("test");
    171         for (int i = 0; i < 1000; i++)
    172         {
    173             psVectorStats (stats, rnd2, NULL, NULL, 1);
    174         }
    175         psF64 delta = psTimerMark("test");
    176         ok (delta < 0.5, "robust mean %f, stdev %f (mask: 0, range: 0): %.3f sec", stats->robustMedian, stats->robustStdev, delta);
    177         psFree (stats);
    178 
    179         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    180     }
    181     // test ROBUST timing
    182     {
    183         // psMemId id = psMemGetId();
    184 
    185         diag ("check robust mean speed : 10000 pts / 1000 loops");
    186 
    187         psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE);
     653        gettimeofday (&start, NULL);
     654        for (int i = 0; i < 1000; i++)
     655        {
     656            psVectorStats (stats, rnd2, NULL, NULL, 1);
     657        }
     658        gettimeofday (&mark, NULL);
     659        psF64 delta = DTIME(mark, start);
     660        ok (delta < 0.8, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec (3000 pts / 1000 loops)", stats->fittedMean, stats->fittedStdev, delta);
     661        psFree (stats);
     662        psFree (rnd2);
     663
     664        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     665    }
     666    {
     667        psMemId id = psMemGetId();
     668
     669        psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2);
    188670        psVector *rnd2 = psVectorAlloc (10000, PS_TYPE_F32);
    189671        for (int i = 0; i < rnd2->n; i++)
    … …  
    192674        }
    193675
    194         psTimerClear ("test");
    195         for (int i = 0; i < 1000; i++)
    196         {
    197             psVectorStats (stats, rnd2, NULL, NULL, 1);
    198         }
    199         psF64 delta = psTimerMark("test");
    200         ok (delta < 1.2, "robust mean %f, stdev %f (mask: 0, range: 0): %.3f sec", stats->robustMedian, stats->robustStdev, delta);
    201         psFree (stats);
    202 
    203         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    204     }
    205     // test stat min,max (no mask, no range)
    206     {
    207         // psMemId id = psMemGetId();
    208 
    209         diag ("check robust mean speed (and value)");
    210 
    211         psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV);
     676        gettimeofday (&start, NULL);
     677        for (int i = 0; i < 1000; i++)
     678        {
     679            psVectorStats (stats, rnd2, NULL, NULL, 1);
     680        }
     681        gettimeofday (&mark, NULL);
     682        psF64 delta = DTIME(mark, start);
     683        ok (delta < 2.2, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec (10000 pts / 1000 loops)", stats->fittedMean, stats->fittedStdev, delta);
     684        psFree (stats);
     685        psFree (rnd2);
     686
     687        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     688    }
     689
     690    diag ("compare sample, robust, and fitted mean and stdev to theoretical");
     691    // compare SAMPLE, FITTED, ROBUST mean to theoretical
     692    {
     693        psMemId id = psMemGetId();
     694
     695        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV | PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV);
    212696        psVector *sample = psVectorAlloc (1000, PS_TYPE_F32);
    213697        psVector *robust = psVectorAlloc (1000, PS_TYPE_F32);
     698        psVector *fitted = psVectorAlloc (1000, PS_TYPE_F32);
    214699
    215700        for (int i = 0; i < 1000; i++)
    … …  
    223708            sample->data.F32[i] = stats->sampleMean;
    224709            robust->data.F32[i] = stats->robustMedian;
     710            fitted->data.F32[i] = stats->fittedMean;
    225711        }
    226712        psFree (stats);
    … …  
    228714        stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV);
    229715        psVectorStats (stats, sample, NULL, NULL, 1);
    230         ok (stats->sampleStdev < 2/sqrt(1000), "sample mean %f, stdev %f", stats->sampleMean, stats->sampleStdev);
     716        ok (stats->sampleStdev < 2/sqrt(1000), "sample mean %f, stdev %f (1000 tries)", stats->sampleMean, stats->sampleStdev);
    231717        psVectorStats (stats, robust, NULL, NULL, 1);
    232         ok (stats->sampleStdev < 2/sqrt(1000), "robust mean %f, stdev %f", stats->sampleMean, stats->sampleStdev);
    233         psFree (stats);
    234 
    235         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    236     }
    237 
    238     /**********  stats ***********/
    239     // test stat sample mean (no mask, no range)
    240     {
    241         // psMemId id = psMemGetId();
    242 
    243         diag ("check sample mean speed (and value)");
    244 
    245         psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN);
    246 
    247         psTimerClear ("test");
    248         for (int i = 0; i < 10000; i++)
    249         {
    250             psVectorStats (stats, rnd, NULL, NULL, 0);
    251         }
    252         psF64 delta = psTimerMark("test");
    253         ok (delta < 0.1, "sample mean %f (mask: 0, range: 0): %.3f sec", stats->sampleMean, delta);
    254         psFree (stats);
    255 
    256         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    257     }
    258 
    259     // test stat sample mean (mask, no range)
    260     {
    261         // psMemId id = psMemGetId();
    262 
    263         diag ("check sample mean speed (and value)");
    264 
    265         psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN);
    266         psVector *mask = psVectorAlloc (1000, PS_TYPE_U8);
    267         psVectorInit (mask, 0);
    268         mask->data.U8[100] = 1;
    269         mask->data.U8[200] = 1;
    270         mask->data.U8[300] = 1;
    271 
    272         psTimerClear ("test");
    273         for (int i = 0; i < 10000; i++)
    274         {
    275             psVectorStats (stats, rnd, NULL, mask, 1);
    276         }
    277         psF64 delta = psTimerMark("test");
    278         ok (delta < 0.12, "sample mean %f (mask: 1, range: 0): %.3f sec", stats->sampleMean, delta);
    279         psFree (stats);
    280 
    281         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    282     }
    283 
    284     // test stat sample mean (no mask, range)
    285     {
    286         // psMemId id = psMemGetId();
    287 
    288         diag ("check sample mean speed (and value)");
    289 
    290         psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_USE_RANGE);
    291         stats->min = -10;
    292         stats->max = +10;
    293 
    294         psTimerClear ("test");
    295         for (int i = 0; i < 10000; i++)
    296         {
    297             psVectorStats (stats, rnd, NULL, NULL, 0);
    298         }
    299         psF64 delta = psTimerMark("test");
    300         ok (delta < 0.18, "sample mean %f (mask: 0, range: 1): %.3f sec", stats->sampleMean, delta);
    301         psFree (stats);
    302 
    303         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    304     }
    305 
    306     // test stat sample mean (mask, range)
    307     {
    308         // psMemId id = psMemGetId();
    309 
    310         diag ("check sample mean speed (and value)");
    311 
    312         psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_USE_RANGE);
    313         stats->min = -10;
    314         stats->max = +10;
    315         psVector *mask = psVectorAlloc (1000, PS_TYPE_U8);
    316         psVectorInit (mask, 0);
    317         mask->data.U8[100] = 1;
    318         mask->data.U8[200] = 1;
    319         mask->data.U8[300] = 1;
    320 
    321         psTimerClear ("test");
    322         for (int i = 0; i < 10000; i++)
    323         {
    324             psVectorStats (stats, rnd, NULL, mask, 1);
    325         }
    326         psF64 delta = psTimerMark("test");
    327         ok (delta < 0.2, "sample mean %f (mask: 1, range: 1): %.3f sec", stats->sampleMean, delta);
    328         psFree (stats);
    329 
    330         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    331     }
    332 
    333     /*************** min,max ******************/
    334     // test stat min,max (no mask, no range)
    335     {
    336         // psMemId id = psMemGetId();
    337 
    338         diag ("check min,max speed (no mask, no range)");
    339 
    340         psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX);
    341         psTimerClear ("test");
    342         for (int i = 0; i < 10000; i++)
    343         {
     718        ok (stats->sampleStdev < 2/sqrt(1000), "robust mean %f, stdev %f (1000 tries)", stats->sampleMean, stats->sampleStdev);
     719        psVectorStats (stats, fitted, NULL, NULL, 1);
     720        ok (stats->sampleStdev < 2/sqrt(1000), "fitted mean %f, stdev %f (1000 tries)", stats->sampleMean, stats->sampleStdev);
     721        psFree (stats);
     722        psFree (sample);
     723        psFree (robust);
     724        psFree (fitted);
     725
     726        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     727    }
     728
     729    diag ("compare sample, robust, and fitted mean and stdev to theoretical");
     730    // compare SAMPLE, FITTED_V2, ROBUST mean to theoretical
     731    {
     732        psMemId id = psMemGetId();
     733
     734        psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV | PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2);
     735        psVector *sample = psVectorAlloc (1000, PS_TYPE_F32);
     736        psVector *robust = psVectorAlloc (1000, PS_TYPE_F32);
     737        psVector *fitted = psVectorAlloc (1000, PS_TYPE_F32);
     738
     739        for (int i = 0; i < 1000; i++)
     740        {
     741            // generate a new sample
     742            for (int j = 0; j < rnd->n; j++) {
     743                rnd->data.F32[j] = psRandomGaussian (seed);
     744            }
     745            // measure the stats
    344746            psVectorStats (stats, rnd, NULL, NULL, 1);
    345         }
    346         psF64 delta = psTimerMark("test");
    347         ok (delta < 0.17, "sample min,max %f,%f (mask: 0, range: 0): %.3f sec", stats->min, stats->max, delta);
    348         psFree (stats);
    349 
    350         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    351     }
    352     // test stat min,max (no mask, no range)
    353     {
    354         // psMemId id = psMemGetId();
    355 
    356         diag ("check min,max speed (mask, no range)");
    357 
    358         psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX);
    359         psVector *mask = psVectorAlloc (1000, PS_TYPE_U8);
    360         psVectorInit (mask, 0);
    361         mask->data.U8[100] = 1;
    362         mask->data.U8[200] = 1;
    363         mask->data.U8[300] = 1;
    364 
    365         psTimerClear ("test");
    366         for (int i = 0; i < 10000; i++)
    367         {
    368             psVectorStats (stats, rnd, NULL, mask, 1);
    369         }
    370         psF64 delta = psTimerMark("test");
    371         ok (delta < 0.18, "sample min,max %f,%f (mask: 1, range: 0): %.3f sec", stats->min, stats->max, delta);
    372         psFree (stats);
    373 
    374         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    375     }
    376     // test stat min,max (no mask, no range)
    377     {
    378         // psMemId id = psMemGetId();
    379 
    380         diag ("check min,max speed (no mask, range)");
    381 
    382         psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX | PS_STAT_USE_RANGE);
    383         stats->min = -10;
    384         stats->max = +10;
    385 
    386         psTimerClear ("test");
    387         for (int i = 0; i < 10000; i++)
    388         {
    389             psVectorStats (stats, rnd, NULL, NULL, 1);
    390         }
    391         psF64 delta = psTimerMark("test");
    392         ok (delta < 0.22, "sample min,max %f,%f (mask: 0, range: 1): %.3f sec", stats->min, stats->max, delta);
    393         psFree (stats);
    394 
    395         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    396     }
    397     // test stat min,max (no mask, no range)
    398     {
    399         // psMemId id = psMemGetId();
    400 
    401         diag ("check min,max speed (mask, range)");
    402 
    403         psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX | PS_STAT_USE_RANGE);
    404         stats->min = -10;
    405         stats->max = +10;
    406         psVector *mask = psVectorAlloc (1000, PS_TYPE_U8);
    407         psVectorInit (mask, 0);
    408         mask->data.U8[100] = 1;
    409         mask->data.U8[200] = 1;
    410         mask->data.U8[300] = 1;
    411 
    412         psTimerClear ("test");
    413         for (int i = 0; i < 10000; i++)
    414         {
    415             psVectorStats (stats, rnd, NULL, mask, 1);
    416         }
    417         psF64 delta = psTimerMark("test");
    418         ok (delta < 0.26, "sample min,max %f,%f (mask: 1, range: 1): %.3f sec", stats->min, stats->max, delta);
    419         psFree (stats);
    420 
    421         // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     747            sample->data.F32[i] = stats->sampleMean;
     748            robust->data.F32[i] = stats->robustMedian;
     749            fitted->data.F32[i] = stats->fittedMean;
     750        }
     751        psFree (stats);
     752
     753        stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV);
     754        psVectorStats (stats, sample, NULL, NULL, 1);
     755        ok (stats->sampleStdev < 2/sqrt(1000), "sample mean %f, stdev %f (1000 tries)", stats->sampleMean, stats->sampleStdev);
     756        psVectorStats (stats, robust, NULL, NULL, 1);
     757        ok (stats->sampleStdev < 2/sqrt(1000), "robust mean %f, stdev %f (1000 tries)", stats->sampleMean, stats->sampleStdev);
     758        psVectorStats (stats, fitted, NULL, NULL, 1);
     759        ok (stats->sampleStdev < 2/sqrt(1000), "fitted mean %f, stdev %f (1000 tries)", stats->sampleMean, stats->sampleStdev);
     760        psFree (stats);
     761        psFree (sample);
     762        psFree (robust);
     763        psFree (fitted);
     764
     765        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    422766    }
    423767

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

    r10395 r10550  
    215215                         };
    216216
     217static float yraw_03[] = {
     218                             183.6000061, 171.3600006, 182.5800018, 178.5, 176.4600067,
     219                             176.4600067, 171.3600006, 178.5, 183.6000061, 175.4400024,
     220                             159.1199951, 180.5399933, 183.6000061, 187.6799927, 175.4400024,
     221                             181.5599976, 174.4199982, 179.5200043, 180.5399933, 187.6799927,
     222                             183.6000061, 171.3600006, 177.4799957, 192.7799988, 184.6199951,
     223                             176.4600067, 178.5, 182.5800018, 173.3999939, 191.7599945,
     224                             202.9799957, 167.2799988, 181.5599976, 185.6399994, 173.3999939,
     225                             159.1199951, 178.5, 188.6999969, 179.5200043, 178.5,
     226                             184.6199951, 175.4400024, 186.6600037, 179.5200043, 183.6000061,
     227                             182.5800018, 173.3999939, 181.5599976, 184.6199951, 177.4799957,
     228                             162.1799927, 186.6600037, 163.1999969, 199.9199982, 173.3999939,
     229                             170.3399963, 184.6199951, 190.7400055, 173.3999939, 178.5,
     230                             189.7200012, 192.7799988, 166.2599945, 187.6799927, 174.4199982,
     231                             176.4600067, 181.5599976, 199.9199982, 193.8000031, 170.3399963,
     232                             182.5800018, 199.9199982, 183.6000061, 160.1399994, 184.6199951,
     233                             195.8399963, 173.3999939, 189.7200012, 192.7799988, 162.1799927,
     234                             174.4199982, 190.7400055, 175.4400024, 192.7799988, 181.5599976,
     235                             185.6399994, 184.6199951, 166.2599945, 189.7200012, 192.7799988,
     236                             183.6000061, 190.7400055, 188.6999969, 174.4199982, 184.6199951,
     237                             186.6600037, 182.5800018, 173.3999939, 171.3600006, 166.2599945,
     238                             166.2599945, 176.4600067, 147.8999939, 187.6799927, 166.2599945,
     239                             173.3999939, 179.5200043, 166.2599945, 169.3200073, 172.3800049,
     240                             174.4199982, 195.8399963, 192.7799988, 177.4799957, 181.5599976,
     241                             163.1999969, 171.3600006, 194.8200073, 159.1199951, 173.3999939,
     242                             182.5800018, 178.5, 179.5200043, 184.6199951, 179.5200043,
     243                             164.2200012, 191.7599945, 177.4799957, 186.6600037, 168.3000031,
     244                             168.3000031, 168.3000031, 180.5399933, 179.5200043, 175.4400024,
     245                             174.4199982, 184.6199951, 186.6600037, 164.2200012, 169.3200073,
     246                             187.6799927, 189.7200012, 166.2599945, 169.3200073, 187.6799927,
     247                             172.3800049, 204, 194.8200073, 177.4799957, 188.6999969,
     248                             171.3600006, 184.6199951, 182.5800018, 184.6199951, 176.4600067,
     249                             186.6600037, 170.3399963, 170.3399963, 182.5800018, 184.6199951,
     250                             168.3000031, 175.4400024, 176.4600067, 164.2200012, 183.6000061,
     251                             161.1600037, 175.4400024, 167.2799988, 179.5200043, 176.4600067,
     252                             175.4400024, 179.5200043, 158.1000061, 168.3000031, 168.3000031,
     253                             179.5200043, 192.7799988, 190.7400055, 178.5, 173.3999939,
     254                             180.5399933, 179.5200043, 191.7599945, 184.6199951, 177.4799957,
     255                             182.5800018, 188.6999969, 169.3200073, 162.1799927, 172.3800049,
     256                             160.1399994, 177.4799957, 176.4600067, 180.5399933, 170.3399963,
     257                             168.3000031, 171.3600006, 180.5399933, 162.1799927, 163.1999969,
     258                             170.3399963, 180.5399933, 164.2200012, 183.6000061, 178.5,
     259                             193.8000031, 177.4799957, 178.5, 183.6000061, 192.7799988,
     260                             157.0800018, 176.4600067, 190.7400055, 179.5200043, 157.0800018,
     261                             178.5, 165.2400055, 195.8399963, 177.4799957, 166.2599945,
     262                             172.3800049, 182.5800018, 175.4400024, 187.6799927, 164.2200012,
     263                             178.5, 173.3999939, 173.3999939, 173.3999939, 172.3800049,
     264                             183.6000061, 181.5599976, 163.1999969, 179.5200043, 193.8000031,
     265                             172.3800049, 158.1000061, 171.3600006, 165.2400055, 183.6000061,
     266                             187.6799927, 158.1000061, 171.3600006, 168.3000031, 166.2599945,
     267                             166.2599945, 178.5, 179.5200043, 165.2400055, 176.4600067,
     268                             160.1399994, 193.8000031, 170.3399963, 162.1799927, 180.5399933,
     269                             159.1199951, 189.7200012, 160.1399994, 196.8600006, 173.3999939,
     270                             170.3399963, 165.2400055, 193.8000031, 192.7799988, 184.6199951,
     271                             151.9799957, 167.2799988, 162.1799927, 183.6000061, 166.2599945,
     272                             177.4799957, 168.3000031, 191.7599945, 181.5599976, 166.2599945,
     273                             171.3600006, 188.6999969, 172.3800049, 195.8399963, 189.7200012,
     274                             177.4799957, 167.2799988, 191.7599945, 169.3200073, 181.5599976,
     275                             180.5399933, 162.1799927, 171.3600006, 162.1799927, 171.3600006,
     276                             177.4799957, 167.2799988, 180.5399933, 182.5800018, 187.6799927,
     277                             175.4400024, 193.8000031, 174.4199982, 183.6000061, 179.5200043,
     278                             164.2200012, 162.1799927, 186.6600037, 189.7200012, 186.6600037,
     279                             171.3600006, 187.6799927, 189.7200012, 175.4400024, 184.6199951,
     280                             172.3800049, 177.4799957, 183.6000061, 176.4600067, 171.3600006,
     281                             172.3800049, 181.5599976, 175.4400024, 170.3399963, 196.8600006,
     282                             201.9600067, 180.5399933, 176.4600067, 183.6000061, 175.4400024,
     283                             184.6199951, 163.1999969, 177.4799957, 176.4600067, 175.4400024,
     284                             192.7799988, 167.2799988, 176.4600067, 184.6199951, 184.6199951,
     285                             177.4799957, 185.6399994, 196.8600006, 186.6600037, 184.6199951,
     286                             169.3200073, 164.2200012, 185.6399994, 168.3000031, 186.6600037,
     287                             180.5399933, 177.4799957, 177.4799957, 186.6600037, 191.7599945,
     288                             177.4799957, 181.5599976, 166.2599945, 179.5200043, 184.6199951,
     289                             178.5, 171.3600006, 184.6199951, 192.7799988, 182.5800018,
     290                             186.6600037, 175.4400024, 182.5800018, 173.3999939, 186.6600037,
     291                             162.1799927, 175.4400024, 196.8600006, 166.2599945, 189.7200012,
     292                             189.7200012, 182.5800018, 172.3800049, 165.2400055, 191.7599945,
     293                             174.4199982, 173.3999939, 178.5, 171.3600006, 157.0800018,
     294                             182.5800018, 161.1600037, 195.8399963, 186.6600037, 167.2799988,
     295                             166.2599945, 182.5800018, 178.5, 176.4600067, 181.5599976,
     296                             184.6199951, 183.6000061, 179.5200043, 174.4199982, 167.2799988,
     297                             187.6799927, 176.4600067, 165.2400055, 179.5200043, 157.0800018,
     298                             171.3600006, 170.3399963, 175.4400024, 161.1600037, 185.6399994,
     299                             169.3200073, 192.7799988, 175.4400024, 172.3800049, 180.5399933,
     300                             183.6000061, 174.4199982, 176.4600067, 164.2200012, 183.6000061,
     301                             179.5200043, 165.2400055, 169.3200073, 172.3800049, 149.9400024,
     302                             175.4400024, 188.6999969, 190.7400055, 171.3600006, 172.3800049,
     303                             183.6000061, 178.5, 165.2400055, 176.4600067, 177.4799957,
     304                             188.6999969, 192.7799988, 183.6000061, 163.1999969, 186.6600037,
     305                             183.6000061, 160.1399994, 167.2799988, 172.3800049, 179.5200043,
     306                             189.7200012, 172.3800049, 177.4799957, 161.1600037, 174.4199982,
     307                             190.7400055, 181.5599976, 187.6799927, 176.4600067, 176.4600067,
     308                             183.6000061, 176.4600067, 188.6999969, 174.4199982, 170.3399963,
     309                             185.6399994, 177.4799957, 172.3800049, 179.5200043, 175.4400024,
     310                             170.3399963, 169.3200073, 176.4600067, 177.4799957, 169.3200073,
     311                             199.9199982, 171.3600006, 194.8200073, 188.6999969, 193.8000031,
     312                             182.5800018, 171.3600006, 177.4799957, 175.4400024, 172.3800049,
     313                             166.2599945, 183.6000061, 157.0800018, 177.4799957, 193.8000031,
     314                             168.3000031, 175.4400024, 175.4400024, 170.3399963, 191.7599945,
     315                             189.7200012, 182.5800018, 177.4799957, 157.0800018, 174.4199982,
     316                             189.7200012, 162.1799927, 184.6199951, 164.2200012, 157.0800018,
     317                             197.8800049, 175.4400024, 184.6199951, 202.9799957, 190.7400055,
     318                             171.3600006, 160.1399994, 162.1799927, 176.4600067, 180.5399933,
     319                             206.0399933, 189.7200012, 170.3399963, 175.4400024, 175.4400024,
     320                             185.6399994, 187.6799927, 168.3000031, 176.4600067, 177.4799957,
     321                             185.6399994, 167.2799988, 178.5, 182.5800018, 179.5200043,
     322                             173.3999939, 185.6399994, 196.8600006, 183.6000061, 162.1799927,
     323                             176.4600067, 189.7200012, 208.0800018, 177.4799957, 163.1999969,
     324                             187.6799927, 196.8600006, 180.5399933, 188.6999969, 163.1999969,
     325                             187.6799927, 168.3000031, 182.5800018, 181.5599976, 174.4199982,
     326                             181.5599976, 161.1600037, 163.1999969, 184.6199951, 190.7400055,
     327                             181.5599976, 185.6399994, 186.6600037, 173.3999939, 172.3800049,
     328                             179.5200043, 187.6799927, 191.7599945, 190.7400055, 183.6000061,
     329                             166.2599945, 196.8600006, 172.3800049, 174.4199982, 181.5599976,
     330                             177.4799957, 176.4600067, 188.6999969, 184.6199951, 169.3200073,
     331                             178.5, 186.6600037, 174.4199982, 185.6399994, 201.9600067,
     332                             171.3600006, 177.4799957, 183.6000061, 165.2400055, 189.7200012,
     333                             188.6999969, 178.5, 163.1999969, 169.3200073, 178.5,
     334                             182.5800018, 173.3999939, 177.4799957, 165.2400055, 163.1999969,
     335                             175.4400024, 184.6199951, 189.7200012, 186.6600037, 188.6999969,
     336                             163.1999969, 158.1000061, 172.3800049, 186.6600037, 173.3999939,
     337                             157.0800018, 158.1000061, 172.3800049, 197.8800049, 171.3600006,
     338                             172.3800049, 184.6199951, 173.3999939, 174.4199982, 175.4400024,
     339                             166.2599945, 166.2599945, 172.3800049, 171.3600006, 181.5599976,
     340                             181.5599976, 187.6799927, 180.5399933, 169.3200073, 182.5800018,
     341                             178.5, 179.5200043, 184.6199951, 175.4400024, 175.4400024,
     342                             158.1000061, 182.5800018, 196.8600006, 167.2799988, 178.5,
     343                             174.4199982, 180.5399933, 195.8399963, 183.6000061, 200.9400024,
     344                             189.7200012, 186.6600037, 173.3999939, 173.3999939, 180.5399933,
     345                             172.3800049, 157.0800018, 163.1999969, 171.3600006, 190.7400055,
     346                             196.8600006, 179.5200043, 175.4400024, 169.3200073, 158.1000061,
     347                             157.0800018, 180.5399933, 173.3999939, 170.3399963, 175.4400024,
     348                             193.8000031, 170.3399963, 164.2200012, 174.4199982, 185.6399994,
     349                             178.5, 176.4600067, 176.4600067, 179.5200043, 176.4600067,
     350                             171.3600006, 205.0200043, 184.6199951, 180.5399933, 165.2400055,
     351                             167.2799988, 162.1799927, 165.2400055, 180.5399933, 169.3200073,
     352                             176.4600067, 182.5800018, 182.5800018, 175.4400024, 186.6600037,
     353                             182.5800018, 183.6000061, 163.1999969, 161.1600037, 189.7200012,
     354                             181.5599976, 187.6799927, 173.3999939, 173.3999939, 177.4799957,
     355                             179.5200043, 198.8999939, 177.4799957, 183.6000061, 154.0200043,
     356                             188.6999969, 181.5599976, 177.4799957, 174.4199982, 202.9799957,
     357                             168.3000031, 164.2200012, 187.6799927, 171.3600006, 189.7200012,
     358                             185.6399994, 187.6799927, 157.0800018, 193.8000031, 160.1399994,
     359                             166.2599945, 193.8000031, 166.2599945, 168.3000031, 179.5200043,
     360                             181.5599976, 172.3800049, 183.6000061, 184.6199951, 180.5399933,
     361                             177.4799957, 192.7799988, 171.3600006, 197.8800049, 190.7400055,
     362                             182.5800018, 178.5, 189.7200012, 172.3800049, 199.9199982,
     363                             183.6000061, 179.5200043, 170.3399963, 179.5200043, 181.5599976,
     364                             178.5, 186.6600037, 177.4799957, 160.1399994, 176.4600067,
     365                             173.3999939, 168.3000031, 180.5399933, 179.5200043, 175.4400024,
     366                             188.6999969, 175.4400024, 178.5, 161.1600037, 181.5599976,
     367                             184.6199951, 169.3200073, 187.6799927, 164.2200012, 176.4600067,
     368                             176.4600067, 174.4199982, 189.7200012, 192.7799988, 181.5599976,
     369                             165.2400055, 173.3999939, 184.6199951, 164.2200012, 181.5599976,
     370                             167.2799988, 157.0800018, 175.4400024, 172.3800049, 172.3800049,
     371                             170.3399963, 166.2599945, 185.6399994, 175.4400024, 184.6199951,
     372                             179.5200043, 198.8999939, 189.7200012, 164.2200012, 198.8999939,
     373                             169.3200073, 183.6000061, 191.7599945, 168.3000031, 178.5,
     374                             172.3800049, 169.3200073, 196.8600006, 170.3399963, 192.7799988,
     375                             183.6000061, 186.6600037, 181.5599976, 187.6799927, 198.8999939,
     376                             167.2799988, 177.4799957, 165.2400055, 173.3999939, 182.5800018,
     377                             190.7400055, 167.2799988, 184.6199951, 180.5399933, 165.2400055,
     378                             166.2599945, 162.1799927, 175.4400024, 169.3200073, 187.6799927,
     379                             155.0399933, 173.3999939, 165.2400055, 174.4199982, 183.6000061,
     380                             167.2799988, 186.6600037, 175.4400024, 173.3999939, 177.4799957,
     381                             192.7799988, 180.5399933, 191.7599945, 185.6399994, 194.8200073,
     382                             201.9600067, 166.2599945, 171.3600006, 177.4799957, 194.8200073,
     383                             191.7599945, 177.4799957, 167.2799988, 188.6999969, 172.3800049,
     384                             162.1799927, 169.3200073, 198.8999939, 183.6000061, 170.3399963,
     385                             190.7400055, 170.3399963, 169.3200073, 185.6399994, 181.5599976,
     386                             166.2599945, 187.6799927, 169.3200073, 157.0800018, 165.2400055,
     387                             176.4600067, 174.4199982, 166.2599945, 177.4799957, 195.8399963,
     388                             187.6799927, 186.6600037, 194.8200073, 181.5599976, 172.3800049,
     389                             166.2599945, 168.3000031, 183.6000061, 168.3000031, 174.4199982,
     390                             185.6399994, 180.5399933, 181.5599976, 189.7200012, 172.3800049,
     391                             183.6000061, 187.6799927, 183.6000061, 200.9400024, 184.6199951,
     392                             173.3999939, 176.4600067, 172.3800049, 169.3200073, 166.2599945,
     393                             186.6600037, 181.5599976, 161.1600037, 182.5800018, 179.5200043,
     394                             178.5, 174.4199982, 170.3399963, 179.5200043, 193.8000031,
     395                             188.6999969, 146.8800049, 192.7799988, 171.3600006, 178.5,
     396                             177.4799957, 184.6199951, 180.5399933, 163.1999969, 159.1199951,
     397                             160.1399994, 178.5, 176.4600067, 176.4600067, 192.7799988,
     398                             161.1600037, 166.2599945, 162.1799927, 172.3800049, 175.4400024,
     399                             168.3000031, 201.9600067, 188.6999969, 185.6399994, 175.4400024,
     400                             175.4400024, 182.5800018, 182.5800018, 172.3800049, 175.4400024,
     401                             179.5200043, 184.6199951, 163.1999969, 195.8399963, 180.5399933,
     402                             170.3399963, 212.1600037, 166.2599945, 187.6799927, 179.5200043,
     403                             178.5, 176.4600067, 172.3800049, 183.6000061, 179.5200043,
     404                             176.4600067, 185.6399994, 161.1600037, 187.6799927, 167.2799988,
     405                             187.6799927, 199.9199982, 187.6799927, 169.3200073, 158.1000061,
     406                             200.9400024, 191.7599945, 179.5200043, 170.3399963, 186.6600037,
     407                             170.3399963, 184.6199951, 189.7200012, 197.8800049, 186.6600037,
     408                             171.3600006, 164.2200012, 183.6000061, 180.5399933, 165.2400055,
     409                             160.1399994, 183.6000061, 166.2599945, 183.6000061, 196.8600006,
     410                             175.4400024, 172.3800049, 172.3800049, 181.5599976, 177.4799957,
     411                             173.3999939, 176.4600067, 180.5399933, 176.4600067, 178.5,
     412                             163.1999969, 189.7200012, 175.4400024, 174.4199982, 185.6399994,
     413                             182.5800018, 169.3200073, 194.8200073, 192.7799988, 188.6999969,
     414                             193.8000031, 175.4400024, 165.2400055, 180.5399933, 184.6199951,
     415                             176.4600067, 171.3600006, 188.6999969, 199.9199982, 183.6000061,
     416                             169.3200073, 175.4400024, 180.5399933, 174.4199982, 167.2799988,
     417                             184.6199951, 177.4799957, 180.5399933, 180.5399933, 184.6199951,
     418                             178.5, 186.6600037, 161.1600037, 183.6000061, 168.3000031,
     419                             188.6999969, 184.6199951, 171.3600006, 185.6399994, 167.2799988,
     420                             162.1799927, 186.6600037, 175.4400024, 166.2599945, 182.5800018,
     421                             171.3600006, 176.4600067, 192.7799988, 178.5, 168.3000031,
     422                             182.5800018, 184.6199951, 148.9199982, 172.3800049, 168.3000031,
     423                             181.5599976, 154.0200043, 166.2599945, 174.4199982, 166.2599945,
     424                             178.5, 184.6199951, 176.4600067, 171.3600006, 188.6999969,
     425                             177.4799957, 172.3800049, 176.4600067, 179.5200043, 176.4600067,
     426                             161.1600037, 166.2599945, 181.5599976, 170.3399963, 176.4600067,
     427                             163.1999969, 183.6000061, 206.0399933, 171.3600006, 186.6600037,
     428                             176.4600067, 163.1999969, 179.5200043, 176.4600067, 182.5800018,
     429                             167.2799988, 174.4199982, 188.6999969, 177.4799957, 190.7400055,
     430                             176.4600067, 175.4400024, 174.4199982, 179.5200043, 182.5800018,
     431                             182.5800018, 175.4400024, 165.2400055, 180.5399933, 178.5,
     432                             176.4600067, 191.7599945, 173.3999939, 186.6600037, 165.2400055,
     433                             173.3999939, 188.6999969, 172.3800049, 168.3000031, 193.8000031,
     434                             180.5399933, 172.3800049, 180.5399933, 189.7200012, 170.3399963,
     435                             170.3399963, 195.8399963, 173.3999939, 187.6799927, 165.2400055,
     436                             147.8999939, 173.3999939, 184.6199951, 171.3600006, 178.5,
     437                             163.1999969, 171.3600006, 190.7400055, 180.5399933, 156.0599976,
     438                             164.2200012, 172.3800049, 202.9799957, 201.9600067, 175.4400024,
     439                             193.8000031, 176.4600067, 182.5800018, 184.6199951, 178.5,
     440                             169.3200073, 166.2599945, 173.3999939, 182.5800018, 171.3600006,
     441                             167.2799988, 185.6399994, 179.5200043, 188.6999969, 194.8200073,
     442                             177.4799957, 177.4799957, 164.2200012, 189.7200012, 193.8000031,
     443                             173.3999939, 178.5, 184.6199951, 191.7599945, 191.7599945,
     444                             162.1799927, 171.3600006, 165.2400055, 197.8800049, 169.3200073,
     445                             178.5, 174.4199982, 183.6000061, 189.7200012, 181.5599976,
     446                             185.6399994, 179.5200043, 181.5599976, 161.1600037, 173.3999939,
     447                             187.6799927, 177.4799957, 182.5800018, 171.3600006, 188.6999969,
     448                             194.8200073, 176.4600067, 182.5800018, 157.0800018, 169.3200073,
     449                             170.3399963, 168.3000031, 190.7400055, 170.3399963, 185.6399994,
     450                             195.8399963, 172.3800049, 213.1799927, 187.6799927, 187.6799927,
     451                             178.5, 181.5599976, 183.6000061, 163.1999969, 169.3200073,
     452                             180.5399933, 204, 175.4400024, 158.1000061, 174.4199982,
     453                             183.6000061, 181.5599976, 181.5599976, 180.5399933, 172.3800049,
     454                             188.6999969, 166.2599945, 196.8600006, 187.6799927, 196.8600006,
     455                             164.2200012, 160.1399994, 165.2400055, 172.3800049, 177.4799957,
     456                             173.3999939, 168.3000031, 181.5599976, 164.2200012, 177.4799957,
     457                             182.5800018, 162.1799927, 168.3000031, 181.5599976, 179.5200043,
     458                             171.3600006, 173.3999939, 176.4600067, 197.8800049, 172.3800049,
     459                             189.7200012, 172.3800049, 161.1600037, 183.6000061, 173.3999939,
     460                             188.6999969, 161.1600037, 180.5399933, 160.1399994, 166.2599945,
     461                             164.2200012, 182.5800018, 169.3200073, 176.4600067, 186.6600037,
     462                             192.7799988, 163.1999969, 153, 182.5800018, 184.6199951,
     463                             166.2599945, 167.2799988, 186.6600037, 177.4799957, 174.4199982,
     464                             175.4400024, 164.2200012, 180.5399933, 178.5, 176.4600067,
     465                             164.2200012, 160.1399994, 178.5, 176.4600067, 180.5399933,
     466                             182.5800018, 179.5200043, 169.3200073, 178.5, 172.3800049,
     467                             171.3600006, 178.5, 166.2599945, 171.3600006, 181.5599976,
     468                             162.1799927, 157.0800018, 189.7200012, 177.4799957, 164.2200012,
     469                             179.5200043, 187.6799927, 172.3800049, 158.1000061, 164.2200012,
     470                             177.4799957, 165.2400055, 185.6399994, 174.4199982, 188.6999969,
     471                             173.3999939, 168.3000031, 164.2200012, 187.6799927, 209.1000061,
     472                             172.3800049, 177.4799957, 170.3399963, 172.3800049, 164.2200012,
     473                             190.7400055, 177.4799957, 165.2400055, 168.3000031, 173.3999939,
     474                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     475                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     476                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     477                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     478                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     479                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     480                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     481                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     482                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     483                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     484                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     485                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     486                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
     487                         };
     488
    217489int main (void)
    218490{
    219491    plan_tests(26);
    220492
    221     diag("psStats Tests with sample SDSS data from RHL");
     493    diag("psStats Tests with sample SDSS data from RHL and Megacam from EAM");
    222494    diag("this file does not yet define a specific test");
    223     diag ("the fitted mean is currently wrong for these two data sets");
     495    diag("the fitted mean is currently wrong for these two data sets");
    224496
    225497    {
    … …  
    243515
    244516        psVectorStats (stats, y, NULL, NULL, 1);
    245         ok (1, "fitted  mean   %f, stdev %f", stats->fittedMean,   stats->fittedStdev);
    246         ok (1, "robust  median %f, stdev %f", stats->robustMedian, stats->robustStdev);
    247         ok (1, "clipped mean   %f, stdev %f", stats->clippedMean,  stats->clippedStdev);
    248         ok (1, "sample  mean   %f, stdev %f", stats->sampleMean,   stats->sampleStdev);
    249         ok (1, "sample  median %f, stdev %f", stats->sampleMedian, stats->sampleStdev);
     517        ok (1, "sample  mean    %f, stdev %f", stats->sampleMean,   stats->sampleStdev);
     518        ok (1, "sample  median  %f, stdev %f", stats->sampleMedian, stats->sampleStdev);
     519        ok (1, "clipped mean    %f, stdev %f", stats->clippedMean,  stats->clippedStdev);
     520        ok (1, "robust  median  %f, stdev %f", stats->robustMedian, stats->robustStdev);
     521        ok (1, "fitted  mean    %f, stdev %f", stats->fittedMean,   stats->fittedStdev);
     522        psFree (stats);
     523
     524        stats = psStatsAlloc (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2 | PS_STAT_USE_BINSIZE);
     525        stats->binsize = 1.0;
     526        psVectorStats (stats, y, NULL, NULL, 1);
     527        ok (1, "fitted  mean v2 %f, stdev %f", stats->fittedMean,   stats->fittedStdev);
     528        psFree (stats);
    250529
    251530        psFree (y);
    252         psFree (stats);
    253531        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    254532    }
    … …  
    273551
    274552        psVectorStats (stats, y, NULL, NULL, 1);
    275         ok (1, "fitted  mean   %f, stdev %f", stats->fittedMean,   stats->fittedStdev);
    276         ok (1, "robust  median %f, stdev %f", stats->robustMedian, stats->robustStdev);
    277         ok (1, "clipped mean   %f, stdev %f", stats->clippedMean,  stats->clippedStdev);
    278553        ok (1, "sample  mean   %f, stdev %f", stats->sampleMean,   stats->sampleStdev);
    279554        ok (1, "sample  median %f, stdev %f", stats->sampleMedian, stats->sampleStdev);
     555        ok (1, "clipped mean   %f, stdev %f", stats->clippedMean,  stats->clippedStdev);
     556        ok (1, "robust  median %f, stdev %f", stats->robustMedian, stats->robustStdev);
     557        ok (1, "fitted  mean   %f, stdev %f", stats->fittedMean,   stats->fittedStdev);
     558        psFree (stats);
     559
     560        stats = psStatsAlloc (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2 | PS_STAT_USE_BINSIZE);
     561        stats->binsize = 1.0;
     562        psVectorStats (stats, y, NULL, NULL, 1);
     563        ok (1, "fitted  mean v2 %f, stdev %f", stats->fittedMean,   stats->fittedStdev);
     564        psFree (stats);
    280565
    281566        psFree (y);
    282         psFree (stats);
    283567        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    284568    }
    285569
     570    {
     571        psMemId id = psMemGetId();
     572
     573        diag("sample 3");
     574        psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV |
     575                                       PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV |
     576                                       PS_STAT_CLIPPED_MEAN | PS_STAT_CLIPPED_STDEV |
     577                                       PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_MEDIAN |
     578                                       PS_STAT_SAMPLE_STDEV | PS_STAT_USE_BINSIZE);
     579        stats->binsize = 1.0;
     580
     581
     582        // copy data in static array
     583        int nPts = sizeof(yraw_03) / sizeof (float);
     584        psVector *y = psVectorAlloc (nPts, PS_TYPE_F32);
     585        for (int i = 0; i < y->n; i++) {
     586            y->data.F32[i] = yraw_03[i];
     587        }
     588
     589        psVectorStats (stats, y, NULL, NULL, 1);
     590        ok (1, "sample  mean   %f, stdev %f", stats->sampleMean,   stats->sampleStdev);
     591        ok (1, "sample  median %f, stdev %f", stats->sampleMedian, stats->sampleStdev);
     592        ok (1, "clipped mean   %f, stdev %f", stats->clippedMean,  stats->clippedStdev);
     593        ok (1, "robust  median %f, stdev %f", stats->robustMedian, stats->robustStdev);
     594        ok (1, "fitted  mean   %f, stdev %f", stats->fittedMean,   stats->fittedStdev);
     595        psFree (stats);
     596
     597        stats = psStatsAlloc (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2 | PS_STAT_USE_BINSIZE);
     598        stats->binsize = 1.0;
     599        psVectorStats (stats, y, NULL, NULL, 1);
     600        ok (1, "fitted  mean v2 %f, stdev %f", stats->fittedMean,   stats->fittedStdev);
     601        psFree (stats);
     602
     603        psFree (y);
     604        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     605    }
     606
    286607    return exit_status();
    287608}
Note: See TracChangeset for help on using the changeset viewer.