Added thirdparty: boost library

thirdparty/include/boost/math/ccmath/signbit.hpp

@@ -0,0 +1,219 @@
+//  (C) Copyright Matt Borland 2022.
+//  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_CCMATH_SIGNBIT_HPP
+#define BOOST_MATH_CCMATH_SIGNBIT_HPP
+
+#include <boost/math/ccmath/detail/config.hpp>
+
+#ifdef BOOST_MATH_NO_CCMATH
+#error "The header <boost/math/signbit.hpp> can only be used in C++17 and later."
+#endif
+
+#include <cstdint>
+#include <boost/math/tools/assert.hpp>
+#include <boost/math/special_functions/detail/fp_traits.hpp>
+#include <boost/math/ccmath/isnan.hpp>
+#include <boost/math/ccmath/abs.hpp>
+
+#ifdef __has_include
+#  if __has_include(<bit>)
+#    include <bit>
+#    if __cpp_lib_bit_cast >= 201806L
+#      define BOOST_MATH_BIT_CAST(T, x) std::bit_cast<T>(x)
+#    endif
+#  elif defined(__has_builtin)
+#    if __has_builtin(__builtin_bit_cast)
+#      define BOOST_MATH_BIT_CAST(T, x) __builtin_bit_cast(T, x)
+#    endif
+#  endif
+#endif
+
+/*
+The following error is given using Apple Clang version 13.1.6, and Clang 13, and 14 on Ubuntu 22.04.01
+TODO: Remove the following undef when Apple Clang supports
+
+ccmath_signbit_test.cpp:32:19: error: static_assert expression is not an integral constant expression
+    static_assert(boost::math::ccmath::signbit(T(-1)) == true);
+                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+../../../boost/math/ccmath/signbit.hpp:62:24: note: constexpr bit_cast involving bit-field is not yet supported
+        const auto u = BOOST_MATH_BIT_CAST(float_bits, arg);
+                       ^
+../../../boost/math/ccmath/signbit.hpp:20:37: note: expanded from macro 'BOOST_MATH_BIT_CAST'
+#  define BOOST_MATH_BIT_CAST(T, x) __builtin_bit_cast(T, x)
+                                    ^
+*/
+
+#if defined(__clang__) && defined(BOOST_MATH_BIT_CAST)
+#  undef BOOST_MATH_BIT_CAST
+#endif
+
+namespace boost::math::ccmath {
+
+namespace detail {
+
+#ifdef BOOST_MATH_BIT_CAST
+
+struct IEEEf2bits
+{
+#if BOOST_MATH_ENDIAN_LITTLE_BYTE
+    std::uint32_t mantissa : 23;
+    std::uint32_t exponent : 8;
+    std::uint32_t sign : 1;
+#else // Big endian
+    std::uint32_t sign : 1;
+    std::uint32_t exponent : 8;
+    std::uint32_t mantissa : 23;
+#endif 
+};
+
+struct IEEEd2bits
+{
+#if BOOST_MATH_ENDIAN_LITTLE_BYTE
+    std::uint32_t mantissa_l : 32;
+    std::uint32_t mantissa_h : 20;
+    std::uint32_t exponent : 11;
+    std::uint32_t sign : 1;
+#else // Big endian
+    std::uint32_t sign : 1;
+    std::uint32_t exponent : 11;
+    std::uint32_t mantissa_h : 20;
+    std::uint32_t mantissa_l : 32;
+#endif
+};
+
+// 80 bit long double
+#if LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384
+
+struct IEEEl2bits
+{
+#if BOOST_MATH_ENDIAN_LITTLE_BYTE
+    std::uint32_t mantissa_l : 32;
+    std::uint32_t mantissa_h : 32;
+    std::uint32_t exponent : 15;
+    std::uint32_t sign : 1;
+    std::uint32_t pad : 32;
+#else // Big endian
+    std::uint32_t pad : 32;
+    std::uint32_t sign : 1;
+    std::uint32_t exponent : 15;
+    std::uint32_t mantissa_h : 32;
+    std::uint32_t mantissa_l : 32;
+#endif
+};
+
+// 128 bit long double
+#elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
+
+struct IEEEl2bits
+{
+#if BOOST_MATH_ENDIAN_LITTLE_BYTE
+    std::uint64_t mantissa_l : 64;
+    std::uint64_t mantissa_h : 48;
+    std::uint32_t exponent : 15;
+    std::uint32_t sign : 1;
+#else // Big endian
+    std::uint32_t sign : 1;
+    std::uint32_t exponent : 15;
+    std::uint64_t mantissa_h : 48;
+    std::uint64_t mantissa_l : 64;
+#endif
+};
+
+// 64 bit long double (double == long double on ARM)
+#elif LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
+
+struct IEEEl2bits
+{
+#if BOOST_MATH_ENDIAN_LITTLE_BYTE
+    std::uint32_t mantissa_l : 32;
+    std::uint32_t mantissa_h : 20;
+    std::uint32_t exponent : 11;
+    std::uint32_t sign : 1;
+#else // Big endian
+    std::uint32_t sign : 1;
+    std::uint32_t exponent : 11;
+    std::uint32_t mantissa_h : 20;
+    std::uint32_t mantissa_l : 32;
+#endif
+};
+
+#else // Unsupported long double representation
+#  define BOOST_MATH_UNSUPPORTED_LONG_DOUBLE
+#endif
+
+template <typename T>
+constexpr bool signbit_impl(T arg)
+{
+    if constexpr (std::is_same_v<T, float>)
+    {   
+        const auto u = BOOST_MATH_BIT_CAST(IEEEf2bits, arg);
+        return u.sign;
+    }
+    else if constexpr (std::is_same_v<T, double>)
+    {
+        const auto u = BOOST_MATH_BIT_CAST(IEEEd2bits, arg);
+        return u.sign;
+    }
+    #ifndef BOOST_MATH_UNSUPPORTED_LONG_DOUBLE
+    else if constexpr (std::is_same_v<T, long double>)
+    {
+        const auto u = BOOST_MATH_BIT_CAST(IEEEl2bits, arg);
+        return u.sign;
+    }
+    #endif
+    else
+    {
+        BOOST_MATH_ASSERT_MSG(!boost::math::ccmath::isnan(arg), "NAN is not supported with this type or platform");
+        BOOST_MATH_ASSERT_MSG(boost::math::ccmath::abs(arg) != 0, "Signed 0 is not support with this type or platform");
+
+        return arg < static_cast<T>(0);
+    }
+}
+
+#else
+
+// Typical implementations of signbit involve type punning via union and manipulating
+// overflow (see libc++ or musl). Neither of these are allowed in constexpr contexts
+// (technically type punning via union in general is UB in c++ but well defined in C) 
+// therefore we static assert these cases.
+
+template <typename T>
+constexpr bool signbit_impl(T arg)
+{
+    BOOST_MATH_ASSERT_MSG(!boost::math::ccmath::isnan(arg), "NAN is not supported without __builtin_bit_cast or std::bit_cast");
+    BOOST_MATH_ASSERT_MSG(boost::math::ccmath::abs(arg) != 0, "Signed 0 is not support without __builtin_bit_cast or std::bit_cast");
+
+    return arg < static_cast<T>(0);
+}
+
+#endif
+
+}
+
+// Return value: true if arg is negative, false if arg is 0, NAN, or positive
+template <typename Real, std::enable_if_t<!std::is_integral_v<Real>, bool> = true>
+constexpr bool signbit(Real arg)
+{
+    if (BOOST_MATH_IS_CONSTANT_EVALUATED(arg))
+    {
+        return boost::math::ccmath::detail::signbit_impl(arg);
+    }
+    else
+    {
+        using std::signbit;
+        return signbit(arg);
+    }
+}
+
+template <typename Z, std::enable_if_t<std::is_integral_v<Z>, bool> = true>
+constexpr bool signbit(Z arg)
+{
+    return boost::math::ccmath::signbit(static_cast<double>(arg));
+}
+
+} // Namespaces
+
+#endif // BOOST_MATH_CCMATH_SIGNBIT_HPP