mirror of
https://github.com/saitohirga/WSJT-X.git
synced 2024-11-15 16:42:12 -05:00
462 lines
21 KiB
C++
462 lines
21 KiB
C++
// Copyright Paul Bristow 2007.
|
|
// Copyright John Maddock 2006.
|
|
|
|
// Use, modification and distribution are subject to the
|
|
// Boost Software License, Version 1.0.
|
|
// (See accompanying file LICENSE_1_0.txt
|
|
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
// test_uniform.cpp
|
|
|
|
#include <pch.hpp>
|
|
|
|
#ifdef _MSC_VER
|
|
# pragma warning(disable: 4127) // conditional expression is constant.
|
|
# pragma warning(disable: 4100) // unreferenced formal parameter.
|
|
#endif
|
|
|
|
#include <boost/math/concepts/real_concept.hpp> // for real_concept
|
|
#define BOOST_TEST_MAIN
|
|
#include <boost/test/unit_test.hpp> // Boost.Test
|
|
#include <boost/test/floating_point_comparison.hpp>
|
|
|
|
#include <boost/math/distributions/uniform.hpp>
|
|
using boost::math::uniform_distribution;
|
|
#include <boost/math/tools/test.hpp>
|
|
#include "test_out_of_range.hpp"
|
|
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
using std::cout;
|
|
using std::endl;
|
|
using std::setprecision;
|
|
#include <limits>
|
|
using std::numeric_limits;
|
|
|
|
template <class RealType>
|
|
void check_uniform(RealType lower, RealType upper, RealType x, RealType p, RealType q, RealType tol)
|
|
{
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
::boost::math::cdf(
|
|
uniform_distribution<RealType>(lower, upper), // distribution.
|
|
x), // random variable.
|
|
p, // probability.
|
|
tol); // tolerance.
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
::boost::math::cdf(
|
|
complement(
|
|
uniform_distribution<RealType>(lower, upper), // distribution.
|
|
x)), // random variable.
|
|
q, // probability complement.
|
|
tol); // tolerance.
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
::boost::math::quantile(
|
|
uniform_distribution<RealType>(lower, upper), // distribution.
|
|
p), // probability.
|
|
x, // random variable.
|
|
tol); // tolerance.
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
::boost::math::quantile(
|
|
complement(
|
|
uniform_distribution<RealType>(lower, upper), // distribution.
|
|
q)), // probability complement.
|
|
x, // random variable.
|
|
tol); // tolerance.
|
|
} // void check_uniform
|
|
|
|
template <class RealType>
|
|
void test_spots(RealType)
|
|
{
|
|
// Basic sanity checks
|
|
//
|
|
// These test values were generated for the normal distribution
|
|
// using the online calculator at
|
|
// http://espse.ed.psu.edu/edpsych/faculty/rhale/hale/507Mat/statlets/free/pdist.htm
|
|
//
|
|
// Tolerance is just over 5 decimal digits expressed as a fraction:
|
|
// that's the limit of the test data.
|
|
RealType tolerance = 2e-5f;
|
|
cout << "Tolerance for type " << typeid(RealType).name() << " is " << tolerance << "." << endl;
|
|
|
|
using std::exp;
|
|
|
|
// Tests for PDF
|
|
//
|
|
BOOST_CHECK_CLOSE_FRACTION( // x == upper
|
|
pdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0)),
|
|
static_cast<RealType>(1),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION( // x == lower
|
|
pdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(1)),
|
|
static_cast<RealType>(1),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION( // x > upper
|
|
pdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(-1)),
|
|
static_cast<RealType>(0),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION( // x < lower
|
|
pdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(2)),
|
|
static_cast<RealType>(0),
|
|
tolerance);
|
|
|
|
if(std::numeric_limits<RealType>::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.
|
|
// #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_MATH_CHECK_THROW tests.
|
|
|
|
BOOST_MATH_CHECK_THROW( // x == infinity should NOT be OK.
|
|
pdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(std::numeric_limits<RealType>::infinity())),
|
|
std::domain_error);
|
|
|
|
BOOST_MATH_CHECK_THROW( // x == minus infinity should be OK too.
|
|
pdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(-std::numeric_limits<RealType>::infinity())),
|
|
std::domain_error);
|
|
}
|
|
if(std::numeric_limits<RealType>::has_quiet_NaN)
|
|
{ // BOOST_CHECK tests for NaN using std::numeric_limits<>::has_quiet_NaN() - should throw.
|
|
BOOST_MATH_CHECK_THROW(
|
|
pdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(std::numeric_limits<RealType>::quiet_NaN())),
|
|
std::domain_error);
|
|
BOOST_MATH_CHECK_THROW(
|
|
pdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(-std::numeric_limits<RealType>::quiet_NaN())),
|
|
std::domain_error);
|
|
} // test for x = NaN using std::numeric_limits<>::quiet_NaN()
|
|
|
|
// cdf
|
|
BOOST_CHECK_EQUAL( // x < lower
|
|
cdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(-1)),
|
|
static_cast<RealType>(0) );
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
cdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0)),
|
|
static_cast<RealType>(0),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
cdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0.5)),
|
|
static_cast<RealType>(0.5),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
cdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0.1)),
|
|
static_cast<RealType>(0.1),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
cdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0.9)),
|
|
static_cast<RealType>(0.9),
|
|
tolerance);
|
|
BOOST_CHECK_EQUAL( // x > upper
|
|
cdf(uniform_distribution<RealType>(0, 1), static_cast<RealType>(2)),
|
|
static_cast<RealType>(1));
|
|
|
|
// cdf complement
|
|
BOOST_CHECK_EQUAL( // x < lower
|
|
cdf(complement(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0))),
|
|
static_cast<RealType>(1));
|
|
BOOST_CHECK_EQUAL( // x == 0
|
|
cdf(complement(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0))),
|
|
static_cast<RealType>(1));
|
|
BOOST_CHECK_CLOSE_FRACTION( // x = 0.1
|
|
cdf(complement(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0.1))),
|
|
static_cast<RealType>(0.9),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION( // x = 0.5
|
|
cdf(complement(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0.5))),
|
|
static_cast<RealType>(0.5),
|
|
tolerance);
|
|
BOOST_CHECK_EQUAL( // x == 1
|
|
cdf(complement(uniform_distribution<RealType>(0, 1), static_cast<RealType>(1))),
|
|
static_cast<RealType>(0));
|
|
BOOST_CHECK_EQUAL( // x > upper
|
|
cdf(complement(uniform_distribution<RealType>(0, 1), static_cast<RealType>(2))),
|
|
static_cast<RealType>(0));
|
|
|
|
// quantile
|
|
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
quantile(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0.9)),
|
|
static_cast<RealType>(0.9),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
quantile(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0.1)),
|
|
static_cast<RealType>(0.1),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
quantile(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0.5)),
|
|
static_cast<RealType>(0.5),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
quantile(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0)),
|
|
static_cast<RealType>(0),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
quantile(uniform_distribution<RealType>(0, 1), static_cast<RealType>(1)),
|
|
static_cast<RealType>(1),
|
|
tolerance);
|
|
|
|
// quantile complement
|
|
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
quantile(complement(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0.1))),
|
|
static_cast<RealType>(0.9),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
quantile(complement(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0.9))),
|
|
static_cast<RealType>(0.1),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
quantile(complement(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0.5))),
|
|
static_cast<RealType>(0.5),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
quantile(complement(uniform_distribution<RealType>(0, 1), static_cast<RealType>(0))),
|
|
static_cast<RealType>(1),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
quantile(complement(uniform_distribution<RealType>(0, 1), static_cast<RealType>(1))),
|
|
static_cast<RealType>(0),
|
|
tolerance);
|
|
|
|
// Some tests using a different location & scale, neight zero or unity.
|
|
BOOST_CHECK_CLOSE_FRACTION( // x == mid
|
|
pdf(uniform_distribution<RealType>(-1, 2), static_cast<RealType>(1)),
|
|
static_cast<RealType>(0.3333333333333333333333333333333333333333333333333333),
|
|
tolerance);
|
|
|
|
BOOST_CHECK_CLOSE_FRACTION( // x == upper
|
|
pdf(uniform_distribution<RealType>(-1, 2), static_cast<RealType>(+2)),
|
|
static_cast<RealType>(0.3333333333333333333333333333333333333333333333333333), // 1 / (2 - -1) = 1/3
|
|
tolerance);
|
|
|
|
BOOST_CHECK_CLOSE_FRACTION( // x == lower
|
|
cdf(uniform_distribution<RealType>(-1, 2), static_cast<RealType>(-1)),
|
|
static_cast<RealType>(0),
|
|
tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION( // x == upper
|
|
cdf(uniform_distribution<RealType>(-1, 2), static_cast<RealType>(0)),
|
|
static_cast<RealType>(0.3333333333333333333333333333333333333333333333333333),
|
|
tolerance);
|
|
|
|
BOOST_CHECK_CLOSE_FRACTION( // x == upper
|
|
cdf(uniform_distribution<RealType>(-1, 2), static_cast<RealType>(1)),
|
|
static_cast<RealType>(0.6666666666666666666666666666666666666666666666666667),
|
|
tolerance);
|
|
|
|
BOOST_CHECK_CLOSE_FRACTION( // x == lower
|
|
cdf(uniform_distribution<RealType>(-1, 2), static_cast<RealType>(2)),
|
|
static_cast<RealType>(1),
|
|
tolerance);
|
|
|
|
BOOST_CHECK_CLOSE_FRACTION( // x == upper
|
|
quantile(uniform_distribution<RealType>(-1, 2), static_cast<RealType>(0.6666666666666666666666666666666666666666666666666667)),
|
|
static_cast<RealType>(1),
|
|
tolerance);
|
|
|
|
check_uniform(
|
|
static_cast<RealType>(0), // lower
|
|
static_cast<RealType>(1), // upper
|
|
static_cast<RealType>(0.5), // x
|
|
static_cast<RealType>(0.5), // p
|
|
static_cast<RealType>(1 - 0.5), // q
|
|
tolerance);
|
|
|
|
// Some Not-standard uniform tests.
|
|
check_uniform(
|
|
static_cast<RealType>(-1), // lower
|
|
static_cast<RealType>(1), // upper
|
|
static_cast<RealType>(0), // x
|
|
static_cast<RealType>(0.5), // p
|
|
static_cast<RealType>(1 - 0.5), // q = 1 - p
|
|
tolerance);
|
|
|
|
check_uniform(
|
|
static_cast<RealType>(1), // lower
|
|
static_cast<RealType>(3), // upper
|
|
static_cast<RealType>(2), // x
|
|
static_cast<RealType>(0.5), // p
|
|
static_cast<RealType>(1 - 0.5), // q = 1 - p
|
|
tolerance);
|
|
|
|
check_uniform(
|
|
static_cast<RealType>(-1), // lower
|
|
static_cast<RealType>(2), // upper
|
|
static_cast<RealType>(1), // x
|
|
static_cast<RealType>(0.66666666666666666666666666666666666666666667), // p
|
|
static_cast<RealType>(0.33333333333333333333333333333333333333333333), // q = 1 - p
|
|
tolerance);
|
|
tolerance = (std::max)(
|
|
boost::math::tools::epsilon<RealType>(),
|
|
static_cast<RealType>(boost::math::tools::epsilon<double>())) * 5; // 5 eps as a fraction.
|
|
cout << "Tolerance (as fraction) for type " << typeid(RealType).name() << " is " << tolerance << "." << endl;
|
|
uniform_distribution<RealType> distu01(0, 1);
|
|
RealType x = static_cast<RealType>(0.5);
|
|
using namespace std; // ADL of std names.
|
|
// mean:
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
mean(distu01), static_cast<RealType>(0.5), tolerance);
|
|
// variance:
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
variance(distu01), static_cast<RealType>(0.0833333333333333333333333333333333333333333), tolerance);
|
|
// std deviation:
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
standard_deviation(distu01), sqrt(variance(distu01)), tolerance);
|
|
// hazard:
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
hazard(distu01, x), pdf(distu01, x) / cdf(complement(distu01, x)), tolerance);
|
|
// cumulative hazard:
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
chf(distu01, x), -log(cdf(complement(distu01, x))), tolerance);
|
|
// coefficient_of_variation:
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
coefficient_of_variation(distu01), standard_deviation(distu01) / mean(distu01), tolerance);
|
|
// mode:
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
mode(distu01), static_cast<RealType>(0), tolerance);
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
median(distu01), static_cast<RealType>(0.5), tolerance);
|
|
// skewness:
|
|
BOOST_CHECK_EQUAL(
|
|
skewness(distu01), static_cast<RealType>(0));
|
|
// kertosis:
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
kurtosis(distu01), kurtosis_excess(distu01) + static_cast<RealType>(3), tolerance);
|
|
// kertosis excess:
|
|
BOOST_CHECK_CLOSE_FRACTION(
|
|
kurtosis_excess(distu01), static_cast<RealType>(-1.2), tolerance);
|
|
|
|
if(std::numeric_limits<RealType>::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, long 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_MATH_CHECK_THROW tests.
|
|
|
|
BOOST_MATH_CHECK_THROW(pdf(distu01, std::numeric_limits<RealType>::infinity()), std::domain_error);
|
|
BOOST_MATH_CHECK_THROW(pdf(distu01, -std::numeric_limits<RealType>::infinity()), std::domain_error);
|
|
} // 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_MATH_CHECK_THROW(pdf(distu01, std::numeric_limits<RealType>::infinity()), std::domain_error);
|
|
//BOOST_MATH_CHECK_THROW(pdf(distu01, std::numeric_limits<RealType>::quiet_NaN()), std::domain_error);
|
|
// BOOST_MATH_CHECK_THROW(pdf(distu01, boost::math::tools::max_value<RealType>() * 2), std::domain_error); // Doesn't throw.
|
|
BOOST_CHECK_EQUAL(pdf(distu01, boost::math::tools::max_value<RealType>()), 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)) == 0);
|
|
|
|
// Error checks:
|
|
if(std::numeric_limits<RealType>::has_quiet_NaN)
|
|
{ // BOOST_CHECK tests for constructing with quiet_NaN (not for real_concept, for example - see notes above).
|
|
BOOST_MATH_CHECK_THROW(uniform_distribution<RealType>(0, std::numeric_limits<RealType>::quiet_NaN()), std::domain_error);
|
|
BOOST_MATH_CHECK_THROW(uniform_distribution<RealType>(0, -std::numeric_limits<RealType>::quiet_NaN()), std::domain_error);
|
|
}
|
|
BOOST_MATH_CHECK_THROW(uniform_distribution<RealType>(1, 0), std::domain_error); // lower > upper!
|
|
BOOST_MATH_CHECK_THROW(uniform_distribution<RealType>(1, 1), std::domain_error); // lower == upper!
|
|
|
|
check_out_of_range<uniform_distribution<RealType> >(1, 5);
|
|
} // template <class RealType>void test_spots(RealType)
|
|
|
|
BOOST_AUTO_TEST_CASE( test_main )
|
|
{
|
|
// Check that can construct uniform distribution using the two convenience methods:
|
|
using namespace boost::math;
|
|
uniform unistd; // Using typedef
|
|
// == uniform_distribution<double> unistd;
|
|
BOOST_CHECK_EQUAL(unistd.lower(), 0); // Check defaults.
|
|
BOOST_CHECK_EQUAL(unistd.upper(), 1);
|
|
uniform_distribution<> myu01(0, 1); // Using default RealType double.
|
|
BOOST_CHECK_EQUAL(myu01.lower(), 0); // Check defaults again.
|
|
BOOST_CHECK_EQUAL(myu01.upper(), 1);
|
|
|
|
// Test on extreme values of random variate x, using just double because it has numeric_limit infinity etc..
|
|
// No longer allow x to be + or - infinity, then these tests should throw.
|
|
BOOST_MATH_CHECK_THROW(pdf(unistd, +std::numeric_limits<double>::infinity()), std::domain_error); // x = + infinity
|
|
BOOST_MATH_CHECK_THROW(pdf(unistd, -std::numeric_limits<double>::infinity()), std::domain_error); // x = - infinity
|
|
BOOST_MATH_CHECK_THROW(cdf(unistd, +std::numeric_limits<double>::infinity()), std::domain_error); // x = + infinity
|
|
BOOST_MATH_CHECK_THROW(cdf(unistd, -std::numeric_limits<double>::infinity()), std::domain_error); // x = - infinity
|
|
|
|
BOOST_CHECK_EQUAL(pdf(unistd, +(std::numeric_limits<double>::max)()), 0); // x = + max
|
|
BOOST_CHECK_EQUAL(pdf(unistd, -(std::numeric_limits<double>::min)()), 0); // x = - min
|
|
BOOST_CHECK_EQUAL(cdf(unistd, +(std::numeric_limits<double>::max)()), 1); // x = + max
|
|
BOOST_CHECK_EQUAL(cdf(unistd, -(std::numeric_limits<double>::min)()), 0); // x = - min
|
|
#ifndef BOOST_NO_EXCEPTIONS
|
|
BOOST_MATH_CHECK_THROW(uniform_distribution<> zinf(0, +std::numeric_limits<double>::infinity()), std::domain_error); // zero to infinity using default RealType double.
|
|
#else
|
|
BOOST_MATH_CHECK_THROW(uniform_distribution<>(0, +std::numeric_limits<double>::infinity()), std::domain_error); // zero to infinity using default RealType double.
|
|
#endif
|
|
uniform_distribution<> zmax(0, +(std::numeric_limits<double>::max)()); // zero to max using default RealType double.
|
|
BOOST_CHECK_EQUAL(zmax.lower(), 0); // Check defaults again.
|
|
BOOST_CHECK_EQUAL(zmax.upper(), +(std::numeric_limits<double>::max)());
|
|
|
|
BOOST_CHECK_EQUAL(pdf(zmax, -1), 0); // pdf is 1/(0 - max) = almost zero for all x
|
|
BOOST_CHECK_EQUAL(pdf(zmax, 0), (std::numeric_limits<double>::min)()/4); // x =
|
|
BOOST_CHECK_EQUAL(pdf(zmax, 1), (std::numeric_limits<double>::min)()/4); // x =
|
|
BOOST_MATH_CHECK_THROW(pdf(zmax, +std::numeric_limits<double>::infinity()), std::domain_error); // pdf is 1/(0 - infinity) = zero for all x
|
|
BOOST_MATH_CHECK_THROW(pdf(zmax, -std::numeric_limits<double>::infinity()), std::domain_error);
|
|
BOOST_CHECK_EQUAL(pdf(zmax, +(std::numeric_limits<double>::max)()), (std::numeric_limits<double>::min)()/4); // x =
|
|
BOOST_CHECK_EQUAL(pdf(zmax, -(std::numeric_limits<double>::max)()), 0); // x =
|
|
#ifndef BOOST_NO_EXCEPTIONS
|
|
// Ensure NaN throws an exception.
|
|
BOOST_MATH_CHECK_THROW(uniform_distribution<> zNaN(0, std::numeric_limits<double>::quiet_NaN()), std::domain_error);
|
|
BOOST_MATH_CHECK_THROW(pdf(unistd, std::numeric_limits<double>::quiet_NaN()), std::domain_error);
|
|
#else
|
|
BOOST_MATH_CHECK_THROW(uniform_distribution<>(0, std::numeric_limits<double>::quiet_NaN()), std::domain_error);
|
|
BOOST_MATH_CHECK_THROW(pdf(unistd, std::numeric_limits<double>::quiet_NaN()), std::domain_error);
|
|
#endif
|
|
// 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::endl;
|
|
#endif
|
|
|
|
|
|
} // BOOST_AUTO_TEST_CASE( test_main )
|
|
|
|
/*
|
|
|
|
Output:
|
|
|
|
Autorun "i:\boost-06-05-03-1300\libs\math\test\Math_test\debug\test_uniform.exe"
|
|
Running 1 test case...
|
|
Tolerance for type float is 2e-005.
|
|
Tolerance (as fraction) for type float is 5.96046e-007.
|
|
Tolerance for type double is 2e-005.
|
|
Tolerance (as fraction) for type double is 1.11022e-015.
|
|
Tolerance for type long double is 2e-005.
|
|
Tolerance (as fraction) for type long double is 1.11022e-015.
|
|
Tolerance for type class boost::math::concepts::real_concept is 2e-005.
|
|
Tolerance (as fraction) for type class boost::math::concepts::real_concept is 1.11022e-015.
|
|
*** No errors detected
|
|
|
|
*/
|
|
|
|
|
|
|