1 // (C) Copyright John Maddock 2006.
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
6 #ifndef BOOST_MATH_TOOLS_TEST_HPP
7 #define BOOST_MATH_TOOLS_TEST_HPP
8
9 #ifdef _MSC_VER
10 #pragma once
11 #endif
12
13 #include <boost/math/tools/config.hpp>
14 #include <boost/math/tools/stats.hpp>
15 #include <boost/math/special_functions/fpclassify.hpp>
16 #include <boost/math/special_functions/relative_difference.hpp>
17 #include <boost/math/policies/error_handling.hpp>
18 #include <boost/test/test_tools.hpp>
19 #include <stdexcept>
20 #include <iostream>
21 #include <iomanip>
22
23 namespace boost{ namespace math{ namespace tools{
24
25 template <class T>
26 struct test_result
27 {
28 private:
29 boost::math::tools::stats<T> stat; // Statistics for the test.
30 unsigned worst_case; // Index of the worst case test.
31 public:
test_resultboost::math::tools::test_result32 test_result() { worst_case = 0; }
set_worstboost::math::tools::test_result33 void set_worst(int i){ worst_case = i; }
addboost::math::tools::test_result34 void add(const T& point){ stat.add(point); }
35 // accessors:
worstboost::math::tools::test_result36 unsigned worst()const{ return worst_case; }
BOOST_PREVENT_MACRO_SUBSTITUTIONboost::math::tools::test_result37 T min BOOST_PREVENT_MACRO_SUBSTITUTION()const{ return (stat.min)(); }
BOOST_PREVENT_MACRO_SUBSTITUTIONboost::math::tools::test_result38 T max BOOST_PREVENT_MACRO_SUBSTITUTION()const{ return (stat.max)(); }
totalboost::math::tools::test_result39 T total()const{ return stat.total(); }
meanboost::math::tools::test_result40 T mean()const{ return stat.mean(); }
countboost::math::tools::test_result41 boost::uintmax_t count()const{ return stat.count(); }
varianceboost::math::tools::test_result42 T variance()const{ return stat.variance(); }
variance1boost::math::tools::test_result43 T variance1()const{ return stat.variance1(); }
rmsboost::math::tools::test_result44 T rms()const{ return stat.rms(); }
45
operator +=boost::math::tools::test_result46 test_result& operator+=(const test_result& t)
47 {
48 if((t.stat.max)() > (stat.max)())
49 worst_case = t.worst_case;
50 stat += t.stat;
51 return *this;
52 }
53 };
54
55 template <class T>
56 struct calculate_result_type
57 {
58 typedef typename T::value_type row_type;
59 typedef typename row_type::value_type value_type;
60 };
61
62 template <class T>
relative_error(T a,T b)63 T relative_error(T a, T b)
64 {
65 return boost::math::relative_difference(a, b);
66 }
67
68
69 template <class T>
set_output_precision(T,std::ostream & os)70 void set_output_precision(T, std::ostream& os)
71 {
72 #ifdef BOOST_MSVC
73 #pragma warning(push)
74 #pragma warning(disable:4127)
75 #endif
76 if(std::numeric_limits<T>::digits10)
77 {
78 os << std::setprecision(std::numeric_limits<T>::digits10 + 2);
79 }
80 #ifdef BOOST_MSVC
81 #pragma warning(pop)
82 #endif
83 }
84
85 template <class Seq>
print_row(const Seq & row,std::ostream & os=std::cout)86 void print_row(const Seq& row, std::ostream& os = std::cout)
87 {
88 try {
89 set_output_precision(row[0], os);
90 for (unsigned i = 0; i < row.size(); ++i)
91 {
92 if (i)
93 os << ", ";
94 os << row[i];
95 }
96 os << std::endl;
97 }
98 catch (const std::exception&) {}
99 }
100
101 //
102 // Function test accepts an matrix of input values (probably a 2D boost::array)
103 // and calls two functors for each row in the array - one calculates a value
104 // to test, and one extracts the expected value from the array (or possibly
105 // calculates it at high precision). The two functors are usually simple lambda
106 // expressions.
107 //
108 template <class A, class F1, class F2>
test(const A & a,F1 test_func,F2 expect_func)109 test_result<typename calculate_result_type<A>::value_type> test(const A& a, F1 test_func, F2 expect_func)
110 {
111 typedef typename A::value_type row_type;
112 typedef typename row_type::value_type value_type;
113
114 test_result<value_type> result;
115
116 for(unsigned i = 0; i < a.size(); ++i)
117 {
118 const row_type& row = a[i];
119 value_type point;
120 #ifndef BOOST_NO_EXCEPTIONS
121 try
122 {
123 #endif
124 point = test_func(row);
125 #ifndef BOOST_NO_EXCEPTIONS
126 }
127 catch(const std::underflow_error&)
128 {
129 point = 0;
130 }
131 catch(const std::overflow_error&)
132 {
133 point = std::numeric_limits<value_type>::has_infinity ?
134 std::numeric_limits<value_type>::infinity()
135 : tools::max_value<value_type>();
136 }
137 catch(const std::exception& e)
138 {
139 std::cerr << e.what() << std::endl;
140 print_row(row, std::cerr);
141 BOOST_ERROR("Unexpected exception.");
142 // so we don't get further errors:
143 point = expect_func(row);
144 }
145 #endif
146 value_type expected = expect_func(row);
147 value_type err = relative_error(point, expected);
148 #ifdef BOOST_INSTRUMENT
149 if(err != 0)
150 {
151 std::cout << row[0] << " " << err;
152 if(std::numeric_limits<value_type>::is_specialized)
153 {
154 std::cout << " (" << err / std::numeric_limits<value_type>::epsilon() << "eps)";
155 }
156 std::cout << std::endl;
157 }
158 #endif
159 if(!(boost::math::isfinite)(point) && (boost::math::isfinite)(expected))
160 {
161 std::cerr << "CAUTION: Found non-finite result, when a finite value was expected at entry " << i << "\n";
162 std::cerr << "Found: " << point << " Expected " << expected << " Error: " << err << std::endl;
163 print_row(row, std::cerr);
164 BOOST_ERROR("Unexpected non-finite result");
165 }
166 if(err > 0.5)
167 {
168 std::cerr << "CAUTION: Gross error found at entry " << i << ".\n";
169 std::cerr << "Found: " << point << " Expected " << expected << " Error: " << err << std::endl;
170 print_row(row, std::cerr);
171 BOOST_ERROR("Gross error");
172 }
173 result.add(err);
174 if((result.max)() == err)
175 result.set_worst(i);
176 }
177 return result;
178 }
179
180 template <class Real, class A, class F1, class F2>
test_hetero(const A & a,F1 test_func,F2 expect_func)181 test_result<Real> test_hetero(const A& a, F1 test_func, F2 expect_func)
182 {
183 typedef typename A::value_type row_type;
184 typedef Real value_type;
185
186 test_result<value_type> result;
187
188 for(unsigned i = 0; i < a.size(); ++i)
189 {
190 const row_type& row = a[i];
191 value_type point;
192 #ifndef BOOST_NO_EXCEPTIONS
193 try
194 {
195 #endif
196 point = test_func(row);
197 #ifndef BOOST_NO_EXCEPTIONS
198 }
199 catch(const std::underflow_error&)
200 {
201 point = 0;
202 }
203 catch(const std::overflow_error&)
204 {
205 point = std::numeric_limits<value_type>::has_infinity ?
206 std::numeric_limits<value_type>::infinity()
207 : tools::max_value<value_type>();
208 }
209 catch(const std::exception& e)
210 {
211 std::cerr << "Unexpected exception at entry: " << i << "\n";
212 std::cerr << e.what() << std::endl;
213 print_row(row, std::cerr);
214 BOOST_ERROR("Unexpected exception.");
215 // so we don't get further errors:
216 point = expect_func(row);
217 }
218 #endif
219 value_type expected = expect_func(row);
220 value_type err = relative_error(point, expected);
221 #ifdef BOOST_INSTRUMENT
222 if(err != 0)
223 {
224 std::cout << row[0] << " " << err;
225 if(std::numeric_limits<value_type>::is_specialized)
226 {
227 std::cout << " (" << err / std::numeric_limits<value_type>::epsilon() << "eps)";
228 }
229 std::cout << std::endl;
230 }
231 #endif
232 if(!(boost::math::isfinite)(point) && (boost::math::isfinite)(expected))
233 {
234 std::cerr << "CAUTION: Found non-finite result, when a finite value was expected at entry " << i << "\n";
235 std::cerr << "Found: " << point << " Expected " << expected << " Error: " << err << std::endl;
236 print_row(row, std::cerr);
237 BOOST_ERROR("Unexpected non-finite result");
238 }
239 if(err > 0.5)
240 {
241 std::cerr << "CAUTION: Gross error found at entry " << i << ".\n";
242 std::cerr << "Found: " << point << " Expected " << expected << " Error: " << err << std::endl;
243 print_row(row, std::cerr);
244 BOOST_ERROR("Gross error");
245 }
246 result.add(err);
247 if((result.max)() == err)
248 result.set_worst(i);
249 }
250 return result;
251 }
252
253 template <class Val, class Exception>
test_check_throw(Val v,Exception e)254 void test_check_throw(Val v, Exception e)
255 {
256 BOOST_CHECK(errno);
257 errno = 0;
258 }
259
260 template <class Val>
test_check_throw(Val val,std::domain_error const * e)261 void test_check_throw(Val val, std::domain_error const* e)
262 {
263 BOOST_CHECK(errno == EDOM);
264 errno = 0;
265 if(std::numeric_limits<Val>::has_quiet_NaN)
266 {
267 BOOST_CHECK((boost::math::isnan)(val));
268 }
269 }
270
271 template <class Val>
test_check_throw(Val v,std::overflow_error const * e)272 void test_check_throw(Val v, std::overflow_error const* e)
273 {
274 BOOST_CHECK(errno == ERANGE);
275 errno = 0;
276 BOOST_CHECK((v >= boost::math::tools::max_value<Val>()) || (v <= -boost::math::tools::max_value<Val>()));
277 }
278
279 template <class Val>
test_check_throw(Val v,boost::math::rounding_error const * e)280 void test_check_throw(Val v, boost::math::rounding_error const* e)
281 {
282 BOOST_CHECK(errno == ERANGE);
283 errno = 0;
284 if(std::numeric_limits<Val>::is_specialized && std::numeric_limits<Val>::is_integer)
285 {
286 BOOST_CHECK((v == (std::numeric_limits<Val>::max)()) || (v == (std::numeric_limits<Val>::min)()));
287 }
288 else
289 {
290 BOOST_CHECK((v == boost::math::tools::max_value<Val>()) || (v == -boost::math::tools::max_value<Val>()));
291 }
292 }
293
294 } // namespace tools
295 } // namespace math
296 } // namespace boost
297
298
299 //
300 // exception-free testing support, ideally we'd only define this in our tests,
301 // but to keep things simple we really need it somewhere that's always included:
302 //
303 #ifdef BOOST_NO_EXCEPTIONS
304 # define BOOST_MATH_CHECK_THROW(x, ExceptionType) boost::math::tools::test_check_throw(x, static_cast<ExceptionType const*>(0));
305 #else
306 # define BOOST_MATH_CHECK_THROW(x, y) BOOST_CHECK_THROW(x, y)
307 #endif
308
309 #endif
310
311
312