From dbaae571f8b2700defa12df47623ef26fcc31808 Mon Sep 17 00:00:00 2001 From: "Paul A. Bristow" Date: Wed, 29 Aug 2007 14:10:31 +0000 Subject: [PATCH] corrected tests. [SVN r39051] --- test/test_triangular.cpp | 103 ++++++++++++++++++++++----------------- 1 file changed, 57 insertions(+), 46 deletions(-) diff --git a/test/test_triangular.cpp b/test/test_triangular.cpp index dc99366ce..85728323e 100644 --- a/test/test_triangular.cpp +++ b/test/test_triangular.cpp @@ -1,5 +1,5 @@ -// Copyright Paul Bristow 2007. -// Copyright John Maddock 2006. +// Copyright Paul Bristow 2006, 2007. +// Copyright John Maddock 2006, 2007. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. @@ -19,7 +19,8 @@ #include using boost::math::triangular_distribution; -#include +#include +#include #include using std::cout; @@ -285,7 +286,7 @@ void test_spots(RealType) tolerance); // cdf complement - BOOST_CHECK_EQUAL( // x < lower + BOOST_CHECK_EQUAL( // x < lower cdf(complement(triangular_distribution(0, 0, 1), static_cast(-1))), static_cast(1)); BOOST_CHECK_EQUAL( // x == lower @@ -303,7 +304,6 @@ void test_spots(RealType) cdf(complement(triangular_distribution(0, 1, 1), static_cast(1))), static_cast(0)); - BOOST_CHECK_EQUAL( // x > upper cdf(complement(triangular_distribution(0, 0, 1), static_cast(2))), static_cast(0)); @@ -316,13 +316,13 @@ void test_spots(RealType) static_cast(0.875L), tolerance); - BOOST_CHECK_CLOSE_FRACTION( // x = +0.5 + BOOST_CHECK_CLOSE_FRACTION( // x = +0.5 cdf(complement(triangular_distribution(-1, 0, 1), static_cast(0.5))), static_cast(0.125), tolerance); - triangular_distribution triang; // Using typedef == triangular_distribution tristd; - triangular_distribution tristd(0, 0.5, 1); // 'Standard' triangular distribution. + triangular_distribution triang; // Using typedef == triangular_distribution tristd; + triangular_distribution tristd(0, 0.5, 1); // 'Standard' triangular distribution. BOOST_CHECK_CLOSE_FRACTION( // median of Standard triangular is sqrt(mode/2) if c > 1/2 else 1 - sqrt((1-c)/2) median(tristd), @@ -389,18 +389,17 @@ void test_spots(RealType) check_triangular( static_cast(0), // lower - static_cast(0.5), // mode + static_cast(0.5), // mode static_cast(1), // upper static_cast(0.5), // x static_cast(0.5), // p static_cast(1 - 0.5), // q tolerance); - return; // Some Not-standard triangular tests. check_triangular( static_cast(-1), // lower - static_cast(1), // mode + static_cast(0), // mode static_cast(1), // upper static_cast(0), // x static_cast(0.5), // p @@ -408,12 +407,12 @@ void test_spots(RealType) tolerance); check_triangular( - static_cast(1), // lower + static_cast(1), // lower static_cast(1), // mode - static_cast(3), // upper - static_cast(2), // x - static_cast(0.5), // p - static_cast(1 - 0.5), // q = 1 - p + static_cast(3), // upper + static_cast(2), // x + static_cast(0.75), // p + static_cast(1 - 0.75), // q = 1 - p tolerance); check_triangular( @@ -428,53 +427,66 @@ void test_spots(RealType) boost::math::tools::epsilon(), static_cast(boost::math::tools::epsilon())) * 5; // 5 eps as a fraction. cout << "Tolerance (as fraction) for type " << typeid(RealType).name() << " is " << tolerance << "." << endl; - triangular_distribution distu01(0, 1); + triangular_distribution tridef; // (-1, 0, 1) // default RealType x = static_cast(0.5); using namespace std; // ADL of std names. // mean: BOOST_CHECK_CLOSE_FRACTION( - mean(distu01), static_cast(0.5), tolerance); + mean(tridef), static_cast(0), tolerance); // variance: BOOST_CHECK_CLOSE_FRACTION( - variance(distu01), static_cast(0.0833333333333333333333333333333333333333333L), tolerance); + variance(tridef), static_cast(0.16666666666666666666666666666666666666666667L), tolerance); + // was 0.0833333333333333333333333333333333333333333L + // std deviation: BOOST_CHECK_CLOSE_FRACTION( - standard_deviation(distu01), sqrt(variance(distu01)), tolerance); + standard_deviation(tridef), sqrt(variance(tridef)), tolerance); // hazard: BOOST_CHECK_CLOSE_FRACTION( - hazard(distu01, x), pdf(distu01, x) / cdf(complement(distu01, x)), tolerance); + hazard(tridef, x), pdf(tridef, x) / cdf(complement(tridef, x)), tolerance); // cumulative hazard: BOOST_CHECK_CLOSE_FRACTION( - chf(distu01, x), -log(cdf(complement(distu01, x))), tolerance); + chf(tridef, x), -log(cdf(complement(tridef, x))), tolerance); // coefficient_of_variation: + if (mean(tridef) != 0) + { BOOST_CHECK_CLOSE_FRACTION( - coefficient_of_variation(distu01), standard_deviation(distu01) / mean(distu01), tolerance); + coefficient_of_variation(tridef), standard_deviation(tridef) / mean(tridef), tolerance); + } // mode: BOOST_CHECK_CLOSE_FRACTION( - mode(distu01), static_cast(0), tolerance); + mode(tridef), static_cast(0), tolerance); // skewness: BOOST_CHECK_CLOSE_FRACTION( median(trim12), static_cast(-0.13397459621556151), tolerance); BOOST_CHECK_EQUAL( - skewness(distu01), static_cast(0)); + skewness(tridef), static_cast(0)); // kurtosis: BOOST_CHECK_CLOSE_FRACTION( - kurtosis_excess(distu01), kurtosis(distu01) - static_cast(3L), tolerance); + kurtosis_excess(tridef), kurtosis(tridef) - static_cast(3L), tolerance); // kurtosis excess = kurtosis - 3; BOOST_CHECK_CLOSE_FRACTION( - kurtosis_excess(distu01), static_cast(-1.2), tolerance); + kurtosis_excess(tridef), static_cast(-0.6), tolerance); // for all distributions. if(std::numeric_limits::has_infinity) { // BOOST_CHECK tests for infinity using std::numeric_limits<>::infinity() // Note that infinity is not implemented for real_concept, so these tests // are only done for types, like built-in float, double.. that have infinity. - // Note that these assume that BOOST_MATH_OVERFLOW_ERROR_POLICY is NOT throw_on_error. + // Note that these assume that BOOST_MATH_OVERFLOW_ERROR_POLICY is NOT throw_on_error. // #define BOOST_MATH_OVERFLOW_ERROR_POLICY == throw_on_error would give a throw here. // #define BOOST_MATH_DOMAIN_ERROR_POLICY == throw_on_error IS defined, so the throw path // of error handling is tested below with BOOST_CHECK_THROW tests. - BOOST_CHECK_EQUAL(pdf(distu01, std::numeric_limits::infinity()), 0); - BOOST_CHECK_EQUAL(pdf(distu01, -std::numeric_limits::infinity()), 0); + using boost::math::policies::policy; + using boost::math::policies::domain_error; + using boost::math::policies::ignore_error; + + // Define a (bad?) policy to ignore domain errors ('bad' arguments): + typedef policy > inf_policy; // domain error returns infinity. + triangular_distribution tridef_inf(-1, 0., 1); + // But can't use BOOST_CHECK_EQUAL(?, quiet_NaN) + using boost::math::isnan; + BOOST_CHECK(isnan(pdf(tridef_inf, std::numeric_limits::infinity()))); } // test for infinity using std::numeric_limits<>::infinity() else { // real_concept case, does has_infinfity == false, so can't check it throws. @@ -483,25 +495,24 @@ void test_spots(RealType) // value of std::numeric_limits::infinity() is zero, so FPclassify is zero, // so (boost::math::isfinite)(std::numeric_limits::infinity()) does not detect infinity. // so these tests would never throw. - //BOOST_CHECK_THROW(pdf(distu01, std::numeric_limits::infinity()), std::domain_error); - //BOOST_CHECK_THROW(pdf(distu01, std::numeric_limits::quiet_NaN()), std::domain_error); - // BOOST_CHECK_THROW(pdf(distu01, boost::math::tools::max_value() * 2), std::domain_error); // Doesn't throw. - BOOST_CHECK_EQUAL(pdf(distu01, boost::math::tools::max_value()), 0); + //BOOST_CHECK_THROW(pdf(tridef, std::numeric_limits::infinity()), std::domain_error); + //BOOST_CHECK_THROW(pdf(tridef, std::numeric_limits::quiet_NaN()), std::domain_error); + // BOOST_CHECK_THROW(pdf(tridef, boost::math::tools::max_value() * 2), std::domain_error); // Doesn't throw. + BOOST_CHECK_EQUAL(pdf(tridef, boost::math::tools::max_value()), 0); } // Special cases: - BOOST_CHECK(pdf(distu01, 0) == 1); - BOOST_CHECK(cdf(distu01, 0) == 0); - BOOST_CHECK(pdf(distu01, 1) == 1); - BOOST_CHECK(cdf(distu01, 1) == 1); - BOOST_CHECK(cdf(complement(distu01, 0)) == 1); - BOOST_CHECK(cdf(complement(distu01, 1)) == 0); - BOOST_CHECK(quantile(distu01, 0) == 0); - BOOST_CHECK(quantile(complement(distu01, 0)) == 1); - BOOST_CHECK(quantile(distu01, 1) == 1); - BOOST_CHECK(quantile(complement(distu01, 1)) == 1); + BOOST_CHECK(pdf(tridef, -1) == 0); + BOOST_CHECK(pdf(tridef, 1) == 0); + BOOST_CHECK(cdf(tridef, 0) == 0.5); + BOOST_CHECK(pdf(tridef, 1) == 0); + BOOST_CHECK(cdf(tridef, 1) == 1); + BOOST_CHECK(cdf(complement(tridef, -1)) == 1); + BOOST_CHECK(cdf(complement(tridef, 1)) == 0); + BOOST_CHECK(quantile(tridef, 1) == 1); + BOOST_CHECK(quantile(complement(tridef, 1)) == -1); - BOOST_CHECK_EQUAL(support(trim12).first, tristd.lower()); - BOOST_CHECK_EQUAL(support(trim12).second, tristd.upper()); + BOOST_CHECK_EQUAL(support(trim12).first, trim12.lower()); + BOOST_CHECK_EQUAL(support(trim12).second, trim12.upper()); // Error checks: if(std::numeric_limits::has_quiet_NaN)