IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Dec 8, 2006, 1:38:54 AM (19 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)
File:
1 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
Note: See TracChangeset for help on using the changeset viewer.