comparison DEPENDENCIES/generic/include/boost/math/special_functions/bessel.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 
 #ifdef _MSC_VER
 #  pragma once
 #endif
 
+#include <limits>
+#include <boost/math/special_functions/math_fwd.hpp>
 #include <boost/math/special_functions/detail/bessel_jy.hpp>
 #include <boost/math/special_functions/detail/bessel_jn.hpp>
 #include <boost/math/special_functions/detail/bessel_yn.hpp>
 #include <boost/math/special_functions/detail/bessel_jy_zero.hpp>
 #include <boost/math/special_functions/detail/bessel_ik.hpp>

          "boost::math::cyl_bessel_i<%1%>(%1%,%1%)",
             "Got x = %1%, but we need x >= 0", x, pol);
    }
    if(x == 0)
    {
-      return (v == 0) ? 1 : 0;
+      return (v == 0) ? static_cast<T>(1) : static_cast<T>(0);
    }
    if(v == 0.5f)
    {
       // common special case, note try and avoid overflow in exp(x):
       if(x >= tools::log_max_value<T>())

 
    // Handle negative rank.
    if(m < 0)
    {
       // Zeros of Jv(x) with negative rank are not defined and requesting one raises a domain error.
-      return policies::raise_domain_error<T>(function, "Requested the %1%'th zero, but the rank must be positive !", m, pol);
+      return policies::raise_domain_error<T>(function, "Requested the %1%'th zero, but the rank must be positive !", static_cast<T>(m), pol);
    }
 
    // Get the absolute value of the order.
    const bool order_is_negative = (v < 0);
    const T vv((!order_is_negative) ? v : T(-v));

    if(m == 0)
    {
       if(order_is_zero)
       {
          // The zero'th zero of J0(x) is not defined and requesting it raises a domain error.
-         return policies::raise_domain_error<T>(function, "Requested the %1%'th zero of J0, but the rank must be > 0 !", m, pol);
+         return policies::raise_domain_error<T>(function, "Requested the %1%'th zero of J0, but the rank must be > 0 !", static_cast<T>(m), pol);
       }
 
       // The zero'th zero of Jv(x) for v < 0 is not defined
       // unless the order is a negative integer.
       if(order_is_negative && (!order_is_integer))
       {
          // For non-integer, negative order, requesting the zero'th zero raises a domain error.
-         return policies::raise_domain_error<T>(function, "Requested the %1%'th zero of Jv for negative, non-integer order, but the rank must be > 0 !", m, pol);
+         return policies::raise_domain_error<T>(function, "Requested the %1%'th zero of Jv for negative, non-integer order, but the rank must be > 0 !", static_cast<T>(m), pol);
       }
 
       // The zero'th zero does exist and its value is zero.
       return T(0);
    }

    // positive integer for the order.
    const T guess_root = boost::math::detail::bessel_zero::cyl_bessel_j_zero_detail::initial_guess<T, Policy>((order_is_integer ? vv : v), m, pol);
 
    // Select the maximum allowed iterations from the policy.
    boost::uintmax_t number_of_iterations = policies::get_max_root_iterations<Policy>();
-
-   // Select the desired number of binary digits of precision.
-   // Account for the radix of number representations having non-two radix!
-   const int my_digits2 = policies::digits<T, Policy>();
 
    const T delta_lo = ((guess_root > 0.2F) ? T(0.2) : T(guess_root / 2U));
 
    // Perform the root-finding using Newton-Raphson iteration from Boost.Math.
    const T jvm =
       boost::math::tools::newton_raphson_iterate(
          boost::math::detail::bessel_zero::cyl_bessel_j_zero_detail::function_object_jv_and_jv_prime<T, Policy>((order_is_integer ? vv : v), order_is_zero, pol),
          guess_root,
          T(guess_root - delta_lo),
          T(guess_root + 0.2F),
-         my_digits2,
+         policies::digits<T, Policy>(),
          number_of_iterations);
 
    if(number_of_iterations >= policies::get_max_root_iterations<Policy>())
    {
-      policies::raise_evaluation_error<T>(function, "Unable to locate root in a reasonable time:"
+      return policies::raise_evaluation_error<T>(function, "Unable to locate root in a reasonable time:"
          "  Current best guess is %1%", jvm, Policy());
    }
 
    return jvm;
 }

    }
 
    // Handle negative rank.
    if(m < 0)
    {
-      return policies::raise_domain_error<T>(function, "Requested the %1%'th zero, but the rank must be positive !", m, pol);
+      return policies::raise_domain_error<T>(function, "Requested the %1%'th zero, but the rank must be positive !", static_cast<T>(m), pol);
    }
 
    const T half_epsilon(boost::math::tools::epsilon<T>() / 2U);
 
    // Get the absolute value of the order.

    // The zero'th zero of Yv(x) for v < 0 is not defined
    // unless the order is a negative integer.
    if((m == 0) && (!order_is_negative_half_integer))
    {
       // For non-integer, negative order, requesting the zero'th zero raises a domain error.
-      return policies::raise_domain_error<T>(function, "Requested the %1%'th zero of Yv for negative, non-half-integer order, but the rank must be > 0 !", m, pol);
+      return policies::raise_domain_error<T>(function, "Requested the %1%'th zero of Yv for negative, non-half-integer order, but the rank must be > 0 !", static_cast<T>(m), pol);
    }
 
    // For negative half-integers, use the corresponding
    // spherical Bessel function of positive half-integer order.
    if(order_is_negative_half_integer)

    // positive integer for the order.
    const T guess_root = boost::math::detail::bessel_zero::cyl_neumann_zero_detail::initial_guess<T, Policy>(v, m, pol);
 
    // Select the maximum allowed iterations from the policy.
    boost::uintmax_t number_of_iterations = policies::get_max_root_iterations<Policy>();
-
-   // Select the desired number of binary digits of precision.
-   // Account for the radix of number representations having non-two radix!
-   const int my_digits2 = policies::digits<T, Policy>();
 
    const T delta_lo = ((guess_root > 0.2F) ? T(0.2) : T(guess_root / 2U));
 
    // Perform the root-finding using Newton-Raphson iteration from Boost.Math.
    const T yvm =
       boost::math::tools::newton_raphson_iterate(
          boost::math::detail::bessel_zero::cyl_neumann_zero_detail::function_object_yv_and_yv_prime<T, Policy>(v, pol),
          guess_root,
          T(guess_root - delta_lo),
          T(guess_root + 0.2F),
-         my_digits2,
+         policies::digits<T, Policy>(),
          number_of_iterations);
 
    if(number_of_iterations >= policies::get_max_root_iterations<Policy>())
    {
-      policies::raise_evaluation_error<T>(function, "Unable to locate root in a reasonable time:"
+      return policies::raise_evaluation_error<T>(function, "Unable to locate root in a reasonable time:"
          "  Current best guess is %1%", yvm, Policy());
    }
 
    return yvm;
 }

       Policy, 
       policies::promote_float<false>, 
       policies::promote_double<false>, 
       policies::discrete_quantile<>,
       policies::assert_undefined<> >::type forwarding_policy;
-   BOOST_STATIC_ASSERT_MSG(false == std::numeric_limits<value_type>::is_integer, "Order must be a floating-point type.");
+
+   BOOST_STATIC_ASSERT_MSG(    false == std::numeric_limits<T>::is_specialized
+                           || (   true  == std::numeric_limits<T>::is_specialized
+                               && false == std::numeric_limits<T>::is_integer),
+                           "Order must be a floating-point type.");
+
    return policies::checked_narrowing_cast<result_type, Policy>(detail::cyl_bessel_j_zero_imp<value_type>(v, m, forwarding_policy()), "boost::math::cyl_bessel_j_zero<%1%>(%1%,%1%)");
 }
 
 template <class T>
 inline typename detail::bessel_traits<T, T, policies::policy<> >::result_type cyl_bessel_j_zero(T v, int m)
 {
-   BOOST_STATIC_ASSERT_MSG(false == std::numeric_limits<T>::is_integer, "Order must be a floating-point type.");
+   BOOST_STATIC_ASSERT_MSG(    false == std::numeric_limits<T>::is_specialized
+                           || (   true  == std::numeric_limits<T>::is_specialized
+                               && false == std::numeric_limits<T>::is_integer),
+                           "Order must be a floating-point type.");
+
    return cyl_bessel_j_zero<T, policies::policy<> >(v, m, policies::policy<>());
 }
 
 template <class T, class OutputIterator, class Policy>
 inline OutputIterator cyl_bessel_j_zero(T v,
                               int start_index,
                               unsigned number_of_zeros,
                               OutputIterator out_it,
                               const Policy& pol)
 {
-   BOOST_STATIC_ASSERT_MSG(false == std::numeric_limits<T>::is_integer, "Order must be a floating-point type.");
-   for(unsigned i = 0; i < number_of_zeros; ++i)
+   BOOST_STATIC_ASSERT_MSG(    false == std::numeric_limits<T>::is_specialized
+                           || (   true  == std::numeric_limits<T>::is_specialized
+                               && false == std::numeric_limits<T>::is_integer),
+                           "Order must be a floating-point type.");
+
+   for(int i = 0; i < static_cast<int>(number_of_zeros); ++i)
    {
       *out_it = boost::math::cyl_bessel_j_zero(v, start_index + i, pol);
       ++out_it;
    }
    return out_it;

       Policy, 
       policies::promote_float<false>, 
       policies::promote_double<false>, 
       policies::discrete_quantile<>,
       policies::assert_undefined<> >::type forwarding_policy;
-   BOOST_STATIC_ASSERT_MSG(false == std::numeric_limits<value_type>::is_integer, "Order must be a floating-point type.");
+
+   BOOST_STATIC_ASSERT_MSG(    false == std::numeric_limits<T>::is_specialized
+                           || (   true  == std::numeric_limits<T>::is_specialized
+                               && false == std::numeric_limits<T>::is_integer),
+                           "Order must be a floating-point type.");
+
    return policies::checked_narrowing_cast<result_type, Policy>(detail::cyl_neumann_zero_imp<value_type>(v, m, forwarding_policy()), "boost::math::cyl_neumann_zero<%1%>(%1%,%1%)");
 }
 
 template <class T>
 inline typename detail::bessel_traits<T, T, policies::policy<> >::result_type cyl_neumann_zero(T v, int m)
 {
-   BOOST_STATIC_ASSERT_MSG(false == std::numeric_limits<T>::is_integer, "Order must be a floating-point type.");
+   BOOST_STATIC_ASSERT_MSG(    false == std::numeric_limits<T>::is_specialized
+                           || (   true  == std::numeric_limits<T>::is_specialized
+                               && false == std::numeric_limits<T>::is_integer),
+                           "Order must be a floating-point type.");
+
    return cyl_neumann_zero<T, policies::policy<> >(v, m, policies::policy<>());
 }
 
 template <class T, class OutputIterator, class Policy>
 inline OutputIterator cyl_neumann_zero(T v,
                              int start_index,
                              unsigned number_of_zeros,
                              OutputIterator out_it,
                              const Policy& pol)
 {
-   BOOST_STATIC_ASSERT_MSG(false == std::numeric_limits<T>::is_integer, "Order must be a floating-point type.");
-   for(unsigned i = 0; i < number_of_zeros; ++i)
+   BOOST_STATIC_ASSERT_MSG(    false == std::numeric_limits<T>::is_specialized
+                           || (   true  == std::numeric_limits<T>::is_specialized
+                               && false == std::numeric_limits<T>::is_integer),
+                           "Order must be a floating-point type.");
+
+   for(int i = 0; i < static_cast<int>(number_of_zeros); ++i)
    {
       *out_it = boost::math::cyl_neumann_zero(v, start_index + i, pol);
       ++out_it;
    }
    return out_it;