1 // test_inverse_gamma.cpp
2
3 // Copyright Paul A. Bristow 2010.
4 // Copyright John Maddock 2010.
5
6 // Use, modification and distribution are subject to the
7 // Boost Software License, Version 1.0.
8 // (See accompanying file LICENSE_1_0.txt
9 // or copy at http://www.boost.org/LICENSE_1_0.txt)
10
11 #ifdef _MSC_VER
12 # pragma warning (disable : 4224) // nonstandard extension used : formal parameter 'type' was previously defined as a type
13 // in Boost.test and lexical_cast
14 # pragma warning (disable : 4310) // cast truncates constant value
15 #endif
16
17 #include <boost/math/tools/test.hpp>
18 #include <boost/math/concepts/real_concept.hpp> // for real_concept
19 using ::boost::math::concepts::real_concept;
20
21 //#include <boost/math/tools/test.hpp>
22 #define BOOST_TEST_MAIN
23 #include <boost/test/unit_test.hpp> // for test_main
24 #include <boost/test/tools/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE_FRACTION
25 #include "test_out_of_range.hpp"
26
27 #include <boost/math/distributions/inverse_gamma.hpp> // for inverse_gamma_distribution
28 using boost::math::inverse_gamma_distribution;
29 using ::boost::math::inverse_gamma;
30 // using ::boost::math::cdf;
31 // using ::boost::math::pdf;
32
33 #include <boost/math/special_functions/gamma.hpp>
34 using boost::math::tgamma; // for naive pdf.
35
36 #include <iostream>
37 using std::cout;
38 using std::endl;
39 #include <limits>
40 using std::numeric_limits;
41
42 template <class RealType>
naive_pdf(RealType shape,RealType scale,RealType x)43 RealType naive_pdf(RealType shape, RealType scale, RealType x)
44 { // Formula from Wikipedia
45 using namespace std; // For ADL of std functions.
46 using boost::math::tgamma;
47 RealType result = (pow(scale, shape) * pow(x, (-shape -1)) * exp(-scale/x) ) / tgamma(shape);
48 return result;
49 }
50
51 // Test using a spot value from some other reference source,
52 // in this case test values from output from R provided by Thomas Mang.
53
54 template <class RealType>
test_spot(RealType shape,RealType scale,RealType x,RealType pd,RealType P,RealType Q,RealType tol)55 void test_spot(
56 RealType shape, // shape,
57 RealType scale, // scale,
58 RealType x, // random variate x,
59 RealType pd, // expected pdf,
60 RealType P, // expected CDF,
61 RealType Q, // expected complement of CDF,
62 RealType tol) // test tolerance.
63 {
64 boost::math::inverse_gamma_distribution<RealType> dist(shape, scale);
65
66 BOOST_CHECK_CLOSE_FRACTION
67 ( // Compare to expected PDF.
68 pdf(dist, x), // calculated.
69 pd, // expected
70 tol);
71
72 BOOST_CHECK_CLOSE_FRACTION( // Compare to naive formula (might be less accurate).
73 pdf(dist, x), naive_pdf(dist.shape(), dist.scale(), x), tol);
74
75 BOOST_CHECK_CLOSE_FRACTION( // Compare to expected CDF.
76 cdf(dist, x), P, tol);
77
78 if((P < 0.999) && (Q < 0.999))
79 { // We can only check this if P is not too close to 1,
80 // so that we can guarantee Q is accurate:
81 BOOST_CHECK_CLOSE_FRACTION(
82 cdf(complement(dist, x)), Q, tol);
83 BOOST_CHECK_CLOSE_FRACTION(
84 quantile(dist, P), x, tol); // quantile(pdf) = x
85 BOOST_CHECK_CLOSE_FRACTION(
86 quantile(complement(dist, Q)), x, tol);
87 }
88 } // test_spot
89
90 // Test using a spot value from some other reference source.
91
92 template <class RealType> // Any floating-point type RealType.
test_spots(RealType)93 void test_spots(RealType)
94 {
95 // Basic sanity checks, test data is to six decimal places only
96 // so set tolerance to 0.000001 expressed as a percentage = 0.0001%.
97
98 RealType tolerance = 0.000001f; // as fraction.
99 cout << "Tolerance = " << tolerance * 100 << "%." << endl;
100
101 // This test values from output from R provided by Thomas Mang.
102 test_spot(static_cast<RealType>(2), static_cast<RealType>(1), // shape, scale
103 static_cast<RealType>(2.L), // x
104 static_cast<RealType>(0.075816332464079136L), // pdf
105 static_cast<RealType>(0.90979598956895047L), // cdf
106 static_cast<RealType>(1 - 0.90979598956895047L), // cdf complement
107 tolerance // tol
108 );
109
110 test_spot(static_cast<RealType>(1.593), static_cast<RealType>( 0.5), // shape, scale
111 static_cast<RealType>( 0.5), // x
112 static_cast<RealType>(0.82415241749687074L), // pdf
113 static_cast<RealType>(0.60648042700409865L), // cdf
114 static_cast<RealType>(1 - 0.60648042700409865L), // cdf complement
115 tolerance // tol
116 );
117
118 test_spot(static_cast<RealType>(13.319), static_cast<RealType>(0.5), // shape, scale
119 static_cast<RealType>(0.5), // x
120 static_cast<RealType>(0.00000000068343206235379223), // pdf
121 static_cast<RealType>(0.99999999997242739L), // cdf
122 static_cast<RealType>(1 - 0.99999999997242739L), // cdf complement
123 tolerance // tol
124 );
125
126 test_spot(static_cast<RealType>(1.593), static_cast<RealType>(1), // shape, scale
127 static_cast<RealType>(1.977), // x
128 static_cast<RealType>(0.11535946773398653L), // pdf
129 static_cast<RealType>(0.82449794420341549L), // cdf
130 static_cast<RealType>(1 - 0.82449794420341549L), // cdf complement
131 tolerance // tol
132 );
133
134 test_spot(static_cast<RealType>(6.666), static_cast<RealType>(1.411), // shape, scale
135 static_cast<RealType>(5), // x
136 static_cast<RealType>(0.000000084415758206386872), // pdf
137 static_cast<RealType>(0.99999993427280998L), // cdf
138 static_cast<RealType>(1 - 0.99999993427280998L), // cdf complement
139 tolerance // tol
140 );
141
142 // Check some bad parameters to the distribution,
143 #ifndef BOOST_NO_EXCEPTIONS
144 BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> igbad1(-1, 0), std::domain_error); // negative shape.
145 BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> igbad2(0, -1), std::domain_error); // negative scale.
146 BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> igbad2(-1, -1), std::domain_error); // negative scale and shape.
147 #else
148 BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(-1, 0), std::domain_error); // negative shape.
149 BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(0, -1), std::domain_error); // negative scale.
150 BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(-1, -1), std::domain_error); // negative scale and shape.
151 #endif
152
153 inverse_gamma_distribution<RealType> ig21(2, 1);
154
155 if(std::numeric_limits<RealType>::has_infinity)
156 {
157 BOOST_MATH_CHECK_THROW(pdf(ig21, +std::numeric_limits<RealType>::infinity()), std::domain_error); // x = + infinity, pdf = 0
158 BOOST_MATH_CHECK_THROW(pdf(ig21, -std::numeric_limits<RealType>::infinity()), std::domain_error); // x = - infinity, pdf = 0
159 BOOST_MATH_CHECK_THROW(cdf(ig21, +std::numeric_limits<RealType>::infinity()),std::domain_error ); // x = + infinity, cdf = 1
160 BOOST_MATH_CHECK_THROW(cdf(ig21, -std::numeric_limits<RealType>::infinity()), std::domain_error); // x = - infinity, cdf = 0
161 BOOST_MATH_CHECK_THROW(cdf(complement(ig21, +std::numeric_limits<RealType>::infinity())), std::domain_error); // x = + infinity, c cdf = 0
162 BOOST_MATH_CHECK_THROW(cdf(complement(ig21, -std::numeric_limits<RealType>::infinity())), std::domain_error); // x = - infinity, c cdf = 1
163 #ifndef BOOST_NO_EXCEPTIONS
164 BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> nbad1(std::numeric_limits<RealType>::infinity(), static_cast<RealType>(1)), std::domain_error); // +infinite mean
165 BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> nbad1(-std::numeric_limits<RealType>::infinity(), static_cast<RealType>(1)), std::domain_error); // -infinite mean
166 BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> nbad1(static_cast<RealType>(0), std::numeric_limits<RealType>::infinity()), std::domain_error); // infinite sd
167 #else
168 BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(std::numeric_limits<RealType>::infinity(), static_cast<RealType>(1)), std::domain_error); // +infinite mean
169 BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(-std::numeric_limits<RealType>::infinity(), static_cast<RealType>(1)), std::domain_error); // -infinite mean
170 BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(static_cast<RealType>(0), std::numeric_limits<RealType>::infinity()), std::domain_error); // infinite sd
171 #endif
172 }
173
174 if (std::numeric_limits<RealType>::has_quiet_NaN)
175 {
176 // No longer allow x to be NaN, then these tests should throw.
177 BOOST_MATH_CHECK_THROW(pdf(ig21, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // x = NaN
178 BOOST_MATH_CHECK_THROW(cdf(ig21, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // x = NaN
179 BOOST_MATH_CHECK_THROW(cdf(complement(ig21, +std::numeric_limits<RealType>::quiet_NaN())), std::domain_error); // x = + infinity
180 BOOST_MATH_CHECK_THROW(quantile(ig21, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // p = + infinity
181 BOOST_MATH_CHECK_THROW(quantile(complement(ig21, +std::numeric_limits<RealType>::quiet_NaN())), std::domain_error); // p = + infinity
182 }
183 // Spot check for pdf using 'naive pdf' function
184 for(RealType x = 0.5; x < 5; x += 0.5)
185 {
186 BOOST_CHECK_CLOSE_FRACTION(
187 pdf(inverse_gamma_distribution<RealType>(5, 6), x),
188 naive_pdf(RealType(5), RealType(6), x),
189 tolerance);
190 } // Spot checks for parameters:
191
192 RealType tol_few_eps = boost::math::tools::epsilon<RealType>() * 5; // 5 eps as a fraction.
193 inverse_gamma_distribution<RealType> dist51(5, 1);
194 inverse_gamma_distribution<RealType> dist52(5, 2);
195 inverse_gamma_distribution<RealType> dist31(3, 1);
196 inverse_gamma_distribution<RealType> dist111(11, 1);
197 // 11 mean 0.10000000000000001, variance 0.0011111111111111111, sd 0.033333333333333333
198
199 RealType x = static_cast<RealType>(0.125);
200 using namespace std; // ADL of std names.
201 using namespace boost::math;
202
203 // mean, variance etc
204 BOOST_CHECK_CLOSE_FRACTION(mean(dist52), static_cast<RealType>(0.5), tol_few_eps);
205 BOOST_CHECK_CLOSE_FRACTION(mean(dist111), static_cast<RealType>(0.1L), tol_few_eps);
206 inverse_gamma_distribution<RealType> igamma41(static_cast<RealType>(4.), static_cast<RealType>(1.) );
207 BOOST_CHECK_CLOSE_FRACTION(mean(igamma41), static_cast<RealType>(0.3333333333333333333333333333333333333333333333333333333L), tol_few_eps);
208 // variance:
209 BOOST_CHECK_CLOSE_FRACTION(variance(dist51), static_cast<RealType>(0.0208333333333333333333333333333333333333333333333333L), tol_few_eps);
210 BOOST_CHECK_CLOSE_FRACTION(variance(dist31), static_cast<RealType>(0.25), tol_few_eps);
211 BOOST_CHECK_CLOSE_FRACTION(variance(dist111), static_cast<RealType>(0.001111111111111111111111111111111111111111111111111L), tol_few_eps);
212 // std deviation:
213 BOOST_CHECK_CLOSE_FRACTION(standard_deviation(dist31), static_cast<RealType>(0.5), tol_few_eps);
214 BOOST_CHECK_CLOSE_FRACTION(standard_deviation(dist111), static_cast<RealType>(0.0333333333333333333333333333333333333333333333333L), tol_few_eps);
215 // hazard:
216 BOOST_CHECK_CLOSE_FRACTION(hazard(dist51, x), pdf(dist51, x) / cdf(complement(dist51, x)), tol_few_eps);
217 // cumulative hazard:
218 BOOST_CHECK_CLOSE_FRACTION(chf(dist51, x), -log(cdf(complement(dist51, x))), tol_few_eps);
219 // coefficient_of_variation:
220 BOOST_CHECK_CLOSE_FRACTION(coefficient_of_variation(dist51), standard_deviation(dist51) / mean(dist51), tol_few_eps);
221 // mode:
222 BOOST_CHECK_CLOSE_FRACTION(mode(dist51), static_cast<RealType>(0.166666666666666666666666666666666666666666666666666L), tol_few_eps);
223 // median
224 //BOOST_CHECK_CLOSE_FRACTION(median(dist52), static_cast<RealType>(0), tol_few_eps);
225 // Useful to have an exact median? Failing that use a loop back test.
226 BOOST_CHECK_CLOSE_FRACTION(cdf(dist111, median(dist111)), 0.5, tol_few_eps);
227 // skewness:
228 BOOST_CHECK_CLOSE_FRACTION(skewness(dist111), static_cast<RealType>(1.5), tol_few_eps);
229 //kurtosis:
230 BOOST_CHECK_CLOSE_FRACTION(kurtosis(dist51), static_cast<RealType>(42 + 3), tol_few_eps);
231 // kurtosis excess:
232 BOOST_CHECK_CLOSE_FRACTION(kurtosis_excess(dist51), static_cast<RealType>(42), tol_few_eps);
233
234 tol_few_eps = boost::math::tools::epsilon<RealType>() * 3; // 3 eps as a percentage.
235
236 // Special and limit cases:
237
238 if(std::numeric_limits<RealType>::is_specialized)
239 {
240 RealType mx = (std::numeric_limits<RealType>::max)();
241 RealType mi = (std::numeric_limits<RealType>::min)();
242
243 BOOST_CHECK_EQUAL(
244 pdf(inverse_gamma_distribution<RealType>(1),
245 static_cast<RealType>(mx)), // max()
246 static_cast<RealType>(0)
247 );
248
249 BOOST_CHECK_EQUAL(
250 pdf(inverse_gamma_distribution<RealType>(1),
251 static_cast<RealType>(mi)), // min()
252 static_cast<RealType>(0)
253 );
254
255 }
256
257 BOOST_CHECK_EQUAL(
258 pdf(inverse_gamma_distribution<RealType>(1), static_cast<RealType>(0)), static_cast<RealType>(0));
259 BOOST_CHECK_EQUAL(
260 pdf(inverse_gamma_distribution<RealType>(3), static_cast<RealType>(0))
261 , static_cast<RealType>(0.0f));
262 BOOST_CHECK_EQUAL(
263 cdf(inverse_gamma_distribution<RealType>(1), static_cast<RealType>(0))
264 , static_cast<RealType>(0.0f));
265 BOOST_CHECK_EQUAL(
266 cdf(inverse_gamma_distribution<RealType>(2), static_cast<RealType>(0))
267 , static_cast<RealType>(0.0f));
268 BOOST_CHECK_EQUAL(
269 cdf(inverse_gamma_distribution<RealType>(3), static_cast<RealType>(0))
270 , static_cast<RealType>(0.0f));
271 BOOST_CHECK_EQUAL(
272 cdf(complement(inverse_gamma_distribution<RealType>(1), static_cast<RealType>(0)))
273 , static_cast<RealType>(1));
274 BOOST_CHECK_EQUAL(
275 cdf(complement(inverse_gamma_distribution<RealType>(2), static_cast<RealType>(0)))
276 , static_cast<RealType>(1));
277 BOOST_CHECK_EQUAL(
278 cdf(complement(inverse_gamma_distribution<RealType>(3), static_cast<RealType>(0)))
279 , static_cast<RealType>(1));
280
281 BOOST_MATH_CHECK_THROW(
282 pdf(
283 inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)), // shape negative.
284 static_cast<RealType>(1)), std::domain_error
285 );
286 BOOST_MATH_CHECK_THROW(
287 pdf(
288 inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
289 static_cast<RealType>(-1)), std::domain_error
290 );
291 BOOST_MATH_CHECK_THROW(
292 cdf(
293 inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)),
294 static_cast<RealType>(1)), std::domain_error
295 );
296 BOOST_MATH_CHECK_THROW(
297 cdf(
298 inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
299 static_cast<RealType>(-1)), std::domain_error
300 );
301 BOOST_MATH_CHECK_THROW(
302 cdf(complement(
303 inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)),
304 static_cast<RealType>(1))), std::domain_error
305 );
306 BOOST_MATH_CHECK_THROW(
307 cdf(complement(
308 inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
309 static_cast<RealType>(-1))), std::domain_error
310 );
311 BOOST_MATH_CHECK_THROW(
312 quantile(
313 inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)),
314 static_cast<RealType>(0.5)), std::domain_error
315 );
316 BOOST_MATH_CHECK_THROW(
317 quantile(
318 inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
319 static_cast<RealType>(-1)), std::domain_error
320 );
321 BOOST_MATH_CHECK_THROW(
322 quantile(
323 inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
324 static_cast<RealType>(1.1)), std::domain_error
325 );
326 BOOST_MATH_CHECK_THROW(
327 quantile(complement(
328 inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)),
329 static_cast<RealType>(0.5))), std::domain_error
330 );
331 BOOST_MATH_CHECK_THROW(
332 quantile(complement(
333 inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
334 static_cast<RealType>(-1))), std::domain_error
335 );
336 BOOST_MATH_CHECK_THROW(
337 quantile(complement(
338 inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
339 static_cast<RealType>(1.1))), std::domain_error
340 );
341 check_out_of_range<inverse_gamma_distribution<RealType> >(1, 1);
342 } // template <class RealType>void test_spots(RealType)
343
BOOST_AUTO_TEST_CASE(test_main)344 BOOST_AUTO_TEST_CASE( test_main )
345 {
346 BOOST_MATH_CONTROL_FP;
347
348 // Check that can generate inverse_gamma distribution using the two convenience methods:
349 // inverse_gamma_distribution; // with default parameters, shape = 1, scale - 1
350 using boost::math::inverse_gamma;
351 inverse_gamma ig2(2.); // Using typedef and shape parameter (and default scale = 1).
352 BOOST_CHECK_EQUAL(ig2.shape(), 2.); // scale == 2.
353 BOOST_CHECK_EQUAL(ig2.scale(), 1.); // scale == 1 (default).
354 inverse_gamma ig; // Using typedef, type double and default values, shape = 1 and scale = 1
355 // check default is (1, 1)
356 BOOST_CHECK_EQUAL(ig.shape(), 1.); // shape == 1
357 BOOST_CHECK_EQUAL(ig.scale(), 1.); // scale == 1
358 BOOST_CHECK_EQUAL(mode(ig), 0.5); // mode = 1/2
359
360 // Used to find some 'exact' values for testing mean, variance ...
361 //for (int shape = 4; shape < 30; shape++)
362 // {
363 // inverse_gamma ig(shape, 1);
364 // cout.precision(17);
365 // cout << shape << ' ' << mean(ig) << ' ' << variance(ig) << ' ' << standard_deviation(ig)
366 // << ' ' << median(ig) << endl;
367 // }
368
369 // and "using boost::math::inverse_gamma_distribution;".
370 inverse_gamma_distribution<> ig23(2., 3.); // Using default RealType double.
371 BOOST_CHECK_EQUAL(ig23.shape(), 2.); //
372 BOOST_CHECK_EQUAL(ig23.scale(), 3.); //
373
374 inverse_gamma_distribution<float> igf23(1.f, 2.f); // Using explicit RealType float.
375 BOOST_CHECK_EQUAL(igf23.shape(), 1.f); //
376 BOOST_CHECK_EQUAL(igf23.scale(), 2.f); //
377 // Some tests using default double.
378 double tol5eps = boost::math::tools::epsilon<double>() * 5; // 5 eps as a fraction.
379 inverse_gamma_distribution<double> ig102(10., 2.); //
380 BOOST_CHECK_EQUAL(ig102.shape(), 10.); //
381 BOOST_CHECK_EQUAL(ig102.scale(), 2.); //
382 // formatC(SuppDists::dinvGauss(10, 1, 0.5), digits=17)[1] "0.0011774669940754754"
383 BOOST_CHECK_CLOSE_FRACTION(pdf(ig102, 0.5), 0.1058495335284024, tol5eps);
384 // formatC(SuppDists::pinvGauss(10, 1, 0.5), digits=17) [1] "0.99681494462166653"
385 BOOST_CHECK_CLOSE_FRACTION(cdf(ig102, 0.5), 0.99186775720306608, tol5eps);
386 BOOST_CHECK_CLOSE_FRACTION(quantile(ig102, 0.05), 0.12734622346137681, tol5eps);
387 BOOST_CHECK_CLOSE_FRACTION(quantile(ig102, 0.5), 0.20685272858879727, tol5eps);
388 BOOST_CHECK_CLOSE_FRACTION(quantile(ig102, 0.95), 0.36863602680851204, tol5eps);
389 // Check mean, etc spot values.
390 inverse_gamma_distribution<double> ig51(5., 1.); // shape = 5, scale = 1
391 BOOST_CHECK_CLOSE_FRACTION(mean(ig51), 0.25, tol5eps);
392 BOOST_CHECK_CLOSE_FRACTION(variance(ig51), 0.0208333333333333333333333333333333333333333, tol5eps);
393 BOOST_CHECK_CLOSE_FRACTION(skewness(ig51), 2 * std::sqrt(3.), tol5eps);
394 BOOST_CHECK_CLOSE_FRACTION(kurtosis_excess(ig51), 42, tol5eps);
395 // mode and median
396 inverse_gamma_distribution<double> ig21(1., 2.);
397 BOOST_CHECK_CLOSE_FRACTION(mode(ig21), 1, tol5eps);
398 BOOST_CHECK_CLOSE_FRACTION(median(ig21), 2.8853900817779268, tol5eps);
399
400 BOOST_CHECK_CLOSE_FRACTION(quantile(ig21, 0.5), 2.8853900817779268, tol5eps);
401 BOOST_CHECK_CLOSE_FRACTION(cdf(ig21, median(ig21)), 0.5, tol5eps);
402
403 // Check throws from bad parameters.
404 inverse_gamma ig051(0.5, 1.); // shape < 1, so wrong for mean.
405 BOOST_MATH_CHECK_THROW(mean(ig051), std::domain_error);
406 inverse_gamma ig191(1.9999, 1.); // shape < 2, so wrong for variance.
407 BOOST_MATH_CHECK_THROW(variance(ig191), std::domain_error);
408 inverse_gamma ig291(2.9999, 1.); // shape < 3, so wrong for skewness.
409 BOOST_MATH_CHECK_THROW(skewness(ig291), std::domain_error);
410 inverse_gamma ig391(3.9999, 1.); // shape < 1, so wrong for kurtosis and kurtosis_excess.
411 BOOST_MATH_CHECK_THROW(kurtosis(ig391), std::domain_error);
412 BOOST_MATH_CHECK_THROW(kurtosis_excess(ig391), std::domain_error);
413
414 // Basic sanity-check spot values.
415 // (Parameter value, arbitrarily zero, only communicates the floating point type).
416 test_spots(0.0F); // Test float. OK at decdigits = 0 tolerance = 0.0001 %
417 test_spots(0.0); // Test double. OK at decdigits 7, tolerance = 1e07 %
418 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
419 test_spots(0.0L); // Test long double.
420 #ifndef BOOST_MATH_NO_REAL_CONCEPT_TESTS
421 test_spots(boost::math::concepts::real_concept(0.)); // Test real concept.
422 #endif
423 #else
424 std::cout << "<note>The long double tests have been disabled on this platform "
425 "either because the long double overloads of the usual math functions are "
426 "not available at all, or because they are too inaccurate for these tests "
427 "to pass.</note>" << std::endl;
428 #endif
429
430 } // BOOST_AUTO_TEST_CASE( test_main )
431
432 /*
433
434 Output:
435
436 ------ Build started: Project: test_inverse_gamma_distribution, Configuration: Release Win32 ------
437 test_inverse_gamma_distribution.cpp
438 Generating code
439 Finished generating code
440 test_inverse_gamma_distribution.vcxproj -> J:\Cpp\MathToolkit\test\Math_test\Release\test_inverse_gamma_distribution.exe
441 Running 1 test case...
442 Tolerance = 0.0001%.
443 Tolerance = 0.0001%.
444 Tolerance = 0.0001%.
445 Tolerance = 0.0001%.
446
447 *** No errors detected
448 ========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========
449
450
451 */
452
453
454
455