#include <utility>
#include <algorithm>
#include <istream>
#include <ostream>
#include <limits>
#include <stdexcept>
#include <climits>
#include <cmath>
#include <cstring>
#include <cstdlib>

Classes
struct	half_float::detail::conditional< bool, T, typename >
	Conditional type. More...
struct	half_float::detail::conditional< false, T, F >
struct	half_float::detail::bool_type< bool >
	Helper for tag dispatching. More...
struct	half_float::detail::is_float< typename >
	Type traits for floating-point types. More...
struct	half_float::detail::is_float< const T >
struct	half_float::detail::is_float< volatile T >
struct	half_float::detail::is_float< const volatile T >
struct	half_float::detail::is_float< float >
struct	half_float::detail::is_float< double >
struct	half_float::detail::is_float< long double >
struct	half_float::detail::bits< T >
	Type traits for floating-point bits. More...
struct	half_float::detail::bits< const T >
struct	half_float::detail::bits< volatile T >
struct	half_float::detail::bits< const volatile T >
struct	half_float::detail::bits< float >
	Unsigned integer of (at least) 32 bits width. More...
struct	half_float::detail::bits< double >
	Unsigned integer of (at least) 64 bits width. More...
struct	half_float::detail::binary_t
	Tag type for binary construction. More...
struct	half_float::detail::f31
	Class for 1.31 unsigned floating-point computation. More...
class	half_float::half
struct	half_float::detail::half_caster< T, U, R >
struct	half_float::detail::half_caster< half, U, R >
struct	half_float::detail::half_caster< T, half, R >
struct	half_float::detail::half_caster< half, half, R >
class	std::numeric_limits< half_float::half >

Namespaces
namespace	half_float
namespace	half_float::detail
namespace	std
	Extensions to the C++ standard library.

Macros
#define	HALF_GCC_VERSION (__GNUC__*100+__GNUC_MINOR__)
#define	HALF_ICC_VERSION 0
#define	HALF_ERRHANDLING (HALF_ERRHANDLING_FLAGS\|\|HALF_ERRHANDLING_ERRNO\|\|HALF_ERRHANDLING_FENV\|\|HALF_ERRHANDLING_THROWS)
#define	HALF_UNUSED_NOERR(name)
#define	HALF_CONSTEXPR
#define	HALF_CONSTEXPR_CONST const
#define	HALF_CONSTEXPR_NOERR
#define	HALF_NOEXCEPT
#define	HALF_NOTHROW throw()
#define	HALF_THREAD_LOCAL static
#define	HALF_ENABLE_F16C_INTRINSICS __F16C__
#define	HALF_ERRHANDLING_OVERFLOW_TO_INEXACT 1
#define	HALF_ERRHANDLING_UNDERFLOW_TO_INEXACT 1
#define	HALF_ROUND_STYLE 1
#define	HUGE_VALH std::numeric_limits<half_float::half>::infinity()
#define	FP_FAST_FMAH 1
#define	HLF_ROUNDS HALF_ROUND_STYLE
#define	FP_ILOGB0 INT_MIN
#define	FP_ILOGBNAN INT_MAX
#define	FP_SUBNORMAL 0
#define	FP_ZERO 1
#define	FP_NAN 2
#define	FP_INFINITE 3
#define	FP_NORMAL 4
#define	FE_INVALID 0x10
#define	FE_DIVBYZERO 0x08
#define	FE_OVERFLOW 0x04
#define	FE_UNDERFLOW 0x02
#define	FE_INEXACT 0x01
#define	FE_ALL_EXCEPT (FE_INVALID\|FE_DIVBYZERO\|FE_OVERFLOW\|FE_UNDERFLOW\|FE_INEXACT)

Typedefs
typedef bool_type< true >	half_float::detail::true_type
typedef bool_type< false >	half_float::detail::false_type
typedef unsigned short	half_float::detail::uint16
	Unsigned integer of (at least) 16 bits width.
typedef unsigned long	half_float::detail::uint32
	Fastest unsigned integer of (at least) 32 bits width.
typedef long	half_float::detail::int32
	Fastest unsigned integer of (at least) 32 bits width.

Functions
Implementation defined classification and arithmetic
template<typename T>
bool	half_float::detail::builtin_isinf (T arg)
template<typename T>
bool	half_float::detail::builtin_isnan (T arg)
template<typename T>
bool	half_float::detail::builtin_signbit (T arg)
uint32	half_float::detail::sign_mask (uint32 arg)
uint32	half_float::detail::arithmetic_shift (uint32 arg, int i)
Error handling
int &	half_float::detail::errflags ()
void	half_float::detail::raise (int, bool=true)
bool	half_float::detail::compsignal (unsigned int x, unsigned int y)
unsigned int	half_float::detail::signal (unsigned int nan)
unsigned int	half_float::detail::signal (unsigned int x, unsigned int y)
unsigned int	half_float::detail::signal (unsigned int x, unsigned int y, unsigned int z)
unsigned int	half_float::detail::select (unsigned int x, unsigned int)
unsigned int	half_float::detail::invalid ()
unsigned int	half_float::detail::pole (unsigned int sign=0)
unsigned int	half_float::detail::check_underflow (unsigned int arg)
Conversion and rounding
template<std::float_round_style R>
unsigned int	half_float::detail::overflow (unsigned int sign=0)
template<std::float_round_style R>
unsigned int	half_float::detail::underflow (unsigned int sign=0)
template<std::float_round_style R, bool I>
unsigned int	half_float::detail::rounded (unsigned int value, int g, int s)
template<std::float_round_style R, bool E, bool I>
unsigned int	half_float::detail::integral (unsigned int value)
template<std::float_round_style R, unsigned int F, bool S, bool N, bool I>
unsigned int	half_float::detail::fixed2half (uint32 m, int exp=14, unsigned int sign=0, int s=0)
template<std::float_round_style R>
unsigned int	half_float::detail::float2half_impl (float value, true_type)
template<std::float_round_style R>
unsigned int	half_float::detail::float2half_impl (double value, true_type)
template<std::float_round_style R, typename T>
unsigned int	half_float::detail::float2half_impl (T value,...)
template<std::float_round_style R, typename T>
unsigned int	half_float::detail::float2half (T value)
template<std::float_round_style R, typename T>
unsigned int	half_float::detail::int2half (T value)
float	half_float::detail::half2float_impl (unsigned int value, float, true_type)
double	half_float::detail::half2float_impl (unsigned int value, double, true_type)
template<typename T>
T	half_float::detail::half2float_impl (unsigned int value, T,...)
template<typename T>
T	half_float::detail::half2float (unsigned int value)
template<std::float_round_style R, bool E, bool I, typename T>
T	half_float::detail::half2int (unsigned int value)
Mathematics
template<std::float_round_style R>
uint32	half_float::detail::mulhi (uint32 x, uint32 y)
uint32	half_float::detail::multiply64 (uint32 x, uint32 y)
uint32	half_float::detail::divide64 (uint32 x, uint32 y, int &s)
template<bool Q, bool R>
unsigned int	half_float::detail::mod (unsigned int x, unsigned int y, int *quo=NULL)
template<unsigned int F>
uint32	half_float::detail::sqrt (uint32 &r, int &exp)
uint32	half_float::detail::exp2 (uint32 m, unsigned int n=32)
uint32	half_float::detail::log2 (uint32 m, unsigned int n=32)
std::pair< uint32, uint32 >	half_float::detail::sincos (uint32 mz, unsigned int n=31)
uint32	half_float::detail::atan2 (uint32 my, uint32 mx, unsigned int n=31)
uint32	half_float::detail::angle_arg (unsigned int abs, int &k)
std::pair< uint32, uint32 >	half_float::detail::atan2_args (unsigned int abs)
std::pair< uint32, uint32 >	half_float::detail::hyperbolic_args (unsigned int abs, int &exp, unsigned int n=32)
template<std::float_round_style R>
unsigned int	half_float::detail::exp2_post (uint32 m, int exp, bool esign, unsigned int sign=0, unsigned int n=32)
template<std::float_round_style R, uint32 L>
unsigned int	half_float::detail::log2_post (uint32 m, int ilog, int exp, unsigned int sign=0)
template<std::float_round_style R>
unsigned int	half_float::detail::hypot_post (uint32 r, int exp)
template<std::float_round_style R>
unsigned int	half_float::detail::tangent_post (uint32 my, uint32 mx, int exp, unsigned int sign=0)
template<std::float_round_style R, bool S>
unsigned int	half_float::detail::area (unsigned int arg)
template<std::float_round_style R, bool C>
unsigned int	half_float::detail::erf (unsigned int arg)
template<std::float_round_style R, bool L>
unsigned int	half_float::detail::gamma (unsigned int arg)
Comparison operators

bool	half_float::operator== (half x, half y)
bool	half_float::operator!= (half x, half y)
bool	half_float::operator< (half x, half y)
bool	half_float::operator> (half x, half y)
bool	half_float::operator<= (half x, half y)
bool	half_float::operator>= (half x, half y)
Arithmetic operators

half	half_float::operator+ (half arg)
half	half_float::operator- (half arg)
half	half_float::operator+ (half x, half y)
half	half_float::operator- (half x, half y)
half	half_float::operator* (half x, half y)
half	half_float::operator/ (half x, half y)
Input and output

template<typename charT, typename traits>
std::basic_ostream< charT, traits > &	half_float::operator<< (std::basic_ostream< charT, traits > &out, half arg)
template<typename charT, typename traits>
std::basic_istream< charT, traits > &	half_float::operator>> (std::basic_istream< charT, traits > &in, half &arg)
Basic mathematical operations

half	half_float::fabs (half arg)
half	half_float::abs (half arg)
half	half_float::fmod (half x, half y)
half	half_float::remainder (half x, half y)
half	half_float::remquo (half x, half y, int *quo)
half	half_float::fma (half x, half y, half z)
half	half_float::fmax (half x, half y)
half	half_float::fmin (half x, half y)
half	half_float::fdim (half x, half y)
half	half_float::nanh (const char *arg)
Exponential functions

half	half_float::exp (half arg)
half	half_float::exp2 (half arg)
half	half_float::expm1 (half arg)
half	half_float::log (half arg)
half	half_float::log10 (half arg)
half	half_float::log2 (half arg)
half	half_float::log1p (half arg)
Power functions

half	half_float::sqrt (half arg)
half	half_float::rsqrt (half arg)
half	half_float::cbrt (half arg)
half	half_float::hypot (half x, half y)
half	half_float::hypot (half x, half y, half z)
half	half_float::pow (half x, half y)
Trigonometric functions

void	half_float::sincos (half arg, half sin, half cos)
half	half_float::sin (half arg)
half	half_float::cos (half arg)
half	half_float::tan (half arg)
half	half_float::asin (half arg)
half	half_float::acos (half arg)
half	half_float::atan (half arg)
half	half_float::atan2 (half y, half x)
Hyperbolic functions

half	half_float::sinh (half arg)
half	half_float::cosh (half arg)
half	half_float::tanh (half arg)
half	half_float::asinh (half arg)
half	half_float::acosh (half arg)
half	half_float::atanh (half arg)
Error and gamma functions

half	half_float::erf (half arg)
half	half_float::erfc (half arg)
half	half_float::lgamma (half arg)
half	half_float::tgamma (half arg)
Rounding

half	half_float::ceil (half arg)
half	half_float::floor (half arg)
half	half_float::trunc (half arg)
half	half_float::round (half arg)
long	half_float::lround (half arg)
half	half_float::rint (half arg)
long	half_float::lrint (half arg)
half	half_float::nearbyint (half arg)
Floating point manipulation

half	half_float::frexp (half arg, int *exp)
half	half_float::scalbln (half arg, long exp)
half	half_float::scalbn (half arg, int exp)
half	half_float::ldexp (half arg, int exp)
half	half_float::modf (half arg, half *iptr)
int	half_float::ilogb (half arg)
half	half_float::logb (half arg)
half	half_float::nextafter (half from, half to)
half	half_float::nexttoward (half from, long double to)
half	half_float::copysign (half x, half y)
Floating point classification

int	half_float::fpclassify (half arg)
bool	half_float::isfinite (half arg)
bool	half_float::isinf (half arg)
bool	half_float::isnan (half arg)
bool	half_float::isnormal (half arg)
bool	half_float::signbit (half arg)
Comparison

bool	half_float::isgreater (half x, half y)
bool	half_float::isgreaterequal (half x, half y)
bool	half_float::isless (half x, half y)
bool	half_float::islessequal (half x, half y)
bool	half_float::islessgreater (half x, half y)
bool	half_float::isunordered (half x, half y)
Casting

template<typename T, typename U>
T	half_float::half_cast (U arg)
template<typename T, std::float_round_style R, typename U>
T	half_float::half_cast (U arg)
Error handling

int	half_float::feclearexcept (int excepts)
int	half_float::fetestexcept (int excepts)
int	half_float::feraiseexcept (int excepts)
int	half_float::fegetexceptflag (int *flagp, int excepts)
int	half_float::fesetexceptflag (const int *flagp, int excepts)
void	half_float::fethrowexcept (int excepts, const char *msg="")

Variables
const binary_t	half_float::detail::binary = binary_t()
	Tag for binary construction.

Detailed Description

Main header file for half-precision functionality.

Macro Definition Documentation

◆ FE_ALL_EXCEPT

#define FE_ALL_EXCEPT (FE_INVALID|FE_DIVBYZERO|FE_OVERFLOW|FE_UNDERFLOW|FE_INEXACT)

◆ FE_DIVBYZERO

#define FE_DIVBYZERO 0x08

◆ FE_INEXACT

#define FE_INEXACT 0x01

◆ FE_INVALID

#define FE_INVALID 0x10

◆ FE_OVERFLOW

#define FE_OVERFLOW 0x04

◆ FE_UNDERFLOW

#define FE_UNDERFLOW 0x02

◆ FP_FAST_FMAH

#define FP_FAST_FMAH 1

Fast half-precision fma function. This symbol is defined if the fma() function generally executes as fast as, or faster than, a separate half-precision multiplication followed by an addition, which is always the case.

See also: Documentation for FP_FAST_FMA

◆ FP_ILOGB0

#define FP_ILOGB0 INT_MIN

◆ FP_ILOGBNAN

#define FP_ILOGBNAN INT_MAX

◆ FP_INFINITE

#define FP_INFINITE 3

◆ FP_NAN

#define FP_NAN 2

◆ FP_NORMAL

#define FP_NORMAL 4

◆ FP_SUBNORMAL

#define FP_SUBNORMAL 0

◆ FP_ZERO

#define FP_ZERO 1

◆ HALF_CONSTEXPR

#define HALF_CONSTEXPR

◆ HALF_CONSTEXPR_CONST

#define HALF_CONSTEXPR_CONST const

◆ HALF_CONSTEXPR_NOERR

#define HALF_CONSTEXPR_NOERR

◆ HALF_ENABLE_F16C_INTRINSICS

#define HALF_ENABLE_F16C_INTRINSICS __F16C__

Enable F16C intruction set intrinsics. Defining this to 1 enables the use of F16C compiler intrinsics for converting between half-precision and single-precision values which may result in improved performance. This will not perform additional checks for support of the F16C instruction set, so an appropriate target platform is required when enabling this feature.

Unless predefined it will be enabled automatically when the __F16C__ symbol is defined, which some compilers do on supporting platforms.

◆ HALF_ERRHANDLING

#define HALF_ERRHANDLING (HALF_ERRHANDLING_FLAGS||HALF_ERRHANDLING_ERRNO||HALF_ERRHANDLING_FENV||HALF_ERRHANDLING_THROWS)

◆ HALF_ERRHANDLING_OVERFLOW_TO_INEXACT

#define HALF_ERRHANDLING_OVERFLOW_TO_INEXACT 1

Raise INEXACT exception on overflow. Defining this to 1 (default) causes overflow errors to also raise inexact exceptions. These will be raised after any possible handling of the underflow exception.

◆ HALF_ERRHANDLING_UNDERFLOW_TO_INEXACT

#define HALF_ERRHANDLING_UNDERFLOW_TO_INEXACT 1

Raise INEXACT exception on underflow. Defining this to 1 (default) causes underflow errors to also raise inexact exceptions. These will be raised after any possible handling of the underflow exception.

Note: This will actually cause underflow (and the accompanying inexact) exceptions to be raised only when the result is inexact, while if disabled bare underflow errors will be raised for any (possibly exact) subnormal result.

◆ HALF_GCC_VERSION

#define HALF_GCC_VERSION (__GNUC__*100+__GNUC_MINOR__)

◆ HALF_ICC_VERSION

#define HALF_ICC_VERSION 0

◆ HALF_NOEXCEPT

#define HALF_NOEXCEPT

◆ HALF_NOTHROW

#define HALF_NOTHROW throw()

◆ HALF_ROUND_STYLE

#define HALF_ROUND_STYLE 1

Default rounding mode. This specifies the rounding mode used for all conversions between halfs and more precise types (unless using half_cast() and specifying the rounding mode directly) as well as in arithmetic operations and mathematical functions. It can be redefined (before including half.hpp) to one of the standard rounding modes using their respective constants or the equivalent values of std::float_round_style:

std::float_round_style	value	rounding
std::round_indeterminate	-1	fastest
std::round_toward_zero	0	toward zero
std::round_to_nearest	1	to nearest (default)
std::round_toward_infinity	2	toward positive infinity
std::round_toward_neg_infinity	3	toward negative infinity

By default this is set to 1 (std::round_to_nearest), which rounds results to the nearest representable value. It can even be set to std::numeric_limits<float>::round_style to synchronize the rounding mode with that of the built-in single-precision implementation (which is likely std::round_to_nearest, though).

◆ HALF_THREAD_LOCAL

#define HALF_THREAD_LOCAL static

◆ HALF_UNUSED_NOERR

#define HALF_UNUSED_NOERR ( name )

◆ HLF_ROUNDS

#define HLF_ROUNDS HALF_ROUND_STYLE

Half rounding mode. In correspondence with FLT_ROUNDS from <cfloat> this symbol expands to the rounding mode used for half-precision operations. It is an alias for HALF_ROUND_STYLE.

See also: Documentation for FLT_ROUNDS

◆ HUGE_VALH

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

Value signaling overflow. In correspondence with HUGE_VAL[F|L] from <cmath> this symbol expands to a positive value signaling the overflow of an operation, in particular it just evaluates to positive infinity.

See also: Documentation for HUGE_VAL

Classes

Namespaces

Macros

Typedefs

Functions

Variables