| // Copyright John Maddock 2007. |
| // 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) |
| |
| #include "required_defines.hpp" |
| |
| #include "performance_measure.hpp" |
| |
| #include <boost/math/distributions.hpp> |
| |
| double probabilities[] = { |
| 1e-5, |
| 1e-4, |
| 1e-3, |
| 1e-2, |
| 0.05, |
| 0.1, |
| 0.2, |
| 0.3, |
| 0.4, |
| 0.5, |
| 0.6, |
| 0.7, |
| 0.8, |
| 0.9, |
| 0.95, |
| 1-1e-5, |
| 1-1e-4, |
| 1-1e-3, |
| 1-1e-2 |
| }; |
| |
| int int_values[] = { |
| 1, |
| 2, |
| 3, |
| 5, |
| 10, |
| 20, |
| 50, |
| 100, |
| 1000, |
| 10000, |
| 100000 |
| }; |
| |
| int small_int_values[] = { |
| 1, |
| 2, |
| 3, |
| 5, |
| 10, |
| 15, |
| 20, |
| 30, |
| 50, |
| 100, |
| 150 |
| }; |
| |
| double real_values[] = { |
| 1e-5, |
| 1e-4, |
| 1e-2, |
| 1e-1, |
| 1, |
| 10, |
| 100, |
| 1000, |
| 10000, |
| 100000 |
| }; |
| |
| #define BOOST_MATH_DISTRIBUTION3_TEST(name, param1_table, param2_table, param3_table, random_variable_table, probability_table) \ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist, name), "dist-" BOOST_STRINGIZE(name) "-cdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(param3_table)/sizeof(param3_table[0]);\ |
| unsigned d_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| for(unsigned l = 0; l < d_size; ++l)\ |
| {\ |
| result += cdf(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i], param2_table[j], param3_table[k]), random_variable_table[l]);\ |
| }\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size * d_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_pdf_, name), "dist-" BOOST_STRINGIZE(name) "-pdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(param3_table)/sizeof(param3_table[0]);\ |
| unsigned d_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| for(unsigned l = 0; l < d_size; ++l)\ |
| {\ |
| result += pdf(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i], param2_table[j], param3_table[k]), random_variable_table[l]);\ |
| }\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size * d_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_quant, name), "dist-" BOOST_STRINGIZE(name) "-quantile")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(param3_table)/sizeof(param3_table[0]);\ |
| unsigned d_size = sizeof(probability_table)/sizeof(probability_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| for(unsigned l = 0; l < d_size; ++l)\ |
| {\ |
| result += quantile(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i], param2_table[j], param3_table[k]), probability_table[l]);\ |
| }\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size * d_size);\ |
| } |
| |
| #define BOOST_MATH_DISTRIBUTION2_TEST(name, param1_table, param2_table, random_variable_table, probability_table) \ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist, name), "dist-" BOOST_STRINGIZE(name) "-cdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += cdf(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i], param2_table[j]), random_variable_table[k]);\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_pdf_, name), "dist-" BOOST_STRINGIZE(name) "-pdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += pdf(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i], param2_table[j]), random_variable_table[k]);\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_quant, name), "dist-" BOOST_STRINGIZE(name) "-quantile")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(probability_table)/sizeof(probability_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += quantile(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i], param2_table[j]), probability_table[k]);\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size);\ |
| } |
| |
| #define BOOST_MATH_DISTRIBUTION1_TEST(name, param1_table, random_variable_table, probability_table) \ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist, name), "dist-" BOOST_STRINGIZE(name) "-cdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned c_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += cdf(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i]), random_variable_table[k]);\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * c_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_pdf_, name), "dist-" BOOST_STRINGIZE(name) "-pdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned c_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += pdf(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i]), random_variable_table[k]);\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * c_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_quant, name), "dist-" BOOST_STRINGIZE(name) "-quantile")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned c_size = sizeof(probability_table)/sizeof(probability_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += quantile(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i]), probability_table[k]);\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * c_size);\ |
| } |
| |
| BOOST_MATH_DISTRIBUTION2_TEST(beta, probabilities, probabilities, probabilities, probabilities) |
| BOOST_MATH_DISTRIBUTION2_TEST(binomial, int_values, probabilities, int_values, probabilities) |
| BOOST_MATH_DISTRIBUTION2_TEST(cauchy, int_values, real_values, int_values, probabilities) |
| BOOST_MATH_DISTRIBUTION1_TEST(chi_squared, int_values, real_values, probabilities) |
| BOOST_MATH_DISTRIBUTION1_TEST(exponential, real_values, real_values, probabilities) |
| BOOST_MATH_DISTRIBUTION2_TEST(fisher_f, int_values, int_values, real_values, probabilities) |
| BOOST_MATH_DISTRIBUTION2_TEST(gamma, real_values, real_values, real_values, probabilities) |
| BOOST_MATH_DISTRIBUTION3_TEST(hypergeometric, small_int_values, small_int_values, small_int_values, small_int_values, probabilities) |
| BOOST_MATH_DISTRIBUTION2_TEST(logistic, real_values, real_values, real_values, probabilities) |
| BOOST_MATH_DISTRIBUTION2_TEST(lognormal, real_values, real_values, real_values, probabilities) |
| BOOST_MATH_DISTRIBUTION2_TEST(negative_binomial, int_values, probabilities, int_values, probabilities) |
| BOOST_MATH_DISTRIBUTION2_TEST(normal, real_values, real_values, real_values, probabilities) |
| BOOST_MATH_DISTRIBUTION1_TEST(poisson, real_values, int_values, probabilities) |
| BOOST_MATH_DISTRIBUTION1_TEST(students_t, int_values, real_values, probabilities) |
| BOOST_MATH_DISTRIBUTION2_TEST(weibull, real_values, real_values, real_values, probabilities) |
| BOOST_MATH_DISTRIBUTION2_TEST(non_central_chi_squared, int_values, int_values, real_values, probabilities) |
| BOOST_MATH_DISTRIBUTION3_TEST(non_central_beta, int_values, int_values, real_values, real_values, probabilities) |
| BOOST_MATH_DISTRIBUTION3_TEST(non_central_f, int_values, int_values, real_values, real_values, probabilities) |
| BOOST_MATH_DISTRIBUTION2_TEST(non_central_t, int_values, small_int_values, real_values, probabilities) |
| |
| #ifdef TEST_R |
| |
| #define MATHLIB_STANDALONE 1 |
| |
| extern "C" { |
| #include "Rmath.h" |
| } |
| |
| #define BOOST_MATH_R_DISTRIBUTION3_TEST(name, param1_table, param2_table, param3_table, random_variable_table, probability_table) \ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist, name), "dist-" #name "-R-cdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(param3_table)/sizeof(param3_table[0]);\ |
| unsigned d_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| for(unsigned l = 0; l < d_size; ++l)\ |
| {\ |
| result += p##name (random_variable_table[l], param1_table[i], param2_table[j], param3_table[k], 1, 0);\ |
| }\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size * d_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_pdf_, name), "dist-" #name "-R-pdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(param3_table)/sizeof(param3_table[0]);\ |
| unsigned d_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| for(unsigned l = 0; l < d_size; ++l)\ |
| {\ |
| result += d##name (random_variable_table[l], param1_table[i], param2_table[j], param3_table[k], 0);\ |
| }\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size * d_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_quant, name), "dist-" #name "-R-quantile")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(param3_table)/sizeof(param3_table[0]);\ |
| unsigned d_size = sizeof(probability_table)/sizeof(probability_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| for(unsigned l = 0; l < d_size; ++l)\ |
| {\ |
| result += q##name (probability_table[l], param1_table[i], param2_table[j], param3_table[k], 1, 0);\ |
| }\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size * d_size);\ |
| } |
| |
| #define BOOST_MATH_R_DISTRIBUTION2_TEST(name, param1_table, param2_table, random_variable_table, probability_table) \ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist, name), "dist-" #name "-R-cdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += p##name (random_variable_table[k], param1_table[i], param2_table[j], 1, 0);\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_pdf_, name), "dist-" #name "-R-pdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += d##name (random_variable_table[k], param1_table[i], param2_table[j], 0);\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_quant, name), "dist-" #name "-R-quantile")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(probability_table)/sizeof(probability_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += q##name (probability_table[k], param1_table[i], param2_table[j], 1, 0);\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size);\ |
| } |
| |
| #define BOOST_MATH_R_DISTRIBUTION1_TEST(name, param1_table, random_variable_table, probability_table) \ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist, name), "dist-" #name "-R-cdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned c_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += p##name (random_variable_table[k], param1_table[i], 1, 0);\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * c_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_pdf_, name), "dist-" #name "-R-pdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned c_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += d##name (random_variable_table[k], param1_table[i], 0);\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * c_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_quant, name), "dist-" #name "-R-quantile")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned c_size = sizeof(probability_table)/sizeof(probability_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += q##name (probability_table[k], param1_table[i], 1, 0);\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * c_size);\ |
| } |
| |
| double qhypergeo(double r, double n, double N, double p, int i, int j) |
| { |
| if(r > N) |
| return std::numeric_limits<double>::quiet_NaN(); |
| double nr = r; |
| double nb = N - r; |
| return qhyper(nr, nb, n, p, i, j); |
| } |
| |
| double phypergeo(double r, double n, double N, double k, int i, int j) |
| { |
| if((r > N) || (k > n) || (k > r)) |
| return std::numeric_limits<double>::quiet_NaN(); |
| double nr = r; |
| double nb = N - r; |
| return phyper(nr, nb, n, k, i, j); |
| } |
| |
| double dhypergeo(double r, double n, double N, double k, int i) |
| { |
| if((r > N) || (k > n) || (k > r)) |
| return std::numeric_limits<double>::quiet_NaN(); |
| double nr = r; |
| double nb = N - r; |
| return dhyper(nr, nb, n, k, i); |
| } |
| |
| BOOST_MATH_R_DISTRIBUTION2_TEST(beta, probabilities, probabilities, probabilities, probabilities) |
| BOOST_MATH_R_DISTRIBUTION2_TEST(binom, int_values, probabilities, int_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION2_TEST(cauchy, int_values, real_values, int_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION1_TEST(chisq, int_values, real_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION1_TEST(exp, real_values, real_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION2_TEST(f, int_values, int_values, real_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION2_TEST(gamma, real_values, real_values, real_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION3_TEST(hypergeo, small_int_values, small_int_values, small_int_values, small_int_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION2_TEST(logis, real_values, real_values, real_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION2_TEST(lnorm, real_values, real_values, real_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION2_TEST(nbinom, int_values, probabilities, int_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION2_TEST(norm, real_values, real_values, real_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION1_TEST(pois, real_values, int_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION1_TEST(t, int_values, real_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION2_TEST(weibull, real_values, real_values, real_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION2_TEST(nchisq, int_values, int_values, real_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION3_TEST(nf, int_values, int_values, real_values, real_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION3_TEST(nbeta, int_values, int_values, real_values, real_values, probabilities) |
| BOOST_MATH_R_DISTRIBUTION2_TEST(nt, int_values, small_int_values, real_values, probabilities) |
| |
| #endif |
| |
| #ifdef TEST_CEPHES |
| |
| extern "C"{ |
| |
| double bdtr(int k, int n, double p); |
| double bdtri(int k, int n, double p); |
| |
| double chdtr(double df, double x); |
| double chdtri(double df, double p); |
| |
| double fdtr(int k, int n, double p); |
| double fdtri(int k, int n, double p); |
| |
| double nbdtr(int k, int n, double p); |
| double nbdtri(int k, int n, double p); |
| |
| } |
| |
| #define BOOST_MATH_CEPHES_DISTRIBUTION2_TEST(name, param1_table, param2_table, random_variable_table, probability_table) \ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist, name), "dist-" #name "-cephes-cdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += name##dtr (param1_table[i], param2_table[j], random_variable_table[k]);\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_quant, name), "dist-" #name "-cephes-quantile")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(probability_table)/sizeof(probability_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += name##dtri (param1_table[i], param2_table[j], probability_table[k]);\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size);\ |
| } |
| |
| #define BOOST_MATH_CEPHES_DISTRIBUTION1_TEST(name, param1_table, random_variable_table, probability_table) \ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist, name), "dist-" #name "-cephes-cdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned c_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += name##dtr (param1_table[i], random_variable_table[k]);\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * c_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dist_quant, name), "dist-" #name "-cephes-quantile")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned c_size = sizeof(probability_table)/sizeof(probability_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| result += name##dtri (param1_table[i], probability_table[k]);\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * c_size);\ |
| } |
| // Cephes inverse doesn't actually calculate the quantile!!! |
| // BOOST_MATH_CEPHES_DISTRIBUTION2_TEST(b, int_values, int_values, probabilities, probabilities) |
| BOOST_MATH_CEPHES_DISTRIBUTION1_TEST(ch, int_values, real_values, probabilities) |
| BOOST_MATH_CEPHES_DISTRIBUTION2_TEST(f, int_values, int_values, real_values, probabilities) |
| // Cephes inverse doesn't calculate the quantile!!! |
| // BOOST_MATH_CEPHES_DISTRIBUTION2_TEST(nb, int_values, int_values, probabilities, probabilities) |
| |
| #endif |
| |
| #ifdef TEST_DCDFLIB |
| #include <dcdflib.h> |
| |
| void cdfbeta( int *which, double *p, double *q, double *x, double *a, double *b, int *status, double *bound) |
| { |
| double y = 1 - *x; |
| cdfbet(which, p, q, x, &y, a, b, status, bound); |
| } |
| |
| void cdfbinomial( int *which, double *p, double *q, double *x, double *a, double *b, int *status, double *bound) |
| { |
| double y = 1 - *x; |
| double cb = 1 - *b; |
| cdfbet(which, p, q, x, a, b, &cb, status, bound); |
| } |
| |
| void cdfnegative_binomial( int *which, double *p, double *q, double *x, double *a, double *b, int *status, double *bound) |
| { |
| double y = 1 - *x; |
| double cb = 1 - *b; |
| cdfnbn(which, p, q, x, a, b, &cb, status, bound); |
| } |
| |
| void cdfchi_squared( int *which, double *p, double *q, double *x, double *a, int *status, double *bound) |
| { |
| cdfchi(which, p, q, x, a, status, bound); |
| } |
| |
| void cdfnon_central_chi_squared( int *which, double *p, double *q, double *x, double *a, double *b, int *status, double *bound) |
| { |
| cdfchn(which, p, q, x, a, b, status, bound); |
| } |
| |
| namespace boost{ namespace math{ |
| |
| template <class T = double> struct f_distribution : public fisher_f_distribution<T> |
| { f_distribution(T a, T b) : fisher_f_distribution<T>(a, b) {} }; |
| template <class T = double> |
| struct fnc_distribution : public non_central_f_distribution<T> |
| { fnc_distribution(T a, T b, T c) : non_central_f_distribution<T>(a, b, c) {} }; |
| template <class T = double> struct gam_distribution : public gamma_distribution<T> |
| { gam_distribution(T a, T b) : gamma_distribution<T>(a, b) {} }; |
| template <class T = double> struct nor_distribution : public normal_distribution<T> |
| { nor_distribution(T a, T b) : normal_distribution<T>(a, b) {} }; |
| template <class T = double> struct poi_distribution : public poisson_distribution<T> |
| { poi_distribution(T a) : poisson_distribution<T>(a) {} }; |
| template <class T = double> struct t_distribution : public students_t_distribution<T> |
| { t_distribution(T a) : students_t_distribution<T>(a) {} }; |
| |
| template <class T> |
| T cdf(const f_distribution<T>& d, const T& r){ return cdf(static_cast<fisher_f_distribution<T> >(d), r); } |
| template <class T> |
| T quantile(const f_distribution<T>& d, const T& r){ return quantile(static_cast<fisher_f_distribution<T> >(d), r); } |
| template <class T> |
| T cdf(const fnc_distribution<T>& d, const T& r){ return cdf(static_cast<non_central_f_distribution<T> >(d), r); } |
| template <class T> |
| T quantile(const fnc_distribution<T>& d, const T& r){ return quantile(static_cast<non_central_f_distribution<T> >(d), r); } |
| template <class T> |
| T cdf(const gam_distribution<T>& d, const T& r){ return cdf(static_cast<gamma_distribution<T> >(d), r); } |
| template <class T> |
| T quantile(const gam_distribution<T>& d, const T& r){ return quantile(static_cast<gamma_distribution<T> >(d), r); } |
| template <class T> |
| T cdf(const nor_distribution<T>& d, const T& r){ return cdf(static_cast<normal_distribution<T> >(d), r); } |
| template <class T> |
| T quantile(const nor_distribution<T>& d, const T& r){ return quantile(static_cast<normal_distribution<T> >(d), r); } |
| template <class T> |
| T cdf(const poi_distribution<T>& d, const T& r){ return cdf(static_cast<poisson_distribution<T> >(d), r); } |
| template <class T> |
| T quantile(const poi_distribution<T>& d, const T& r){ return quantile(static_cast<poisson_distribution<T> >(d), r); } |
| template <class T> |
| T cdf(const t_distribution<T>& d, const T& r){ return cdf(static_cast<students_t_distribution<T> >(d), r); } |
| template <class T> |
| T quantile(const t_distribution<T>& d, const T& r){ return quantile(static_cast<students_t_distribution<T> >(d), r); } |
| |
| }} |
| |
| bool check_near(double a, double b) |
| { |
| bool r = ((fabs(a) <= 1e-7) || (fabs(b) <= 1e-7)) ? (fabs(a-b) < 1e-7) : fabs((a - b) / a) < 1e-5; |
| return r; |
| } |
| |
| #define BOOST_MATH_DCD_DISTRIBUTION3_TEST(name, param1_table, param2_table, param3_table, random_variable_table, probability_table) \ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dcd_dist, name), "dist-" BOOST_STRINGIZE(name) "-dcd-cdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(param3_table)/sizeof(param3_table[0]);\ |
| unsigned d_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| for(unsigned l = 0; l < d_size; ++l)\ |
| {\ |
| int which = 1;\ |
| double p; double q; \ |
| double rv = random_variable_table[l];\ |
| double a = param1_table[i];\ |
| double b = param2_table[j];\ |
| double c = param3_table[k];\ |
| int status = 0;\ |
| double bound = 0;\ |
| BOOST_JOIN(cdf, name)(&which, &p, &q, &rv, &a, &b, &c, &status, &bound);\ |
| result += p;\ |
| BOOST_ASSERT(\ |
| (status != 0) || check_near(p, \ |
| cdf(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i], param2_table[j], param3_table[k]), random_variable_table[l])\ |
| ));\ |
| }\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size * d_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dcd_dist_quant, name), "dist-" BOOST_STRINGIZE(name) "-dcd-quantile")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(param3_table)/sizeof(param3_table[0]);\ |
| unsigned d_size = sizeof(probability_table)/sizeof(probability_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| for(unsigned l = 0; l < d_size; ++l)\ |
| {\ |
| int which = 2;\ |
| double p = probability_table[l];\ |
| double q = 1 - p; \ |
| double rv;\ |
| double a = param1_table[i];\ |
| double b = param2_table[j];\ |
| double c = param3_table[k];\ |
| int status = 0;\ |
| double bound = 0;\ |
| BOOST_JOIN(cdf, name)(&which, &p, &q, &rv, &a, &b, &c, &status, &bound);\ |
| result += rv;\ |
| BOOST_ASSERT((status != 0) || (p > 0.99) || check_near(rv, quantile(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i], param2_table[j], param3_table[k]), probability_table[l])));\ |
| }\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size * d_size);\ |
| } |
| |
| #define BOOST_MATH_DCD_DISTRIBUTION2_TEST(name, param1_table, param2_table, random_variable_table, probability_table) \ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dcd_dist, name), "dist-" BOOST_STRINGIZE(name) "-dcd-cdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| int which = 1;\ |
| double p; double q; \ |
| double rv = random_variable_table[k];\ |
| double a = param1_table[i];\ |
| double b = param2_table[j];\ |
| int status = 0;\ |
| double bound = 0;\ |
| BOOST_JOIN(cdf, name)(&which, &p, &q, &rv, &a, &b, &status, &bound);\ |
| result += p;\ |
| BOOST_ASSERT((status != 0) || check_near(p, cdf(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i], param2_table[j]), random_variable_table[k])));\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dcd_dist_quant, name), "dist-" BOOST_STRINGIZE(name) "-dcd-quantile")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned b_size = sizeof(param2_table)/sizeof(param2_table[0]);\ |
| unsigned c_size = sizeof(probability_table)/sizeof(probability_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned j = 0; j < b_size; ++j)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| int which = 2;\ |
| double p = probability_table[k];\ |
| double q = 1 - p; \ |
| double rv;\ |
| double a = param1_table[i];\ |
| double b = param2_table[j];\ |
| int status = 0;\ |
| double bound = 0;\ |
| BOOST_JOIN(cdf, name)(&which, &p, &q, &rv, &a, &b, &status, &bound);\ |
| result += rv;\ |
| BOOST_ASSERT((status != 0) || (p > 0.99) || check_near(rv, quantile(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i], param2_table[j]), probability_table[k])));\ |
| }\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * b_size * c_size);\ |
| } |
| |
| #define BOOST_MATH_DCD_DISTRIBUTION1_TEST(name, param1_table, random_variable_table, probability_table) \ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dcd_dist, name), "dist-" BOOST_STRINGIZE(name) "-dcd-cdf")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned c_size = sizeof(random_variable_table)/sizeof(random_variable_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| int which = 1;\ |
| double p; double q; \ |
| double rv = random_variable_table[k];\ |
| double a = param1_table[i];\ |
| int status = 0;\ |
| double bound = 0;\ |
| BOOST_JOIN(cdf, name)(&which, &p, &q, &rv, &a, &status, &bound);\ |
| result += p;\ |
| BOOST_ASSERT((status != 0) || check_near(p, cdf(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i]), random_variable_table[k])));\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * c_size);\ |
| }\ |
| BOOST_MATH_PERFORMANCE_TEST(BOOST_JOIN(dcd_dist_quant, name), "dist-" BOOST_STRINGIZE(name) "-dcd-quantile")\ |
| {\ |
| double result = 0;\ |
| unsigned a_size = sizeof(param1_table)/sizeof(param1_table[0]);\ |
| unsigned c_size = sizeof(probability_table)/sizeof(probability_table[0]);\ |
| \ |
| for(unsigned i = 0; i < a_size; ++i)\ |
| {\ |
| for(unsigned k = 0; k < c_size; ++k)\ |
| {\ |
| int which = 2;\ |
| double p = probability_table[k];\ |
| double q = 1 - p; \ |
| double rv;\ |
| double a = param1_table[i];\ |
| int status = 0;\ |
| double bound = 0;\ |
| BOOST_JOIN(cdf, name)(&which, &p, &q, &rv, &a, &status, &bound);\ |
| result += rv;\ |
| BOOST_ASSERT((status != 0) || (p > 0.99) || check_near(rv, quantile(boost::math:: BOOST_JOIN(name, _distribution) <>(param1_table[i]), probability_table[k])));\ |
| }\ |
| }\ |
| \ |
| consume_result(result);\ |
| set_call_count(a_size * c_size);\ |
| } |
| |
| BOOST_MATH_DCD_DISTRIBUTION2_TEST(beta, probabilities, probabilities, probabilities, probabilities) // ?? |
| BOOST_MATH_DCD_DISTRIBUTION2_TEST(binomial, int_values, probabilities, int_values, probabilities) // OK ish |
| BOOST_MATH_DCD_DISTRIBUTION1_TEST(chi_squared, int_values, real_values, probabilities) // OK |
| BOOST_MATH_DCD_DISTRIBUTION2_TEST(non_central_chi_squared, int_values, int_values, real_values, probabilities) // Error rates quite high for DCD version? |
| BOOST_MATH_DCD_DISTRIBUTION2_TEST(f, int_values, int_values, real_values, probabilities) // OK |
| BOOST_MATH_DCD_DISTRIBUTION3_TEST(fnc, int_values, int_values, real_values, real_values, probabilities) // Error rates quite high for DCD version? |
| BOOST_MATH_DCD_DISTRIBUTION2_TEST(gam, real_values, real_values, real_values, probabilities) // ?? |
| BOOST_MATH_DCD_DISTRIBUTION2_TEST(negative_binomial, int_values, probabilities, int_values, probabilities) // OK |
| BOOST_MATH_DCD_DISTRIBUTION2_TEST(nor, real_values, real_values, real_values, probabilities) // OK |
| BOOST_MATH_DCD_DISTRIBUTION1_TEST(poi, real_values, int_values, probabilities) // OK |
| BOOST_MATH_DCD_DISTRIBUTION1_TEST(t, int_values, real_values, probabilities) // OK |
| |
| #endif |
