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;
}
