diff DEPENDENCIES/generic/include/boost/math/special_functions/detail/bessel_kn.hpp @ 16:2665513ce2d3

Add boost headers

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DEPENDENCIES/generic/include/boost/math/special_functions/detail/bessel_kn.hpp	Tue Aug 05 11:11:38 2014 +0100
@@ -0,0 +1,85 @@
+//  Copyright (c) 2006 Xiaogang Zhang
+//  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)
+
+#ifndef BOOST_MATH_BESSEL_KN_HPP
+#define BOOST_MATH_BESSEL_KN_HPP
+
+#ifdef _MSC_VER
+#pragma once
+#endif
+
+#include <boost/math/special_functions/detail/bessel_k0.hpp>
+#include <boost/math/special_functions/detail/bessel_k1.hpp>
+#include <boost/math/policies/error_handling.hpp>
+
+// Modified Bessel function of the second kind of integer order
+// K_n(z) is the dominant solution, forward recurrence always OK (though unstable)
+
+namespace boost { namespace math { namespace detail{
+
+template <typename T, typename Policy>
+T bessel_kn(int n, T x, const Policy& pol)
+{
+    T value, current, prev;
+
+    using namespace boost::math::tools;
+
+    static const char* function = "boost::math::bessel_kn<%1%>(%1%,%1%)";
+
+    if (x < 0)
+    {
+       return policies::raise_domain_error<T>(function,
+            "Got x = %1%, but argument x must be non-negative, complex number result not supported.", x, pol);
+    }
+    if (x == 0)
+    {
+       return policies::raise_overflow_error<T>(function, 0, pol);
+    }
+
+    if (n < 0)
+    {
+        n = -n;                             // K_{-n}(z) = K_n(z)
+    }
+    if (n == 0)
+    {
+        value = bessel_k0(x, pol);
+    }
+    else if (n == 1)
+    {
+        value = bessel_k1(x, pol);
+    }
+    else
+    {
+       prev = bessel_k0(x, pol);
+       current = bessel_k1(x, pol);
+       int k = 1;
+       BOOST_ASSERT(k < n);
+       T scale = 1;
+       do
+       {
+           T fact = 2 * k / x;
+           if((tools::max_value<T>() - fabs(prev)) / fact < fabs(current))
+           {
+              scale /= current;
+              prev /= current;
+              current = 1;
+           }
+           value = fact * current + prev;
+           prev = current;
+           current = value;
+           ++k;
+       }
+       while(k < n);
+       if(tools::max_value<T>() * scale < fabs(value))
+          return sign(scale) * sign(value) * policies::raise_overflow_error<T>(function, 0, pol);
+       value /= scale;
+    }
+    return value;
+}
+
+}}} // namespaces
+
+#endif // BOOST_MATH_BESSEL_KN_HPP
+