Changeset 481 for library/tests/epdf_harness.cpp

Timestamp:

08/06/09 13:38:17 (15 years ago)

Author:

vbarta

Message:

doubled tolerance computed from variance, repeating failing tests (at most) 3 times; epdf tests pass

Files:

• library/tests/epdf_harness.cpp (modified) (5 diffs)

library/tests/epdf_harness.cpp

@@ -3 +3 @@
 #include "base/user_info.h"
 #include "stat/exp_family.h"
-#include "stat/emix.h"
 #include "mat_checks.h"
 #include "test_util.h"
@@ -50 +49 @@
 
         if ( support.rows() == 2 ) {
-                vec xb = support.get_row ( 0 );
-                vec yb = support.get_row ( 1 );
-
                 int old_size = nbins.size();
                 if ( old_size < 2 ) {
@@ -63 +59 @@
                 }
 
-                CHECK_CLOSE_EX ( mean, num_mean2 ( hepdf.get(), xb, yb, nbins ( 0 ), nbins ( 1 ) ), tolerance );
-                CHECK_CLOSE_EX ( 1.0, normcoef ( hepdf.get(), xb, yb, nbins ( 0 ), nbins ( 1 ) ), tolerance );
+                check_support_mean();
+                check_support_integral();
         }
 
         if ( R.rows() > 0 ) {
-                mat smp = hepdf->sample_m ( nsamples );
-                vec emu = smp * ones ( nsamples ) / nsamples;
-                mat er = ( smp * smp.T() ) / nsamples - outer_product ( emu, emu );
-
-                // simplify overloading for Visual Studio
-                vec delta = sqrt ( variance ) / sqrt ( static_cast<double> ( nsamples ) );
-                CHECK_CLOSE_EX ( mean, emu, delta );
-
-                CHECK_CLOSE_EX ( R, er, tolerance );
+                check_sample_mean();
+                check_covariance();
         }
 
@@ -90 +79 @@
                 mprod mEp ( aa );
 
-                mat smp = mEp.samplecond ( vec ( 0 ), nsamples );
-                vec emu = sum ( smp, 2 ) / nsamples;
-
-                // simplify overloading for Visual Studio
-                vec delta = sqrt ( variance ) / sqrt ( static_cast<double> ( nsamples ) );
-                CHECK_CLOSE_EX ( mean, emu, delta );
-
+                check_cond_mean(mEp);
                 if ( R.rows() > 0 ) {
-                        mat er = ( smp * smp.T() ) / nsamples - outer_product ( emu, emu );
-                        CHECK_CLOSE_EX ( R, er, tolerance );
+                        check_cond_covariance( mEp );
                 }
 
@@ -113 +95 @@
 }
 
-}
+void epdf_harness::check_support_mean() {
+        vec xb = support.get_row ( 0 );
+        vec yb = support.get_row ( 1 );
+
+        int tc = 0;
+        Array<vec> actual(CurrentContext::max_trial_count);
+        do {
+                vec emu = num_mean2 ( hepdf.get(), xb, yb, nbins ( 0 ), nbins ( 1 ) );
+                actual( tc ) = emu;
+                ++tc;
+        } while ( ( tc < CurrentContext::max_trial_count ) &&
+                  !UnitTest::AreClose ( mean, actual( tc - 1 ), tolerance ) );
+        if ( ( tc == CurrentContext::max_trial_count ) &&
+             ( !UnitTest::AreClose ( mean, actual( CurrentContext::max_trial_count - 1 ), tolerance ) ) ) {
+                UnitTest::MemoryOutStream stream;
+                stream << CurrentContext::format_context(__LINE__) << "expected " << mean << " +/- " << tolerance << " but was " << actual;
+
+                UnitTest::TestDetails details(*UnitTest::CurrentTest::Details(), 0, false);
+
+                UnitTest::CurrentTest::Results()->OnTestFailure ( details, stream.GetText() );
+       }
+}
+
+void epdf_harness::check_support_integral() {
+        vec xb = support.get_row ( 0 );
+        vec yb = support.get_row ( 1 );
+
+        int tc = 0;
+        Array<double> actual(CurrentContext::max_trial_count);
+        do {
+                double nc = normcoef ( hepdf.get(), xb, yb, nbins ( 0 ), nbins ( 1 ) );
+                actual( tc ) = nc;
+                ++tc;
+        } while ( ( tc < CurrentContext::max_trial_count ) &&
+                  !UnitTest::AreClose ( 1.0, actual( tc - 1 ), tolerance ) );
+        if ( ( tc == CurrentContext::max_trial_count ) &&
+             ( !UnitTest::AreClose ( 1.0, actual( CurrentContext::max_trial_count - 1 ), tolerance ) ) ) {
+                UnitTest::MemoryOutStream stream;
+                stream << CurrentContext::format_context(__LINE__) << "expected " << mean << " +/- " << tolerance << " but was " << actual;
+
+                UnitTest::TestDetails details(*UnitTest::CurrentTest::Details(), 0, false);
+
+                UnitTest::CurrentTest::Results()->OnTestFailure ( details, stream.GetText() );
+       }
+}
+
+void epdf_harness::check_sample_mean() {
+        // simplify overloading for Visual Studio
+        vec delta = 2 * ( sqrt ( variance ) / sqrt ( static_cast<double> ( nsamples ) ) );
+
+        int tc = 0;
+        Array<vec> actual(CurrentContext::max_trial_count);
+        do {
+                mat smp = hepdf->sample_m ( nsamples );
+                vec emu = smp * ones ( nsamples ) / nsamples;
+                actual( tc ) = emu;
+                ++tc;
+        } while ( ( tc < CurrentContext::max_trial_count ) &&
+                  !UnitTest::AreClose ( mean, actual( tc - 1 ), delta ) );
+        if ( ( tc == CurrentContext::max_trial_count ) &&
+             ( !UnitTest::AreClose ( mean, actual( CurrentContext::max_trial_count - 1 ), delta ) ) ) {
+                UnitTest::MemoryOutStream stream;
+                stream << CurrentContext::format_context(__LINE__) << "expected " << mean << " +/- " << delta << " but was " << actual;
+
+                UnitTest::TestDetails details(*UnitTest::CurrentTest::Details(), 0, false);
+
+                UnitTest::CurrentTest::Results()->OnTestFailure ( details, stream.GetText() );
+       }
+}
+
+
+void epdf_harness::check_covariance() {
+        int tc = 0;
+        Array<mat> actual(CurrentContext::max_trial_count);
+        do {
+                mat smp = hepdf->sample_m ( nsamples );
+                vec emu = smp * ones ( nsamples ) / nsamples;
+                mat er = ( smp * smp.T() ) / nsamples - outer_product ( emu, emu );
+                actual( tc ) = er;
+                ++tc;
+        } while ( ( tc < CurrentContext::max_trial_count ) &&
+                  !UnitTest::AreClose ( R, actual( tc - 1 ), tolerance ) );
+        if ( ( tc == CurrentContext::max_trial_count ) &&
+             ( !UnitTest::AreClose ( R, actual( CurrentContext::max_trial_count - 1 ), tolerance ) ) ) {
+                UnitTest::MemoryOutStream stream;
+                stream << CurrentContext::format_context(__LINE__) << "expected " << R << " +/- " << tolerance << " but was " << actual;
+
+                UnitTest::TestDetails details(*UnitTest::CurrentTest::Details(), 0, false);
+
+                UnitTest::CurrentTest::Results()->OnTestFailure ( details, stream.GetText() );
+       }
+}
+
+void epdf_harness::check_cond_mean( mprod &mep ) {
+        // simplify overloading for Visual Studio
+        vec delta = 2 * ( sqrt ( variance ) / sqrt ( static_cast<double> ( nsamples ) ) );
+
+        int tc = 0;
+        Array<vec> actual(CurrentContext::max_trial_count);
+        do {
+                mat smp = mep.samplecond ( vec ( 0 ), nsamples );
+                vec emu = sum ( smp, 2 ) / nsamples;
+                actual( tc ) = emu;
+                ++tc;
+        } while ( ( tc < CurrentContext::max_trial_count ) &&
+                  !UnitTest::AreClose ( mean, actual( tc - 1 ), delta ) );
+        if ( ( tc == CurrentContext::max_trial_count ) &&
+             ( !UnitTest::AreClose ( mean, actual( CurrentContext::max_trial_count - 1 ), delta ) ) ) {
+                UnitTest::MemoryOutStream stream;
+                stream << CurrentContext::format_context(__LINE__) << "expected " << mean << " +/- " << delta << " but was " << actual;
+
+                UnitTest::TestDetails details(*UnitTest::CurrentTest::Details(), 0, false);
+
+                UnitTest::CurrentTest::Results()->OnTestFailure ( details, stream.GetText() );
+       }
+}
+
+void epdf_harness::check_cond_covariance( mprod &mep ) {
+        int tc = 0;
+        Array<mat> actual(CurrentContext::max_trial_count);
+        do {
+                mat smp = mep.samplecond ( vec ( 0 ), nsamples );
+                vec emu = sum ( smp, 2 ) / nsamples;
+                mat er = ( smp * smp.T() ) / nsamples - outer_product ( emu, emu );
+                actual( tc ) = er;
+                ++tc;
+        } while ( ( tc < CurrentContext::max_trial_count ) &&
+                  !UnitTest::AreClose ( R, actual( tc - 1 ), tolerance ) );
+        if ( ( tc == CurrentContext::max_trial_count ) &&
+             ( !UnitTest::AreClose ( R, actual( CurrentContext::max_trial_count - 1 ), tolerance ) ) ) {
+                UnitTest::MemoryOutStream stream;
+                stream << CurrentContext::format_context(__LINE__) << "expected " << mean << " +/- " << tolerance << " but was " << actual;
+
+                UnitTest::TestDetails details(*UnitTest::CurrentTest::Details(), 0, false);
+
+                UnitTest::CurrentTest::Results()->OnTestFailure ( details, stream.GetText() );
+       }
+}
+
+}