Index: trunk/psLib/test/math/tap_psStatsTiming.c =================================================================== --- trunk/psLib/test/math/tap_psStatsTiming.c (revision 10395) +++ trunk/psLib/test/math/tap_psStatsTiming.c (revision 10550) @@ -9,4 +9,7 @@ // ok(condition, "condition succeeded"); // skip_start(condition, Nskip, "Skipping tests because of failure"); + +# define DTIME(A,B) ((A.tv_sec - B.tv_sec) + 1e-6*(A.tv_usec - B.tv_usec)) +struct timeval start, mark; int main (void) @@ -22,12 +25,525 @@ rnd->data.F32[i] = psRandomGaussian (seed); } - psTimerStart ("test"); - - /********** fitted stats ***********/ - // test FITTED timing - { - // psMemId id = psMemGetId(); - - diag ("check fitted mean speed : 1000 pts / 1000 loops"); + + diag ("timing for sample mean"); + /********** SAMPLE MEAN ***********/ + // test stat sample mean (no mask, no range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN); + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, NULL, 0); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.1, "sample mean %f (mask: 0, range: 0): %.3f sec", stats->sampleMean, delta); + psFree (stats); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // test stat sample mean (mask, no range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN); + psVector *mask = psVectorAlloc (1000, PS_TYPE_U8); + psVectorInit (mask, 0); + mask->data.U8[100] = 1; + mask->data.U8[200] = 1; + mask->data.U8[300] = 1; + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, mask, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.12, "sample mean %f (mask: 1, range: 0): %.3f sec", stats->sampleMean, delta); + psFree (stats); + psFree (mask); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // test stat sample mean (no mask, range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_USE_RANGE); + stats->min = -10; + stats->max = +10; + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, NULL, 0); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.18, "sample mean %f (mask: 0, range: 1): %.3f sec", stats->sampleMean, delta); + psFree (stats); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // test stat sample mean (mask, range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_USE_RANGE); + stats->min = -10; + stats->max = +10; + psVector *mask = psVectorAlloc (1000, PS_TYPE_U8); + psVectorInit (mask, 0); + mask->data.U8[100] = 1; + mask->data.U8[200] = 1; + mask->data.U8[300] = 1; + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, mask, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.2, "sample mean %f (mask: 1, range: 1): %.3f sec", stats->sampleMean, delta); + psFree (stats); + psFree (mask); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + diag ("timing for sample median"); + /********** SAMPLE MEDIAN ***********/ + // test stat sample median (no mask, no range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN); + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, NULL, 0); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 2.8, "sample median %f (mask: 0, range: 0): %.3f sec", stats->sampleMedian, delta); + psFree (stats); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // test stat sample median (mask, no range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN); + psVector *mask = psVectorAlloc (1000, PS_TYPE_U8); + psVectorInit (mask, 0); + mask->data.U8[100] = 1; + mask->data.U8[200] = 1; + mask->data.U8[300] = 1; + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, mask, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 2.8, "sample median %f (mask: 1, range: 0): %.3f sec", stats->sampleMedian, delta); + psFree (stats); + psFree (mask); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // test stat sample median (no mask, range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN | PS_STAT_USE_RANGE); + stats->min = -10; + stats->max = +10; + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, NULL, 0); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 2.8, "sample median %f (mask: 0, range: 1): %.3f sec", stats->sampleMedian, delta); + psFree (stats); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // test stat sample median (mask, range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN | PS_STAT_USE_RANGE); + stats->min = -10; + stats->max = +10; + psVector *mask = psVectorAlloc (1000, PS_TYPE_U8); + psVectorInit (mask, 0); + mask->data.U8[100] = 1; + mask->data.U8[200] = 1; + mask->data.U8[300] = 1; + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, mask, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 2.8, "sample median %f (mask: 1, range: 1): %.3f sec", stats->sampleMedian, delta); + psFree (stats); + psFree (mask); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + diag ("timing for sample stdev"); + /********** SAMPLE STDEV ***********/ + // test stat sample stdev (no mask, no range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_STDEV); + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, NULL, 0); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.2, "sample stdev %f (mask: 0, range: 0): %.3f sec", stats->sampleStdev, delta); + psFree (stats); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // test stat sample stdev (mask, no range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_STDEV); + psVector *mask = psVectorAlloc (1000, PS_TYPE_U8); + psVectorInit (mask, 0); + mask->data.U8[100] = 1; + mask->data.U8[200] = 1; + mask->data.U8[300] = 1; + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, mask, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.27, "sample stdev %f (mask: 1, range: 0): %.3f sec", stats->sampleStdev, delta); + psFree (stats); + psFree (mask); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // test stat sample stdev (no mask, range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_STDEV | PS_STAT_USE_RANGE); + stats->min = -10; + stats->max = +10; + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, NULL, 0); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.36, "sample stdev %f (mask: 0, range: 1): %.3f sec", stats->sampleStdev, delta); + psFree (stats); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // test stat sample stdev (mask, range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_STDEV | PS_STAT_USE_RANGE); + stats->min = -10; + stats->max = +10; + psVector *mask = psVectorAlloc (1000, PS_TYPE_U8); + psVectorInit (mask, 0); + mask->data.U8[100] = 1; + mask->data.U8[200] = 1; + mask->data.U8[300] = 1; + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, mask, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.42, "sample stdev %f (mask: 1, range: 1): %.3f sec", stats->sampleStdev, delta); + psFree (stats); + psFree (mask); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + diag ("timing for sample min,max"); + /*************** MIN,MAX ******************/ + // test stat min,max (no mask, no range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX); + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, NULL, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.17, "sample min,max %f,%f (mask: 0, range: 0): %.3f sec", stats->min, stats->max, delta); + psFree (stats); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + // test stat min,max (no mask, no range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX); + psVector *mask = psVectorAlloc (1000, PS_TYPE_U8); + psVectorInit (mask, 0); + mask->data.U8[100] = 1; + mask->data.U8[200] = 1; + mask->data.U8[300] = 1; + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, mask, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.18, "sample min,max %f,%f (mask: 1, range: 0): %.3f sec", stats->min, stats->max, delta); + psFree (stats); + psFree (mask); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + // test stat min,max (no mask, no range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX | PS_STAT_USE_RANGE); + stats->min = -10; + stats->max = +10; + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, NULL, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.22, "sample min,max %f,%f (mask: 0, range: 1): %.3f sec", stats->min, stats->max, delta); + psFree (stats); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + // test stat min,max (no mask, no range) + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX | PS_STAT_USE_RANGE); + stats->min = -10; + stats->max = +10; + psVector *mask = psVectorAlloc (1000, PS_TYPE_U8); + psVectorInit (mask, 0); + mask->data.U8[100] = 1; + mask->data.U8[200] = 1; + mask->data.U8[300] = 1; + + gettimeofday (&start, NULL); + for (int i = 0; i < 10000; i++) + { + psVectorStats (stats, rnd, NULL, mask, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.26, "sample min,max %f,%f (mask: 1, range: 1): %.3f sec", stats->min, stats->max, delta); + psFree (stats); + psFree (mask); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + diag ("timing for clipped stats"); + /********** CLIPPED STATS ***********/ + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_CLIPPED_MEAN | PS_STAT_CLIPPED_STDEV); + psVector *rnd2 = psVectorAlloc (1000, PS_TYPE_F32); + for (int i = 0; i < rnd2->n; i++) + { + rnd2->data.F32[i] = psRandomGaussian (seed); + } + + gettimeofday (&start, NULL); + for (int i = 0; i < 1000; i++) + { + psVectorStats (stats, rnd2, NULL, NULL, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.3, "clipped mean %f, stdev %f (mask: 0, range: 0): %.3f sec (1000 pts / 1000 loops)", stats->clippedMean, stats->clippedStdev, delta); + psFree (stats); + psFree (rnd2); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_CLIPPED_MEAN | PS_STAT_CLIPPED_STDEV); + psVector *rnd2 = psVectorAlloc (3000, PS_TYPE_F32); + for (int i = 0; i < rnd2->n; i++) + { + rnd2->data.F32[i] = psRandomGaussian (seed); + } + + gettimeofday (&start, NULL); + for (int i = 0; i < 1000; i++) + { + psVectorStats (stats, rnd2, NULL, NULL, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.5, "clipped mean %f, stdev %f (mask: 0, range: 0): %.3f sec (3000 pts / 1000 loops)", stats->clippedMean, stats->clippedStdev, delta); + psFree (stats); + psFree (rnd2); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_CLIPPED_MEAN | PS_STAT_CLIPPED_STDEV); + psVector *rnd2 = psVectorAlloc (10000, PS_TYPE_F32); + for (int i = 0; i < rnd2->n; i++) + { + rnd2->data.F32[i] = psRandomGaussian (seed); + } + + gettimeofday (&start, NULL); + for (int i = 0; i < 1000; i++) + { + psVectorStats (stats, rnd2, NULL, NULL, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 1.2, "clipped mean %f, stdev %f (mask: 0, range: 0): %.3f sec (10000 pts / 1000 loops)", stats->clippedMean, stats->clippedStdev, delta); + psFree (stats); + psFree (rnd2); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + diag ("timing for robust stats"); + /********** ROBUST STATS ***********/ + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE); + psVector *rnd2 = psVectorAlloc (1000, PS_TYPE_F32); + for (int i = 0; i < rnd2->n; i++) + { + rnd2->data.F32[i] = psRandomGaussian (seed); + } + + gettimeofday (&start, NULL); + for (int i = 0; i < 1000; i++) + { + psVectorStats (stats, rnd2, NULL, NULL, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.3, "robust mean %f, stdev %f (mask: 0, range: 0): %.3f sec (1000 pts / 1000 loops)", stats->robustMedian, stats->robustStdev, delta); + psFree (stats); + psFree (rnd2); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE); + psVector *rnd2 = psVectorAlloc (3000, PS_TYPE_F32); + for (int i = 0; i < rnd2->n; i++) + { + rnd2->data.F32[i] = psRandomGaussian (seed); + } + + gettimeofday (&start, NULL); + for (int i = 0; i < 1000; i++) + { + psVectorStats (stats, rnd2, NULL, NULL, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.5, "robust mean %f, stdev %f (mask: 0, range: 0): %.3f sec (3000 pts / 1000 loops)", stats->robustMedian, stats->robustStdev, delta); + psFree (stats); + psFree (rnd2); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE); + psVector *rnd2 = psVectorAlloc (10000, PS_TYPE_F32); + for (int i = 0; i < rnd2->n; i++) + { + rnd2->data.F32[i] = psRandomGaussian (seed); + } + + gettimeofday (&start, NULL); + for (int i = 0; i < 1000; i++) + { + psVectorStats (stats, rnd2, NULL, NULL, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 1.2, "robust mean %f, stdev %f (mask: 0, range: 0): %.3f sec (10000 pts / 1000 loops)", stats->robustMedian, stats->robustStdev, delta); + psFree (stats); + psFree (rnd2); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + diag ("timing for fitted stats"); + /********** FITTED TIMING ***********/ + { + psMemId id = psMemGetId(); psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV); @@ -38,20 +554,20 @@ } - psTimerClear ("test"); - for (int i = 0; i < 1000; i++) - { - psVectorStats (stats, rnd2, NULL, NULL, 1); - } - psF64 delta = psTimerMark("test"); - ok (delta < 0.5, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec", stats->fittedMean, stats->fittedStdev, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - // test FITTED timing - { - // psMemId id = psMemGetId(); - - diag ("check fitted mean speed : 3000 pts / 1000 loops"); + gettimeofday (&start, NULL); + for (int i = 0; i < 1000; i++) + { + psVectorStats (stats, rnd2, NULL, NULL, 1); + + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.7, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec (1000 pts / 1000 loops)", stats->fittedMean, stats->fittedStdev, delta); + psFree (stats); + psFree (rnd2); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + { + psMemId id = psMemGetId(); psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV); @@ -62,20 +578,19 @@ } - psTimerClear ("test"); - for (int i = 0; i < 1000; i++) - { - psVectorStats (stats, rnd2, NULL, NULL, 1); - } - psF64 delta = psTimerMark("test"); - ok (delta < 0.8, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec", stats->fittedMean, stats->fittedStdev, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - // test FITTED timing - { - // psMemId id = psMemGetId(); - - diag ("check fitted mean speed : 10000 pts / 1000 loops"); + gettimeofday (&start, NULL); + for (int i = 0; i < 1000; i++) + { + psVectorStats (stats, rnd2, NULL, NULL, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.8, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec (3000 pts / 1000 loops)", stats->fittedMean, stats->fittedStdev, delta); + psFree (stats); + psFree (rnd2); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + { + psMemId id = psMemGetId(); psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV); @@ -86,56 +601,24 @@ } - psTimerClear ("test"); - for (int i = 0; i < 1000; i++) - { - psVectorStats (stats, rnd2, NULL, NULL, 1); - } - psF64 delta = psTimerMark("test"); - ok (delta < 2.2, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec", stats->fittedMean, stats->fittedStdev, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - // test stat min,max (no mask, no range) - { - // psMemId id = psMemGetId(); - - diag ("check fitted mean speed (and value)"); - - psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV | PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV); - psVector *sample = psVectorAlloc (1000, PS_TYPE_F32); - psVector *fitted = psVectorAlloc (1000, PS_TYPE_F32); - - for (int i = 0; i < 1000; i++) - { - // generate a new sample - for (int j = 0; j < rnd->n; j++) { - rnd->data.F32[j] = psRandomGaussian (seed); - } - // measure the stats - psVectorStats (stats, rnd, NULL, NULL, 1); - sample->data.F32[i] = stats->sampleMean; - fitted->data.F32[i] = stats->fittedMean; - } - psFree (stats); - - stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV); - psVectorStats (stats, sample, NULL, NULL, 1); - ok (stats->sampleStdev < 2/sqrt(1000), "sample mean %f, stdev %f", stats->sampleMean, stats->sampleStdev); - psVectorStats (stats, fitted, NULL, NULL, 1); - ok (stats->sampleStdev < 2/sqrt(1000), "fitted mean %f, stdev %f", stats->sampleMean, stats->sampleStdev); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - /********** robust stats ***********/ - // test ROBUST timing - { - // psMemId id = psMemGetId(); - - diag ("check robust mean speed : 1000 pts / 1000 loops"); - - psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE); + gettimeofday (&start, NULL); + for (int i = 0; i < 1000; i++) + { + psVectorStats (stats, rnd2, NULL, NULL, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 2.2, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec (10000 pts / 1000 loops)", stats->fittedMean, stats->fittedStdev, delta); + psFree (stats); + psFree (rnd2); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + diag ("timing for fitted (v2) stats"); + /********** FITTED (v2) TIMING ***********/ + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2); psVector *rnd2 = psVectorAlloc (1000, PS_TYPE_F32); for (int i = 0; i < rnd2->n; i++) @@ -144,22 +627,22 @@ } - psTimerClear ("test"); - for (int i = 0; i < 1000; i++) - { - psVectorStats (stats, rnd2, NULL, NULL, 1); - } - psF64 delta = psTimerMark("test"); - ok (delta < 0.2, "robust mean %f, stdev %f (mask: 0, range: 0): %.3f sec", stats->robustMedian, stats->robustStdev, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - // test ROBUST timing - { - // psMemId id = psMemGetId(); - - diag ("check robust mean speed : 3000 pts / 1000 loops"); - - psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE); + gettimeofday (&start, NULL); + for (int i = 0; i < 1000; i++) + { + psVectorStats (stats, rnd2, NULL, NULL, 1); + + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.7, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec (1000 pts / 1000 loops)", stats->fittedMean, stats->fittedStdev, delta); + psFree (stats); + psFree (rnd2); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2); psVector *rnd2 = psVectorAlloc (3000, PS_TYPE_F32); for (int i = 0; i < rnd2->n; i++) @@ -168,22 +651,21 @@ } - psTimerClear ("test"); - for (int i = 0; i < 1000; i++) - { - psVectorStats (stats, rnd2, NULL, NULL, 1); - } - psF64 delta = psTimerMark("test"); - ok (delta < 0.5, "robust mean %f, stdev %f (mask: 0, range: 0): %.3f sec", stats->robustMedian, stats->robustStdev, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - // test ROBUST timing - { - // psMemId id = psMemGetId(); - - diag ("check robust mean speed : 10000 pts / 1000 loops"); - - psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_ROBUST_QUARTILE); + gettimeofday (&start, NULL); + for (int i = 0; i < 1000; i++) + { + psVectorStats (stats, rnd2, NULL, NULL, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 0.8, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec (3000 pts / 1000 loops)", stats->fittedMean, stats->fittedStdev, delta); + psFree (stats); + psFree (rnd2); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + { + psMemId id = psMemGetId(); + + psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2); psVector *rnd2 = psVectorAlloc (10000, PS_TYPE_F32); for (int i = 0; i < rnd2->n; i++) @@ -192,24 +674,27 @@ } - psTimerClear ("test"); - for (int i = 0; i < 1000; i++) - { - psVectorStats (stats, rnd2, NULL, NULL, 1); - } - psF64 delta = psTimerMark("test"); - ok (delta < 1.2, "robust mean %f, stdev %f (mask: 0, range: 0): %.3f sec", stats->robustMedian, stats->robustStdev, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - // test stat min,max (no mask, no range) - { - // psMemId id = psMemGetId(); - - diag ("check robust mean speed (and value)"); - - psStats *stats = psStatsAlloc (PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV); + gettimeofday (&start, NULL); + for (int i = 0; i < 1000; i++) + { + psVectorStats (stats, rnd2, NULL, NULL, 1); + } + gettimeofday (&mark, NULL); + psF64 delta = DTIME(mark, start); + ok (delta < 2.2, "fitted mean %f, stdev %f (mask: 0, range: 0): %.3f sec (10000 pts / 1000 loops)", stats->fittedMean, stats->fittedStdev, delta); + psFree (stats); + psFree (rnd2); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + diag ("compare sample, robust, and fitted mean and stdev to theoretical"); + // compare SAMPLE, FITTED, ROBUST mean to theoretical + { + psMemId id = psMemGetId(); + + 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); psVector *sample = psVectorAlloc (1000, PS_TYPE_F32); psVector *robust = psVectorAlloc (1000, PS_TYPE_F32); + psVector *fitted = psVectorAlloc (1000, PS_TYPE_F32); for (int i = 0; i < 1000; i++) @@ -223,4 +708,5 @@ sample->data.F32[i] = stats->sampleMean; robust->data.F32[i] = stats->robustMedian; + fitted->data.F32[i] = stats->fittedMean; } psFree (stats); @@ -228,196 +714,54 @@ stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV); psVectorStats (stats, sample, NULL, NULL, 1); - ok (stats->sampleStdev < 2/sqrt(1000), "sample mean %f, stdev %f", stats->sampleMean, stats->sampleStdev); + ok (stats->sampleStdev < 2/sqrt(1000), "sample mean %f, stdev %f (1000 tries)", stats->sampleMean, stats->sampleStdev); psVectorStats (stats, robust, NULL, NULL, 1); - ok (stats->sampleStdev < 2/sqrt(1000), "robust mean %f, stdev %f", stats->sampleMean, stats->sampleStdev); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - /********** stats ***********/ - // test stat sample mean (no mask, no range) - { - // psMemId id = psMemGetId(); - - diag ("check sample mean speed (and value)"); - - psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN); - - psTimerClear ("test"); - for (int i = 0; i < 10000; i++) - { - psVectorStats (stats, rnd, NULL, NULL, 0); - } - psF64 delta = psTimerMark("test"); - ok (delta < 0.1, "sample mean %f (mask: 0, range: 0): %.3f sec", stats->sampleMean, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - // test stat sample mean (mask, no range) - { - // psMemId id = psMemGetId(); - - diag ("check sample mean speed (and value)"); - - psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN); - psVector *mask = psVectorAlloc (1000, PS_TYPE_U8); - psVectorInit (mask, 0); - mask->data.U8[100] = 1; - mask->data.U8[200] = 1; - mask->data.U8[300] = 1; - - psTimerClear ("test"); - for (int i = 0; i < 10000; i++) - { - psVectorStats (stats, rnd, NULL, mask, 1); - } - psF64 delta = psTimerMark("test"); - ok (delta < 0.12, "sample mean %f (mask: 1, range: 0): %.3f sec", stats->sampleMean, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - // test stat sample mean (no mask, range) - { - // psMemId id = psMemGetId(); - - diag ("check sample mean speed (and value)"); - - psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_USE_RANGE); - stats->min = -10; - stats->max = +10; - - psTimerClear ("test"); - for (int i = 0; i < 10000; i++) - { - psVectorStats (stats, rnd, NULL, NULL, 0); - } - psF64 delta = psTimerMark("test"); - ok (delta < 0.18, "sample mean %f (mask: 0, range: 1): %.3f sec", stats->sampleMean, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - // test stat sample mean (mask, range) - { - // psMemId id = psMemGetId(); - - diag ("check sample mean speed (and value)"); - - psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_USE_RANGE); - stats->min = -10; - stats->max = +10; - psVector *mask = psVectorAlloc (1000, PS_TYPE_U8); - psVectorInit (mask, 0); - mask->data.U8[100] = 1; - mask->data.U8[200] = 1; - mask->data.U8[300] = 1; - - psTimerClear ("test"); - for (int i = 0; i < 10000; i++) - { - psVectorStats (stats, rnd, NULL, mask, 1); - } - psF64 delta = psTimerMark("test"); - ok (delta < 0.2, "sample mean %f (mask: 1, range: 1): %.3f sec", stats->sampleMean, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - /*************** min,max ******************/ - // test stat min,max (no mask, no range) - { - // psMemId id = psMemGetId(); - - diag ("check min,max speed (no mask, no range)"); - - psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX); - psTimerClear ("test"); - for (int i = 0; i < 10000; i++) - { + ok (stats->sampleStdev < 2/sqrt(1000), "robust mean %f, stdev %f (1000 tries)", stats->sampleMean, stats->sampleStdev); + psVectorStats (stats, fitted, NULL, NULL, 1); + ok (stats->sampleStdev < 2/sqrt(1000), "fitted mean %f, stdev %f (1000 tries)", stats->sampleMean, stats->sampleStdev); + psFree (stats); + psFree (sample); + psFree (robust); + psFree (fitted); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + diag ("compare sample, robust, and fitted mean and stdev to theoretical"); + // compare SAMPLE, FITTED_V2, ROBUST mean to theoretical + { + psMemId id = psMemGetId(); + + 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); + psVector *sample = psVectorAlloc (1000, PS_TYPE_F32); + psVector *robust = psVectorAlloc (1000, PS_TYPE_F32); + psVector *fitted = psVectorAlloc (1000, PS_TYPE_F32); + + for (int i = 0; i < 1000; i++) + { + // generate a new sample + for (int j = 0; j < rnd->n; j++) { + rnd->data.F32[j] = psRandomGaussian (seed); + } + // measure the stats psVectorStats (stats, rnd, NULL, NULL, 1); - } - psF64 delta = psTimerMark("test"); - ok (delta < 0.17, "sample min,max %f,%f (mask: 0, range: 0): %.3f sec", stats->min, stats->max, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - // test stat min,max (no mask, no range) - { - // psMemId id = psMemGetId(); - - diag ("check min,max speed (mask, no range)"); - - psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX); - psVector *mask = psVectorAlloc (1000, PS_TYPE_U8); - psVectorInit (mask, 0); - mask->data.U8[100] = 1; - mask->data.U8[200] = 1; - mask->data.U8[300] = 1; - - psTimerClear ("test"); - for (int i = 0; i < 10000; i++) - { - psVectorStats (stats, rnd, NULL, mask, 1); - } - psF64 delta = psTimerMark("test"); - ok (delta < 0.18, "sample min,max %f,%f (mask: 1, range: 0): %.3f sec", stats->min, stats->max, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - // test stat min,max (no mask, no range) - { - // psMemId id = psMemGetId(); - - diag ("check min,max speed (no mask, range)"); - - psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX | PS_STAT_USE_RANGE); - stats->min = -10; - stats->max = +10; - - psTimerClear ("test"); - for (int i = 0; i < 10000; i++) - { - psVectorStats (stats, rnd, NULL, NULL, 1); - } - psF64 delta = psTimerMark("test"); - ok (delta < 0.22, "sample min,max %f,%f (mask: 0, range: 1): %.3f sec", stats->min, stats->max, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - // test stat min,max (no mask, no range) - { - // psMemId id = psMemGetId(); - - diag ("check min,max speed (mask, range)"); - - psStats *stats = psStatsAlloc (PS_STAT_MIN | PS_STAT_MAX | PS_STAT_USE_RANGE); - stats->min = -10; - stats->max = +10; - psVector *mask = psVectorAlloc (1000, PS_TYPE_U8); - psVectorInit (mask, 0); - mask->data.U8[100] = 1; - mask->data.U8[200] = 1; - mask->data.U8[300] = 1; - - psTimerClear ("test"); - for (int i = 0; i < 10000; i++) - { - psVectorStats (stats, rnd, NULL, mask, 1); - } - psF64 delta = psTimerMark("test"); - ok (delta < 0.26, "sample min,max %f,%f (mask: 1, range: 1): %.3f sec", stats->min, stats->max, delta); - psFree (stats); - - // ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + sample->data.F32[i] = stats->sampleMean; + robust->data.F32[i] = stats->robustMedian; + fitted->data.F32[i] = stats->fittedMean; + } + psFree (stats); + + stats = psStatsAlloc (PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_STDEV); + psVectorStats (stats, sample, NULL, NULL, 1); + ok (stats->sampleStdev < 2/sqrt(1000), "sample mean %f, stdev %f (1000 tries)", stats->sampleMean, stats->sampleStdev); + psVectorStats (stats, robust, NULL, NULL, 1); + ok (stats->sampleStdev < 2/sqrt(1000), "robust mean %f, stdev %f (1000 tries)", stats->sampleMean, stats->sampleStdev); + psVectorStats (stats, fitted, NULL, NULL, 1); + ok (stats->sampleStdev < 2/sqrt(1000), "fitted mean %f, stdev %f (1000 tries)", stats->sampleMean, stats->sampleStdev); + psFree (stats); + psFree (sample); + psFree (robust); + psFree (fitted); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); } Index: trunk/psLib/test/math/tap_psStatsTiming.txt =================================================================== --- trunk/psLib/test/math/tap_psStatsTiming.txt (revision 10550) +++ trunk/psLib/test/math/tap_psStatsTiming.txt (revision 10550) @@ -0,0 +1,47 @@ + +Running tap_psStatsTiming on alala (dual AMD Opteron, 64bit, 2.2GHz) +yields the following timing results: + +# timing for sample mean (1000 loops of 10000 pts) +ok 1 - sample mean 0.009719 (mask: 0, range: 0): 0.072 sec +ok 3 - sample mean 0.011060 (mask: 1, range: 0): 0.119 sec +ok 5 - sample mean 0.009719 (mask: 0, range: 1): 0.170 sec +ok 7 - sample mean 0.011060 (mask: 1, range: 1): 0.198 sec + +# timing for sample median (1000 loops of 10000 pts) +ok 9 - sample median 0.021781 (mask: 0, range: 0): 2.625 sec +ok 11 - sample median 0.023795 (mask: 1, range: 0): 2.646 sec +ok 13 - sample median 0.021781 (mask: 0, range: 1): 2.703 sec +ok 15 - sample median 0.023795 (mask: 1, range: 1): 2.716 sec + +# timing for sample stdev (1000 loops of 10000 pts) +ok 17 - sample stdev 0.964753 (mask: 0, range: 0): 0.193 sec +ok 19 - sample stdev 0.965887 (mask: 1, range: 0): 0.257 sec +ok 21 - sample stdev 0.964753 (mask: 0, range: 1): 0.353 sec +ok 23 - sample stdev 0.965887 (mask: 1, range: 1): 0.401 sec + +# timing for sample min,max (1000 loops of 10000 pts) +ok 25 - sample min,max -3.205688,2.706797 (mask: 0, range: 0): 0.125 sec +ok 27 - sample min,max -3.205688,2.706797 (mask: 1, range: 0): 0.152 sec +ok 29 - sample min,max -3.205688,2.706797 (mask: 0, range: 1): 0.201 sec +ok 31 - sample min,max -3.205688,2.706797 (mask: 1, range: 1): 0.238 sec + +# timing for clipped stats +not ok 33 - clipped mean -0.047714, stdev 0.991979 (mask: 0, range: 0): 0.369 sec (1000 pts / 1000 loops) +not ok 35 - clipped mean 0.023963, stdev 0.972186 (mask: 0, range: 0): 1.219 sec (3000 pts / 1000 loops) +not ok 37 - clipped mean -0.007020, stdev 0.985410 (mask: 0, range: 0): 4.883 sec (10000 pts / 1000 loops) + +NOTE: these fail because they are being compared to the 'robust' stats +limits below. The clipped mean algorithm should not be so slow (and +apparently non-linear in npts). + +# timing for robust stats +ok 39 - robust mean 0.123348, stdev 1.014896 (mask: 0, range: 0): 0.187 sec (1000 pts / 1000 loops) +ok 41 - robust mean -0.006812, stdev 0.974468 (mask: 0, range: 0): 0.382 sec (3000 pts / 1000 loops) +ok 43 - robust mean -0.013591, stdev 1.001539 (mask: 0, range: 0): 1.076 sec (10000 pts / 1000 loops) + +# timing for fitted stats +ok 45 - fitted mean -0.029859, stdev 0.982947 (mask: 0, range: 0): 0.381 sec (1000 pts / 1000 loops) +ok 47 - fitted mean 0.014660, stdev 0.956168 (mask: 0, range: 0): 0.727 sec (3000 pts / 1000 loops) +ok 49 - fitted mean -0.008402, stdev 1.001366 (mask: 0, range: 0): 1.914 sec (10000 pts / 1000 loops) + Index: trunk/psLib/test/math/tap_psStats_Sample_01.c =================================================================== --- trunk/psLib/test/math/tap_psStats_Sample_01.c (revision 10395) +++ trunk/psLib/test/math/tap_psStats_Sample_01.c (revision 10550) @@ -215,11 +215,283 @@ }; +static float yraw_03[] = { + 183.6000061, 171.3600006, 182.5800018, 178.5, 176.4600067, + 176.4600067, 171.3600006, 178.5, 183.6000061, 175.4400024, + 159.1199951, 180.5399933, 183.6000061, 187.6799927, 175.4400024, + 181.5599976, 174.4199982, 179.5200043, 180.5399933, 187.6799927, + 183.6000061, 171.3600006, 177.4799957, 192.7799988, 184.6199951, + 176.4600067, 178.5, 182.5800018, 173.3999939, 191.7599945, + 202.9799957, 167.2799988, 181.5599976, 185.6399994, 173.3999939, + 159.1199951, 178.5, 188.6999969, 179.5200043, 178.5, + 184.6199951, 175.4400024, 186.6600037, 179.5200043, 183.6000061, + 182.5800018, 173.3999939, 181.5599976, 184.6199951, 177.4799957, + 162.1799927, 186.6600037, 163.1999969, 199.9199982, 173.3999939, + 170.3399963, 184.6199951, 190.7400055, 173.3999939, 178.5, + 189.7200012, 192.7799988, 166.2599945, 187.6799927, 174.4199982, + 176.4600067, 181.5599976, 199.9199982, 193.8000031, 170.3399963, + 182.5800018, 199.9199982, 183.6000061, 160.1399994, 184.6199951, + 195.8399963, 173.3999939, 189.7200012, 192.7799988, 162.1799927, + 174.4199982, 190.7400055, 175.4400024, 192.7799988, 181.5599976, + 185.6399994, 184.6199951, 166.2599945, 189.7200012, 192.7799988, + 183.6000061, 190.7400055, 188.6999969, 174.4199982, 184.6199951, + 186.6600037, 182.5800018, 173.3999939, 171.3600006, 166.2599945, + 166.2599945, 176.4600067, 147.8999939, 187.6799927, 166.2599945, + 173.3999939, 179.5200043, 166.2599945, 169.3200073, 172.3800049, + 174.4199982, 195.8399963, 192.7799988, 177.4799957, 181.5599976, + 163.1999969, 171.3600006, 194.8200073, 159.1199951, 173.3999939, + 182.5800018, 178.5, 179.5200043, 184.6199951, 179.5200043, + 164.2200012, 191.7599945, 177.4799957, 186.6600037, 168.3000031, + 168.3000031, 168.3000031, 180.5399933, 179.5200043, 175.4400024, + 174.4199982, 184.6199951, 186.6600037, 164.2200012, 169.3200073, + 187.6799927, 189.7200012, 166.2599945, 169.3200073, 187.6799927, + 172.3800049, 204, 194.8200073, 177.4799957, 188.6999969, + 171.3600006, 184.6199951, 182.5800018, 184.6199951, 176.4600067, + 186.6600037, 170.3399963, 170.3399963, 182.5800018, 184.6199951, + 168.3000031, 175.4400024, 176.4600067, 164.2200012, 183.6000061, + 161.1600037, 175.4400024, 167.2799988, 179.5200043, 176.4600067, + 175.4400024, 179.5200043, 158.1000061, 168.3000031, 168.3000031, + 179.5200043, 192.7799988, 190.7400055, 178.5, 173.3999939, + 180.5399933, 179.5200043, 191.7599945, 184.6199951, 177.4799957, + 182.5800018, 188.6999969, 169.3200073, 162.1799927, 172.3800049, + 160.1399994, 177.4799957, 176.4600067, 180.5399933, 170.3399963, + 168.3000031, 171.3600006, 180.5399933, 162.1799927, 163.1999969, + 170.3399963, 180.5399933, 164.2200012, 183.6000061, 178.5, + 193.8000031, 177.4799957, 178.5, 183.6000061, 192.7799988, + 157.0800018, 176.4600067, 190.7400055, 179.5200043, 157.0800018, + 178.5, 165.2400055, 195.8399963, 177.4799957, 166.2599945, + 172.3800049, 182.5800018, 175.4400024, 187.6799927, 164.2200012, + 178.5, 173.3999939, 173.3999939, 173.3999939, 172.3800049, + 183.6000061, 181.5599976, 163.1999969, 179.5200043, 193.8000031, + 172.3800049, 158.1000061, 171.3600006, 165.2400055, 183.6000061, + 187.6799927, 158.1000061, 171.3600006, 168.3000031, 166.2599945, + 166.2599945, 178.5, 179.5200043, 165.2400055, 176.4600067, + 160.1399994, 193.8000031, 170.3399963, 162.1799927, 180.5399933, + 159.1199951, 189.7200012, 160.1399994, 196.8600006, 173.3999939, + 170.3399963, 165.2400055, 193.8000031, 192.7799988, 184.6199951, + 151.9799957, 167.2799988, 162.1799927, 183.6000061, 166.2599945, + 177.4799957, 168.3000031, 191.7599945, 181.5599976, 166.2599945, + 171.3600006, 188.6999969, 172.3800049, 195.8399963, 189.7200012, + 177.4799957, 167.2799988, 191.7599945, 169.3200073, 181.5599976, + 180.5399933, 162.1799927, 171.3600006, 162.1799927, 171.3600006, + 177.4799957, 167.2799988, 180.5399933, 182.5800018, 187.6799927, + 175.4400024, 193.8000031, 174.4199982, 183.6000061, 179.5200043, + 164.2200012, 162.1799927, 186.6600037, 189.7200012, 186.6600037, + 171.3600006, 187.6799927, 189.7200012, 175.4400024, 184.6199951, + 172.3800049, 177.4799957, 183.6000061, 176.4600067, 171.3600006, + 172.3800049, 181.5599976, 175.4400024, 170.3399963, 196.8600006, + 201.9600067, 180.5399933, 176.4600067, 183.6000061, 175.4400024, + 184.6199951, 163.1999969, 177.4799957, 176.4600067, 175.4400024, + 192.7799988, 167.2799988, 176.4600067, 184.6199951, 184.6199951, + 177.4799957, 185.6399994, 196.8600006, 186.6600037, 184.6199951, + 169.3200073, 164.2200012, 185.6399994, 168.3000031, 186.6600037, + 180.5399933, 177.4799957, 177.4799957, 186.6600037, 191.7599945, + 177.4799957, 181.5599976, 166.2599945, 179.5200043, 184.6199951, + 178.5, 171.3600006, 184.6199951, 192.7799988, 182.5800018, + 186.6600037, 175.4400024, 182.5800018, 173.3999939, 186.6600037, + 162.1799927, 175.4400024, 196.8600006, 166.2599945, 189.7200012, + 189.7200012, 182.5800018, 172.3800049, 165.2400055, 191.7599945, + 174.4199982, 173.3999939, 178.5, 171.3600006, 157.0800018, + 182.5800018, 161.1600037, 195.8399963, 186.6600037, 167.2799988, + 166.2599945, 182.5800018, 178.5, 176.4600067, 181.5599976, + 184.6199951, 183.6000061, 179.5200043, 174.4199982, 167.2799988, + 187.6799927, 176.4600067, 165.2400055, 179.5200043, 157.0800018, + 171.3600006, 170.3399963, 175.4400024, 161.1600037, 185.6399994, + 169.3200073, 192.7799988, 175.4400024, 172.3800049, 180.5399933, + 183.6000061, 174.4199982, 176.4600067, 164.2200012, 183.6000061, + 179.5200043, 165.2400055, 169.3200073, 172.3800049, 149.9400024, + 175.4400024, 188.6999969, 190.7400055, 171.3600006, 172.3800049, + 183.6000061, 178.5, 165.2400055, 176.4600067, 177.4799957, + 188.6999969, 192.7799988, 183.6000061, 163.1999969, 186.6600037, + 183.6000061, 160.1399994, 167.2799988, 172.3800049, 179.5200043, + 189.7200012, 172.3800049, 177.4799957, 161.1600037, 174.4199982, + 190.7400055, 181.5599976, 187.6799927, 176.4600067, 176.4600067, + 183.6000061, 176.4600067, 188.6999969, 174.4199982, 170.3399963, + 185.6399994, 177.4799957, 172.3800049, 179.5200043, 175.4400024, + 170.3399963, 169.3200073, 176.4600067, 177.4799957, 169.3200073, + 199.9199982, 171.3600006, 194.8200073, 188.6999969, 193.8000031, + 182.5800018, 171.3600006, 177.4799957, 175.4400024, 172.3800049, + 166.2599945, 183.6000061, 157.0800018, 177.4799957, 193.8000031, + 168.3000031, 175.4400024, 175.4400024, 170.3399963, 191.7599945, + 189.7200012, 182.5800018, 177.4799957, 157.0800018, 174.4199982, + 189.7200012, 162.1799927, 184.6199951, 164.2200012, 157.0800018, + 197.8800049, 175.4400024, 184.6199951, 202.9799957, 190.7400055, + 171.3600006, 160.1399994, 162.1799927, 176.4600067, 180.5399933, + 206.0399933, 189.7200012, 170.3399963, 175.4400024, 175.4400024, + 185.6399994, 187.6799927, 168.3000031, 176.4600067, 177.4799957, + 185.6399994, 167.2799988, 178.5, 182.5800018, 179.5200043, + 173.3999939, 185.6399994, 196.8600006, 183.6000061, 162.1799927, + 176.4600067, 189.7200012, 208.0800018, 177.4799957, 163.1999969, + 187.6799927, 196.8600006, 180.5399933, 188.6999969, 163.1999969, + 187.6799927, 168.3000031, 182.5800018, 181.5599976, 174.4199982, + 181.5599976, 161.1600037, 163.1999969, 184.6199951, 190.7400055, + 181.5599976, 185.6399994, 186.6600037, 173.3999939, 172.3800049, + 179.5200043, 187.6799927, 191.7599945, 190.7400055, 183.6000061, + 166.2599945, 196.8600006, 172.3800049, 174.4199982, 181.5599976, + 177.4799957, 176.4600067, 188.6999969, 184.6199951, 169.3200073, + 178.5, 186.6600037, 174.4199982, 185.6399994, 201.9600067, + 171.3600006, 177.4799957, 183.6000061, 165.2400055, 189.7200012, + 188.6999969, 178.5, 163.1999969, 169.3200073, 178.5, + 182.5800018, 173.3999939, 177.4799957, 165.2400055, 163.1999969, + 175.4400024, 184.6199951, 189.7200012, 186.6600037, 188.6999969, + 163.1999969, 158.1000061, 172.3800049, 186.6600037, 173.3999939, + 157.0800018, 158.1000061, 172.3800049, 197.8800049, 171.3600006, + 172.3800049, 184.6199951, 173.3999939, 174.4199982, 175.4400024, + 166.2599945, 166.2599945, 172.3800049, 171.3600006, 181.5599976, + 181.5599976, 187.6799927, 180.5399933, 169.3200073, 182.5800018, + 178.5, 179.5200043, 184.6199951, 175.4400024, 175.4400024, + 158.1000061, 182.5800018, 196.8600006, 167.2799988, 178.5, + 174.4199982, 180.5399933, 195.8399963, 183.6000061, 200.9400024, + 189.7200012, 186.6600037, 173.3999939, 173.3999939, 180.5399933, + 172.3800049, 157.0800018, 163.1999969, 171.3600006, 190.7400055, + 196.8600006, 179.5200043, 175.4400024, 169.3200073, 158.1000061, + 157.0800018, 180.5399933, 173.3999939, 170.3399963, 175.4400024, + 193.8000031, 170.3399963, 164.2200012, 174.4199982, 185.6399994, + 178.5, 176.4600067, 176.4600067, 179.5200043, 176.4600067, + 171.3600006, 205.0200043, 184.6199951, 180.5399933, 165.2400055, + 167.2799988, 162.1799927, 165.2400055, 180.5399933, 169.3200073, + 176.4600067, 182.5800018, 182.5800018, 175.4400024, 186.6600037, + 182.5800018, 183.6000061, 163.1999969, 161.1600037, 189.7200012, + 181.5599976, 187.6799927, 173.3999939, 173.3999939, 177.4799957, + 179.5200043, 198.8999939, 177.4799957, 183.6000061, 154.0200043, + 188.6999969, 181.5599976, 177.4799957, 174.4199982, 202.9799957, + 168.3000031, 164.2200012, 187.6799927, 171.3600006, 189.7200012, + 185.6399994, 187.6799927, 157.0800018, 193.8000031, 160.1399994, + 166.2599945, 193.8000031, 166.2599945, 168.3000031, 179.5200043, + 181.5599976, 172.3800049, 183.6000061, 184.6199951, 180.5399933, + 177.4799957, 192.7799988, 171.3600006, 197.8800049, 190.7400055, + 182.5800018, 178.5, 189.7200012, 172.3800049, 199.9199982, + 183.6000061, 179.5200043, 170.3399963, 179.5200043, 181.5599976, + 178.5, 186.6600037, 177.4799957, 160.1399994, 176.4600067, + 173.3999939, 168.3000031, 180.5399933, 179.5200043, 175.4400024, + 188.6999969, 175.4400024, 178.5, 161.1600037, 181.5599976, + 184.6199951, 169.3200073, 187.6799927, 164.2200012, 176.4600067, + 176.4600067, 174.4199982, 189.7200012, 192.7799988, 181.5599976, + 165.2400055, 173.3999939, 184.6199951, 164.2200012, 181.5599976, + 167.2799988, 157.0800018, 175.4400024, 172.3800049, 172.3800049, + 170.3399963, 166.2599945, 185.6399994, 175.4400024, 184.6199951, + 179.5200043, 198.8999939, 189.7200012, 164.2200012, 198.8999939, + 169.3200073, 183.6000061, 191.7599945, 168.3000031, 178.5, + 172.3800049, 169.3200073, 196.8600006, 170.3399963, 192.7799988, + 183.6000061, 186.6600037, 181.5599976, 187.6799927, 198.8999939, + 167.2799988, 177.4799957, 165.2400055, 173.3999939, 182.5800018, + 190.7400055, 167.2799988, 184.6199951, 180.5399933, 165.2400055, + 166.2599945, 162.1799927, 175.4400024, 169.3200073, 187.6799927, + 155.0399933, 173.3999939, 165.2400055, 174.4199982, 183.6000061, + 167.2799988, 186.6600037, 175.4400024, 173.3999939, 177.4799957, + 192.7799988, 180.5399933, 191.7599945, 185.6399994, 194.8200073, + 201.9600067, 166.2599945, 171.3600006, 177.4799957, 194.8200073, + 191.7599945, 177.4799957, 167.2799988, 188.6999969, 172.3800049, + 162.1799927, 169.3200073, 198.8999939, 183.6000061, 170.3399963, + 190.7400055, 170.3399963, 169.3200073, 185.6399994, 181.5599976, + 166.2599945, 187.6799927, 169.3200073, 157.0800018, 165.2400055, + 176.4600067, 174.4199982, 166.2599945, 177.4799957, 195.8399963, + 187.6799927, 186.6600037, 194.8200073, 181.5599976, 172.3800049, + 166.2599945, 168.3000031, 183.6000061, 168.3000031, 174.4199982, + 185.6399994, 180.5399933, 181.5599976, 189.7200012, 172.3800049, + 183.6000061, 187.6799927, 183.6000061, 200.9400024, 184.6199951, + 173.3999939, 176.4600067, 172.3800049, 169.3200073, 166.2599945, + 186.6600037, 181.5599976, 161.1600037, 182.5800018, 179.5200043, + 178.5, 174.4199982, 170.3399963, 179.5200043, 193.8000031, + 188.6999969, 146.8800049, 192.7799988, 171.3600006, 178.5, + 177.4799957, 184.6199951, 180.5399933, 163.1999969, 159.1199951, + 160.1399994, 178.5, 176.4600067, 176.4600067, 192.7799988, + 161.1600037, 166.2599945, 162.1799927, 172.3800049, 175.4400024, + 168.3000031, 201.9600067, 188.6999969, 185.6399994, 175.4400024, + 175.4400024, 182.5800018, 182.5800018, 172.3800049, 175.4400024, + 179.5200043, 184.6199951, 163.1999969, 195.8399963, 180.5399933, + 170.3399963, 212.1600037, 166.2599945, 187.6799927, 179.5200043, + 178.5, 176.4600067, 172.3800049, 183.6000061, 179.5200043, + 176.4600067, 185.6399994, 161.1600037, 187.6799927, 167.2799988, + 187.6799927, 199.9199982, 187.6799927, 169.3200073, 158.1000061, + 200.9400024, 191.7599945, 179.5200043, 170.3399963, 186.6600037, + 170.3399963, 184.6199951, 189.7200012, 197.8800049, 186.6600037, + 171.3600006, 164.2200012, 183.6000061, 180.5399933, 165.2400055, + 160.1399994, 183.6000061, 166.2599945, 183.6000061, 196.8600006, + 175.4400024, 172.3800049, 172.3800049, 181.5599976, 177.4799957, + 173.3999939, 176.4600067, 180.5399933, 176.4600067, 178.5, + 163.1999969, 189.7200012, 175.4400024, 174.4199982, 185.6399994, + 182.5800018, 169.3200073, 194.8200073, 192.7799988, 188.6999969, + 193.8000031, 175.4400024, 165.2400055, 180.5399933, 184.6199951, + 176.4600067, 171.3600006, 188.6999969, 199.9199982, 183.6000061, + 169.3200073, 175.4400024, 180.5399933, 174.4199982, 167.2799988, + 184.6199951, 177.4799957, 180.5399933, 180.5399933, 184.6199951, + 178.5, 186.6600037, 161.1600037, 183.6000061, 168.3000031, + 188.6999969, 184.6199951, 171.3600006, 185.6399994, 167.2799988, + 162.1799927, 186.6600037, 175.4400024, 166.2599945, 182.5800018, + 171.3600006, 176.4600067, 192.7799988, 178.5, 168.3000031, + 182.5800018, 184.6199951, 148.9199982, 172.3800049, 168.3000031, + 181.5599976, 154.0200043, 166.2599945, 174.4199982, 166.2599945, + 178.5, 184.6199951, 176.4600067, 171.3600006, 188.6999969, + 177.4799957, 172.3800049, 176.4600067, 179.5200043, 176.4600067, + 161.1600037, 166.2599945, 181.5599976, 170.3399963, 176.4600067, + 163.1999969, 183.6000061, 206.0399933, 171.3600006, 186.6600037, + 176.4600067, 163.1999969, 179.5200043, 176.4600067, 182.5800018, + 167.2799988, 174.4199982, 188.6999969, 177.4799957, 190.7400055, + 176.4600067, 175.4400024, 174.4199982, 179.5200043, 182.5800018, + 182.5800018, 175.4400024, 165.2400055, 180.5399933, 178.5, + 176.4600067, 191.7599945, 173.3999939, 186.6600037, 165.2400055, + 173.3999939, 188.6999969, 172.3800049, 168.3000031, 193.8000031, + 180.5399933, 172.3800049, 180.5399933, 189.7200012, 170.3399963, + 170.3399963, 195.8399963, 173.3999939, 187.6799927, 165.2400055, + 147.8999939, 173.3999939, 184.6199951, 171.3600006, 178.5, + 163.1999969, 171.3600006, 190.7400055, 180.5399933, 156.0599976, + 164.2200012, 172.3800049, 202.9799957, 201.9600067, 175.4400024, + 193.8000031, 176.4600067, 182.5800018, 184.6199951, 178.5, + 169.3200073, 166.2599945, 173.3999939, 182.5800018, 171.3600006, + 167.2799988, 185.6399994, 179.5200043, 188.6999969, 194.8200073, + 177.4799957, 177.4799957, 164.2200012, 189.7200012, 193.8000031, + 173.3999939, 178.5, 184.6199951, 191.7599945, 191.7599945, + 162.1799927, 171.3600006, 165.2400055, 197.8800049, 169.3200073, + 178.5, 174.4199982, 183.6000061, 189.7200012, 181.5599976, + 185.6399994, 179.5200043, 181.5599976, 161.1600037, 173.3999939, + 187.6799927, 177.4799957, 182.5800018, 171.3600006, 188.6999969, + 194.8200073, 176.4600067, 182.5800018, 157.0800018, 169.3200073, + 170.3399963, 168.3000031, 190.7400055, 170.3399963, 185.6399994, + 195.8399963, 172.3800049, 213.1799927, 187.6799927, 187.6799927, + 178.5, 181.5599976, 183.6000061, 163.1999969, 169.3200073, + 180.5399933, 204, 175.4400024, 158.1000061, 174.4199982, + 183.6000061, 181.5599976, 181.5599976, 180.5399933, 172.3800049, + 188.6999969, 166.2599945, 196.8600006, 187.6799927, 196.8600006, + 164.2200012, 160.1399994, 165.2400055, 172.3800049, 177.4799957, + 173.3999939, 168.3000031, 181.5599976, 164.2200012, 177.4799957, + 182.5800018, 162.1799927, 168.3000031, 181.5599976, 179.5200043, + 171.3600006, 173.3999939, 176.4600067, 197.8800049, 172.3800049, + 189.7200012, 172.3800049, 161.1600037, 183.6000061, 173.3999939, + 188.6999969, 161.1600037, 180.5399933, 160.1399994, 166.2599945, + 164.2200012, 182.5800018, 169.3200073, 176.4600067, 186.6600037, + 192.7799988, 163.1999969, 153, 182.5800018, 184.6199951, + 166.2599945, 167.2799988, 186.6600037, 177.4799957, 174.4199982, + 175.4400024, 164.2200012, 180.5399933, 178.5, 176.4600067, + 164.2200012, 160.1399994, 178.5, 176.4600067, 180.5399933, + 182.5800018, 179.5200043, 169.3200073, 178.5, 172.3800049, + 171.3600006, 178.5, 166.2599945, 171.3600006, 181.5599976, + 162.1799927, 157.0800018, 189.7200012, 177.4799957, 164.2200012, + 179.5200043, 187.6799927, 172.3800049, 158.1000061, 164.2200012, + 177.4799957, 165.2400055, 185.6399994, 174.4199982, 188.6999969, + 173.3999939, 168.3000031, 164.2200012, 187.6799927, 209.1000061, + 172.3800049, 177.4799957, 170.3399963, 172.3800049, 164.2200012, + 190.7400055, 177.4799957, 165.2400055, 168.3000031, 173.3999939, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + int main (void) { plan_tests(26); - diag("psStats Tests with sample SDSS data from RHL"); + diag("psStats Tests with sample SDSS data from RHL and Megacam from EAM"); diag("this file does not yet define a specific test"); - diag ("the fitted mean is currently wrong for these two data sets"); + diag("the fitted mean is currently wrong for these two data sets"); { @@ -243,12 +515,18 @@ psVectorStats (stats, y, NULL, NULL, 1); - ok (1, "fitted mean %f, stdev %f", stats->fittedMean, stats->fittedStdev); - ok (1, "robust median %f, stdev %f", stats->robustMedian, stats->robustStdev); - ok (1, "clipped mean %f, stdev %f", stats->clippedMean, stats->clippedStdev); - ok (1, "sample mean %f, stdev %f", stats->sampleMean, stats->sampleStdev); - ok (1, "sample median %f, stdev %f", stats->sampleMedian, stats->sampleStdev); + ok (1, "sample mean %f, stdev %f", stats->sampleMean, stats->sampleStdev); + ok (1, "sample median %f, stdev %f", stats->sampleMedian, stats->sampleStdev); + ok (1, "clipped mean %f, stdev %f", stats->clippedMean, stats->clippedStdev); + ok (1, "robust median %f, stdev %f", stats->robustMedian, stats->robustStdev); + ok (1, "fitted mean %f, stdev %f", stats->fittedMean, stats->fittedStdev); + psFree (stats); + + stats = psStatsAlloc (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2 | PS_STAT_USE_BINSIZE); + stats->binsize = 1.0; + psVectorStats (stats, y, NULL, NULL, 1); + ok (1, "fitted mean v2 %f, stdev %f", stats->fittedMean, stats->fittedStdev); + psFree (stats); psFree (y); - psFree (stats); ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); } @@ -273,15 +551,58 @@ psVectorStats (stats, y, NULL, NULL, 1); - ok (1, "fitted mean %f, stdev %f", stats->fittedMean, stats->fittedStdev); - ok (1, "robust median %f, stdev %f", stats->robustMedian, stats->robustStdev); - ok (1, "clipped mean %f, stdev %f", stats->clippedMean, stats->clippedStdev); ok (1, "sample mean %f, stdev %f", stats->sampleMean, stats->sampleStdev); ok (1, "sample median %f, stdev %f", stats->sampleMedian, stats->sampleStdev); + ok (1, "clipped mean %f, stdev %f", stats->clippedMean, stats->clippedStdev); + ok (1, "robust median %f, stdev %f", stats->robustMedian, stats->robustStdev); + ok (1, "fitted mean %f, stdev %f", stats->fittedMean, stats->fittedStdev); + psFree (stats); + + stats = psStatsAlloc (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2 | PS_STAT_USE_BINSIZE); + stats->binsize = 1.0; + psVectorStats (stats, y, NULL, NULL, 1); + ok (1, "fitted mean v2 %f, stdev %f", stats->fittedMean, stats->fittedStdev); + psFree (stats); psFree (y); - psFree (stats); ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); } + { + psMemId id = psMemGetId(); + + diag("sample 3"); + psStats *stats = psStatsAlloc (PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV | + PS_STAT_ROBUST_MEDIAN | PS_STAT_ROBUST_STDEV | + PS_STAT_CLIPPED_MEAN | PS_STAT_CLIPPED_STDEV | + PS_STAT_SAMPLE_MEAN | PS_STAT_SAMPLE_MEDIAN | + PS_STAT_SAMPLE_STDEV | PS_STAT_USE_BINSIZE); + stats->binsize = 1.0; + + + // copy data in static array + int nPts = sizeof(yraw_03) / sizeof (float); + psVector *y = psVectorAlloc (nPts, PS_TYPE_F32); + for (int i = 0; i < y->n; i++) { + y->data.F32[i] = yraw_03[i]; + } + + psVectorStats (stats, y, NULL, NULL, 1); + ok (1, "sample mean %f, stdev %f", stats->sampleMean, stats->sampleStdev); + ok (1, "sample median %f, stdev %f", stats->sampleMedian, stats->sampleStdev); + ok (1, "clipped mean %f, stdev %f", stats->clippedMean, stats->clippedStdev); + ok (1, "robust median %f, stdev %f", stats->robustMedian, stats->robustStdev); + ok (1, "fitted mean %f, stdev %f", stats->fittedMean, stats->fittedStdev); + psFree (stats); + + stats = psStatsAlloc (PS_STAT_FITTED_MEAN_V2 | PS_STAT_FITTED_STDEV_V2 | PS_STAT_USE_BINSIZE); + stats->binsize = 1.0; + psVectorStats (stats, y, NULL, NULL, 1); + ok (1, "fitted mean v2 %f, stdev %f", stats->fittedMean, stats->fittedStdev); + psFree (stats); + + psFree (y); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + return exit_status(); }