test_triangular.cpp

Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work

    // 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.
    // #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.

    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<domain_error<ignore_error> > inf_policy; // domain error returns infinity.
    triangular_distribution<RealType, inf_policy> 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<RealType>::infinity())));
  } // test for infinity using std::numeric_limits<>::infinity()
  else
  { // real_concept case, does has_infinfity == false, so can't check it throws.
    // cout << std::numeric_limits<RealType>::infinity() << ' '
    // << boost::math::fpclassify(std::numeric_limits<RealType>::infinity()) << endl;
    // value of std::numeric_limits<RealType>::infinity() is zero, so FPclassify is zero,
    // so (boost::math::isfinite)(std::numeric_limits<RealType>::infinity()) does not detect infinity.
    // so these tests would never throw.
    //BOOST_CHECK_THROW(pdf(tridef, std::numeric_limits<RealType>::infinity()),  std::domain_error);
    //BOOST_CHECK_THROW(pdf(tridef, std::numeric_limits<RealType>::quiet_NaN()),  std::domain_error);
    // BOOST_CHECK_THROW(pdf(tridef, boost::math::tools::max_value<RealType>() * 2),  std::domain_error); // Doesn't throw.
    BOOST_CHECK_EQUAL(pdf(tridef, boost::math::tools::max_value<RealType>()), 0); 
  }
  // Special cases:
  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, trim12.lower());
  BOOST_CHECK_EQUAL(support(trim12).second, trim12.upper());

  // Error checks:
  if(std::numeric_limits<RealType>::has_quiet_NaN)
  { // BOOST_CHECK tests for quiet_NaN (not for real_concept, for example - see notes above).
    BOOST_CHECK_THROW(triangular_distribution<RealType>(0, std::numeric_limits<RealType>::quiet_NaN()), std::domain_error);
    BOOST_CHECK_THROW(triangular_distribution<RealType>(0, -std::numeric_limits<RealType>::quiet_NaN()), std::domain_error);
  }
  BOOST_CHECK_THROW(triangular_distribution<RealType>(1, 0), std::domain_error); // lower > upper!

} // template <class RealType>void test_spots(RealType)

int test_main(int, char* [])
{
  //  double toleps = std::numeric_limits<double>::epsilon(); // 5 eps as a fraction.
  double tol5eps = std::numeric_limits<double>::epsilon() * 5; // 5 eps as a fraction.
  // double tol50eps = std::numeric_limits<double>::epsilon() * 50; // 50 eps as a fraction.
  double tol500eps = std::numeric_limits<double>::epsilon() * 500; // 500 eps as a fraction.

  // Check that can construct triangular distribution using the two convenience methods:
  using namespace boost::math;
  triangular triang; // Using typedef
  // == triangular_distribution<double> triang;

  BOOST_CHECK_EQUAL(triang.lower(), -1); // Check default.
  BOOST_CHECK_EQUAL(triang.mode(), 0);
  BOOST_CHECK_EQUAL(triang.upper(), 1);

  triangular tristd (0, 0.5, 1); // Using typedef

  BOOST_CHECK_EQUAL(tristd.lower(), 0); 
  BOOST_CHECK_EQUAL(tristd.mode(), 0.5);
  BOOST_CHECK_EQUAL(tristd.upper(), 1);

  //cout << "X range from " << range(tristd).first << " to " << range(tristd).second << endl;
  //cout << "Supported from "<< support(tristd).first << ' ' << support(tristd).second << endl;

  BOOST_CHECK_EQUAL(support(tristd).first, tristd.lower());
  BOOST_CHECK_EQUAL(support(tristd).second, tristd.upper());

  triangular_distribution<> tri011(0, 1, 1); // Using default RealType double.
  // mode is upper
  BOOST_CHECK_EQUAL(tri011.lower(), 0); // Check defaults again.
  BOOST_CHECK_EQUAL(tri011.mode(), 1); // Check defaults again.
  BOOST_CHECK_EQUAL(tri011.upper(), 1);
  BOOST_CHECK_EQUAL(mode(tri011), 1);

  BOOST_CHECK_EQUAL(pdf(tri011, 0), 0);
  BOOST_CHECK_EQUAL(pdf(tri011, 0.1), 0.2);
  BOOST_CHECK_EQUAL(pdf(tri011, 0.5), 1);
  BOOST_CHECK_EQUAL(pdf(tri011, 0.9), 1.8);
  BOOST_CHECK_EQUAL(pdf(tri011, 1), 2);

  BOOST_CHECK_EQUAL(cdf(tri011, 0), 0);
  BOOST_CHECK_CLOSE_FRACTION(cdf(tri011, 0.1), 0.01, tol5eps);
  BOOST_CHECK_EQUAL(cdf(tri011, 0.5), 0.25);
  BOOST_CHECK_EQUAL(cdf(tri011, 0.9), 0.81);
  BOOST_CHECK_EQUAL(cdf(tri011, 1), 1);
  BOOST_CHECK_EQUAL(cdf(tri011, 9), 1);
  BOOST_CHECK_EQUAL(mean(tri011), 0.666666666666666666666666666666666666666666666666667);
  BOOST_CHECK_EQUAL(variance(tri011), 1./18.);

  triangular tri0h1(0, 0.5, 1); // Equilateral triangle - mode is the middle.
  BOOST_CHECK_EQUAL(tri0h1.lower(), 0);
  BOOST_CHECK_EQUAL(tri0h1.mode(), 0.5);
  BOOST_CHECK_EQUAL(tri0h1.upper(), 1);
  BOOST_CHECK_EQUAL(mean(tri0h1), 0.5);
  BOOST_CHECK_EQUAL(mode(tri0h1), 0.5);
  BOOST_CHECK_EQUAL(pdf(tri0h1, -1), 0);
  BOOST_CHECK_EQUAL(cdf(tri0h1, -1), 0);
  BOOST_CHECK_EQUAL(pdf(tri0h1, 1), 0);
  BOOST_CHECK_EQUAL(pdf(tri0h1, 999), 0);
  BOOST_CHECK_EQUAL(cdf(tri0h1, 999), 1);
  BOOST_CHECK_EQUAL(cdf(tri0h1, 1), 1);
  BOOST_CHECK_CLOSE_FRACTION(cdf(tri0h1, 0.1), 0.02, tol5eps);
  BOOST_CHECK_EQUAL(cdf(tri0h1, 0.5), 0.5);
  BOOST_CHECK_CLOSE_FRACTION(cdf(tri0h1, 0.9), 0.98, tol5eps);

  BOOST_CHECK_CLOSE_FRACTION(quantile(tri0h1, 0.), 0., tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(quantile(tri0h1, 0.02), 0.1, tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(quantile(tri0h1, 0.5), 0.5, tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(quantile(tri0h1, 0.98), 0.9, tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(quantile(tri0h1, 1.), 1., tol5eps);

  triangular tri0q1(0, 0.25, 1); // mode is near bottom.
  BOOST_CHECK_CLOSE_FRACTION(cdf(tri0q1, 0.02), 0.0016, tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(cdf(tri0q1, 0.5), 0.66666666666666666666666666666666666666666666667, tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(cdf(tri0q1, 0.98), 0.99946666666666661, tol5eps);

  BOOST_CHECK_CLOSE_FRACTION(quantile(tri0q1, 0.0016), 0.02, tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(quantile(tri0q1, 0.66666666666666666666666666666666666666666666667), 0.5, tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(quantile(complement(tri0q1, 0.3333333333333333333333333333333333333333333333333)), 0.5, tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(quantile(tri0q1, 0.99946666666666661), 0.98, 10 * tol5eps);

  triangular trim12(-1, -0.5, 2); // mode is negative.
  BOOST_CHECK_CLOSE_FRACTION(pdf(trim12, 0), 0.533333333333333333333333333333333333333333333, tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(cdf(trim12, 0), 0.466666666666666666666666666666666666666666667, tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(cdf(complement(trim12, 0)), 1 - 0.466666666666666666666666666666666666666666667, tol5eps);

  BOOST_CHECK_CLOSE_FRACTION(quantile(complement(tri0q1, 1 - 0.99946666666666661)), 0.98, 10 * tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(quantile(complement(tri0h1, 1.)), 0., tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(quantile(complement(tri0h1, 0.5)), 0.5, tol5eps); // OK
  BOOST_CHECK_CLOSE_FRACTION(quantile(complement(tri0h1, 1. - 0.02)), 0.1, tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(quantile(complement(tri0h1, 1. - 0.98)), 0.9, tol5eps);
  BOOST_CHECK_CLOSE_FRACTION(quantile(complement(tri0h1, 0)), 1., tol5eps);

  double xs [] = {0., 0.01, 0.02, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 0.98, 0.99, 1.};

  const triangular_distribution<double>& distr = tristd;
  BOOST_CHECK_CLOSE_FRACTION(quantile(complement(distr, 1.)), 0., tol5eps);
  const triangular_distribution<double>* distp = &tristd;
  BOOST_CHECK_CLOSE_FRACTION(quantile(complement(*distp, 1.)), 0., tol5eps);

  const triangular_distribution<double>* dists [] = {&tristd, &tri011, &tri0q1, &tri0h1, &trim12};
  BOOST_CHECK_CLOSE_FRACTION(quantile(complement(*dists[1], 1.)), 0., tol5eps);

  for (int i = 0; i < 5; i++)
  {
    const triangular_distribution<double>* const dist = dists[i];
    cout << "Distribution " << i << endl;
    BOOST_CHECK_EQUAL(quantile(complement(*dists[i], 1.)), quantile(*dists[i], 0.));
    BOOST_CHECK_CLOSE_FRACTION(quantile(*dists[i], 0.5), quantile(complement(*dist, 0.5)),  tol5eps); // OK
    BOOST_CHECK_CLOSE_FRACTION(quantile(*dists[i], 0.98), quantile(complement(*dist, 1. - 0.98)),tol5eps);
    // cout << setprecision(17) <<  median(*dist) << endl;
  }

  cout << showpos << setprecision(2) << endl;

  //triangular_distribution<double>& dist = trim12; 
  for (unsigned i = 0; i < sizeof(xs) /sizeof(double); i++)
  {
    double x = xs[i] * (trim12.upper() - trim12.lower()) + trim12.lower();
    double dx = cdf(trim12, x);
    double cx = cdf(complement(trim12, x));
    //cout << fixed << showpos << setprecision(3) 
    //  << xs[i] << ", " << x << ",  " << pdf(trim12, x) << ",  " << dx << ",  " << cx << ",, " ;

    BOOST_CHECK_CLOSE_FRACTION(cx, 1 - dx, tol500eps); // cx == 1 - dx

    // << setprecision(2) << scientific << cr - x << ", " // difference x - quan(cdf)
    // << setprecision(3) << fixed
    // << quantile(trim12, dx) << ", " 
    // << quantile(complement(trim12, 1 - dx)) << ", " 
    // << quantile(complement(trim12, cx)) << ", " 
    // << endl;
    BOOST_CHECK_CLOSE_FRACTION(quantile(trim12, dx), quantile(complement(trim12, 1 - dx)), tol500eps);
  }
  cout << endl;
  // Basic sanity-check spot values.
  // (Parameter value, arbitrarily zero, only communicates the floating point type).
  test_spots(0.0F); // Test float. OK at decdigits = 0 tolerance = 0.0001 %
  test_spots(0.0); // Test double. OK at decdigits 7, tolerance = 1e07 %
  #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
    test_spots(0.0L); // Test long double.
  #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0582))
    test_spots(boost::math::concepts::real_concept(0.)); // Test real concept.
  #endif
  #else
     std::cout << "<note>The long double tests have been disabled on this platform "
        "either because the long double overloads of the usual math functions are "
        "not available at all, or because they are too inaccurate for these tests "
        "to pass.</note>" << std::cout;
  #endif

  return 0;
} // int test_main(int, char* [])

/*

Output:

Autorun "i:\boost-06-05-03-1300\libs\math\test\Math_test\debug\test_triangular.exe"
Running 1 test case...
Distribution 0
Distribution 1
Distribution 2
Distribution 3
Distribution 4
Tolerance for type float is 5.96046e-007.
Tolerance for type double is 1.11022e-015.
Tolerance for type long double is 1.11022e-015.
Tolerance for type class boost::math::concepts::real_concept is 1.11022e-015.
*** No errors detected



*/