#ifndef HALF_HALF_HPP

#define HALF_HALF_HPP

#define HALF_GNUC_VERSION (__GNUC__*100+__GNUC_MINOR__)

#if defined(__clang__) //clang

#if __has_feature(cxx_static_assert) && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)

#define HALF_ENABLE_CPP11_STATIC_ASSERT 1

#endif

#if __has_feature(cxx_constexpr) && !defined(HALF_ENABLE_CPP11_CONSTEXPR)

#define HALF_ENABLE_CPP11_CONSTEXPR 1

#endif

#if __has_feature(cxx_noexcept) && !defined(HALF_ENABLE_CPP11_NOEXCEPT)

#define HALF_ENABLE_CPP11_NOEXCEPT 1

#endif

#if __has_feature(cxx_user_literals) && !defined(HALF_ENABLE_CPP11_USER_LITERALS)

#define HALF_ENABLE_CPP11_USER_LITERALS 1

#endif

#if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L) && !defined(HALF_ENABLE_CPP11_LONG_LONG)

#define HALF_ENABLE_CPP11_LONG_LONG 1

#endif

#elif defined(__GNUC__) //gcc

#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L

#if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)

#define HALF_ENABLE_CPP11_STATIC_ASSERT 1

#endif

#if HALF_GNUC_VERSION >= 406 && !defined(HALF_ENABLE_CPP11_CONSTEXPR)

#define HALF_ENABLE_CPP11_CONSTEXPR 1

#endif

#if HALF_GNUC_VERSION >= 406 && !defined(HALF_ENABLE_CPP11_NOEXCEPT)

#define HALF_ENABLE_CPP11_NOEXCEPT 1

#endif

#if HALF_GNUC_VERSION >= 407 && !defined(HALF_ENABLE_CPP11_USER_LITERALS)

#define HALF_ENABLE_CPP11_USER_LITERALS 1

#endif

#if !defined(HALF_ENABLE_CPP11_LONG_LONG)

#define HALF_ENABLE_CPP11_LONG_LONG 1

#endif

#endif

#elif defined(_MSC_VER) //Visual C++

#if _MSC_VER >= 1900 && !defined(HALF_ENABLE_CPP11_CONSTEXPR)

#define HALF_ENABLE_CPP11_CONSTEXPR 1

#endif

#if _MSC_VER >= 1900 && !defined(HALF_ENABLE_CPP11_NOEXCEPT)

#define HALF_ENABLE_CPP11_NOEXCEPT 1

#endif

#if _MSC_VER >= 1900 && !defined(HALF_ENABLE_CPP11_USER_LITERALS)

#define HALF_ENABLE_CPP11_USER_LITERALS 1

#endif

#if _MSC_VER >= 1600 && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)

#define HALF_ENABLE_CPP11_STATIC_ASSERT 1

#endif

#if _MSC_VER >= 1310 && !defined(HALF_ENABLE_CPP11_LONG_LONG)

#define HALF_ENABLE_CPP11_LONG_LONG 1

#endif

#define HALF_POP_WARNINGS 1

#pragma warning(push)

#pragma warning(disable : 4099 4127 4146) //struct vs class, constant in if, negative unsigned

#endif

#include <utility>

#if defined(_LIBCPP_VERSION) //libc++

#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103

#ifndef HALF_ENABLE_CPP11_TYPE_TRAITS

#define HALF_ENABLE_CPP11_TYPE_TRAITS 1

#endif

#ifndef HALF_ENABLE_CPP11_CSTDINT

#define HALF_ENABLE_CPP11_CSTDINT 1

#endif

#ifndef HALF_ENABLE_CPP11_CMATH

#define HALF_ENABLE_CPP11_CMATH 1

#endif

#ifndef HALF_ENABLE_CPP11_HASH

#define HALF_ENABLE_CPP11_HASH 1

#endif

#endif

#elif defined(__GLIBCXX__) //libstdc++

#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103

#ifdef __clang__

#if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_TYPE_TRAITS)

#define HALF_ENABLE_CPP11_TYPE_TRAITS 1

#endif

#if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_CSTDINT)

#define HALF_ENABLE_CPP11_CSTDINT 1

#endif

#if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_CMATH)

#define HALF_ENABLE_CPP11_CMATH 1

#endif

#if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_HASH)

#define HALF_ENABLE_CPP11_HASH 1

#endif

#else

#if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_CSTDINT)

#define HALF_ENABLE_CPP11_CSTDINT 1

#endif

#if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_CMATH)

#define HALF_ENABLE_CPP11_CMATH 1

#endif

#if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_HASH)

#define HALF_ENABLE_CPP11_HASH 1

#endif

#endif

#endif

#elif defined(_CPPLIB_VER) //Dinkumware/Visual C++

#if _CPPLIB_VER >= 520

#ifndef HALF_ENABLE_CPP11_TYPE_TRAITS

#define HALF_ENABLE_CPP11_TYPE_TRAITS 1

#endif

#ifndef HALF_ENABLE_CPP11_CSTDINT

#define HALF_ENABLE_CPP11_CSTDINT 1

#endif

#ifndef HALF_ENABLE_CPP11_HASH

#define HALF_ENABLE_CPP11_HASH 1

#endif

#endif

#if _CPPLIB_VER >= 610

#ifndef HALF_ENABLE_CPP11_CMATH

#define HALF_ENABLE_CPP11_CMATH 1

#endif

#endif

#endif

#undef HALF_GNUC_VERSION

#if HALF_ENABLE_CPP11_CONSTEXPR

#define HALF_CONSTEXPR constexpr

#define HALF_CONSTEXPR_CONST constexpr

#else

#define HALF_CONSTEXPR

#define HALF_CONSTEXPR_CONST const

#endif

#if HALF_ENABLE_CPP11_NOEXCEPT

#define HALF_NOEXCEPT noexcept

#define HALF_NOTHROW noexcept

#else

#define HALF_NOEXCEPT

#define HALF_NOTHROW throw()

#endif

#include <algorithm>

#include <iostream>

#include <limits>

#include <climits>

#include <cmath>

#include <cstring>

#if HALF_ENABLE_CPP11_TYPE_TRAITS

#include <type_traits>

#endif

#if HALF_ENABLE_CPP11_CSTDINT

#include <cstdint>

#endif

#if HALF_ENABLE_CPP11_HASH

#include <functional>

#endif

#ifndef HALF_ROUND_STYLE

#define HALF_ROUND_STYLE -1 // = std::round_indeterminate

#endif

#ifndef HALF_ROUND_TIES_TO_EVEN

#define HALF_ROUND_TIES_TO_EVEN 0 // ties away from zero

#endif

#define HUGE_VALH std::numeric_limits<half_float::half>::infinity()

#define FP_FAST_FMAH 1

#ifndef FP_ILOGB0

#define FP_ILOGB0 INT_MIN

#endif

#ifndef FP_ILOGBNAN

#define FP_ILOGBNAN INT_MAX

#endif

#ifndef FP_SUBNORMAL

#define FP_SUBNORMAL 0

#endif

#ifndef FP_ZERO

#define FP_ZERO 1

#endif

#ifndef FP_NAN

#define FP_NAN 2

#endif

#ifndef FP_INFINITE

#define FP_INFINITE 3

#endif

#ifndef FP_NORMAL

#define FP_NORMAL 4

#endif

namespace half_float

{

class half;

#if HALF_ENABLE_CPP11_USER_LITERALS

/// Library-defined half-precision literals.

/// Import this namespace to enable half-precision floating point literals:

/// ~~~~{.cpp}

/// using namespace half_float::literal;

/// half_float::half = 4.2_h;

/// ~~~~

namespace literal

{

half operator""_h(long double);

}

#endif

/// \internal

/// \brief Implementation details.

namespace detail

{

#if HALF_ENABLE_CPP11_TYPE_TRAITS

/// Conditional type.

template<bool B,typename T,typename F> struct conditional : std::conditional<B,T,F> {};

/// Helper for tag dispatching.

template<bool B> struct bool_type : std::integral_constant<bool,B> {};

using std::true_type;

using std::false_type;

/// Type traits for floating point types.

template<typename T> struct is_float : std::is_floating_point<T> {};

#else

/// Conditional type.

template<bool,typename T,typename> struct conditional { typedef T type; };

template<typename T,typename F> struct conditional<false,T,F> { typedef F type; };

/// Helper for tag dispatching.

template<bool> struct bool_type {};

typedef bool_type<true> true_type;

typedef bool_type<false> false_type;

/// Type traits for floating point types.

template<typename> struct is_float : false_type {};

template<typename T> struct is_float<const T> : is_float<T> {};

template<typename T> struct is_float<volatile T> : is_float<T> {};

template<typename T> struct is_float<const volatile T> : is_float<T> {};

template<> struct is_float<float> : true_type {};

template<> struct is_float<double> : true_type {};

template<> struct is_float<long double> : true_type {};

#endif

/// Type traits for floating point bits.

template<typename T> struct bits { typedef unsigned char type; };

template<typename T> struct bits<const T> : bits<T> {};

template<typename T> struct bits<volatile T> : bits<T> {};

template<typename T> struct bits<const volatile T> : bits<T> {};

#if HALF_ENABLE_CPP11_CSTDINT

/// Unsigned integer of (at least) 16 bits width.

typedef std::uint_least16_t uint16;

/// Unsigned integer of (at least) 32 bits width.

template<> struct bits<float> { typedef std::uint_least32_t type; };

/// Unsigned integer of (at least) 64 bits width.

template<> struct bits<double> { typedef std::uint_least64_t type; };

#else

/// Unsigned integer of (at least) 16 bits width.

typedef unsigned short uint16;

/// Unsigned integer of (at least) 32 bits width.

template<> struct bits<float> : conditional<std::numeric_limits<unsigned int>::digits>=32,unsigned int,unsigned long> {};

#if HALF_ENABLE_CPP11_LONG_LONG

/// Unsigned integer of (at least) 64 bits width.

template<> struct bits<double> : conditional<std::numeric_limits<unsigned long>::digits>=64,unsigned long,unsigned long long> {};

#else

/// Unsigned integer of (at least) 64 bits width.

template<> struct bits<double> { typedef unsigned long type; };

#endif

#endif

/// Tag type for binary construction.

struct binary_t {};

/// Tag for binary construction.

HALF_CONSTEXPR_CONST binary_t binary = binary_t();

/// Temporary half-precision expression.

/// This class represents a half-precision expression which just stores a single-precision value internally.

struct expr

};

/// SFINAE helper for generic half-precision functions.

/// This class template has to be specialized for each valid combination of argument types to provide a corresponding

/// `type` member equivalent to \a T.

/// \tparam T type to return

template<typename T,typename,typename=void,typename=void> struct enable {};

template<typename T> struct enable<T,half,void,void> { typedef T type; };

template<typename T> struct enable<T,expr,void,void> { typedef T type; };

template<typename T> struct enable<T,half,half,void> { typedef T type; };

template<typename T> struct enable<T,half,expr,void> { typedef T type; };

template<typename T> struct enable<T,expr,half,void> { typedef T type; };

template<typename T> struct enable<T,expr,expr,void> { typedef T type; };

template<typename T> struct enable<T,half,half,half> { typedef T type; };

template<typename T> struct enable<T,half,half,expr> { typedef T type; };

template<typename T> struct enable<T,half,expr,half> { typedef T type; };

template<typename T> struct enable<T,half,expr,expr> { typedef T type; };

template<typename T> struct enable<T,expr,half,half> { typedef T type; };

template<typename T> struct enable<T,expr,half,expr> { typedef T type; };

template<typename T> struct enable<T,expr,expr,half> { typedef T type; };

template<typename T> struct enable<T,expr,expr,expr> { typedef T type; };

/// Return type for specialized generic 2-argument half-precision functions.

/// This class template has to be specialized for each valid combination of argument types to provide a corresponding

/// `type` member denoting the appropriate return type.

/// \tparam T first argument type

/// \tparam U first argument type

template<typename T,typename U> struct result : enable<expr,T,U> {};

template<> struct result<half,half> { typedef half type; };

/// \name Classification helpers

/// \{

/// Check for infinity.

/// \tparam T argument type (builtin floating point type)

/// \param arg value to query

/// \retval true if infinity

/// \retval false else

template<typename T> bool builtin_isinf(T arg)

}

/// Check for NaN.

/// \tparam T argument type (builtin floating point type)

/// \param arg value to query

/// \retval true if not a number

/// \retval false else

template<typename T> bool builtin_isnan(T arg)

}

/// Check sign.

/// \tparam T argument type (builtin floating point type)

/// \param arg value to query

/// \retval true if signbit set

/// \retval false else

template<typename T> bool builtin_signbit(T arg)

}

/// \}

/// \name Conversion

/// \{

/// Convert IEEE single-precision to half-precision.

/// Credit for this goes to [Jeroen van der Zijp](ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.pdf).

/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding

/// \param value single-precision value

/// \return binary representation of half-precision value

template<std::float_round_style R> uint16 float2half_impl(float value, true_type)

}

/// Convert IEEE double-precision to half-precision.

/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding

/// \param value double-precision value

/// \return binary representation of half-precision value

template<std::float_round_style R> uint16 float2half_impl(double value, true_type)

}

/// Convert non-IEEE floating point to half-precision.

/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding

/// \tparam T source type (builtin floating point type)

/// \param value floating point value

/// \return binary representation of half-precision value

template<std::float_round_style R,typename T> uint16 float2half_impl(T value, ...)

}

/// Convert floating point to half-precision.

/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding

/// \tparam T source type (builtin floating point type)

/// \param value floating point value

/// \return binary representation of half-precision value

template<std::float_round_style R,typename T> uint16 float2half(T value)

{

return float2half_impl<R>(value, bool_type<std::numeric_limits<T>::is_iec559&&sizeof(typename bits<T>::type)==sizeof(T)>());

}

/// Convert integer to half-precision floating point.

/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding

/// \tparam S `true` if value negative, `false` else

/// \tparam T type to convert (builtin integer type)

/// \param value non-negative integral value

/// \return binary representation of half-precision value

template<std::float_round_style R,bool S,typename T> uint16 int2half_impl(T value)

}

/// Convert integer to half-precision floating point.

/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding

/// \tparam T type to convert (builtin integer type)

/// \param value integral value

/// \return binary representation of half-precision value

template<std::float_round_style R,typename T> uint16 int2half(T value)

{

return (value<0) ? int2half_impl<R,true>(value) : int2half_impl<R,false>(value);

}

/// Convert half-precision to IEEE single-precision.

/// Credit for this goes to [Jeroen van der Zijp](ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.pdf).

/// \param value binary representation of half-precision value

/// \return single-precision value

inline float half2float_impl(uint16 value, float, true_type)