]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // (C) Copyright John Maddock 2007. |
2 | // Use, modification and distribution are subject to the | |
3 | // Boost Software License, Version 1.0. (See accompanying file | |
4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
5 | ||
92f5a8d4 | 6 | #ifndef BOOST_MATH_OVERFLOW_ERROR_POLICY |
7c673cae | 7 | #define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error |
92f5a8d4 | 8 | #endif |
7c673cae FG |
9 | #include <boost/math/concepts/real_concept.hpp> |
10 | #define BOOST_TEST_MAIN | |
11 | #include <boost/test/unit_test.hpp> | |
92f5a8d4 | 12 | #include <boost/test/tools/floating_point_comparison.hpp> |
7c673cae FG |
13 | #include <boost/math/distributions/non_central_beta.hpp> |
14 | #include <boost/math/distributions/poisson.hpp> | |
15 | #include <boost/type_traits/is_floating_point.hpp> | |
16 | #include <boost/array.hpp> | |
17 | #include "functor.hpp" | |
18 | ||
19 | #include "handle_test_result.hpp" | |
20 | #include "table_type.hpp" | |
21 | ||
22 | #define BOOST_CHECK_CLOSE_EX(a, b, prec, i) \ | |
23 | {\ | |
24 | unsigned int failures = boost::unit_test::results_collector.results( boost::unit_test::framework::current_test_case().p_id ).p_assertions_failed;\ | |
25 | BOOST_CHECK_CLOSE(a, b, prec); \ | |
26 | if(failures != boost::unit_test::results_collector.results( boost::unit_test::framework::current_test_case().p_id ).p_assertions_failed)\ | |
27 | {\ | |
28 | std::cerr << "Failure was at row " << i << std::endl;\ | |
29 | std::cerr << std::setprecision(35); \ | |
30 | std::cerr << "{ " << data[i][0] << " , " << data[i][1] << " , " << data[i][2];\ | |
31 | std::cerr << " , " << data[i][3] << " , " << data[i][4] << " } " << std::endl;\ | |
32 | }\ | |
33 | } | |
34 | ||
35 | #define BOOST_CHECK_EX(a, i) \ | |
36 | {\ | |
37 | unsigned int failures = boost::unit_test::results_collector.results( boost::unit_test::framework::current_test_case().p_id ).p_assertions_failed;\ | |
38 | BOOST_CHECK(a); \ | |
39 | if(failures != boost::unit_test::results_collector.results( boost::unit_test::framework::current_test_case().p_id ).p_assertions_failed)\ | |
40 | {\ | |
41 | std::cerr << "Failure was at row " << i << std::endl;\ | |
42 | std::cerr << std::setprecision(35); \ | |
43 | std::cerr << "{ " << data[i][0] << " , " << data[i][1] << " , " << data[i][2];\ | |
44 | std::cerr << " , " << data[i][3] << " , " << data[i][4] << " } " << std::endl;\ | |
45 | }\ | |
46 | } | |
47 | ||
48 | template <class T> | |
49 | T nc_beta_cdf(T a, T b, T nc, T x) | |
50 | { | |
51 | #ifdef NC_BETA_CDF_FUNCTION_TO_TEST | |
52 | return NC_BETA_CDF_FUNCTION_TO_TEST(a, b, nc, x); | |
53 | #else | |
54 | return cdf(boost::math::non_central_beta_distribution<T>(a, b, nc), x); | |
55 | #endif | |
56 | } | |
57 | ||
58 | template <class T> | |
59 | T nc_beta_ccdf(T a, T b, T nc, T x) | |
60 | { | |
61 | #ifdef NC_BETA_CCDF_FUNCTION_TO_TEST | |
62 | return NC_BETA_CCDF_FUNCTION_TO_TEST(a, b, nc, x); | |
63 | #else | |
64 | return cdf(complement(boost::math::non_central_beta_distribution<T>(a, b, nc), x)); | |
65 | #endif | |
66 | } | |
67 | ||
68 | template <typename Real, typename T> | |
69 | void do_test_nc_chi_squared(T& data, const char* type_name, const char* test) | |
70 | { | |
71 | typedef Real value_type; | |
72 | ||
73 | std::cout << "Testing: " << test << std::endl; | |
74 | ||
75 | value_type(*fp1)(value_type, value_type, value_type, value_type) = nc_beta_cdf; | |
76 | boost::math::tools::test_result<value_type> result; | |
77 | ||
78 | #if !(defined(ERROR_REPORTING_MODE) && !defined(NC_BETA_CDF_FUNCTION_TO_TEST)) | |
79 | result = boost::math::tools::test_hetero<Real>( | |
80 | data, | |
81 | bind_func<Real>(fp1, 0, 1, 2, 3), | |
82 | extract_result<Real>(4)); | |
83 | handle_test_result(result, data[result.worst()], result.worst(), | |
84 | type_name, "non central beta CDF", test); | |
85 | #endif | |
86 | #if !(defined(ERROR_REPORTING_MODE) && !defined(NC_BETA_CCDF_FUNCTION_TO_TEST)) | |
87 | fp1 = nc_beta_ccdf; | |
88 | result = boost::math::tools::test_hetero<Real>( | |
89 | data, | |
90 | bind_func<Real>(fp1, 0, 1, 2, 3), | |
91 | extract_result<Real>(5)); | |
92 | handle_test_result(result, data[result.worst()], result.worst(), | |
93 | type_name, "non central beta CDF complement", test); | |
94 | #endif | |
95 | std::cout << std::endl; | |
96 | ||
97 | } | |
98 | ||
99 | template <typename Real, typename T> | |
100 | void quantile_sanity_check(T& data, const char* type_name, const char* test) | |
101 | { | |
102 | #ifndef ERROR_REPORTING_MODE | |
103 | typedef Real value_type; | |
104 | ||
105 | // | |
106 | // Tests with type real_concept take rather too long to run, so | |
107 | // for now we'll disable them: | |
108 | // | |
109 | if(!boost::is_floating_point<value_type>::value) | |
110 | return; | |
111 | ||
112 | std::cout << "Testing: " << type_name << " quantile sanity check, with tests " << test << std::endl; | |
113 | ||
114 | // | |
115 | // These sanity checks test for a round trip accuracy of one half | |
116 | // of the bits in T, unless T is type float, in which case we check | |
117 | // for just one decimal digit. The problem here is the sensitivity | |
118 | // of the functions, not their accuracy. This test data was generated | |
119 | // for the forward functions, which means that when it is used as | |
120 | // the input to the inverses then it is necessarily inexact. This rounding | |
121 | // of the input is what makes the data unsuitable for use as an accuracy check, | |
122 | // and also demonstrates that you can't in general round-trip these functions. | |
123 | // It is however a useful sanity check. | |
124 | // | |
125 | value_type precision = static_cast<value_type>(ldexp(1.0, 1 - boost::math::policies::digits<value_type, boost::math::policies::policy<> >() / 2)) * 100; | |
126 | if(boost::math::policies::digits<value_type, boost::math::policies::policy<> >() < 50) | |
127 | precision = 1; // 1% or two decimal digits, all we can hope for when the input is truncated to float | |
128 | ||
129 | for(unsigned i = 0; i < data.size(); ++i) | |
130 | { | |
131 | // | |
132 | // Test case 493 fails at float precision: not enough bits to get | |
133 | // us back where we started: | |
134 | // | |
135 | if((i == 493) && boost::is_same<float, value_type>::value) | |
136 | continue; | |
137 | ||
138 | if(data[i][4] == 0) | |
139 | { | |
140 | BOOST_CHECK(0 == quantile(boost::math::non_central_beta_distribution<value_type>(data[i][0], data[i][1], data[i][2]), data[i][4])); | |
141 | } | |
142 | else if(data[i][4] < 0.9999f) | |
143 | { | |
144 | value_type p = quantile(boost::math::non_central_beta_distribution<value_type>(data[i][0], data[i][1], data[i][2]), data[i][4]); | |
145 | value_type pt = data[i][3]; | |
146 | BOOST_CHECK_CLOSE_EX(pt, p, precision, i); | |
147 | } | |
148 | if(data[i][5] == 0) | |
149 | { | |
150 | BOOST_CHECK(1 == quantile(complement(boost::math::non_central_beta_distribution<value_type>(data[i][0], data[i][1], data[i][2]), data[i][5]))); | |
151 | } | |
152 | else if(data[i][5] < 0.9999f) | |
153 | { | |
154 | value_type p = quantile(complement(boost::math::non_central_beta_distribution<value_type>(data[i][0], data[i][1], data[i][2]), data[i][5])); | |
155 | value_type pt = data[i][3]; | |
156 | BOOST_CHECK_CLOSE_EX(pt, p, precision, i); | |
157 | } | |
158 | if(boost::math::tools::digits<value_type>() > 50) | |
159 | { | |
160 | // | |
161 | // Sanity check mode, accuracy of | |
162 | // the mode is at *best* the square root of the accuracy of the PDF: | |
163 | // | |
164 | value_type m = mode(boost::math::non_central_beta_distribution<value_type>(data[i][0], data[i][1], data[i][2])); | |
165 | if((m == 1) || (m == 0)) | |
166 | break; | |
167 | value_type p = pdf(boost::math::non_central_beta_distribution<value_type>(data[i][0], data[i][1], data[i][2]), m); | |
168 | if(m * (1 + sqrt(precision) * 10) < 1) | |
169 | { | |
170 | BOOST_CHECK_EX(pdf(boost::math::non_central_beta_distribution<value_type>(data[i][0], data[i][1], data[i][2]), m * (1 + sqrt(precision) * 10)) <= p, i); | |
171 | } | |
172 | if(m * (1 - sqrt(precision)) * 10 > boost::math::tools::min_value<value_type>()) | |
173 | { | |
174 | BOOST_CHECK_EX(pdf(boost::math::non_central_beta_distribution<value_type>(data[i][0], data[i][1], data[i][2]), m * (1 - sqrt(precision)) * 10) <= p, i); | |
175 | } | |
176 | } | |
177 | } | |
178 | #endif | |
179 | } | |
180 | ||
181 | template <typename T> | |
182 | void test_accuracy(T, const char* type_name) | |
183 | { | |
184 | #if !defined(TEST_DATA) || (TEST_DATA == 1) | |
185 | #include "ncbeta.ipp" | |
186 | do_test_nc_chi_squared<T>(ncbeta, type_name, "Non Central Beta, medium parameters"); | |
187 | quantile_sanity_check<T>(ncbeta, type_name, "Non Central Beta, medium parameters"); | |
188 | #endif | |
189 | #if !defined(TEST_DATA) || (TEST_DATA == 2) | |
190 | #include "ncbeta_big.ipp" | |
191 | do_test_nc_chi_squared<T>(ncbeta_big, type_name, "Non Central Beta, large parameters"); | |
192 | // Takes too long to run: | |
193 | // quantile_sanity_check(ncbeta_big, type_name, "Non Central Beta, large parameters"); | |
194 | #endif | |
195 | } |