//	Distributed under the Boost Software License Version 1.0 https://www.boost.org/LICENSE_1_0.txt
//	Copyright Gero Peterhoff

#ifndef BOOST_TYPE_TRAITS_IS_FLOATING_POINT_MORE_HPP
#define BOOST_TYPE_TRAITS_IS_FLOATING_POINT_MORE_HPP

#include <boost/math/cstdfloat/cstdfloat_types_more.hpp>
#include <boost/type_traits/is_floating_point.hpp>
#include <boost/type_traits/remove_cv_ref.hpp>
#include <boost/type_traits/is_same.hpp>



//	todo float8
//	https://www.heise.de/news/Gleitkommazahlen-im-Machine-Learning-Weniger-ist-mehr-fuer-Intel-Nvidia-und-ARM-7264714.html

namespace boost
{
//	std-types
template <typename Type> struct is_std_longdouble : public integral_constant
<
	bool,
	is_same<long double, typename remove_cv_ref<Type>::type>::value
>	{};

template <typename Type> struct is_std_double : public integral_constant
<
	bool,
	is_same<double, typename remove_cv_ref<Type>::type>::value
>	{};


template <typename Type> struct is_std_float : public integral_constant
<
	bool,
	is_same<float, typename remove_cv_ref<Type>::type>::value
>	{};



//	add C++23-types
#if defined(__STDCPP_FLOAT128_T__)
   template <> struct is_floating_point<std::float128_t> : public true_type{};
#endif

#if defined(__STDCPP_FLOAT64_T__)
   template <> struct is_floating_point<std::float64_t> : public true_type{};
#endif

#if defined(__STDCPP_FLOAT32_T__)
   template <> struct is_floating_point<std::float32_t> : public true_type{};
#endif

#if defined(__STDCPP_FLOAT16_T__)
   template <> struct is_floating_point<std::float16_t> : public true_type{};
#endif

#if defined(__STDCPP_BFLOAT16_T__)
   template <> struct is_floating_point<std::bfloat16_t> : public true_type{};
#endif



//	C++23 std-types
template <typename Type> struct is_std_float128 : public integral_constant
<
	bool,
	#if defined(__STDCPP_FLOAT128_T__)
		is_same<std::float128_t, typename remove_cv_ref<Type>::type>::value
	#else
		false
	#endif
>	{};

template <typename Type> struct is_std_float64 : public integral_constant
<
	bool,
	#if defined(__STDCPP_FLOAT64_T__)
		is_same<std::float64_t, typename remove_cv_ref<Type>::type>::value
	#else
		false
	#endif
>	{};

template <typename Type> struct is_std_float32 : public integral_constant
<
	bool,
	#if defined(__STDCPP_FLOAT32_T__)
		is_same<std::float32_t, typename remove_cv_ref<Type>::type>::value
	#else
		false
	#endif
>	{};

template <typename Type> struct is_std_float16 : public integral_constant
<
	bool,
	#if defined(__STDCPP_FLOAT16_T__)
		is_same<std::float16_t, typename remove_cv_ref<Type>::type>::value
	#else
		false
	#endif
>	{};

template <typename Type> struct is_std_bfloat16 : public integral_constant
<
	bool,
	#if defined(__STDCPP_BFLOAT16_T__)
		is_same<std::bfloat16_t, typename remove_cv_ref<Type>::type>::value
	#else
		false
	#endif
>	{};



//	boost-types
template <typename Type> struct is_boost_float128 : public integral_constant
<
	bool,
	#if defined(BOOST_CSTDFLOAT_FLOAT128_NATIVE_TYPE)
		is_same<boost::float128_t, typename remove_cv_ref<Type>::type>::value
	#else
		false
	#endif
>	{};

template <typename Type> struct is_boost_float80 : public integral_constant
<
	bool,
	#if defined(BOOST_CSTDFLOAT_FLOAT80_NATIVE_TYPE)
		is_same<boost::float80_t, typename remove_cv_ref<Type>::type>::value
	#else
		false
	#endif
>	{};

template <typename Type> struct is_boost_float64 : public integral_constant
<
	bool,
	#if defined(BOOST_CSTDFLOAT_FLOAT64_NATIVE_TYPE)
		is_same<boost::float64_t, typename remove_cv_ref<Type>::type>::value
	#else
		false
	#endif
>	{};

template <typename Type> struct is_boost_float32 : public integral_constant
<
	bool,
	#if defined(BOOST_CSTDFLOAT_FLOAT32_NATIVE_TYPE)
		is_same<boost::float32_t, typename remove_cv_ref<Type>::type>::value
	#else
		false
	#endif
>	{};

template <typename Type> struct is_boost_float16 : public integral_constant
<
	bool,
	#if defined(BOOST_CSTDFLOAT_FLOAT16_NATIVE_TYPE)
		is_same<boost::float16_t, typename remove_cv_ref<Type>::type>::value
	#else
		false
	#endif
>	{};



//	general
template <typename Type> struct is_float128 : public integral_constant
<
	bool,
	is_std_float128<Type>::value || is_boost_float128<Type>::value
>	{};

template <typename Type> struct is_float80 : public integral_constant
<
	bool,
	is_boost_float80<Type>::value
>	{};

template <typename Type> struct is_float64 : public integral_constant
<
	bool,
	is_std_float64<Type>::value || is_boost_float64<Type>::value
>	{};

template <typename Type> struct is_float32 : public integral_constant
<
	bool,
	is_std_float32<Type>::value || is_boost_float32<Type>::value
>	{};

template <typename Type> struct is_float16 : public integral_constant
<
	bool,
	is_std_float16<Type>::value || is_boost_float16<Type>::value
>	{};

template <typename Type> struct is_bfloat16 : public integral_constant
<
	bool,
	is_std_bfloat16<Type>::value
>	{};



#if !defined(BOOST_NO_CXX17_INLINE_VARIABLES)
template <typename Type> inline constexpr bool is_std_longdouble_v	= is_std_longdouble<Type>::value;
template <typename Type> inline constexpr bool is_std_double_v		= is_std_double<Type>::value;
template <typename Type> inline constexpr bool is_std_float_v		= is_std_float<Type>::value;

template <typename Type> inline constexpr bool is_std_float128_v	= is_std_float128<Type>::value;
template <typename Type> inline constexpr bool is_std_float64_v		= is_std_float64<Type>::value;
template <typename Type> inline constexpr bool is_std_float32_v		= is_std_float32<Type>::value;
template <typename Type> inline constexpr bool is_std_float16_v		= is_std_float16<Type>::value;
template <typename Type> inline constexpr bool is_std_bfloat16_v	= is_std_bfloat16<Type>::value;

template <typename Type> inline constexpr bool is_boost_float128_v	= is_boost_float128<Type>::value;
template <typename Type> inline constexpr bool is_boost_float80_v	= is_boost_float80<Type>::value;
template <typename Type> inline constexpr bool is_boost_float64_v	= is_boost_float64<Type>::value;
template <typename Type> inline constexpr bool is_boost_float32_v	= is_boost_float32<Type>::value;
template <typename Type> inline constexpr bool is_boost_float16_v	= is_boost_float16<Type>::value;

template <typename Type> inline constexpr bool is_float128_v		= is_float128<Type>::value;
template <typename Type> inline constexpr bool is_float80_v			= is_float80<Type>::value;
template <typename Type> inline constexpr bool is_float64_v			= is_float64<Type>::value;
template <typename Type> inline constexpr bool is_float32_v			= is_float32<Type>::value;
template <typename Type> inline constexpr bool is_float16_v			= is_float16<Type>::value;
template <typename Type> inline constexpr bool is_bfloat16_v		= is_bfloat16<Type>::value;
#endif
}	//	boost

#endif	//	BOOST_TYPE_TRAITS_IS_FLOATING_POINT_MORE_HPP