Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/math')
11 files changed, 621 insertions, 322 deletions
diff --git a/3rdParty/Boost/src/boost/math/common_factor_ct.hpp b/3rdParty/Boost/src/boost/math/common_factor_ct.hpp index 848c925..bf58b94 100644 --- a/3rdParty/Boost/src/boost/math/common_factor_ct.hpp +++ b/3rdParty/Boost/src/boost/math/common_factor_ct.hpp @@ -24,5 +24,4 @@ namespace math namespace detail { -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // Build GCD with Euclid's recursive algorithm template < static_gcd_type Value1, static_gcd_type Value2 > @@ -55,46 +54,5 @@ namespace detail BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 ); }; -#else - // Use inner class template workaround from Peter Dimov - template < static_gcd_type Value1 > - struct static_gcd_helper2_t - { - template < static_gcd_type Value2 > - struct helper - { - BOOST_STATIC_CONSTANT( static_gcd_type, value - = static_gcd_helper2_t<Value2>::BOOST_NESTED_TEMPLATE - helper<Value1 % Value2>::value ); - }; - - template < > - struct helper< 0UL > - { - BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 ); - }; - }; - - // Special case - template < > - struct static_gcd_helper2_t< 0UL > - { - template < static_gcd_type Value2 > - struct helper - { - BOOST_STATIC_CONSTANT( static_gcd_type, value = Value2 ); - }; - }; - - // Build the GCD from the above template(s) - template < static_gcd_type Value1, static_gcd_type Value2 > - struct static_gcd_helper_t - { - BOOST_STATIC_CONSTANT( static_gcd_type, value - = static_gcd_helper2_t<Value1>::BOOST_NESTED_TEMPLATE - helper<Value2>::value ); - }; -#endif -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // Build the LCM from the GCD template < static_gcd_type Value1, static_gcd_type Value2 > @@ -113,45 +71,4 @@ namespace detail BOOST_STATIC_CONSTANT( static_gcd_type, value = 0UL ); }; -#else - // Adapt GCD's inner class template workaround for LCM - template < static_gcd_type Value1 > - struct static_lcm_helper2_t - { - template < static_gcd_type Value2 > - struct helper - { - typedef static_gcd_helper_t<Value1, Value2> gcd_type; - - BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 - / gcd_type::value * Value2 ); - }; - - template < > - struct helper< 0UL > - { - BOOST_STATIC_CONSTANT( static_gcd_type, value = 0UL ); - }; - }; - - // Special case - template < > - struct static_lcm_helper2_t< 0UL > - { - template < static_gcd_type Value2 > - struct helper - { - BOOST_STATIC_CONSTANT( static_gcd_type, value = 0UL ); - }; - }; - - // Build the LCM from the above template(s) - template < static_gcd_type Value1, static_gcd_type Value2 > - struct static_lcm_helper_t - { - BOOST_STATIC_CONSTANT( static_gcd_type, value - = static_lcm_helper2_t<Value1>::BOOST_NESTED_TEMPLATE - helper<Value2>::value ); - }; -#endif } // namespace detail diff --git a/3rdParty/Boost/src/boost/math/common_factor_rt.hpp b/3rdParty/Boost/src/boost/math/common_factor_rt.hpp index 4582a96..10a92eb 100644 --- a/3rdParty/Boost/src/boost/math/common_factor_rt.hpp +++ b/3rdParty/Boost/src/boost/math/common_factor_rt.hpp @@ -223,5 +223,4 @@ namespace detail // Function objects to find the best way of computing GCD or LCM #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template < typename T, bool IsSpecialized, bool IsSigned > struct gcd_optimal_evaluator_helper_t @@ -241,38 +240,4 @@ namespace detail } }; -#else - template < bool IsSpecialized, bool IsSigned > - struct gcd_optimal_evaluator_helper2_t - { - template < typename T > - struct helper - { - T operator ()( T const &a, T const &b ) - { - return gcd_euclidean( a, b ); - } - }; - }; - - template < > - struct gcd_optimal_evaluator_helper2_t< true, true > - { - template < typename T > - struct helper - { - T operator ()( T const &a, T const &b ) - { - return gcd_integer( a, b ); - } - }; - }; - - template < typename T, bool IsSpecialized, bool IsSigned > - struct gcd_optimal_evaluator_helper_t - : gcd_optimal_evaluator_helper2_t<IsSpecialized, IsSigned> - ::BOOST_NESTED_TEMPLATE helper<T> - { - }; -#endif template < typename T > @@ -349,5 +314,4 @@ namespace detail #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template < typename T, bool IsSpecialized, bool IsSigned > struct lcm_optimal_evaluator_helper_t @@ -367,38 +331,4 @@ namespace detail } }; -#else - template < bool IsSpecialized, bool IsSigned > - struct lcm_optimal_evaluator_helper2_t - { - template < typename T > - struct helper - { - T operator ()( T const &a, T const &b ) - { - return lcm_euclidean( a, b ); - } - }; - }; - - template < > - struct lcm_optimal_evaluator_helper2_t< true, true > - { - template < typename T > - struct helper - { - T operator ()( T const &a, T const &b ) - { - return lcm_integer( a, b ); - } - }; - }; - - template < typename T, bool IsSpecialized, bool IsSigned > - struct lcm_optimal_evaluator_helper_t - : lcm_optimal_evaluator_helper2_t<IsSpecialized, IsSigned> - ::BOOST_NESTED_TEMPLATE helper<T> - { - }; -#endif template < typename T > diff --git a/3rdParty/Boost/src/boost/math/policies/policy.hpp b/3rdParty/Boost/src/boost/math/policies/policy.hpp index 01fe3d0..49068a6 100644 --- a/3rdParty/Boost/src/boost/math/policies/policy.hpp +++ b/3rdParty/Boost/src/boost/math/policies/policy.hpp @@ -95,6 +95,5 @@ namespace policies{ #endif -#if !defined(__BORLANDC__) \ - && !(defined(__GNUC__) && (__GNUC__ == 3) && (__GNUC_MINOR__ <= 2)) +#if !defined(__BORLANDC__) #define BOOST_MATH_META_INT(type, name, Default)\ template <type N = Default> struct name : public boost::mpl::int_<N>{};\ @@ -814,4 +813,14 @@ struct precision #endif +#ifdef BOOST_MATH_USE_FLOAT128 + +template <class Policy> +struct precision<BOOST_MATH_FLOAT128_TYPE, Policy> +{ + typedef mpl::int_<113> type; +}; + +#endif + namespace detail{ diff --git a/3rdParty/Boost/src/boost/math/special_functions/detail/fp_traits.hpp b/3rdParty/Boost/src/boost/math/special_functions/detail/fp_traits.hpp index 50c034d..63ebf11 100644 --- a/3rdParty/Boost/src/boost/math/special_functions/detail/fp_traits.hpp +++ b/3rdParty/Boost/src/boost/math/special_functions/detail/fp_traits.hpp @@ -352,4 +352,11 @@ struct fp_traits_non_native<long double, extended_double_precision> // the IEEE extended double precision format with 15 exponent bits (128 bits). +#elif defined(__GNUC__) && (LDBL_MANT_DIG == 106) + +// +// Define nothing here and fall though to generic_tag: +// We have GCC's "double double" in effect, and any attempt +// to handle it via bit-fiddling is pretty much doomed to fail... +// // long double (>64 bits), PowerPC --------------------------------------------- @@ -547,5 +554,7 @@ struct select_native<long double> && !defined(__osf__) \ && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)\ - && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY) + && !defined(__FAST_MATH__)\ + && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)\ + && !defined(BOOST_INTEL) # define BOOST_MATH_USE_STD_FPCLASSIFY #endif diff --git a/3rdParty/Boost/src/boost/math/special_functions/detail/round_fwd.hpp b/3rdParty/Boost/src/boost/math/special_functions/detail/round_fwd.hpp index 952259a..8c45a7d 100644 --- a/3rdParty/Boost/src/boost/math/special_functions/detail/round_fwd.hpp +++ b/3rdParty/Boost/src/boost/math/special_functions/detail/round_fwd.hpp @@ -10,4 +10,5 @@ #include <boost/config.hpp> +#include <boost/math/tools/promotion.hpp> #ifdef _MSC_VER @@ -21,7 +22,7 @@ namespace boost template <class T, class Policy> - T trunc(const T& v, const Policy& pol); + typename tools::promote_args<T>::type trunc(const T& v, const Policy& pol); template <class T> - T trunc(const T& v); + typename tools::promote_args<T>::type trunc(const T& v); template <class T, class Policy> int itrunc(const T& v, const Policy& pol); @@ -39,7 +40,7 @@ namespace boost #endif template <class T, class Policy> - T round(const T& v, const Policy& pol); + typename tools::promote_args<T>::type round(const T& v, const Policy& pol); template <class T> - T round(const T& v); + typename tools::promote_args<T>::type round(const T& v); template <class T, class Policy> int iround(const T& v, const Policy& pol); @@ -77,4 +78,16 @@ namespace boost } } + +#undef BOOST_MATH_STD_USING +#define BOOST_MATH_STD_USING BOOST_MATH_STD_USING_CORE\ + using boost::math::round;\ + using boost::math::iround;\ + using boost::math::lround;\ + using boost::math::trunc;\ + using boost::math::itrunc;\ + using boost::math::ltrunc;\ + using boost::math::modf; + + #endif // BOOST_MATH_SPECIAL_ROUND_FWD_HPP diff --git a/3rdParty/Boost/src/boost/math/special_functions/fpclassify.hpp b/3rdParty/Boost/src/boost/math/special_functions/fpclassify.hpp index 6f92d18..40f6e14 100644 --- a/3rdParty/Boost/src/boost/math/special_functions/fpclassify.hpp +++ b/3rdParty/Boost/src/boost/math/special_functions/fpclassify.hpp @@ -38,11 +38,11 @@ a floating point type (float, double or long double) can be determined at compile time, then the following algorithm is used: - If all exponent bits, the flag bit (if there is one), + If all exponent bits, the flag bit (if there is one), and all significand bits are 0, then the number is zero. - If all exponent bits and the flag bit (if there is one) are 0, + If all exponent bits and the flag bit (if there is one) are 0, and at least one significand bit is 1, then the number is subnormal. - If all exponent bits are 1 and all significand bits are 0, + If all exponent bits are 1 and all significand bits are 0, then the number is infinity. @@ -57,5 +57,5 @@ at compile time, then the following algorithm is used: Most formats have the structure sign bit + exponent bits + significand bits. - + A few have the structure sign bit + exponent bits + flag bit + significand bits. @@ -86,5 +86,5 @@ is used. #endif -namespace boost{ +namespace boost{ // @@ -95,4 +95,9 @@ namespace boost{ namespace math_detail{ +#ifdef BOOST_MSVC +#pragma warning(push) +#pragma warning(disable:4800) +#endif + template <class T> inline bool is_nan_helper(T t, const boost::true_type&) @@ -101,4 +106,5 @@ inline bool is_nan_helper(T t, const boost::true_type&) return isnan(t); #elif defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY) || !defined(BOOST_HAS_FPCLASSIFY) + (void)t; return false; #else // BOOST_HAS_FPCLASSIFY @@ -107,4 +113,8 @@ inline bool is_nan_helper(T t, const boost::true_type&) } +#ifdef BOOST_MSVC +#pragma warning(pop) +#endif + template <class T> inline bool is_nan_helper(T, const boost::false_type&) @@ -170,5 +180,5 @@ inline int fpclassify_imp BOOST_NO_MACRO_EXPAND(T t, const generic_tag<false>&) return fpclassify_imp(t, generic_tag<true>()); #endif - // + // // An unknown type with no numeric_limits support, // so what are we supposed to do we do here? @@ -179,5 +189,5 @@ inline int fpclassify_imp BOOST_NO_MACRO_EXPAND(T t, const generic_tag<false>&) } -template<class T> +template<class T> int fpclassify_imp BOOST_NO_MACRO_EXPAND(T x, ieee_copy_all_bits_tag) { @@ -208,5 +218,5 @@ int fpclassify_imp BOOST_NO_MACRO_EXPAND(T x, ieee_copy_all_bits_tag) } -template<class T> +template<class T> int fpclassify_imp BOOST_NO_MACRO_EXPAND(T x, ieee_copy_leading_bits_tag) { @@ -216,5 +226,5 @@ int fpclassify_imp BOOST_NO_MACRO_EXPAND(T x, ieee_copy_leading_bits_tag) BOOST_DEDUCED_TYPENAME traits::bits a; - traits::get_bits(x,a); + traits::get_bits(x,a); a &= traits::exponent | traits::flag | traits::significand; @@ -235,7 +245,6 @@ int fpclassify_imp BOOST_NO_MACRO_EXPAND(T x, ieee_copy_leading_bits_tag) } -#if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && defined(BOOST_MATH_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY) -template <> -inline int fpclassify_imp<long double> BOOST_NO_MACRO_EXPAND(long double t, const native_tag&) +#if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && (defined(BOOST_MATH_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY) || defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)) +inline int fpclassify_imp BOOST_NO_MACRO_EXPAND(long double t, const native_tag&) { return boost::math::detail::fpclassify_imp(t, generic_tag<true>()); @@ -250,5 +259,5 @@ inline int fpclassify BOOST_NO_MACRO_EXPAND(T t) typedef typename detail::fp_traits<T>::type traits; typedef typename traits::method method; - typedef typename tools::promote_args<T>::type value_type; + typedef typename tools::promote_args_permissive<T>::type value_type; #ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS if(std::numeric_limits<T>::is_specialized && detail::is_generic_tag_false(static_cast<method*>(0))) @@ -260,8 +269,25 @@ inline int fpclassify BOOST_NO_MACRO_EXPAND(T t) } +#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS +template <> +inline int fpclassify<long double> BOOST_NO_MACRO_EXPAND(long double t) +{ + typedef detail::fp_traits<long double>::type traits; + typedef traits::method method; + typedef long double value_type; +#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS + if(std::numeric_limits<long double>::is_specialized && detail::is_generic_tag_false(static_cast<method*>(0))) + return detail::fpclassify_imp(static_cast<value_type>(t), detail::generic_tag<true>()); + return detail::fpclassify_imp(static_cast<value_type>(t), method()); +#else + return detail::fpclassify_imp(static_cast<value_type>(t), method()); +#endif +} +#endif + namespace detail { #ifdef BOOST_MATH_USE_STD_FPCLASSIFY - template<class T> + template<class T> inline bool isfinite_impl(T x, native_tag const&) { @@ -270,5 +296,5 @@ namespace detail { #endif - template<class T> + template<class T> inline bool isfinite_impl(T x, generic_tag<true> const&) { @@ -277,5 +303,5 @@ namespace detail { } - template<class T> + template<class T> inline bool isfinite_impl(T x, generic_tag<false> const&) { @@ -288,5 +314,5 @@ namespace detail { } - template<class T> + template<class T> inline bool isfinite_impl(T x, ieee_tag const&) { @@ -299,6 +325,5 @@ namespace detail { #if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && defined(BOOST_MATH_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY) -template <> -inline bool isfinite_impl<long double> BOOST_NO_MACRO_EXPAND(long double t, const native_tag&) +inline bool isfinite_impl BOOST_NO_MACRO_EXPAND(long double t, const native_tag&) { return boost::math::detail::isfinite_impl(t, generic_tag<true>()); @@ -308,14 +333,26 @@ inline bool isfinite_impl<long double> BOOST_NO_MACRO_EXPAND(long double t, cons } -template<class T> +template<class T> inline bool (isfinite)(T x) { //!< \brief return true if floating-point type t is finite. typedef typename detail::fp_traits<T>::type traits; typedef typename traits::method method; - typedef typename boost::is_floating_point<T>::type fp_tag; - typedef typename tools::promote_args<T>::type value_type; + // typedef typename boost::is_floating_point<T>::type fp_tag; + typedef typename tools::promote_args_permissive<T>::type value_type; return detail::isfinite_impl(static_cast<value_type>(x), method()); } +#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS +template<> +inline bool (isfinite)(long double x) +{ //!< \brief return true if floating-point type t is finite. + typedef detail::fp_traits<long double>::type traits; + typedef traits::method method; + //typedef boost::is_floating_point<long double>::type fp_tag; + typedef long double value_type; + return detail::isfinite_impl(static_cast<value_type>(x), method()); +} +#endif + //------------------------------------------------------------------------------ @@ -323,5 +360,5 @@ namespace detail { #ifdef BOOST_MATH_USE_STD_FPCLASSIFY - template<class T> + template<class T> inline bool isnormal_impl(T x, native_tag const&) { @@ -330,5 +367,5 @@ namespace detail { #endif - template<class T> + template<class T> inline bool isnormal_impl(T x, generic_tag<true> const&) { @@ -338,5 +375,5 @@ namespace detail { } - template<class T> + template<class T> inline bool isnormal_impl(T x, generic_tag<false> const&) { @@ -348,5 +385,5 @@ namespace detail { } - template<class T> + template<class T> inline bool isnormal_impl(T x, ieee_tag const&) { @@ -359,6 +396,5 @@ namespace detail { #if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && defined(BOOST_MATH_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY) -template <> -inline bool isnormal_impl<long double> BOOST_NO_MACRO_EXPAND(long double t, const native_tag&) +inline bool isnormal_impl BOOST_NO_MACRO_EXPAND(long double t, const native_tag&) { return boost::math::detail::isnormal_impl(t, generic_tag<true>()); @@ -368,14 +404,26 @@ inline bool isnormal_impl<long double> BOOST_NO_MACRO_EXPAND(long double t, cons } -template<class T> +template<class T> inline bool (isnormal)(T x) { typedef typename detail::fp_traits<T>::type traits; typedef typename traits::method method; - typedef typename boost::is_floating_point<T>::type fp_tag; - typedef typename tools::promote_args<T>::type value_type; + //typedef typename boost::is_floating_point<T>::type fp_tag; + typedef typename tools::promote_args_permissive<T>::type value_type; return detail::isnormal_impl(static_cast<value_type>(x), method()); } +#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS +template<> +inline bool (isnormal)(long double x) +{ + typedef detail::fp_traits<long double>::type traits; + typedef traits::method method; + //typedef boost::is_floating_point<long double>::type fp_tag; + typedef long double value_type; + return detail::isnormal_impl(static_cast<value_type>(x), method()); +} +#endif + //------------------------------------------------------------------------------ @@ -383,5 +431,5 @@ namespace detail { #ifdef BOOST_MATH_USE_STD_FPCLASSIFY - template<class T> + template<class T> inline bool isinf_impl(T x, native_tag const&) { @@ -390,14 +438,14 @@ namespace detail { #endif - template<class T> + template<class T> inline bool isinf_impl(T x, generic_tag<true> const&) { (void)x; // in case the compiler thinks that x is unused because std::numeric_limits<T>::has_infinity is false - return std::numeric_limits<T>::has_infinity + return std::numeric_limits<T>::has_infinity && ( x == std::numeric_limits<T>::infinity() || x == -std::numeric_limits<T>::infinity()); } - template<class T> + template<class T> inline bool isinf_impl(T x, generic_tag<false> const&) { @@ -410,5 +458,5 @@ namespace detail { } - template<class T> + template<class T> inline bool isinf_impl(T x, ieee_copy_all_bits_tag const&) { @@ -421,5 +469,5 @@ namespace detail { } - template<class T> + template<class T> inline bool isinf_impl(T x, ieee_copy_leading_bits_tag const&) { @@ -437,6 +485,5 @@ namespace detail { #if defined(BOOST_MATH_USE_STD_FPCLASSIFY) && defined(BOOST_MATH_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY) -template <> -inline bool isinf_impl<long double> BOOST_NO_MACRO_EXPAND(long double t, const native_tag&) +inline bool isinf_impl BOOST_NO_MACRO_EXPAND(long double t, const native_tag&) { return boost::math::detail::isinf_impl(t, generic_tag<true>()); @@ -446,13 +493,25 @@ inline bool isinf_impl<long double> BOOST_NO_MACRO_EXPAND(long double t, const n } // namespace detail -template<class T> +template<class T> inline bool (isinf)(T x) { typedef typename detail::fp_traits<T>::type traits; typedef typename traits::method method; - typedef typename boost::is_floating_point<T>::type fp_tag; - typedef typename tools::promote_args<T>::type value_type; + // typedef typename boost::is_floating_point<T>::type fp_tag; + typedef typename tools::promote_args_permissive<T>::type value_type; + return detail::isinf_impl(static_cast<value_type>(x), method()); +} + +#ifdef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS +template<> +inline bool (isinf)(long double x) +{ + typedef detail::fp_traits<long double>::type traits; + typedef traits::method method; + //typedef boost::is_floating_point<long double>::type fp_tag; + typedef long double value_type; return detail::isinf_impl(static_cast<value_type>(x), method()); } +#endif //------------------------------------------------------------------------------ @@ -461,5 +520,5 @@ namespace detail { #ifdef BOOST_MATH_USE_STD_FPCLASSIFY - template<class T> + template<class T> inline bool isnan_impl(T x, native_tag const&) { @@ -468,5 +527,5 @@ namespace detail { #endif - template<class T> + template<class T> inline bool isnan_impl(T x, generic_tag<true> const&) { @@ -476,5 +535,5 @@ namespace detail { } - template<class T> + template<class T> inline bool isnan_impl(T x, generic_tag<false> const&) { @@ -487,5 +546,5 @@ namespace detail { } - template<class T> + template<class T> inline bool isnan_impl(T x, ieee_copy_all_bits_tag const&) { @@ -498,5 +557,5 @@ namespace detail { } - template<class T> + template<class T> inline bool isnan_impl(T x, ieee_copy_leading_bits_tag const&) { @@ -517,9 +576,10 @@ namespace detail { } // namespace detail -template<class T> bool (isnan)(T x) +template<class T> +inline bool (isnan)(T x) { //!< \brief return true if floating-point type t is NaN (Not A Number). typedef typename detail::fp_traits<T>::type traits; typedef typename traits::method method; - typedef typename boost::is_floating_point<T>::type fp_tag; + // typedef typename boost::is_floating_point<T>::type fp_tag; return detail::isnan_impl(x, method()); } @@ -529,4 +589,13 @@ template <> inline bool isnan BOOST_NO_MACRO_EXPAND<float>(float t){ return ::bo template <> inline bool isnan BOOST_NO_MACRO_EXPAND<double>(double t){ return ::boost::math_detail::is_nan_helper(t, boost::true_type()); } template <> inline bool isnan BOOST_NO_MACRO_EXPAND<long double>(long double t){ return ::boost::math_detail::is_nan_helper(t, boost::true_type()); } +#elif defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS) +template<> +inline bool (isnan)(long double x) +{ //!< \brief return true if floating-point type t is NaN (Not A Number). + typedef detail::fp_traits<long double>::type traits; + typedef traits::method method; + //typedef boost::is_floating_point<long double>::type fp_tag; + return detail::isnan_impl(x, method()); +} #endif diff --git a/3rdParty/Boost/src/boost/math/special_functions/math_fwd.hpp b/3rdParty/Boost/src/boost/math/special_functions/math_fwd.hpp index 6669e3f..e952dcd 100644 --- a/3rdParty/Boost/src/boost/math/special_functions/math_fwd.hpp +++ b/3rdParty/Boost/src/boost/math/special_functions/math_fwd.hpp @@ -15,5 +15,5 @@ // IT = Integer type. // RT = Real type (built-in floating-point types, float, double, long double) & User Defined Types -// AT = Integer or Real type +// AT = Integer or Real type #ifndef BOOST_MATH_SPECIAL_MATH_FWD_HPP @@ -39,109 +39,109 @@ namespace boost // Beta functions. template <class RT1, class RT2> - typename tools::promote_args<RT1, RT2>::type + typename tools::promote_args<RT1, RT2>::type beta(RT1 a, RT2 b); // Beta function (2 arguments). template <class RT1, class RT2, class A> - typename tools::promote_args<RT1, RT2, A>::type + typename tools::promote_args<RT1, RT2, A>::type beta(RT1 a, RT2 b, A x); // Beta function (3 arguments). template <class RT1, class RT2, class RT3, class Policy> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type beta(RT1 a, RT2 b, RT3 x, const Policy& pol); // Beta function (3 arguments). template <class RT1, class RT2, class RT3> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type betac(RT1 a, RT2 b, RT3 x); template <class RT1, class RT2, class RT3, class Policy> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type betac(RT1 a, RT2 b, RT3 x, const Policy& pol); template <class RT1, class RT2, class RT3> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibeta(RT1 a, RT2 b, RT3 x); // Incomplete beta function. template <class RT1, class RT2, class RT3, class Policy> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibeta(RT1 a, RT2 b, RT3 x, const Policy& pol); // Incomplete beta function. template <class RT1, class RT2, class RT3> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibetac(RT1 a, RT2 b, RT3 x); // Incomplete beta complement function. template <class RT1, class RT2, class RT3, class Policy> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibetac(RT1 a, RT2 b, RT3 x, const Policy& pol); // Incomplete beta complement function. template <class T1, class T2, class T3, class T4> - typename tools::promote_args<T1, T2, T3, T4>::type + typename tools::promote_args<T1, T2, T3, T4>::type ibeta_inv(T1 a, T2 b, T3 p, T4* py); template <class T1, class T2, class T3, class T4, class Policy> - typename tools::promote_args<T1, T2, T3, T4>::type + typename tools::promote_args<T1, T2, T3, T4>::type ibeta_inv(T1 a, T2 b, T3 p, T4* py, const Policy& pol); template <class RT1, class RT2, class RT3> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibeta_inv(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function. template <class RT1, class RT2, class RT3, class Policy> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibeta_inv(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function. template <class RT1, class RT2, class RT3> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibeta_inva(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function. template <class RT1, class RT2, class RT3, class Policy> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibeta_inva(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function. template <class RT1, class RT2, class RT3> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibeta_invb(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function. template <class RT1, class RT2, class RT3, class Policy> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibeta_invb(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function. template <class T1, class T2, class T3, class T4> - typename tools::promote_args<T1, T2, T3, T4>::type + typename tools::promote_args<T1, T2, T3, T4>::type ibetac_inv(T1 a, T2 b, T3 q, T4* py); template <class T1, class T2, class T3, class T4, class Policy> - typename tools::promote_args<T1, T2, T3, T4>::type + typename tools::promote_args<T1, T2, T3, T4>::type ibetac_inv(T1 a, T2 b, T3 q, T4* py, const Policy& pol); template <class RT1, class RT2, class RT3> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibetac_inv(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function. template <class RT1, class RT2, class RT3, class Policy> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibetac_inv(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function. template <class RT1, class RT2, class RT3> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibetac_inva(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function. template <class RT1, class RT2, class RT3, class Policy> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibetac_inva(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function. template <class RT1, class RT2, class RT3> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibetac_invb(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function. template <class RT1, class RT2, class RT3, class Policy> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibetac_invb(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function. template <class RT1, class RT2, class RT3> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibeta_derivative(RT1 a, RT2 b, RT3 x); // derivative of incomplete beta template <class RT1, class RT2, class RT3, class Policy> - typename tools::promote_args<RT1, RT2, RT3>::type + typename tools::promote_args<RT1, RT2, RT3>::type ibeta_derivative(RT1 a, RT2 b, RT3 x, const Policy& pol); // derivative of incomplete beta @@ -169,49 +169,49 @@ namespace boost // Polynomials: template <class T1, class T2, class T3> - typename tools::promote_args<T1, T2, T3>::type + typename tools::promote_args<T1, T2, T3>::type legendre_next(unsigned l, T1 x, T2 Pl, T3 Plm1); template <class T> - typename tools::promote_args<T>::type + typename tools::promote_args<T>::type legendre_p(int l, T x); template <class T, class Policy> - typename tools::promote_args<T>::type + typename tools::promote_args<T>::type legendre_p(int l, T x, const Policy& pol); template <class T> - typename tools::promote_args<T>::type + typename tools::promote_args<T>::type legendre_q(unsigned l, T x); template <class T, class Policy> - typename tools::promote_args<T>::type + typename tools::promote_args<T>::type legendre_q(unsigned l, T x, const Policy& pol); template <class T1, class T2, class T3> - typename tools::promote_args<T1, T2, T3>::type + typename tools::promote_args<T1, T2, T3>::type legendre_next(unsigned l, unsigned m, T1 x, T2 Pl, T3 Plm1); template <class T> - typename tools::promote_args<T>::type + typename tools::promote_args<T>::type legendre_p(int l, int m, T x); template <class T, class Policy> - typename tools::promote_args<T>::type + typename tools::promote_args<T>::type legendre_p(int l, int m, T x, const Policy& pol); template <class T1, class T2, class T3> - typename tools::promote_args<T1, T2, T3>::type + typename tools::promote_args<T1, T2, T3>::type laguerre_next(unsigned n, T1 x, T2 Ln, T3 Lnm1); template <class T1, class T2, class T3> - typename tools::promote_args<T1, T2, T3>::type + typename tools::promote_args<T1, T2, T3>::type laguerre_next(unsigned n, unsigned l, T1 x, T2 Pl, T3 Plm1); template <class T> - typename tools::promote_args<T>::type + typename tools::promote_args<T>::type laguerre(unsigned n, T x); template <class T, class Policy> - typename tools::promote_args<T>::type + typename tools::promote_args<T>::type laguerre(unsigned n, unsigned m, T x, const Policy& pol); @@ -227,74 +227,74 @@ namespace boost template <class T1, class T2> - typename laguerre_result<T1, T2>::type + typename laguerre_result<T1, T2>::type laguerre(unsigned n, T1 m, T2 x); template <class T> - typename tools::promote_args<T>::type + typename tools::promote_args<T>::type hermite(unsigned n, T x); template <class T, class Policy> - typename tools::promote_args<T>::type + typename tools::promote_args<T>::type hermite(unsigned n, T x, const Policy& pol); template <class T1, class T2, class T3> - typename tools::promote_args<T1, T2, T3>::type + typename tools::promote_args<T1, T2, T3>::type hermite_next(unsigned n, T1 x, T2 Hn, T3 Hnm1); template <class T1, class T2> - std::complex<typename tools::promote_args<T1, T2>::type> + std::complex<typename tools::promote_args<T1, T2>::type> spherical_harmonic(unsigned n, int m, T1 theta, T2 phi); template <class T1, class T2, class Policy> - std::complex<typename tools::promote_args<T1, T2>::type> + std::complex<typename tools::promote_args<T1, T2>::type> spherical_harmonic(unsigned n, int m, T1 theta, T2 phi, const Policy& pol); template <class T1, class T2> - typename tools::promote_args<T1, T2>::type + typename tools::promote_args<T1, T2>::type spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi); template <class T1, class T2, class Policy> - typename tools::promote_args<T1, T2>::type + typename tools::promote_args<T1, T2>::type spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi, const Policy& pol); template <class T1, class T2> - typename tools::promote_args<T1, T2>::type + typename tools::promote_args<T1, T2>::type spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi); template <class T1, class T2, class Policy> - typename tools::promote_args<T1, T2>::type + typename tools::promote_args<T1, T2>::type spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol); // Elliptic integrals: template <class T1, class T2, class T3> - typename tools::promote_args<T1, T2, T3>::type + typename tools::promote_args<T1, T2, T3>::type ellint_rf(T1 x, T2 y, T3 z); template <class T1, class T2, class T3, class Policy> - typename tools::promote_args<T1, T2, T3>::type + typename tools::promote_args<T1, T2, T3>::type ellint_rf(T1 x, T2 y, T3 z, const Policy& pol); template <class T1, class T2, class T3> - typename tools::promote_args<T1, T2, T3>::type + typename tools::promote_args<T1, T2, T3>::type ellint_rd(T1 x, T2 y, T3 z); template <class T1, class T2, class T3, class Policy> - typename tools::promote_args<T1, T2, T3>::type + typename tools::promote_args<T1, T2, T3>::type ellint_rd(T1 x, T2 y, T3 z, const Policy& pol); template <class T1, class T2> - typename tools::promote_args<T1, T2>::type + typename tools::promote_args<T1, T2>::type ellint_rc(T1 x, T2 y); template <class T1, class T2, class Policy> - typename tools::promote_args<T1, T2>::type + typename tools::promote_args<T1, T2>::type ellint_rc(T1 x, T2 y, const Policy& pol); template <class T1, class T2, class T3, class T4> - typename tools::promote_args<T1, T2, T3, T4>::type + typename tools::promote_args<T1, T2, T3, T4>::type ellint_rj(T1 x, T2 y, T3 z, T4 p); template <class T1, class T2, class T3, class T4, class Policy> - typename tools::promote_args<T1, T2, T3, T4>::type + typename tools::promote_args<T1, T2, T3, T4>::type ellint_rj(T1 x, T2 y, T3 z, T4 p, const Policy& pol); @@ -350,5 +350,5 @@ namespace boost RT factorial(unsigned int, const Policy& pol); template <class RT> - RT unchecked_factorial(unsigned int BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(RT)); + RT unchecked_factorial(unsigned int BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(RT)); template <class RT> RT double_factorial(unsigned i); @@ -466,9 +466,9 @@ namespace boost // Hypotenuse function sqrt(x ^ 2 + y ^ 2). template <class T1, class T2> - typename tools::promote_args<T1, T2>::type + typename tools::promote_args<T1, T2>::type hypot(T1 x, T2 y); template <class T1, class T2, class Policy> - typename tools::promote_args<T1, T2>::type + typename tools::promote_args<T1, T2>::type hypot(T1 x, T2 y, const Policy&); @@ -503,9 +503,9 @@ namespace boost // Power - 1 template <class T1, class T2> - typename tools::promote_args<T1, T2>::type + typename tools::promote_args<T1, T2>::type powm1(const T1 a, const T2 z); template <class T1, class T2, class Policy> - typename tools::promote_args<T1, T2>::type + typename tools::promote_args<T1, T2>::type powm1(const T1 a, const T2 z, const Policy&); @@ -581,40 +581,99 @@ namespace boost template <class T1, class T2, class Policy> typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_j(T1 v, T2 x, const Policy& pol); + template <class T1, class T2, class Policy> + typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_j_prime(T1 v, T2 x, const Policy& pol); template <class T1, class T2> typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_j(T1 v, T2 x); + template <class T1, class T2> + typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_j_prime(T1 v, T2 x); template <class T, class Policy> typename detail::bessel_traits<T, T, Policy>::result_type sph_bessel(unsigned v, T x, const Policy& pol); + template <class T, class Policy> + typename detail::bessel_traits<T, T, Policy>::result_type sph_bessel_prime(unsigned v, T x, const Policy& pol); template <class T> typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_bessel(unsigned v, T x); + template <class T> + typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_bessel_prime(unsigned v, T x); template <class T1, class T2, class Policy> typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i(T1 v, T2 x, const Policy& pol); + template <class T1, class T2, class Policy> + typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i_prime(T1 v, T2 x, const Policy& pol); template <class T1, class T2> typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_i(T1 v, T2 x); + template <class T1, class T2> + typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_i_prime(T1 v, T2 x); template <class T1, class T2, class Policy> typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k(T1 v, T2 x, const Policy& pol); + template <class T1, class T2, class Policy> + typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k_prime(T1 v, T2 x, const Policy& pol); template <class T1, class T2> typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_k(T1 v, T2 x); + template <class T1, class T2> + typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_k_prime(T1 v, T2 x); template <class T1, class T2, class Policy> typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_neumann(T1 v, T2 x, const Policy& pol); + template <class T1, class T2, class Policy> + typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_neumann_prime(T1 v, T2 x, const Policy& pol); template <class T1, class T2> typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_neumann(T1 v, T2 x); + template <class T1, class T2> + typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_neumann_prime(T1 v, T2 x); template <class T, class Policy> typename detail::bessel_traits<T, T, Policy>::result_type sph_neumann(unsigned v, T x, const Policy& pol); + template <class T, class Policy> + typename detail::bessel_traits<T, T, Policy>::result_type sph_neumann_prime(unsigned v, T x, const Policy& pol); template <class T> typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_neumann(unsigned v, T x); + template <class T> + typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_neumann_prime(unsigned v, T x); - template <class T1, class T2, class Policy> - std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> cyl_hankel_1(T1 v, T2 x, const Policy& pol); + template <class T, class Policy> + typename detail::bessel_traits<T, T, Policy>::result_type cyl_bessel_j_zero(T v, int m, const Policy& pol); + + template <class T> + typename detail::bessel_traits<T, T, policies::policy<> >::result_type cyl_bessel_j_zero(T v, int m); + + template <class T, class OutputIterator> + OutputIterator cyl_bessel_j_zero(T v, + int start_index, + unsigned number_of_zeros, + OutputIterator out_it); + + template <class T, class OutputIterator, class Policy> + OutputIterator cyl_bessel_j_zero(T v, + int start_index, + unsigned number_of_zeros, + OutputIterator out_it, + const Policy&); + + template <class T, class Policy> + typename detail::bessel_traits<T, T, Policy>::result_type cyl_neumann_zero(T v, int m, const Policy& pol); + + template <class T> + typename detail::bessel_traits<T, T, policies::policy<> >::result_type cyl_neumann_zero(T v, int m); + + template <class T, class OutputIterator> + OutputIterator cyl_neumann_zero(T v, + int start_index, + unsigned number_of_zeros, + OutputIterator out_it); + + template <class T, class OutputIterator, class Policy> + OutputIterator cyl_neumann_zero(T v, + int start_index, + unsigned number_of_zeros, + OutputIterator out_it, + const Policy&); template <class T1, class T2> @@ -622,4 +681,7 @@ namespace boost template <class T1, class T2, class Policy> + std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> cyl_hankel_1(T1 v, T2 x, const Policy& pol); + + template <class T1, class T2, class Policy> std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> cyl_hankel_2(T1 v, T2 x, const Policy& pol); @@ -663,4 +725,38 @@ namespace boost typename tools::promote_args<T>::type airy_bi_prime(T x); + template <class T> + T airy_ai_zero(int m); + template <class T, class Policy> + T airy_ai_zero(int m, const Policy&); + + template <class OutputIterator> + OutputIterator airy_ai_zero( + int start_index, + unsigned number_of_zeros, + OutputIterator out_it); + template <class OutputIterator, class Policy> + OutputIterator airy_ai_zero( + int start_index, + unsigned number_of_zeros, + OutputIterator out_it, + const Policy&); + + template <class T> + T airy_bi_zero(int m); + template <class T, class Policy> + T airy_bi_zero(int m, const Policy&); + + template <class OutputIterator> + OutputIterator airy_bi_zero( + int start_index, + unsigned number_of_zeros, + OutputIterator out_it); + template <class OutputIterator, class Policy> + OutputIterator airy_bi_zero( + int start_index, + unsigned number_of_zeros, + OutputIterator out_it, + const Policy&); + template <class T, class Policy> typename tools::promote_args<T>::type sin_pi(T x, const Policy&); @@ -690,5 +786,5 @@ namespace boost bool isnormal BOOST_NO_MACRO_EXPAND(T t); - template<class T> + template<class T> int signbit BOOST_NO_MACRO_EXPAND(T x); @@ -696,9 +792,9 @@ namespace boost int sign BOOST_NO_MACRO_EXPAND(const T& z); - template <class T> - T copysign BOOST_NO_MACRO_EXPAND(const T& x, const T& y); + template <class T, class U> + typename tools::promote_args_permissive<T, U>::type copysign BOOST_NO_MACRO_EXPAND(const T& x, const U& y); template <class T> - T changesign BOOST_NO_MACRO_EXPAND(const T& z); + typename tools::promote_args_permissive<T>::type changesign BOOST_NO_MACRO_EXPAND(const T& z); // Exponential integrals: @@ -738,9 +834,9 @@ namespace boost // Jacobi Functions: - template <class T, class Policy> - typename tools::promote_args<T>::type jacobi_elliptic(T k, T theta, T* pcn, T* pdn, const Policy&); + template <class T, class U, class V, class Policy> + typename tools::promote_args<T, U, V>::type jacobi_elliptic(T k, U theta, V* pcn, V* pdn, const Policy&); - template <class T> - typename tools::promote_args<T>::type jacobi_elliptic(T k, T theta, T* pcn = 0, T* pdn = 0); + template <class T, class U, class V> + typename tools::promote_args<T, U, V>::type jacobi_elliptic(T k, U theta, V* pcn = 0, V* pdn = 0); template <class U, class T, class Policy> @@ -828,20 +924,53 @@ namespace boost // next: + template <class T, class U, class Policy> + typename tools::promote_args<T, U>::type nextafter(const T&, const U&, const Policy&); + template <class T, class U> + typename tools::promote_args<T, U>::type nextafter(const T&, const U&); + template <class T, class Policy> + typename tools::promote_args<T>::type float_next(const T&, const Policy&); + template <class T> + typename tools::promote_args<T>::type float_next(const T&); template <class T, class Policy> - T nextafter(const T&, const T&, const Policy&); + typename tools::promote_args<T>::type float_prior(const T&, const Policy&); template <class T> - T nextafter(const T&, const T&); + typename tools::promote_args<T>::type float_prior(const T&); + template <class T, class U, class Policy> + typename tools::promote_args<T, U>::type float_distance(const T&, const U&, const Policy&); + template <class T, class U> + typename tools::promote_args<T, U>::type float_distance(const T&, const U&); template <class T, class Policy> - T float_next(const T&, const Policy&); + typename tools::promote_args<T>::type float_advance(T val, int distance, const Policy& pol); template <class T> - T float_next(const T&); + typename tools::promote_args<T>::type float_advance(const T& val, int distance); + + template<class T> + T unchecked_bernoulli_b2n(const std::size_t n); template <class T, class Policy> - T float_prior(const T&, const Policy&); + T bernoulli_b2n(const int i, const Policy &pol); template <class T> - T float_prior(const T&); + T bernoulli_b2n(const int i); + template <class T, class OutputIterator, class Policy> + OutputIterator bernoulli_b2n(const int start_index, + const unsigned number_of_bernoullis_b2n, + OutputIterator out_it, + const Policy& pol); + template <class T, class OutputIterator> + OutputIterator bernoulli_b2n(const int start_index, + const unsigned number_of_bernoullis_b2n, + OutputIterator out_it); template <class T, class Policy> - T float_distance(const T&, const T&, const Policy&); + T tangent_t2n(const int i, const Policy &pol); template <class T> - T float_distance(const T&, const T&); + T tangent_t2n(const int i); + template <class T, class OutputIterator, class Policy> + OutputIterator tangent_t2n(const int start_index, + const unsigned number_of_bernoullis_b2n, + OutputIterator out_it, + const Policy& pol); + template <class T, class OutputIterator> + OutputIterator tangent_t2n(const int start_index, + const unsigned number_of_bernoullis_b2n, + OutputIterator out_it); } // namespace math @@ -1119,8 +1248,16 @@ namespace boost { return boost::math::cyl_bessel_j(v, x, Policy()); }\ \ + template <class T1, class T2>\ + inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_j_prime(T1 v, T2 x)\ + { return boost::math::cyl_bessel_j_prime(v, x, Policy()); }\ +\ template <class T>\ inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type sph_bessel(unsigned v, T x)\ { return boost::math::sph_bessel(v, x, Policy()); }\ \ + template <class T>\ + inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type sph_bessel_prime(unsigned v, T x)\ + { return boost::math::sph_bessel_prime(v, x, Policy()); }\ +\ template <class T1, class T2>\ inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \ @@ -1129,10 +1266,22 @@ namespace boost template <class T1, class T2>\ inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \ + cyl_bessel_i_prime(T1 v, T2 x) { return boost::math::cyl_bessel_i_prime(v, x, Policy()); }\ +\ + template <class T1, class T2>\ + inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \ cyl_bessel_k(T1 v, T2 x) { return boost::math::cyl_bessel_k(v, x, Policy()); }\ \ template <class T1, class T2>\ inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \ + cyl_bessel_k_prime(T1 v, T2 x) { return boost::math::cyl_bessel_k_prime(v, x, Policy()); }\ +\ + template <class T1, class T2>\ + inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \ cyl_neumann(T1 v, T2 x){ return boost::math::cyl_neumann(v, x, Policy()); }\ \ + template <class T1, class T2>\ + inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \ + cyl_neumann_prime(T1 v, T2 x){ return boost::math::cyl_neumann_prime(v, x, Policy()); }\ +\ template <class T>\ inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type \ @@ -1140,4 +1289,30 @@ namespace boost \ template <class T>\ + inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type \ + sph_neumann_prime(unsigned v, T x){ return boost::math::sph_neumann_prime(v, x, Policy()); }\ +\ + template <class T>\ + inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type cyl_bessel_j_zero(T v, int m)\ + { return boost::math::cyl_bessel_j_zero(v, m, Policy()); }\ +\ +template <class OutputIterator, class T>\ + inline void cyl_bessel_j_zero(T v,\ + int start_index,\ + unsigned number_of_zeros,\ + OutputIterator out_it)\ + { boost::math::cyl_bessel_j_zero(v, start_index, number_of_zeros, out_it, Policy()); }\ +\ + template <class T>\ + inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type cyl_neumann_zero(T v, int m)\ + { return boost::math::cyl_neumann_zero(v, m, Policy()); }\ +\ +template <class OutputIterator, class T>\ + inline void cyl_neumann_zero(T v,\ + int start_index,\ + unsigned number_of_zeros,\ + OutputIterator out_it)\ + { boost::math::cyl_neumann_zero(v, start_index, number_of_zeros, out_it, Policy()); }\ +\ + template <class T>\ inline typename boost::math::tools::promote_args<T>::type sin_pi(T x){ return boost::math::sin_pi(x); }\ \ @@ -1287,4 +1462,32 @@ namespace boost { return boost::math::airy_bi_prime(x, Policy()); }\ \ + template <class T>\ + inline T airy_ai_zero(int m)\ + { return boost::math::airy_ai_zero<T>(m, Policy()); }\ + template <class T, class OutputIterator>\ + OutputIterator airy_ai_zero(int start_index, unsigned number_of_zeros, OutputIterator out_it)\ + { return boost::math::airy_ai_zero<T>(start_index, number_of_zeros, out_it, Policy()); }\ + \ + template <class T>\ + inline T airy_bi_zero(int m)\ + { return boost::math::airy_bi_zero<T>(m, Policy()); }\ + template <class T, class OutputIterator>\ + OutputIterator airy_bi_zero(int start_index, unsigned number_of_zeros, OutputIterator out_it)\ + { return boost::math::airy_bi_zero<T>(start_index, number_of_zeros, out_it, Policy()); }\ + \ + template <class T>\ + T bernoulli_b2n(const int i)\ + { return boost::math::bernoulli_b2n<T>(i, Policy()); }\ + template <class T, class OutputIterator>\ + OutputIterator bernoulli_b2n(int start_index, unsigned number_of_bernoullis_b2n, OutputIterator out_it)\ + { return boost::math::bernoulli_b2n<T>(start_index, number_of_bernoullis_b2n, out_it, Policy()); }\ + \ + template <class T>\ + T tangent_t2n(const int i)\ + { return boost::math::tangent_t2n<T>(i, Policy()); }\ + template <class T, class OutputIterator>\ + OutputIterator tangent_t2n(int start_index, unsigned number_of_bernoullis_b2n, OutputIterator out_it)\ + { return boost::math::tangent_t2n<T>(start_index, number_of_bernoullis_b2n, out_it, Policy()); }\ + \ diff --git a/3rdParty/Boost/src/boost/math/special_functions/sign.hpp b/3rdParty/Boost/src/boost/math/special_functions/sign.hpp index 6de88b2..f5c562d 100644 --- a/3rdParty/Boost/src/boost/math/special_functions/sign.hpp +++ b/3rdParty/Boost/src/boost/math/special_functions/sign.hpp @@ -32,5 +32,8 @@ namespace detail { #endif - template<class T> + // Generic versions first, note that these do not handle + // signed zero or NaN. + + template<class T> inline int signbit_impl(T x, generic_tag<true> const&) { @@ -44,5 +47,23 @@ namespace detail { } - template<class T> +#if defined(__GNUC__) && (LDBL_MANT_DIG == 106) + // + // Special handling for GCC's "double double" type, + // in this case the sign is the same as the sign we + // get by casting to double, no overflow/underflow + // can occur since the exponents are the same magnitude + // for the two types: + // + inline int signbit_impl(long double x, generic_tag<true> const&) + { + return boost::math::signbit(static_cast<double>(x)); + } + inline int signbit_impl(long double x, generic_tag<false> const&) + { + return boost::math::signbit(static_cast<double>(x)); + } +#endif + + template<class T> inline int signbit_impl(T x, ieee_copy_all_bits_tag const&) { @@ -66,4 +87,7 @@ namespace detail { // Changesign + + // Generic versions first, note that these do not handle + // signed zero or NaN. template<class T> @@ -78,5 +102,25 @@ namespace detail { return -x; } - +#if defined(__GNUC__) && (LDBL_MANT_DIG == 106) + // + // Special handling for GCC's "double double" type, + // in this case we need to change the sign of both + // components of the "double double": + // + inline long double (changesign_impl)(long double x, generic_tag<true> const&) + { + double* pd = reinterpret_cast<double*>(&x); + pd[0] = boost::math::changesign(pd[0]); + pd[1] = boost::math::changesign(pd[1]); + return x; + } + inline long double (changesign_impl)(long double x, generic_tag<false> const&) + { + double* pd = reinterpret_cast<double*>(&x); + pd[0] = boost::math::changesign(pd[0]); + pd[1] = boost::math::changesign(pd[1]); + return x; + } +#endif template<class T> @@ -111,6 +155,7 @@ template<class T> int (signbit)(T x) typedef typename detail::fp_traits<T>::type traits; typedef typename traits::method method; - typedef typename boost::is_floating_point<T>::type fp_tag; - return detail::signbit_impl(x, method()); + // typedef typename boost::is_floating_point<T>::type fp_tag; + typedef typename tools::promote_args_permissive<T>::type result_type; + return detail::signbit_impl(static_cast<result_type>(x), method()); } @@ -121,18 +166,22 @@ inline int sign BOOST_NO_MACRO_EXPAND(const T& z) } -template<class T> T (changesign)(const T& x) +template <class T> typename tools::promote_args_permissive<T>::type (changesign)(const T& x) { //!< \brief return unchanged binary pattern of x, except for change of sign bit. typedef typename detail::fp_traits<T>::sign_change_type traits; typedef typename traits::method method; - typedef typename boost::is_floating_point<T>::type fp_tag; + // typedef typename boost::is_floating_point<T>::type fp_tag; + typedef typename tools::promote_args_permissive<T>::type result_type; - return detail::changesign_impl(x, method()); + return detail::changesign_impl(static_cast<result_type>(x), method()); } -template <class T> -inline T copysign BOOST_NO_MACRO_EXPAND(const T& x, const T& y) +template <class T, class U> +inline typename tools::promote_args_permissive<T, U>::type + copysign BOOST_NO_MACRO_EXPAND(const T& x, const U& y) { BOOST_MATH_STD_USING - return (boost::math::signbit)(x) != (boost::math::signbit)(y) ? (boost::math::changesign)(x) : x; + typedef typename tools::promote_args_permissive<T, U>::type result_type; + return (boost::math::signbit)(static_cast<result_type>(x)) != (boost::math::signbit)(static_cast<result_type>(y)) + ? (boost::math::changesign)(static_cast<result_type>(x)) : static_cast<result_type>(x); } diff --git a/3rdParty/Boost/src/boost/math/tools/config.hpp b/3rdParty/Boost/src/boost/math/tools/config.hpp index b1fcd13..4ec5768 100644 --- a/3rdParty/Boost/src/boost/math/tools/config.hpp +++ b/3rdParty/Boost/src/boost/math/tools/config.hpp @@ -14,4 +14,5 @@ #include <boost/cstdint.hpp> // for boost::uintmax_t #include <boost/detail/workaround.hpp> +#include <boost/type_traits/is_integral.hpp> #include <algorithm> // for min and max #include <boost/config/no_tr1/cmath.hpp> @@ -21,7 +22,9 @@ # include <math.h> #endif +#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS +# include <limits> +#endif #include <boost/math/tools/user.hpp> -#include <boost/math/special_functions/detail/round_fwd.hpp> #if (defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__NetBSD__) \ @@ -100,11 +103,16 @@ #endif +#if defined(_LIBCPP_VERSION) && !defined(_MSC_VER) +# define BOOST_MATH_USE_C99 +#endif + #if defined(__CYGWIN__) || defined(__HP_aCC) || defined(BOOST_INTEL) \ || defined(BOOST_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY) \ - || (defined(__GNUC__) && !defined(BOOST_MATH_USE_C99)) + || (defined(__GNUC__) && !defined(BOOST_MATH_USE_C99))\ + || defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS) # define BOOST_MATH_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY #endif -#if defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) +#if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) # include "boost/type.hpp" @@ -140,10 +148,10 @@ -#endif // defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS +#endif // __SUNPRO_CC #if (defined(__SUNPRO_CC) || defined(__hppa) || defined(__GNUC__)) && !defined(BOOST_MATH_SMALL_CONSTANT) // Sun's compiler emits a hard error if a constant underflows, // as does aCC on PA-RISC, while gcc issues a large number of warnings: -# define BOOST_MATH_SMALL_CONSTANT(x) 0 +# define BOOST_MATH_SMALL_CONSTANT(x) 0.0 #else # define BOOST_MATH_SMALL_CONSTANT(x) x @@ -204,4 +212,35 @@ # define BOOST_MATH_INT_VALUE_SUFFIX(RV, SUF) RV##SUF #endif +// +// Test whether to support __float128: +// +#if defined(_GLIBCXX_USE_FLOAT128) && defined(BOOST_GCC) && !defined(__STRICT_ANSI__) \ + && !defined(BOOST_MATH_DISABLE_FLOAT128) || defined(BOOST_MATH_USE_FLOAT128) +// +// Only enable this when the compiler really is GCC as clang and probably +// intel too don't support __float128 yet :-( +// +#ifndef BOOST_MATH_USE_FLOAT128 +# define BOOST_MATH_USE_FLOAT128 +#endif + +# if defined(BOOST_INTEL) && defined(BOOST_INTEL_CXX_VERSION) && (BOOST_INTEL_CXX_VERSION >= 1310) && defined(__GNUC__) +# if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) +# define BOOST_MATH_FLOAT128_TYPE __float128 +# endif +# elif defined(__GNUC__) +# define BOOST_MATH_FLOAT128_TYPE __float128 +# endif + +# ifndef BOOST_MATH_FLOAT128_TYPE +# define BOOST_MATH_FLOAT128_TYPE _Quad +# endif +#endif +// +// Check for WinCE with no iostream support: +// +#if defined(_WIN32_WCE) && !defined(__SGI_STL_PORT) +# define BOOST_MATH_NO_LEXICAL_CAST +#endif // @@ -214,5 +253,5 @@ // Helper macro for using statements: // -#define BOOST_MATH_STD_USING \ +#define BOOST_MATH_STD_USING_CORE \ using std::abs;\ using std::acos;\ @@ -237,13 +276,7 @@ using std::floor;\ using std::log10;\ - using std::sqrt;\ - using boost::math::round;\ - using boost::math::iround;\ - using boost::math::lround;\ - using boost::math::trunc;\ - using boost::math::itrunc;\ - using boost::math::ltrunc;\ - using boost::math::modf; + using std::sqrt; +#define BOOST_MATH_STD_USING BOOST_MATH_STD_USING_CORE namespace boost{ namespace math{ @@ -270,7 +303,33 @@ void suppress_unused_variable_warning(const T&) } +namespace detail{ + +template <class T> +struct is_integer_for_rounding +{ + static const bool value = boost::is_integral<T>::value +#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS + || (std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer) +#endif + ; +}; + +} + }} // namespace boost namespace math -#if ((defined(__linux__) && !defined(__UCLIBC__)) || defined(__QNX__) || defined(__IBMCPP__)) && !defined(BOOST_NO_FENV_H) +#ifdef __GLIBC_PREREQ +# if __GLIBC_PREREQ(2,14) +# define BOOST_MATH_HAVE_FIXED_GLIBC +# endif +#endif + +#if ((defined(__linux__) && !defined(__UCLIBC__) && !defined(BOOST_MATH_HAVE_FIXED_GLIBC)) || defined(__QNX__) || defined(__IBMCPP__)) && !defined(BOOST_NO_FENV_H) +// +// This code was introduced in response to this glibc bug: http://sourceware.org/bugzilla/show_bug.cgi?id=2445 +// Basically powl and expl can return garbage when the result is small and certain exception flags are set +// on entrance to these functions. This appears to have been fixed in Glibc 2.14 (May 2011). +// Much more information in this message thread: https://groups.google.com/forum/#!topic/boost-list/ZT99wtIFlb4 +// #include <boost/detail/fenv.hpp> @@ -315,10 +374,18 @@ namespace boost{ namespace math{ #ifdef BOOST_MATH_INSTRUMENT -#define BOOST_MATH_INSTRUMENT_CODE(x) \ - std::cout << std::setprecision(35) << __FILE__ << ":" << __LINE__ << " " << x << std::endl; -#define BOOST_MATH_INSTRUMENT_VARIABLE(name) BOOST_MATH_INSTRUMENT_CODE(BOOST_STRINGIZE(name) << " = " << name) + +# include <iostream> +# include <iomanip> +# include <typeinfo> + +# define BOOST_MATH_INSTRUMENT_CODE(x) \ + std::cout << std::setprecision(35) << __FILE__ << ":" << __LINE__ << " " << x << std::endl; +# define BOOST_MATH_INSTRUMENT_VARIABLE(name) BOOST_MATH_INSTRUMENT_CODE(BOOST_STRINGIZE(name) << " = " << name) + #else -#define BOOST_MATH_INSTRUMENT_CODE(x) -#define BOOST_MATH_INSTRUMENT_VARIABLE(name) + +# define BOOST_MATH_INSTRUMENT_CODE(x) +# define BOOST_MATH_INSTRUMENT_VARIABLE(name) + #endif diff --git a/3rdParty/Boost/src/boost/math/tools/promotion.hpp b/3rdParty/Boost/src/boost/math/tools/promotion.hpp index 728aaf1..b3ad204 100644 --- a/3rdParty/Boost/src/boost/math/tools/promotion.hpp +++ b/3rdParty/Boost/src/boost/math/tools/promotion.hpp @@ -139,8 +139,33 @@ namespace boost // Guard against use of long double if it's not supported: // - BOOST_STATIC_ASSERT((0 == ::boost::is_same<type, long double>::value)); + BOOST_STATIC_ASSERT_MSG((0 == ::boost::is_same<type, long double>::value), "Sorry, but this platform does not have sufficient long double support for the special functions to be reliably implemented."); #endif }; + // + // This struct is the same as above, but has no static assert on long double usage, + // it should be used only on functions that can be implemented for long double + // even when std lib support is missing or broken for that type. + // + template <class T1, class T2=float, class T3=float, class T4=float, class T5=float, class T6=float> + struct promote_args_permissive + { + typedef typename promote_args_2< + typename remove_cv<T1>::type, + typename promote_args_2< + typename remove_cv<T2>::type, + typename promote_args_2< + typename remove_cv<T3>::type, + typename promote_args_2< + typename remove_cv<T4>::type, + typename promote_args_2< + typename remove_cv<T5>::type, typename remove_cv<T6>::type + >::type + >::type + >::type + >::type + >::type type; + }; + } // namespace tools } // namespace math diff --git a/3rdParty/Boost/src/boost/math/tools/user.hpp b/3rdParty/Boost/src/boost/math/tools/user.hpp index c1bdaf7..08a7e53 100644 --- a/3rdParty/Boost/src/boost/math/tools/user.hpp +++ b/3rdParty/Boost/src/boost/math/tools/user.hpp @@ -92,4 +92,12 @@ // // define BOOST_MATH_MAX_ROOT_ITERATION_POLICY 200 +// +// Enable use of __float128 in numeric constants: +// +// #define BOOST_MATH_USE_FLOAT128 +// +// Disable use of __float128 in numeric_constants even if the compiler looks to support it: +// +// #define BOOST_MATH_DISABLE_FLOAT128 #endif // BOOST_MATH_TOOLS_USER_HPP |