boost/math
2
0
Fork 0
mirror of https://github.com/boostorg/math.git synced 2026-01-27 07:02:08 +00:00
Code Issues Projects Releases Wiki Activity

Commit of more or less complete non-central chi-square distribution: docs still to come.

Browse Source 
[SVN r42820]
This commit is contained in:
John Maddock
2008-01-16 19:02:45 +00:00
parent 4786b056bb
commit 8081dc49df
5 changed files with 3577 additions and 5880 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
test/Jamfile.v2
View File

@@ -247,6 +247,30 @@ run test_negative_binomial.cpp
: # requirements
<define>TEST_REAL_CONCEPT
: test_negative_binomial_real_concept ;
run test_nc_chi_squared.cpp
: # command line
: # input files
: # requirements
<define>TEST_FLOAT
: test_nc_chi_squared_float ;
run test_nc_chi_squared.cpp
: # command line
: # input files
: # requirements
<define>TEST_DOUBLE
: test_nc_chi_squared_double ;
run test_nc_chi_squared.cpp
: # command line
: # input files
: # requirements
<define>TEST_LDOUBLE
: test_nc_chi_squared_long_double ;
run test_nc_chi_squared.cpp
: # command line
: # input files
: # requirements
<define>TEST_REAL_CONCEPT
: test_nc_chi_squared_real_concept ;
run test_normal.cpp ;
run test_pareto.cpp ;
run test_poisson.cpp

8858
test/nccs.ipp
View File

File diff suppressed because it is too large Load Diff

207
test/test_nc_chi_squared.cpp
View File

@@ -7,8 +7,20 @@
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifdef _MSC_VER
#pragma warning (disable:4127 4512)
#endif
#if !defined(TEST_FLOAT) && !defined(TEST_DOUBLE) && !defined(TEST_LDOUBLE) && !defined(TEST_REAL_CONCEPT)
# define TEST_FLOAT
# define TEST_DOUBLE
# define TEST_LDOUBLE
# define TEST_REAL_CONCEPT
#endif
#include <boost/math/concepts/real_concept.hpp> // for real_concept
#include <boost/math/distributions/non_central_chi_squared.hpp> // for chi_squared_distribution
#include <boost/math/special_functions/cbrt.hpp> // for chi_squared_distribution
#include <boost/test/included/test_exec_monitor.hpp> // for test_main
#include <boost/test/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE
@@ -31,21 +43,87 @@ using std::numeric_limits;
std::cerr << "Failure was at row " << i << std::endl;\
std::cerr << std::setprecision(35); \
std::cerr << "{ " << data[i][0] << " , " << data[i][1] << " , " << data[i][2];\
std::cerr << " , " << data[i][3] << " , " << data[i][4] << " , " << data[i][5] << " } " << std::endl;\
std::cerr << " , " << data[i][3] << " , " << data[i][4] << " } " << std::endl;\
}\
}
#define BOOST_CHECK_EX(a, i) \
{\
unsigned int failures = boost::unit_test::results_collector.results( boost::unit_test::framework::current_test_case().p_id ).p_assertions_failed;\
BOOST_CHECK(a); \
if(failures != boost::unit_test::results_collector.results( boost::unit_test::framework::current_test_case().p_id ).p_assertions_failed)\
{\
std::cerr << "Failure was at row " << i << std::endl;\
std::cerr << std::setprecision(35); \
std::cerr << "{ " << data[i][0] << " , " << data[i][1] << " , " << data[i][2];\
std::cerr << " , " << data[i][3] << " , " << data[i][4] << " } " << std::endl;\
}\
}
void expected_results()
{
//
// Define the max and mean errors expected for
// various compilers and platforms.
//
const char* largest_type;
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
if(boost::math::policies::digits<double, boost::math::policies::policy<> >() == boost::math::policies::digits<long double, boost::math::policies::policy<> >())
{
largest_type = "(long\\s+)?double|real_concept";
}
else
{
largest_type = "long double|real_concept";
}
#else
largest_type = "(long\\s+)?double|real_concept";
#endif
//
// Catch all cases come last:
//
add_expected_result(
"[^|]*", // compiler
"[^|]*", // stdlib
"[^|]*", // platform
largest_type, // test type(s)
"[^|]*medium[^|]*", // test data group
"[^|]*", 350, 100); // test function
add_expected_result(
"[^|]*", // compiler
"[^|]*", // stdlib
"[^|]*", // platform
largest_type, // test type(s)
"[^|]*large[^|]*", // test data group
"[^|]*", 10000, 3000); // test function
//
// Finish off by printing out the compiler/stdlib/platform names,
// we do this to make it easier to mark up expected error rates.
//
std::cout << "Tests run with " << BOOST_COMPILER << ", "
<< BOOST_STDLIB << ", " << BOOST_PLATFORM << std::endl;
}
template <class RealType>
RealType naive_pdf(RealType v, RealType lam, RealType x)
{
// Formula direct from
// http://mathworld.wolfram.com/NoncentralChi-SquaredDistribution.html
// with no simplification:
RealType r = -(x+lam)/2 + log(x) * (v-1)/2 + log(lam) / 2;
r -= log(lam * x) * v/4;
r = exp(r) / 2;
r *= boost::math::cyl_bessel_i(v/2 - 1, sqrt(lam * x));
return r;
RealType sum, term, prefix(1);
RealType eps = boost::math::tools::epsilon<RealType>();
term = sum = pdf(boost::math::chi_squared_distribution<RealType>(v), x);
for(int i = 1;; ++i)
{
prefix *= lam / (2 * i);
term = prefix * pdf(boost::math::chi_squared_distribution<RealType>(v + 2 * i), x);
sum += term;
if(term / sum < eps)
break;
}
return sum * exp(-lam/2);
}
template <class RealType>
@@ -60,20 +138,32 @@ void test_spot(
boost::math::non_central_chi_squared_distribution<RealType> dist(df, ncp);
BOOST_CHECK_CLOSE(
cdf(dist, cs), P, tol);
BOOST_CHECK_CLOSE(
pdf(dist, cs), naive_pdf(dist.degrees_of_freedom(), ncp, cs), tol);
try{
BOOST_CHECK_CLOSE(
pdf(dist, cs), naive_pdf(dist.degrees_of_freedom(), ncp, cs), tol * 50);
}
catch(const std::overflow_error&)
{}
if((P < 0.99) && (Q < 0.99))
{
//
// We can only check this if P is not too close to 1,
// so that we can guarentee Q is free of error:
// so that we can guarentee Q is reasonably free of error:
//
BOOST_CHECK_CLOSE(
cdf(complement(dist, cs)), Q, tol);
BOOST_CHECK_CLOSE(
quantile(dist, P), cs, tol);
quantile(dist, P), cs, tol * 10);
BOOST_CHECK_CLOSE(
quantile(complement(dist, Q)), cs, tol);
quantile(complement(dist, Q)), cs, tol * 10);
BOOST_CHECK_CLOSE(
dist.find_degrees_of_freedom(ncp, cs, P), df, tol * 10);
BOOST_CHECK_CLOSE(
dist.find_degrees_of_freedom(boost::math::complement(ncp, cs, Q)), df, tol * 10);
BOOST_CHECK_CLOSE(
dist.find_non_centrality(df, cs, P), ncp, tol * 10);
BOOST_CHECK_CLOSE(
dist.find_non_centrality(boost::math::complement(df, cs, Q)), ncp, tol * 10);
}
}
@@ -90,6 +180,8 @@ void test_spots(RealType)
//
if(boost::math::tools::digits<RealType>() < 50)
tolerance *= 50;
if(boost::is_floating_point<RealType>::value != 1)
tolerance *= 20; // real_concept special functions are less accurate
cout << "Tolerance = " << tolerance << "%." << endl;
@@ -140,7 +232,7 @@ void test_spots(RealType)
static_cast<RealType>(38.56038), // Chi Squared statistic
static_cast<RealType>(0.8519497361859118e-1), // Probability of result (CDF), P
static_cast<RealType>(1-0.8519497361859118e-1), // Q = 1 - P
tolerance);
tolerance * 2);
test_spot(
static_cast<RealType>(100), // degrees of freedom
static_cast<RealType>(16), // non centrality
@@ -205,16 +297,14 @@ void test_spots(RealType)
BOOST_CHECK_CLOSE(
coefficient_of_variation(dist)
, standard_deviation(dist) / mean(dist), tol2);
#if 0
// mode:
BOOST_CHECK_CLOSE(
mode(dist)
, static_cast<RealType>(6), tol2);
#endif
, static_cast<RealType>(17.184201151792944), sqrt(tolerance));
BOOST_CHECK_CLOSE(
median(dist),
quantile(
non_central_chi_squared_distribution<RealType>(
boost::math::non_central_chi_squared_distribution<RealType>(
static_cast<RealType>(8),
static_cast<RealType>(12)),
static_cast<RealType>(0.5)), static_cast<RealType>(tol2));
@@ -290,6 +380,13 @@ void quantile_sanity_check(T& data, const char* type_name, const char* test)
typedef typename T::value_type row_type;
typedef typename row_type::value_type value_type;
//
// Tests with type real_concept take rather too long to run, so
// for now we'll disable them:
//
if(!boost::is_floating_point<value_type>::value)
return;
std::cout << "Testing: " << type_name << " quantile sanity check, with tests " << test << std::endl;
//
@@ -329,17 +426,65 @@ void quantile_sanity_check(T& data, const char* type_name, const char* test)
value_type pt = data[i][2];
BOOST_CHECK_CLOSE_EX(pt, p, precision, i);
}
//
// Sanity check mode as well, note this may well overflow
// since we don't know how to compute PDF's (and hence the mode)
// for large values of the parameters, in addition accuracy of
// the mode is at *best* the square root of the accuracy of the PDF:
//
try
{
value_type m = mode(boost::math::non_central_chi_squared_distribution<value_type>(data[i][0], data[i][1]));
value_type p = pdf(boost::math::non_central_chi_squared_distribution<value_type>(data[i][0], data[i][1]), m);
BOOST_CHECK_EX(pdf(boost::math::non_central_chi_squared_distribution<value_type>(data[i][0], data[i][1]), m * (1 + sqrt(precision))) <= p, i);
BOOST_CHECK_EX(pdf(boost::math::non_central_chi_squared_distribution<value_type>(data[i][0], data[i][1]), m * (1 - sqrt(precision))) <= p, i);
}
catch(const std::overflow_error&)
{
}
//
// Sanity check degrees-of-freedom finder, don't bother at float
// precision though as there's not enough data in the probability
// values to get back to the correct degrees of freedom or
// non-cenrality parameter:
//
if(boost::math::tools::digits<value_type>() > 50)
{
try{
if((data[i][3] < 0.99) && (data[i][3] != 0))
{
BOOST_CHECK_CLOSE_EX(
boost::math::non_central_chi_squared_distribution<value_type>::find_degrees_of_freedom(data[i][1], data[i][2], data[i][3]),
data[i][0], precision, i);
BOOST_CHECK_CLOSE_EX(
boost::math::non_central_chi_squared_distribution<value_type>::find_non_centrality(data[i][0], data[i][2], data[i][3]),
data[i][1], precision, i);
}
if((data[i][4] < 0.99) && (data[i][4] != 0))
{
BOOST_CHECK_CLOSE_EX(
boost::math::non_central_chi_squared_distribution<value_type>::find_degrees_of_freedom(boost::math::complement(data[i][1], data[i][2], data[i][4])),
data[i][0], precision, i);
BOOST_CHECK_CLOSE_EX(
boost::math::non_central_chi_squared_distribution<value_type>::find_non_centrality(boost::math::complement(data[i][0], data[i][2], data[i][4])),
data[i][1], precision, i);
}
}
catch(const std::exception& e)
{
BOOST_ERROR(e.what());
}
}
}
}
template <typename T>
void test_accuracy(T, const char* type_name)
{
#if 0
#include "nccs.ipp"
do_test_nc_chi_squared(nccs, type_name, "Non Central Chi Squared, medium parameters");
quantile_sanity_check(nccs, type_name, "Non Central Chi Squared, medium parameters");
#endif
#include "nccs_big.ipp"
do_test_nc_chi_squared(nccs_big, type_name, "Non Central Chi Squared, large parameters");
quantile_sanity_check(nccs_big, type_name, "Non Central Chi Squared, large parameters");
@@ -349,31 +494,41 @@ int test_main(int, char* [])
{
BOOST_MATH_CONTROL_FP;
// Basic sanity-check spot values.
expected_results();
// (Parameter value, arbitrarily zero, only communicates the floating point type).
#ifdef TEST_FLOAT
test_spots(0.0F); // Test float.
#endif
#ifdef TEST_DOUBLE
test_spots(0.0); // Test double.
#endif
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
#ifdef TEST_LDOUBLE
test_spots(0.0L); // Test long double.
#endif
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
#ifdef TEST_REAL_CONCEPT
test_spots(boost::math::concepts::real_concept(0.)); // Test real concept.
#endif
#endif
#endif
#ifdef TEST_FLOAT
test_accuracy(0.0F, "float"); // Test float.
#endif
#ifdef TEST_DOUBLE
test_accuracy(0.0, "double"); // Test double.
#endif
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
#ifdef TEST_LDOUBLE
test_accuracy(0.0L, "long double"); // Test long double.
#endif
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
#ifdef TEST_REAL_CONCEPT
test_accuracy(boost::math::concepts::real_concept(0.), "real_concept"); // Test real concept.
#endif
#endif
#endif
return 0;
} // int test_main(int, char* [])
/*
*/