void expected_results() { // // Define the max and mean errors expected for // various compilers and platforms. // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) "Beta Function: Small.*", // test data group "beta", 8, 5); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) "Beta Function: Medium.*", // test data group "beta", 1000, 750); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) "Beta Function: Divergent.*", // test data group "beta", 1000, 700); // 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; }
void expected_results() { // // Define the max and mean errors expected for // various compilers and platforms. // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*mpfr_float_backend<18>.*", // test type(s) ".*Negative.*", // test data group ".*", 20000, 2000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) ".*Negative.*", // test data group ".*", 350, 40); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) ".*", // test data group ".*", 80, 30); // 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; }
void expected_results() { // // Define the max and mean errors expected for // various compilers and platforms. // #ifdef BOOST_INTEL add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "float128", // test type(s) ".*", // test data group "boost::math::hermite", 70, 25); // test function #endif add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) ".*", // test data group "boost::math::hermite", 10, 5); // 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; }
void expected_results() { // // Define the max and mean errors expected for // various compilers and platforms. // // // 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; add_expected_result( "Borland.*", // compiler ".*", // stdlib ".*", // platform "long double", // test type(s) ".*", // test data group ".*", 10, 6); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "(long )?double|real_concept", // test type(s) ".*", // test data group ".*", 2, 2); // test function }
void expected_results() { // // Define the max and mean errors expected for // various compilers and platforms. // add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform ".*", // test type(s) "(?i).*small.*", // test data group ".*", 90, 25); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform ".*", // test type(s) "(?i).*medium.*", // test data group ".*", 200, 50); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform ".*", // test type(s) "(?i).*large.*", // test data group ".*", 6000000, 500000); // 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; }
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"; } else { largest_type = "long double"; } #else largest_type = "(long\\s+)?double"; #endif add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*Random values less than 1", // test data group ".*", 1200, 500); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) ".*Random values less than 1", // test data group ".*", 1200, 500); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*Integer.*", // test data group ".*", 30, 15); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*", // test data group ".*", 3, 3); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) ".*", // test data group ".*", 40, 15); // test function std::cout << "Tests run with " << BOOST_COMPILER << ", " << BOOST_STDLIB << ", " << BOOST_PLATFORM << 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"; } else { largest_type = "long double"; } #else largest_type = "(long\\s+)?double"; #endif // // Catch all cases come last: // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*Large.*", // test data group ".*", 50, 20); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) ".*Large.*", // test data group ".*", 50, 20); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*", // test data group ".*", 15, 8); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) ".*", // test data group ".*", 15, 8); // 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; }
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 // // On MacOS X cyl_bessel_k has much higher error levels than // expected: given that the implementation is basically // just a continued fraction evaluation combined with // exponentiation, we conclude that exp and pow are less // accurate on this platform, especially when the result // is outside the range of a double. // add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS", // platform largest_type, // test type(s) ".*", // test data group ".*", 4000, 1300); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*large.*", // test data group ".*", 80, 50); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*", // test data group ".*", 35, 15); // 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; }
void expected_results() { // // Define the max and mean errors expected for // various compilers and platforms. // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) ".*J0.*Tricky.*", // test data group ".*", 400000000, 400000000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) ".*J1.*Tricky.*", // test data group ".*", 10000000, 5000000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) ".*JN.*Integer.*", // test data group ".*", 50000, 15000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) ".*(JN|j).*|.*Tricky.*", // test data group ".*", 7000, 3000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) ".*", // test data group ".*", 40, 20); // 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; }
void expected_results() { // // Define the max and mean errors expected for // various compilers and platforms. // // // Catch all cases come last: // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) ".*", // test data group ".*", // test function 500, // Max Peek error 200); // Max mean error // // 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; }
void expected_results() { // // Define the max and mean errors expected for // various compilers and platforms. // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*gmp_float<18>.*", // test type(s) "Erf Function:.*", // test data group "boost::math::erfc?", 2200, 1500);// test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*gmp_float<18>.*", // test type(s) "Inverse Erf.*", // test data group "boost::math::erfc?_inv", 2200, 1500); // test function #ifdef BOOST_INTEL add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "float128", // test type(s) "Erf Function:.*", // test data group "boost::math::erfc?", 15000, 1000); // test function #endif add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*cpp_bin_float.*", // test type(s) "Erf Function:.*", // test data group "boost::math::erfc?", 3000, 1000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) "Erf Function:.*", // test data group "boost::math::erfc?", 300, 200); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) "Inverse Erf.*", // test data group "boost::math::erfc?_inv", 60, 20); // 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; }
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"; } else { largest_type = "long double"; } #else largest_type = "(long\\s+)?double"; #endif // // Linux: // // These should not really be needed, but on *some* Linux // versions these error rates are quite large and appear to // be related to the accuracy of powl and expl. On Itanium // or Xeon machines the error rates are much lower than this. // Worst cases appear to be AMD64 machines. // add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "linux", // platform largest_type, // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 1000, 200); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "linux", // platform largest_type, // test type(s) "[^|]*integer[^|]*", // test data group "[^|]*", 1000, 200); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "linux", // platform "real_concept", // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 1000, 200); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "linux", // platform "real_concept", // test type(s) "[^|]*integer[^|]*", // test data group "[^|]*", 600, 200); // test function // // Mac OS X: // It's not clear why these should be required, but see notes above // about Linux. // add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "Mac OS", // platform largest_type, // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 5000, 1000); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "Mac OS", // platform largest_type, // test type(s) "[^|]*small[^|]*", // test data group "[^|]*", 40, 15); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "Mac OS", // platform largest_type, // test type(s) "[^|]*integer[^|]*", // test data group "[^|]*", 2000, 300); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "Mac OS", // platform "real_concept", // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 5000, 1000); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "Mac OS", // platform "real_concept", // test type(s) "[^|]*small[^|]*", // test data group "[^|]*", 40, 15); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "Mac OS", // platform "real_concept", // test type(s) "[^|]*integer[^|]*", // test data group "[^|]*", 2000, 300); // test function // // HP-UX: // add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "HP-UX", // platform largest_type, // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 500, 50); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "HP-UX", // platform "real_concept", // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 500, 100); // test function // // Sun OS: // add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "Sun.*", // platform largest_type, // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 500, 100); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "Sun.*", // platform largest_type, // test type(s) "[^|]*integer[^|]*", // test data group "[^|]*", 100, 30); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "Sun.*", // platform "real_concept", // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 500, 100); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "Sun.*", // platform "real_concept", // test type(s) "[^|]*integer[^|]*", // test data group "[^|]*", 100, 30); // test function // // Mac OS X: // add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "Mac OS", // platform largest_type, // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 100, 50); // test function // // Minw: // add_expected_result( "GNU[^|]*", // compiler "[^|]*", // stdlib "Win32[^|]*", // platform "real_concept", // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 700, 200); // test function add_expected_result( "GNU[^|]*", // compiler "[^|]*", // stdlib "Win32[^|]*", // platform largest_type, // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 700, 200); // test function add_expected_result( "GNU[^|]*", // compiler "[^|]*", // stdlib "Win32[^|]*", // platform largest_type, // test type(s) "[^|]*small[^|]*", // test data group "[^|]*", 100, 50); // test function add_expected_result( "GNU[^|]*", // compiler "[^|]*", // stdlib "Win32[^|]*", // platform largest_type, // test type(s) "[^|]*integer[^|]*", // test data group ".*", 120, 50); // test function add_expected_result( "GNU[^|]*", // compiler "[^|]*", // stdlib "Win32[^|]*", // platform "real_concept", // test type(s) "[^|]*integer[^|]*", // test data group ".*", 100, 50); // test function // // Large exponent range causes more extreme test cases to be evaluated: // if(std::numeric_limits<long double>::max_exponent > std::numeric_limits<double>::max_exponent) { add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*large[^|]*", // test data group ".*", 40000, 3000); // test function } // // Catch all cases come last: // add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 50, 20); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*small[^|]*", // test data group "[^|]*", 20, 10); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*large[^|]*", // test data group "boost::math::gamma_q", 500, 50); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "Cygwin", // platform largest_type, // test type(s) "[^|]*large[^|]*", // test data group "boost::math::gamma_p", 700, 50); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*large[^|]*", // test data group "boost::math::gamma_p", 350, 50); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*integer[^|]*", // test data group ".*", 20, 10); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "real_concept", // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 200, 50); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "real_concept", // test type(s) "[^|]*small[^|]*", // test data group ".*", 20, 10); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "real_concept", // test type(s) "[^|]*large[^|]*", // test data group ".*", 1000000, 100000); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "real_concept", // test type(s) "[^|]*integer[^|]*", // test data group ".*", 40, 10); // 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; }
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"; } else { largest_type = "long double"; } #else largest_type = "(long\\s+)?double"; #endif // // Mac OS has higher error rates, why? // add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS", // platform largest_type, // test type(s) ".*", // test data group ".*", 3500, 1500); // test function // // G++ on Linux, results vary a bit by processor type, // on Itanium results are *much* better than listed here, // but x86 appears to have much less accurate std::pow // that throws off the results for tgamma(long double) // which then impacts on the Bessel functions: // add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform largest_type, // test type(s) ".*Random.*", // test data group ".*", 600, 200); // test function add_expected_result( "GNU.*", // compiler ".*", // stdlib "Win32.*", // platform largest_type, // test type(s) ".*Random.*", // test data group ".*", 500, 200); // test function add_expected_result( "GNU.*", // compiler ".*", // stdlib "Win32.*", // platform largest_type, // test type(s) ".*", // test data group ".*", 3500, 1000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*I'v.*Mathworld.*", // test data group ".*", 4000, 2000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*", // test data group ".*", 40, 25); // test function // // Set error rates a little higher for real_concept - // now that we use a series approximation for small z // that relies on tgamma the error rates are a little // higher only when a Lanczos approximation is not available. // All other types are unaffected. // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) ".*I'v.*Mathworld.*", // test data group ".*", 4000, 2000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) ".*", // test data group ".*", 600, 200); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*", // test data group ".*", 2, 1); // 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; }
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"; } else { largest_type = "long double"; } #else largest_type = "(long\\s+)?double"; #endif // // Large exponent range causes more extreme test cases to be evaluated: // if(std::numeric_limits<long double>::max_exponent > std::numeric_limits<double>::max_exponent) { add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*small[^|]*", // test data group "[^|]*", 200000, 10000); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "real_concept", // test type(s) "[^|]*small[^|]*", // test data group "[^|]*", 70000, 8000); // test function } // // These high error rates are seen on on some Linux // architectures: // add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "linux.*", // platform largest_type, // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 350, 5); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "linux.*", // platform largest_type, // test type(s) "[^|]*large[^|]*", // test data group "[^|]*", 150, 5); // test function // // Catch all cases come last: // add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 20, 5); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*large[^|]*", // test data group "[^|]*", 5, 2); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*small[^|]*", // test data group "[^|]*", 2100, 500); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "float|double", // test type(s) "[^|]*small[^|]*", // test data group "boost::math::gamma_p_inv", 500, 60); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "float|double", // test type(s) "[^|]*", // test data group "boost::math::gamma_q_inv", 350, 60); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "float|double", // test type(s) "[^|]*", // test data group "[^|]*", 4, 2); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "real_concept", // test type(s) "[^|]*medium[^|]*", // test data group "[^|]*", 20, 5); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "real_concept", // test type(s) "[^|]*large[^|]*", // test data group "[^|]*", 1000, 500); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "real_concept", // test type(s) "[^|]*small[^|]*", // test data group "[^|]*", 3700, 500); // 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; }
void expected_results() { // // Define the max and mean errors expected for // various compilers and platforms. // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*gmp_float<18>.*", // test type(s) ".*", // test data group "boost::math::tgamma", 4000, 2500); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) "factorials", // test data group "boost::math::tgamma", 140, 70); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) "factorials", // test data group "boost::math::lgamma", 750, 100); // test function #ifdef BOOST_INTEL add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "float128", // test type(s) ".*near -.*", // test data group ".*", 150000L, 30000L); // test function #endif add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) "near.*", // test data group "boost::math::tgamma", 200, 100); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) "near.*", // test data group "boost::math::lgamma", 10000000, 10000000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) "tgamma1pm1.*", // test data group "boost::math::tgamma1pm1", 1000, 150); // 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; }
void expected_results() { // // Define the max and mean errors expected for // various compilers and platforms. // #if LDBL_MANT_DIG == 106 // Darwin: add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS.*", // platform "(long\\s+)?double", // test type(s) "Beta Function: Medium.*", // test data group "beta", 200, 35); // test function #endif add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "(long\\s+)?double", // test type(s) "Beta Function: Small.*", // test data group "beta", 8, 5); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "(long\\s+)?double", // test type(s) "Beta Function: Medium.*", // test data group "beta", 160, 35); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "(long\\s+)?double", // test type(s) "Beta Function: Divergent.*", // test data group "beta", 30, 6); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "Beta Function: Small.*", // test data group "beta", 15, 15); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "Beta Function: Medium.*", // test data group "beta", 150, 40); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "Beta Function: Divergent.*", // test data group "beta", 25, 8); // 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; }
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"; } else { largest_type = "long double"; } #else largest_type = "(long\\s+)?double"; #endif // // On MacOS X erfc has much higher error levels than // expected: given that the implementation is basically // just a rational function evaluation combined with // exponentiation, we conclude that exp and pow are less // accurate on this platform, especially when the result // is outside the range of a double. // add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS", // platform "float|double|long double", // test type(s) ".*E1.*", // test data group ".*", 30, 10); // test function add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS", // platform "float|double|long double|real_concept", // test type(s) ".*Ei.*", // test data group ".*", 300, 200); // test function add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS", // platform ".*", // test type(s) ".*", // test data group ".*", 40, 15); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "float|double|long double", // test type(s) ".*E1.*", // test data group ".*", 2, 1); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "float|double|long double", // test type(s) ".*Ei.*", // test data group ".*", 6, 3); // test function if(std::numeric_limits<long double>::digits > 100) { add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) ".*Ei.*", // test data group ".*", 150, 50); // test function } add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) ".*Ei.*", // test data group ".*", 150, 50); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) ".*", // test data group ".*", 25, 5); // test function std::cout << "Tests run with " << BOOST_COMPILER << ", " << BOOST_STDLIB << ", " << BOOST_PLATFORM << 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"; } else { largest_type = "long double"; } #else largest_type = "(long\\s+)?double"; #endif // // HP-UX // This is a weird one, HP-UX and Mac OS X show up errors at float // precision, that don't show up on other platforms. // There appears to be some kind of rounding issue going on (not enough // precision in the input to get the answer right): // add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "HP-UX|Mac OS|linux|.*(bsd|BSD).*", // platform "float", // test type(s) "[^|]*", // test data group "tgamma_ratio[^|]*", 35, 8); // test function // // Linux AMD x86em64 has slightly higher rates: // add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "linux.*", // platform largest_type, // test type(s) "[^|]*", // test data group "tgamma_ratio[^|]*", 300, 100); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "linux.*", // platform "real_concept", // test type(s) "[^|]*", // test data group "tgamma_ratio[^|]*", 300, 100); // test function add_expected_result( "GNU.*", // compiler "[^|]*", // stdlib "Win32.*", // platform largest_type, // test type(s) "[^|]*", // test data group "tgamma_ratio[^|]*", 300, 100); // test function // // Catch all cases come last: // add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*", // test data group "tgamma_delta_ratio[^|]*", 30, 20); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*", // test data group "tgamma_ratio[^|]*", 100, 50); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "real_concept", // test type(s) "[^|]*", // test data group "tgamma_delta_ratio[^|]*", 40, 15); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "real_concept", // test type(s) "[^|]*", // test data group "[^|]*", 250, 150); // 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; }
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"; } else { largest_type = "long double"; } #else largest_type = "(long\\s+)?double"; #endif add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "float", // test type(s) ".*", // test data group ".*", 1, 1); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*rational.*", // test data group ".*", 15, 2); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*pade.*", // test data group ".*", 30, 3); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*", // test data group ".*", 10, 2); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*rational.*", // test data group ".*", 26000, 2000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*pade.*", // test data group ".*", 60000, 5000); // test function // worst case in choice of 13.3.7 and backward recurrence add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*", // test data group ".*", 4000, 600); // 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; }
void expected_results() { // // Define the max and mean errors expected for // various compilers and platforms. // // Note that permitted max errors are really pretty high // at around 10000eps. The reason for this is that even // if the forward function is off by 1eps, it's enough to // throw out the inverse by ~7000eps. In other words the // forward function may flatline, so that many x-values // all map to about the same p. Trying to invert in this // region is almost futile. // 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"; } else { largest_type = "long double"; } #else largest_type = "(long\\s+)?double"; #endif #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS // // Linux etc, // Extended exponent range of long double // causes more extreme test cases to be executed: // if(std::numeric_limits<long double>::digits == 64) { add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*", // test data group ".*", 20, 10); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "long double", // test type(s) ".*", // test data group ".*", 200000, 100000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) ".*", // test data group ".*", 5000000L, 500000); // test function } #endif // // MinGW, // Extended exponent range of long double // causes more extreme test cases to be executed: // add_expected_result( ".*mingw.*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*", // test data group ".*", 10, 10); // test function add_expected_result( ".*mingw.*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*", // test data group ".*", 300000, 20000); // test function // // HP-UX and Solaris: // Extended exponent range of long double // causes more extreme test cases to be executed: // add_expected_result( ".*", // compiler ".*", // stdlib "HP-UX|Sun Solaris", // platform "long double", // test type(s) ".*", // test data group ".*", 200000, 100000); // test function // // HP Tru64: // Extended exponent range of long double // causes more extreme test cases to be executed: // add_expected_result( "HP Tru64.*", // compiler ".*", // stdlib ".*", // platform "long double", // test type(s) ".*", // test data group ".*", 200000, 100000); // test function // // Catch all cases come last: // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*", // test data group ".*", 10000, 1000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) ".*", // test data group ".*", 500000, 500000); // 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; }
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"; } else { largest_type = "long double"; } #else largest_type = "(long\\s+)?double"; #endif // // Linux special cases, error rates seem to be much higer here // even though the implementation contains nothing but basic // arithmetic? // if((std::numeric_limits<long double>::digits <= 64) && (std::numeric_limits<long double>::digits != std::numeric_limits<double>::digits)) { #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*", // test data group ".*", 10, 5); // test function #endif } add_expected_result( ".*", // compiler ".*", // stdlib "linux.*|Mac OS|Sun.*", // platform largest_type, // test type(s) ".*", // test data group ".*", 40000, 1000); // test function add_expected_result( ".*", // compiler ".*", // stdlib "linux.*|Mac OS|Sun.*", // platform "real_concept", // test type(s) ".*", // test data group ".*", 40000, 1000); // test function add_expected_result( "GNU.*", // compiler ".*", // stdlib "Win32.*", // platform largest_type, // test type(s) ".*", // test data group ".*", 40000, 1000); // test function add_expected_result( "GNU.*", // compiler ".*", // stdlib "Win32.*", // platform "real_concept", // test type(s) ".*", // test data group ".*", 40000, 1000); // test function add_expected_result( ".*", // compiler ".*", // stdlib "IBM Aix", // platform largest_type, // test type(s) ".*", // test data group ".*", 5000, 500); // test function add_expected_result( ".*", // compiler ".*", // stdlib "IBM Aix", // platform "real_concept", // test type(s) ".*", // test data group ".*", 5000, 500); // test function // // Catch all cases come last: // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*", // test data group ".*", 4000, 500); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) ".*", // test data group ".*", 4000, 500); // 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; }
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"; #endif // // HP-UX and Solaris rates are very slightly higher: // add_expected_result( ".*", // compiler ".*", // stdlib "HP-UX|Sun Solaris", // platform largest_type, // test type(s) ".*(Y[nv]|y).*Random.*", // test data group ".*", 30000, 30000); // test function add_expected_result( ".*", // compiler ".*", // stdlib "HP-UX|Sun Solaris", // platform largest_type, // test type(s) ".*Y[01Nv].*", // test data group ".*", 1300, 500); // test function // // Tru64: // add_expected_result( ".*Tru64.*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*(Y[nv]|y).*Random.*", // test data group ".*", 30000, 30000); // test function add_expected_result( ".*Tru64.*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*Y[01Nv].*", // test data group ".*", 400, 200); // test function // // Mac OS X rates are very slightly higher: // add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS", // platform largest_type, // test type(s) ".*(Y[nv1]).*", // test data group ".*", 600000, 100000); // test function add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS", // platform "long double|real_concept", // test type(s) ".*Y[0].*", // test data group ".*", 1200, 1000); // test function // // Linux: // add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform largest_type, // test type(s) ".*Yv.*Random.*", // test data group ".*", 200000, 200000); // test function add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform largest_type, // test type(s) ".*Y[01v].*", // test data group ".*", 2000, 1000); // test function add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform largest_type, // test type(s) ".*Yn.*", // test data group ".*", 30000, 30000); // test function // // MinGW: // add_expected_result( ".*mingw.*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*Yv.*Random.*", // test data group ".*", 200000, 200000); // test function add_expected_result( ".*mingw.*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*Y[01v].*", // test data group ".*", 2000, 1000); // test function add_expected_result( ".*mingw.*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*Yn.*", // test data group ".*", 30000, 30000); // test function // // Solaris version of long double has it's own error rates, // again just a touch higher than msvc's 64-bit double: // add_expected_result( "GNU.*", // compiler ".*", // stdlib "Sun.*", // platform largest_type, // test type(s) "Y[0N].*Mathworld.*", // test data group ".*", 2000, 2000); // test function #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS if((std::numeric_limits<double>::digits != std::numeric_limits<long double>::digits) && (std::numeric_limits<long double>::digits < 90)) { // some errors spill over into type double as well: add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*Y[Nn].*", // test data group ".*", 20, 20); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*Yv.*", // test data group ".*", 80, 70); // test function } #endif // // defaults are based on MSVC-8 on Win32: // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*Y0.*Random.*", // test data group ".*", 600, 400); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) ".*(Y[nv]|y).*Random.*", // test data group ".*", 2000, 2000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*(Y[nv]|y).*Random.*", // test data group ".*", 1500, 1000); // test function // // Fallback for sun has to go after the general cases above: // add_expected_result( "GNU.*", // compiler ".*", // stdlib "Sun.*", // platform largest_type, // test type(s) "Y[0N].*", // test data group ".*", 200, 200); // test function // // General fallback: // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*", // test data group ".*", 80, 40); // 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; }
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"; } else { largest_type = "long double"; } #else largest_type = "(long\\s+)?double"; #endif // // Linux: // if((std::numeric_limits<long double>::digits <= 64) && (std::numeric_limits<long double>::digits != std::numeric_limits<double>::digits)) { #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*", // test data group ".*", 10, 5); // test function #endif } if(std::numeric_limits<long double>::digits == 64) { add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "Legendre Polynomials.*Large.*", // test data group "legendre_p", 1000, 200); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "Legendre Polynomials.*Large.*", // test data group "legendre_q", 7000, 1000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "Legendre Polynomials.*Large.*", // test data group "legendre_p", 1000, 200); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "Legendre Polynomials.*Large.*", // test data group "legendre_q", 7000, 1000); // test function } // // Catch all cases come last: // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "Legendre Polynomials.*Large.*", // test data group "legendre_p", 500, 200); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "Legendre Polynomials.*Large.*", // test data group "legendre_q", 5400, 500); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "Legendre Polynomials.*", // test data group "legendre_p", 300, 80); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "Legendre Polynomials.*", // test data group "legendre_q", 100, 50); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "Associated Legendre Polynomials.*", // test data group ".*", 200, 20); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "Legendre Polynomials.*Large.*", // test data group "legendre_p", 500, 200); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "Legendre Polynomials.*Large.*", // test data group "legendre_q", 5400, 500); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "Legendre Polynomials.*", // test data group "legendre_p", 300, 80); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "Legendre Polynomials.*", // test data group "legendre_q", 100, 50); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "Associated Legendre Polynomials.*", // test data group ".*", 200, 20); // 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; }
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"; #endif if(std::numeric_limits<long double>::max_exponent > std::numeric_limits<double>::max_exponent) { add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*Medium.*", // test data group ".*", 200000, 7000); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*Large.*", // test data group ".*", 80000, 5000); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*Integer.*", // test data group ".*", 30000, 1500); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "double", // test type(s) "[^|]*Large.*", // test data group ".*", 3000, 200); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "double", // test type(s) "[^|]*", // test data group ".*", 200, 50); // test function } // catch all default is 2eps for all types: add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform "real_concept", // test type(s) "[^|]*large.*", // test data group ".*", 200000, 6000); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*large.*", // test data group ".*", 3000, 200); // test function add_expected_result( "[^|]*", // compiler "[^|]*", // stdlib "[^|]*", // platform largest_type, // test type(s) "[^|]*", // test data group ".*", 300, 100); // 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; }
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"; } else { largest_type = "long double"; } #else largest_type = "(long\\s+)?double"; #endif // // G++ on Darwin: results are just slightly worse than we might hope for // but still pretty good: // add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS", // platform largest_type, // test type(s) "factorials", // test data group "boost::math::tgamma", 100, 15); // test function // // G++ On Win32: // add_expected_result( "GNU.*", // compiler ".*", // stdlib "Win32.*", // platform largest_type, // test type(s) "factorials", // test data group "boost::math::tgamma", 100, 15); // test function add_expected_result( "GNU.*", // compiler ".*", // stdlib "Win32.*", // platform "real_concept", // test type(s) "factorials", // test data group "boost::math::tgamma", 200, 100); // test function add_expected_result( "GNU.*", // compiler ".*", // stdlib "Win32.*", // platform "real_concept", // test type(s) "near.*", // test data group "boost::math::tgamma", 200, 60); // test function // // G++ on Linux, result vary a bit by processor type, // on Itanium results are *much* better than listed here, // but x86 appears to have much less accurate std::pow // that throws off the results: // add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform largest_type, // test type(s) "factorials", // test data group "boost::math::tgamma", 400, 200); // test function add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform largest_type, // test type(s) "factorials", // test data group "boost::math::lgamma", 30, 10); // test function add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform largest_type, // test type(s) "near (1|2|-10)", // test data group "boost::math::tgamma", 10, 5); // test function add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform largest_type, // test type(s) "near (1|2|-10)", // test data group "boost::math::lgamma", 50, 50); // test function add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform largest_type, // test type(s) "tgamma1pm1.*", // test data group "boost::math::tgamma1pm1", 50, 15); // test function add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform "real_concept", // test type(s) "factorials", // test data group "boost::math::tgamma", 220, 70); // test function add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform "real_concept", // test type(s) "near (0|-55)", // test data group "boost::math::(t|l)gamma", 130, 80); // test function add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform "real_concept", // test type(s) "tgamma1pm1.*", // test data group "boost::math::tgamma1pm1", 40, 10); // test function // // HP-UX results: // add_expected_result( ".*", // compiler ".*", // stdlib "HP-UX", // platform largest_type, // test type(s) "factorials", // test data group "boost::math::tgamma", 5, 4); // test function add_expected_result( ".*", // compiler ".*", // stdlib "HP-UX", // platform largest_type, // test type(s) "near (0|-55)", // test data group "boost::math::tgamma", 10, 5); // test function add_expected_result( ".*", // compiler ".*", // stdlib "HP-UX", // platform largest_type, // test type(s) "near (1|2|-10)", // test data group "boost::math::lgamma", 250, 200); // test function add_expected_result( ".*", // compiler ".*", // stdlib "HP-UX", // platform "real_concept", // test type(s) "factorials", // test data group "boost::math::lgamma", 50, 20); // test function add_expected_result( ".*", // compiler ".*", // stdlib "HP-UX", // platform "real_concept", // test type(s) "tgamma1pm1.*", // test data group "boost::math::tgamma1pm1", 200, 80); // test function // // Tru64: // add_expected_result( ".*Tru64.*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "factorials", // test data group "boost::math::lgamma", 50, 20); // test function // // Sun OS: // add_expected_result( ".*", // compiler ".*", // stdlib "Sun.*", // platform largest_type, // test type(s) "factorials", // test data group "boost::math::tgamma", 300, 50); // test function add_expected_result( ".*", // compiler ".*", // stdlib "Sun.*", // platform "real_concept", // test type(s) "factorials", // test data group "boost::math::tgamma", 300, 50); // test function // // Catch all cases come last: // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "factorials", // test data group "boost::math::tgamma", 4, 1); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "factorials", // test data group "boost::math::lgamma", 9, 1); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "near (0|-55)", // test data group "boost::math::(t|l)gamma", 200, 100); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "near (1|2|-10)", // test data group "boost::math::tgamma", 10, 5); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "near (1|2|-10)", // test data group "boost::math::lgamma", 14, 7); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "tgamma1pm1.*", // test data group "boost::math::tgamma1pm1", 30, 9); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "factorials", // test data group "boost::math::tgamma", 70, 25); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "factorials", // test data group "boost::math::lgamma", 40, 4); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "near.*", // test data group "boost::math::tgamma", 80, 60); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "near.*", // test data group "boost::math::lgamma", 10000000, 10000000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "real_concept", // test type(s) "tgamma1pm1.*", // test data group "boost::math::tgamma1pm1", 20, 5); // 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; }
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 add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*large arguments", // test data group ".*", 400, 200); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*negative.*", // test data group ".*", 800, 500); // test function #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS if((std::numeric_limits<long double>::digits > std::numeric_limits<double>::digits) && (std::numeric_limits<long double>::digits - std::numeric_limits<double>::digits < 20)) { add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*bug cases.*", // test data group ".*", 100, 30); // test function } #endif add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*bug cases.*", // test data group ".*", 100000, 50000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*", // test data group ".*", 40, 10); // 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; }
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"; #endif // // HP-UX specific rates: // // Error rate for double precision are limited by the accuracy of // the approximations use, which bracket rather than preserve the root. // add_expected_result( ".*", // compiler ".*", // stdlib "HP-UX", // platform largest_type, // test type(s) ".*J0'.*Tricky.*", // test data group ".*", 80000000000LL, 80000000000LL); // test function add_expected_result( ".*", // compiler ".*", // stdlib "HP-UX", // platform largest_type, // test type(s) ".*J1'.*Tricky.*", // test data group ".*", 3000000, 2000000); // test function add_expected_result( ".*", // compiler ".*", // stdlib "HP-UX", // platform "double", // test type(s) ".*Tricky.*", // test data group ".*", 100000, 100000); // test function add_expected_result( ".*", // compiler ".*", // stdlib "HP-UX", // platform largest_type, // test type(s) ".*J'.*Tricky.*", // test data group ".*", 3000, 500); // test function // // HP Tru64: // add_expected_result( ".*Tru64.*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*Tricky.*", // test data group ".*", 100000, 100000); // test function add_expected_result( ".*Tru64.*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*Tricky large.*", // test data group ".*", 3000, 1000); // test function // // Solaris specific rates: // // Error rate for double precision are limited by the accuracy of // the approximations use, which bracket rather than preserve the root. // add_expected_result( ".*", // compiler ".*", // stdlib "Sun Solaris", // platform largest_type, // test type(s) "Bessel J': Random Data.*Tricky.*", // test data group ".*", 3000, 500); // test function add_expected_result( ".*", // compiler ".*", // stdlib "Sun Solaris", // platform "double", // test type(s) ".*Tricky.*", // test data group ".*", 200000, 100000); // test function add_expected_result( ".*", // compiler ".*", // stdlib "Sun Solaris", // platform largest_type, // test type(s) ".*J'.*tricky.*", // test data group ".*", 400000000, 200000000); // test function // // Mac OS X: // add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS", // platform largest_type, // test type(s) ".*J0'.*Tricky.*", // test data group ".*", 400000000, 400000000); // test function add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS", // platform largest_type, // test type(s) ".*J1'.*Tricky.*", // test data group ".*", 3000000, 2000000); // test function add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS", // platform largest_type, // test type(s) "Bessel JN'.*", // test data group ".*", 60000, 20000); // test function add_expected_result( ".*", // compiler ".*", // stdlib "Mac OS", // platform largest_type, // test type(s) "Bessel J':.*", // test data group ".*", 60000, 20000); // test function // // Linux specific results: // // sin and cos appear to have only double precision for large // arguments on some linux distros: // add_expected_result( ".*", // compiler ".*", // stdlib "linux", // platform largest_type, // test type(s) ".*J':.*", // test data group ".*", 60000, 30000); // test function #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS if((std::numeric_limits<double>::digits != std::numeric_limits<long double>::digits) && (std::numeric_limits<long double>::digits < 90)) { // some errors spill over into type double as well: add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*J0'.*Tricky.*", // test data group ".*", 400000, 400000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*J1'.*Tricky.*", // test data group ".*", 5000, 5000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*(JN'|j').*|.*Tricky.*", // test data group ".*", 50, 50); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "double", // test type(s) ".*", // test data group ".*", 30, 30); // test function // // and we have a few cases with higher limits as well: // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*J0'.*Tricky.*", // test data group ".*", 400000000, 400000000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*J1'.*Tricky.*", // test data group ".*", 5000000, 5000000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*(JN'|j').*|.*Tricky.*", // test data group ".*", 60000, 40000); // test function } #endif add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*J0'.*Tricky.*", // test data group ".*", 400000000, 400000000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*J1'.*Tricky.*", // test data group ".*", 5000000, 5000000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) "Bessel j':.*|Bessel JN': Mathworld.*|.*Tricky.*", // test data group ".*", 1500, 700); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform largest_type, // test type(s) ".*", // test data group ".*", 40, 20); // test function // // One set of float tests has inexact input values, so there is a slight error: // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform "float", // test type(s) "Bessel J': Mathworld Data", // test data group ".*", 30, 20); // 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; }
void expected_results() { // // Define the max and mean errors expected for // various compilers and platforms. // add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*gmp.*", // test type(s) ".*", // test data group ".*", 2000, 1500); // test function #ifdef BOOST_INTEL add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*float128.*", // test type(s) ".*", // test data group ".*", 300, 100); // test function #endif add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*mpfr_float_backend<18>.*", // test type(s) ".*", // test data group ".*", 3000, 1000); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*mpfr_float_backend<0>.*", // test type(s) ".*", // test data group ".*", 300, 150); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) ".*large.*", // test data group ".*", 80, 50); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*cpp_bin_float.*", // test type(s) ".*", // test data group ".*", 300, 150); // test function add_expected_result( ".*", // compiler ".*", // stdlib ".*", // platform ".*", // test type(s) ".*", // test data group ".*", 50, 15); // 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; }