text: //  Copyright (c) 2013 Anton Bikineev
  //  Use, modification and distribution are subject to the
  //  Boost Software License, Version 1.0. (See accompanying file
  //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  
  #include "pch_light.hpp"
  
  #ifdef _MSC_VER
  #  pragma warning(disable : 4756) // overflow in constant arithmetic
  // Constants are too big for float case, but this doesn't matter for test.
  #endif
  
  #include "test_bessel_k_prime.hpp"
  
  //
  // DESCRIPTION:
  // ~~~~~~~~~~~~
  //
  // This file tests the bessel K functions derivatives.  There are two sets of tests, spot
  // tests which compare our results with selected values computed
  // using the online special function calculator at 
  // functions.wolfram.com, while the bulk of the accuracy tests
  // use values generated with Boost.Multiprecision at 50 precision
  // and our generic versions of these functions.
  //
  // Note that when this file is first run on a new platform many of
  // these tests will fail: the default accuracy is 1 epsilon which
  // is too tight for most platforms.  In this situation you will 
  // need to cast a human eye over the error rates reported and make
  // a judgement as to whether they are acceptable.  Either way please
  // report the results to the Boost mailing list.  Acceptable rates of
  // error are marked up below as a series of regular expressions that
  // identify the compiler/stdlib/platform/data-type/test-data/test-function
  // along with the maximum expected peek and RMS mean errors for that
  // test.
  //
  
  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(
        "GNU.*",                          // compiler
        ".*",                          // stdlib
        "Win32.*",                          // platform
        largest_type,                  // test type(s)
        ".*large.*",                   // test data group
        ".*", 250, 100);                 // test function
     add_expected_result(
        ".*",                          // compiler
        ".*",                          // stdlib
        ".*",                          // platform
        largest_type,                  // test type(s)
        ".*large.*",                   // test data group
        ".*", 100, 75);                // 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;
  }
  
  BOOST_AUTO_TEST_CASE( test_main )
  {
  #ifdef TEST_GSL
     gsl_set_error_handler_off();
  #endif
     expected_results();
     BOOST_MATH_CONTROL_FP;
  
  #ifndef BOOST_MATH_BUGGY_LARGE_FLOAT_CONSTANTS
     test_bessel(0.1F, "float");
  #endif
     test_bessel(0.1, "double");
  #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
     test_bessel(0.1L, "long double");
  #ifndef BOOST_MATH_NO_REAL_CONCEPT_TESTS
     test_bessel(boost::math::concepts::real_concept(0.1), "real_concept");
  #endif
  #else
     std::cout << "<note>The long double tests have been disabled on this platform "
        "either because the long double overloads of the usual math functions are "
        "not available at all, or because they are too inaccurate for these tests "
        "to pass.</note>" << std::endl;
  #endif
  }
  
  
  
  
  