half_float::detail Namespace Reference

Classes
struct	binary_specialized
struct	binary_specialized< half, half >
struct	binary_t
	Tag type for binary construction. More...
struct	bits
	Type traits for floating point bits. More...
struct	bits< const T >
struct	bits< const volatile T >
struct	bits< double >
	Unsigned integer of (at least) 64 bits width. More...
struct	bits< float >
	Unsigned integer of (at least) 32 bits width. More...
struct	bits< volatile T >
struct	bool_type
	Helper for tag dispatching. More...
struct	conditional
	Conditional type. More...
struct	conditional< false, T, F >
struct	enable
struct	enable< T, expr, expr, expr >
struct	enable< T, expr, expr, half >
struct	enable< T, expr, expr, void >
struct	enable< T, expr, half, expr >
struct	enable< T, expr, half, half >
struct	enable< T, expr, half, void >
struct	enable< T, expr, void, void >
struct	enable< T, half, expr, expr >
struct	enable< T, half, expr, half >
struct	enable< T, half, expr, void >
struct	enable< T, half, half, expr >
struct	enable< T, half, half, half >
struct	enable< T, half, half, void >
struct	enable< T, half, void, void >
struct	expr
struct	functions
	Wrapper implementing unspecialized half-precision functions. More...
struct	half_caster
struct	half_caster< half, expr, R >
struct	half_caster< half, half, R >
struct	half_caster< half, U, R >
struct	half_caster< T, expr, R >
struct	half_caster< T, half, R >
struct	is_float
	Type traits for floating point types. More...
struct	is_float< const T >
struct	is_float< const volatile T >
struct	is_float< double >
struct	is_float< float >
struct	is_float< long double >
struct	is_float< volatile T >
struct	result
struct	result< half, half >
struct	unary_specialized
struct	unary_specialized< expr >

Typedefs
typedef bool_type< true >	true_type
typedef bool_type< false >	false_type
typedef unsigned short	uint16
	Unsigned integer of (at least) 16 bits width.

Functions
Classification helpers
template<typename T >
bool	builtin_isinf (T arg)
template<typename T >
bool	builtin_isnan (T arg)
template<typename T >
bool	builtin_signbit (T arg)
Conversion
template<std::float_round_style R>
uint16	float2half_impl (float value, true_type)
template<std::float_round_style R>
uint16	float2half_impl (double value, true_type)
template<std::float_round_style R, typename T >
uint16	float2half_impl (T value,...)
template<std::float_round_style R, typename T >
uint16	float2half (T value)
template<std::float_round_style R, bool S, typename T >
uint16	int2half_impl (T value)
template<std::float_round_style R, typename T >
uint16	int2half (T value)
float	half2float_impl (uint16 value, float, true_type)
double	half2float_impl (uint16 value, double, true_type)
template<typename T >
T	half2float_impl (uint16 value, T,...)
template<typename T >
T	half2float (uint16 value)
template<std::float_round_style R, bool E, typename T >
T	half2int_impl (uint16 value)
template<std::float_round_style R, typename T >
T	half2int (uint16 value)
template<typename T >
T	half2int_up (uint16 value)
template<std::float_round_style R, bool E>
uint16	round_half_impl (uint16 value)
template<std::float_round_style R>
uint16	round_half (uint16 value)
uint16	round_half_up (uint16 value)
Comparison operators
template<typename T , typename U >
enable< bool, T, U >::type	operator== (T x, U y)
template<typename T , typename U >
enable< bool, T, U >::type	operator!= (T x, U y)
template<typename T , typename U >
enable< bool, T, U >::type	operator< (T x, U y)
template<typename T , typename U >
enable< bool, T, U >::type	operator> (T x, U y)
template<typename T , typename U >
enable< bool, T, U >::type	operator<= (T x, U y)
template<typename T , typename U >
enable< bool, T, U >::type	operator>= (T x, U y)
Arithmetic operators
template<typename T , typename U >
enable< expr, T, U >::type	operator+ (T x, U y)
template<typename T , typename U >
enable< expr, T, U >::type	operator- (T x, U y)
template<typename T , typename U >
enable< expr, T, U >::type	operator* (T x, U y)
template<typename T , typename U >
enable< expr, T, U >::type	operator/ (T x, U y)
template<typename T >
HALF_CONSTEXPR enable< T, T >::type	operator+ (T arg)
template<typename T >
HALF_CONSTEXPR enable< T, T >::type	operator- (T arg)
Input and output
template<typename T , typename charT , typename traits >
enable< std::basic_ostream< charT, traits > &, T >::type	operator<< (std::basic_ostream< charT, traits > &out, T arg)
template<typename charT , typename traits >
std::basic_istream< charT, traits > &	operator>> (std::basic_istream< charT, traits > &in, half &arg)
Basic mathematical operations
half	abs (half arg)
expr	abs (expr arg)
half	fabs (half arg)
expr	fabs (expr arg)
expr	fmod (half x, half y)
expr	fmod (half x, expr y)
expr	fmod (expr x, half y)
expr	fmod (expr x, expr y)
expr	remainder (half x, half y)
expr	remainder (half x, expr y)
expr	remainder (expr x, half y)
expr	remainder (expr x, expr y)
expr	remquo (half x, half y, int *quo)
expr	remquo (half x, expr y, int *quo)
expr	remquo (expr x, half y, int *quo)
expr	remquo (expr x, expr y, int *quo)
expr	fma (half x, half y, half z)
expr	fma (half x, half y, expr z)
expr	fma (half x, expr y, half z)
expr	fma (half x, expr y, expr z)
expr	fma (expr x, half y, half z)
expr	fma (expr x, half y, expr z)
expr	fma (expr x, expr y, half z)
expr	fma (expr x, expr y, expr z)
half	fmax (half x, half y)
expr	fmax (half x, expr y)
expr	fmax (expr x, half y)
expr	fmax (expr x, expr y)
half	fmin (half x, half y)
expr	fmin (half x, expr y)
expr	fmin (expr x, half y)
expr	fmin (expr x, expr y)
expr	fdim (half x, half y)
expr	fdim (half x, expr y)
expr	fdim (expr x, half y)
expr	fdim (expr x, expr y)
half	nanh (const char *)
Exponential functions
expr	exp (half arg)
expr	exp (expr arg)
expr	expm1 (half arg)
expr	expm1 (expr arg)
expr	exp2 (half arg)
expr	exp2 (expr arg)
expr	log (half arg)
expr	log (expr arg)
expr	log10 (half arg)
expr	log10 (expr arg)
expr	log1p (half arg)
expr	log1p (expr arg)
expr	log2 (half arg)
expr	log2 (expr arg)
Power functions
expr	sqrt (half arg)
expr	sqrt (expr arg)
expr	cbrt (half arg)
expr	cbrt (expr arg)
expr	hypot (half x, half y)
expr	hypot (half x, expr y)
expr	hypot (expr x, half y)
expr	hypot (expr x, expr y)
expr	pow (half base, half exp)
expr	pow (half base, expr exp)
expr	pow (expr base, half exp)
expr	pow (expr base, expr exp)
Trigonometric functions
expr	sin (half arg)
expr	sin (expr arg)
expr	cos (half arg)
expr	cos (expr arg)
expr	tan (half arg)
expr	tan (expr arg)
expr	asin (half arg)
expr	asin (expr arg)
expr	acos (half arg)
expr	acos (expr arg)
expr	atan (half arg)
expr	atan (expr arg)
expr	atan2 (half x, half y)
expr	atan2 (half x, expr y)
expr	atan2 (expr x, half y)
expr	atan2 (expr x, expr y)
Hyperbolic functions
expr	sinh (half arg)
expr	sinh (expr arg)
expr	cosh (half arg)
expr	cosh (expr arg)
expr	tanh (half arg)
expr	tanh (expr arg)
expr	asinh (half arg)
expr	asinh (expr arg)
expr	acosh (half arg)
expr	acosh (expr arg)
expr	atanh (half arg)
expr	atanh (expr arg)
Error and gamma functions
expr	erf (half arg)
expr	erf (expr arg)
expr	erfc (half arg)
expr	erfc (expr arg)
expr	lgamma (half arg)
expr	lgamma (expr arg)
expr	tgamma (half arg)
expr	tgamma (expr arg)
Rounding
half	ceil (half arg)
half	ceil (expr arg)
half	floor (half arg)
half	floor (expr arg)
half	trunc (half arg)
half	trunc (expr arg)
half	round (half arg)
half	round (expr arg)
long	lround (half arg)
long	lround (expr arg)
half	nearbyint (half arg)
half	nearbyint (expr arg)
half	rint (half arg)
half	rint (expr arg)
long	lrint (half arg)
long	lrint (expr arg)
Floating point manipulation
half	frexp (half arg, int *exp)
half	frexp (expr arg, int *exp)
half	ldexp (half arg, int exp)
half	ldexp (expr arg, int exp)
half	modf (half arg, half *iptr)
half	modf (expr arg, half *iptr)
half	scalbn (half arg, int exp)
half	scalbn (expr arg, int exp)
half	scalbln (half arg, long exp)
half	scalbln (expr arg, long exp)
int	ilogb (half arg)
int	ilogb (expr arg)
half	logb (half arg)
half	logb (expr arg)
half	nextafter (half from, half to)
half	nextafter (half from, expr to)
half	nextafter (expr from, half to)
half	nextafter (expr from, expr to)
half	nexttoward (half from, long double to)
half	nexttoward (expr from, long double to)
half	copysign (half x, half y)
half	copysign (half x, expr y)
half	copysign (expr x, half y)
half	copysign (expr x, expr y)
Floating point classification
int	fpclassify (half arg)
int	fpclassify (expr arg)
bool	isfinite (half arg)
bool	isfinite (expr arg)
bool	isinf (half arg)
bool	isinf (expr arg)
bool	isnan (half arg)
bool	isnan (expr arg)
bool	isnormal (half arg)
bool	isnormal (expr arg)
bool	signbit (half arg)
bool	signbit (expr arg)
Comparison
bool	isgreater (half x, half y)
bool	isgreater (half x, expr y)
bool	isgreater (expr x, half y)
bool	isgreater (expr x, expr y)
bool	isgreaterequal (half x, half y)
bool	isgreaterequal (half x, expr y)
bool	isgreaterequal (expr x, half y)
bool	isgreaterequal (expr x, expr y)
bool	isless (half x, half y)
bool	isless (half x, expr y)
bool	isless (expr x, half y)
bool	isless (expr x, expr y)
bool	islessequal (half x, half y)
bool	islessequal (half x, expr y)
bool	islessequal (expr x, half y)
bool	islessequal (expr x, expr y)
bool	islessgreater (half x, half y)
bool	islessgreater (half x, expr y)
bool	islessgreater (expr x, half y)
bool	islessgreater (expr x, expr y)
bool	isunordered (half x, half y)
bool	isunordered (half x, expr y)
bool	isunordered (expr x, half y)
bool	isunordered (expr x, expr y)
Casting
template<typename T , typename U >
T	half_cast (U arg)
template<typename T , std::float_round_style R, typename U >
T	half_cast (U arg)

Variables
HALF_CONSTEXPR_CONST binary_t	binary = binary_t()
	Tag for binary construction.

Typedef Documentation

false_type

typedef bool_type<false> half_float::detail::false_type

true_type

typedef bool_type<true> half_float::detail::true_type

uint16

typedef unsigned short half_float::detail::uint16

Unsigned integer of (at least) 16 bits width.

Function Documentation

abs() [1/2]

expr half_float::detail::abs ( expr arg )

inline

abs() [2/2]

half half_float::detail::abs ( half arg )

inline

Absolute value.

Parameters

arg

operand

Returns

absolute value of arg

acos() [1/2]

expr half_float::detail::acos ( expr arg )

inline

acos() [2/2]

expr half_float::detail::acos ( half arg )

inline

Arc cosine function.

Parameters

arg	function argument

Returns

arc cosine value of arg

acosh() [1/2]

expr half_float::detail::acosh ( expr arg )

inline

acosh() [2/2]

expr half_float::detail::acosh ( half arg )

inline

Hyperbolic area cosine.

Parameters

arg	function argument

Returns

area cosine value of arg

asin() [1/2]

expr half_float::detail::asin ( expr arg )

inline

asin() [2/2]

expr half_float::detail::asin ( half arg )

inline

Arc sine.

Parameters

arg	function argument

Returns

arc sine value of arg

asinh() [1/2]

expr half_float::detail::asinh ( expr arg )

inline

asinh() [2/2]

expr half_float::detail::asinh ( half arg )

inline

Hyperbolic area sine.

Parameters

arg	function argument

Returns

area sine value of arg

atan() [1/2]

expr half_float::detail::atan ( expr arg )

inline

atan() [2/2]

expr half_float::detail::atan ( half arg )

inline

Arc tangent function.

Parameters

arg	function argument

Returns

arc tangent value of arg

atan2() [1/4]

expr half_float::detail::atan2 ( expr x, expr y )

inline

atan2() [2/4]

expr half_float::detail::atan2 ( expr x, half y )

inline

atan2() [3/4]

expr half_float::detail::atan2 ( half x, expr y )

inline

atan2() [4/4]

expr half_float::detail::atan2 ( half x, half y )

inline

Arc tangent function.

Parameters

x	first argument
y	second argument

Returns

arc tangent value

atanh() [1/2]

expr half_float::detail::atanh ( expr arg )

inline

atanh() [2/2]

expr half_float::detail::atanh ( half arg )

inline

Hyperbolic area tangent.

Parameters

arg	function argument

Returns

area tangent value of arg

builtin_isinf()

template<typename T >

bool half_float::detail::builtin_isinf

(

T

arg

)

Check for infinity.

Template Parameters

T	argument type (builtin floating point type)

Parameters

arg	value to query

Return values

true	if infinity
false	else

builtin_isnan()

template<typename T >

bool half_float::detail::builtin_isnan

(

T

arg

)

Check for NaN.

Template Parameters

T	argument type (builtin floating point type)

Parameters

arg	value to query

Return values

true	if not a number
false	else

builtin_signbit()

template<typename T >

bool half_float::detail::builtin_signbit

(

T

arg

)

Check sign.

Template Parameters

T	argument type (builtin floating point type)

Parameters

arg	value to query

Return values

true	if signbit set
false	else

cbrt() [1/2]

expr half_float::detail::cbrt ( expr arg )

inline

cbrt() [2/2]

expr half_float::detail::cbrt ( half arg )

inline

Cubic root.

Parameters

arg	function argument

Returns

cubic root of arg

ceil() [1/2]

half half_float::detail::ceil ( expr arg )

inline

ceil() [2/2]

half half_float::detail::ceil ( half arg )

inline

Nearest integer not less than half value.

Parameters

arg	half to round

Returns

nearest integer not less than arg

copysign() [1/4]

half half_float::detail::copysign ( expr x, expr y )

inline

copysign() [2/4]

half half_float::detail::copysign ( expr x, half y )

inline

copysign() [3/4]

half half_float::detail::copysign ( half x, expr y )

inline

copysign() [4/4]

half half_float::detail::copysign ( half x, half y )

inline

Take sign.

Parameters

x	value to change sign for
y	value to take sign from

Returns

value equal to x in magnitude and to y in sign

cos() [1/2]

expr half_float::detail::cos ( expr arg )

inline

cos() [2/2]

expr half_float::detail::cos ( half arg )

inline

Cosine function.

Parameters

arg	function argument

Returns

cosine value of arg

cosh() [1/2]

expr half_float::detail::cosh ( expr arg )

inline

cosh() [2/2]

expr half_float::detail::cosh ( half arg )

inline

Hyperbolic cosine.

Parameters

arg	function argument

Returns

hyperbolic cosine value of arg

erf() [1/2]

expr half_float::detail::erf ( expr arg )

inline

erf() [2/2]

expr half_float::detail::erf ( half arg )

inline

Error function.

Parameters

arg	function argument

Returns

error function value of arg

erfc() [1/2]

expr half_float::detail::erfc ( expr arg )

inline

erfc() [2/2]

expr half_float::detail::erfc ( half arg )

inline

Complementary error function.

Parameters

arg	function argument

Returns

1 minus error function value of arg

exp() [1/2]

expr half_float::detail::exp ( expr arg )

inline

exp() [2/2]

expr half_float::detail::exp ( half arg )

inline

Exponential function.

Parameters

arg	function argument

Returns

e raised to arg

exp2() [1/2]

expr half_float::detail::exp2 ( expr arg )

inline

exp2() [2/2]

expr half_float::detail::exp2 ( half arg )

inline

Binary exponential.

Parameters

arg	function argument

Returns

2 raised to arg

expm1() [1/2]

expr half_float::detail::expm1 ( expr arg )

inline

expm1() [2/2]

expr half_float::detail::expm1 ( half arg )

inline

Exponential minus one.

Parameters

arg	function argument

Returns

e raised to arg subtracted by 1

fabs() [1/2]

expr half_float::detail::fabs ( expr arg )

inline

fabs() [2/2]

half half_float::detail::fabs ( half arg )

inline

Absolute value.

Parameters

arg

operand

Returns

absolute value of arg

fdim() [1/4]

expr half_float::detail::fdim ( expr x, expr y )

inline

fdim() [2/4]

expr half_float::detail::fdim ( expr x, half y )

inline

fdim() [3/4]

expr half_float::detail::fdim ( half x, expr y )

inline

fdim() [4/4]

expr half_float::detail::fdim ( half x, half y )

inline

Positive difference.

Parameters

x	first operand
y	second operand

Returns

x - y or 0 if difference negative

float2half()

template<std::float_round_style R, typename T >

uint16 half_float::detail::float2half

(

T

value

)

Convert floating point to half-precision.

Template Parameters

R	rounding mode to use, std::round_indeterminate for fastest rounding
T	source type (builtin floating point type)

Parameters

value

floating point value

Returns

binary representation of half-precision value

float2half_impl() [1/3]

template<std::float_round_style R>

uint16 half_float::detail::float2half_impl	(	double	value,
		true_type	)

Convert IEEE double-precision to half-precision.

Template Parameters

R	rounding mode to use, std::round_indeterminate for fastest rounding

Parameters

value

double-precision value

Returns

binary representation of half-precision value

float2half_impl() [2/3]

template<std::float_round_style R>

uint16 half_float::detail::float2half_impl	(	float	value,
		true_type	)

Convert IEEE single-precision to half-precision. Credit for this goes to Jeroen van der Zijp.

Template Parameters

R	rounding mode to use, std::round_indeterminate for fastest rounding

Parameters

value

single-precision value

Returns

binary representation of half-precision value

float2half_impl() [3/3]

template<std::float_round_style R, typename T >

uint16 half_float::detail::float2half_impl	(	T	value,
			... )

Convert non-IEEE floating point to half-precision.

Template Parameters

R	rounding mode to use, std::round_indeterminate for fastest rounding
T	source type (builtin floating point type)

Parameters

value

floating point value

Returns

binary representation of half-precision value

floor() [1/2]

half half_float::detail::floor ( expr arg )

inline

floor() [2/2]

half half_float::detail::floor ( half arg )

inline

Nearest integer not greater than half value.

Parameters

arg	half to round

Returns

nearest integer not greater than arg

fma() [1/8]

expr half_float::detail::fma ( expr x, expr y, expr z )

inline

fma() [2/8]

expr half_float::detail::fma ( expr x, expr y, half z )

inline

fma() [3/8]

expr half_float::detail::fma ( expr x, half y, expr z )

inline

fma() [4/8]

expr half_float::detail::fma ( expr x, half y, half z )

inline

fma() [5/8]

expr half_float::detail::fma ( half x, expr y, expr z )

inline

fma() [6/8]

expr half_float::detail::fma ( half x, expr y, half z )

inline

fma() [7/8]

expr half_float::detail::fma ( half x, half y, expr z )

inline

fma() [8/8]

expr half_float::detail::fma ( half x, half y, half z )

inline

Fused multiply add.

Parameters

x	first operand
y	second operand
z	third operand

Returns

( x * y ) + z rounded as one operation.

fmax() [1/4]

expr half_float::detail::fmax ( expr x, expr y )

inline

fmax() [2/4]

expr half_float::detail::fmax ( expr x, half y )

inline

fmax() [3/4]

expr half_float::detail::fmax ( half x, expr y )

inline

fmax() [4/4]

half half_float::detail::fmax ( half x, half y )

inline

Maximum of half expressions.

Parameters

x	first operand
y	second operand

Returns

maximum of operands

fmin() [1/4]

expr half_float::detail::fmin ( expr x, expr y )

inline

fmin() [2/4]

expr half_float::detail::fmin ( expr x, half y )

inline

fmin() [3/4]

expr half_float::detail::fmin ( half x, expr y )

inline

fmin() [4/4]

half half_float::detail::fmin ( half x, half y )

inline

Minimum of half expressions.

Parameters

x	first operand
y	second operand

Returns

minimum of operands

fmod() [1/4]

expr half_float::detail::fmod ( expr x, expr y )

inline

fmod() [2/4]

expr half_float::detail::fmod ( expr x, half y )

inline

fmod() [3/4]

expr half_float::detail::fmod ( half x, expr y )

inline

fmod() [4/4]

expr half_float::detail::fmod ( half x, half y )

inline

Remainder of division.

Parameters

x	first operand
y	second operand

Returns

remainder of floating point division.

fpclassify() [1/2]

int half_float::detail::fpclassify ( expr arg )

inline

fpclassify() [2/2]

int half_float::detail::fpclassify ( half arg )

inline

Classify floating point value.

Parameters

arg	number to classify

Return values

FP_ZERO	for positive and negative zero
FP_SUBNORMAL	for subnormal numbers
FP_INFINITY	for positive and negative infinity
FP_NAN	for NaNs
FP_NORMAL	for all other (normal) values

frexp() [1/2]

half half_float::detail::frexp ( expr arg, int * exp )

inline

frexp() [2/2]

half half_float::detail::frexp ( half arg, int * exp )

inline

Decompress floating point number.

Parameters

arg	number to decompress
exp	address to store exponent at

Returns

significant in range [0.5, 1)

half2float()

template<typename T >

T half_float::detail::half2float

(

uint16

value

)

Convert half-precision to floating point.

Template Parameters

T	type to convert to (builtin integer type)

Parameters

value

binary representation of half-precision value

Returns

floating point value

half2float_impl() [1/3]

double half_float::detail::half2float_impl ( uint16 value, double , true_type  )

inline

Convert half-precision to IEEE double-precision.

Parameters

value

binary representation of half-precision value

Returns

double-precision value

half2float_impl() [2/3]

float half_float::detail::half2float_impl ( uint16 value, float , true_type  )

inline

Convert half-precision to IEEE single-precision. Credit for this goes to Jeroen van der Zijp.

Parameters

value

binary representation of half-precision value

Returns

single-precision value

half2float_impl() [3/3]

template<typename T >

T half_float::detail::half2float_impl	(	uint16	value,
		T	,
			... )

Convert half-precision to non-IEEE floating point.

Template Parameters

T	type to convert to (builtin integer type)

Parameters

value

binary representation of half-precision value

Returns

floating point value

half2int()

template<std::float_round_style R, typename T >

T half_float::detail::half2int

(

uint16

value

)

Convert half-precision floating point to integer.

Template Parameters

R	rounding mode to use, std::round_indeterminate for fastest rounding
T	type to convert to (buitlin integer type with at least 16 bits precision, excluding any implicit sign bits)

Parameters

value

binary representation of half-precision value

Returns

integral value

half2int_impl()

template<std::float_round_style R, bool E, typename T >

T half_float::detail::half2int_impl

(

uint16

value

)

Convert half-precision floating point to integer.

Template Parameters

R	rounding mode to use, std::round_indeterminate for fastest rounding
E	true for round to even, false for round away from zero
T	type to convert to (buitlin integer type with at least 16 bits precision, excluding any implicit sign bits)

Parameters

value

binary representation of half-precision value

Returns

integral value

half2int_up()

template<typename T >

T half_float::detail::half2int_up

(

uint16

value

)

Convert half-precision floating point to integer using round-to-nearest-away-from-zero.

Template Parameters

T	type to convert to (buitlin integer type with at least 16 bits precision, excluding any implicit sign bits)

Parameters

value

binary representation of half-precision value

Returns

integral value

half_cast() [1/2]

template<typename T , typename U >

T half_float::detail::half_cast

(

U

arg

)

Cast to or from half-precision floating point number. This casts between half and any built-in arithmetic type. The values are converted directly using the given rounding mode, without any roundtrip over float that a static_cast would otherwise do. It uses the default rounding mode.

Using this cast with neither of the two types being a half or with any of the two types not being a built-in arithmetic type (apart from half, of course) results in a compiler error and casting between halfs is just a no-op.

Template Parameters

T	destination type (half or built-in arithmetic type)
U	source type (half or built-in arithmetic type)

Parameters

arg	value to cast

Returns

arg converted to destination type

half_cast() [2/2]

template<typename T , std::float_round_style R, typename U >

T half_float::detail::half_cast

(

U

arg

)

Cast to or from half-precision floating point number. This casts between half and any built-in arithmetic type. The values are converted directly using the given rounding mode, without any roundtrip over float that a static_cast would otherwise do.

Using this cast with neither of the two types being a half or with any of the two types not being a built-in arithmetic type (apart from half, of course) results in a compiler error and casting between halfs is just a no-op.

Template Parameters

T	destination type (half or built-in arithmetic type)
R	rounding mode to use.
U	source type (half or built-in arithmetic type)

Parameters

arg	value to cast

Returns

arg converted to destination type

hypot() [1/4]

expr half_float::detail::hypot ( expr x, expr y )

inline

hypot() [2/4]

expr half_float::detail::hypot ( expr x, half y )

inline

hypot() [3/4]

expr half_float::detail::hypot ( half x, expr y )

inline

hypot() [4/4]

expr half_float::detail::hypot ( half x, half y )

inline

Hypotenuse function.

Parameters

x	first argument
y	second argument

Returns

square root of sum of squares without internal over- or underflows

ilogb() [1/2]

int half_float::detail::ilogb ( expr arg )

inline

ilogb() [2/2]

int half_float::detail::ilogb ( half arg )

inline

Extract exponent.

Parameters

arg	number to query

Returns

floating point exponent

Return values

FP_ILOGB0	for zero
FP_ILOGBNAN	for NaN
MAX_INT	for infinity

int2half()

template<std::float_round_style R, typename T >

uint16 half_float::detail::int2half

(

T

value

)

Convert integer to half-precision floating point.

Template Parameters

R	rounding mode to use, std::round_indeterminate for fastest rounding
T	type to convert (builtin integer type)

Parameters

value

integral value

Returns

binary representation of half-precision value

int2half_impl()

template<std::float_round_style R, bool S, typename T >

uint16 half_float::detail::int2half_impl

(

T

value

)

Convert integer to half-precision floating point.

Template Parameters

R	rounding mode to use, std::round_indeterminate for fastest rounding
S	true if value negative, false else
T	type to convert (builtin integer type)

Parameters

value

non-negative integral value

Returns

binary representation of half-precision value

isfinite() [1/2]

bool half_float::detail::isfinite ( expr arg )

inline

isfinite() [2/2]

bool half_float::detail::isfinite ( half arg )

inline

Check if finite number.

Parameters

arg	number to check

Return values

true	if neither infinity nor NaN
false	else

isgreater() [1/4]

bool half_float::detail::isgreater ( expr x, expr y )

inline

isgreater() [2/4]

bool half_float::detail::isgreater ( expr x, half y )

inline

isgreater() [3/4]

bool half_float::detail::isgreater ( half x, expr y )

inline

isgreater() [4/4]

bool half_float::detail::isgreater ( half x, half y )

inline

Comparison for greater than.

Parameters

x	first operand
y	second operand

Return values

true	if x greater than y
false	else

isgreaterequal() [1/4]

bool half_float::detail::isgreaterequal ( expr x, expr y )

inline

isgreaterequal() [2/4]

bool half_float::detail::isgreaterequal ( expr x, half y )

inline

isgreaterequal() [3/4]

bool half_float::detail::isgreaterequal ( half x, expr y )

inline

isgreaterequal() [4/4]

bool half_float::detail::isgreaterequal ( half x, half y )

inline

Comparison for greater equal.

Parameters

x	first operand
y	second operand

Return values

true	if x greater equal y
false	else

isinf() [1/2]

bool half_float::detail::isinf ( expr arg )

inline

isinf() [2/2]

bool half_float::detail::isinf ( half arg )

inline

Check for infinity.

Parameters

arg	number to check

Return values

true	for positive or negative infinity
false	else

isless() [1/4]

bool half_float::detail::isless ( expr x, expr y )

inline

isless() [2/4]

bool half_float::detail::isless ( expr x, half y )

inline

isless() [3/4]

bool half_float::detail::isless ( half x, expr y )

inline

isless() [4/4]

bool half_float::detail::isless ( half x, half y )

inline

Comparison for less than.

Parameters

x	first operand
y	second operand

Return values

true	if x less than y
false	else

islessequal() [1/4]

bool half_float::detail::islessequal ( expr x, expr y )

inline

islessequal() [2/4]

bool half_float::detail::islessequal ( expr x, half y )

inline

islessequal() [3/4]

bool half_float::detail::islessequal ( half x, expr y )

inline

islessequal() [4/4]

bool half_float::detail::islessequal ( half x, half y )

inline

Comparison for less equal.

Parameters

x	first operand
y	second operand

Return values

true	if x less equal y
false	else

islessgreater() [1/4]

bool half_float::detail::islessgreater ( expr x, expr y )

inline

islessgreater() [2/4]

bool half_float::detail::islessgreater ( expr x, half y )

inline

islessgreater() [3/4]

bool half_float::detail::islessgreater ( half x, expr y )

inline

islessgreater() [4/4]

bool half_float::detail::islessgreater ( half x, half y )

inline

Comarison for less or greater.

Parameters

x	first operand
y	second operand

Return values

true	if either less or greater
false	else

isnan() [1/2]

bool half_float::detail::isnan ( expr arg )

inline

isnan() [2/2]

bool half_float::detail::isnan ( half arg )

inline

Check for NaN.

Parameters

arg	number to check

Return values

true	for NaNs
false	else

isnormal() [1/2]

bool half_float::detail::isnormal ( expr arg )

inline

isnormal() [2/2]

bool half_float::detail::isnormal ( half arg )

inline

Check if normal number.

Parameters

arg	number to check

Return values

true	if normal number
false	if either subnormal, zero, infinity or NaN

isunordered() [1/4]

bool half_float::detail::isunordered ( expr x, expr y )

inline

isunordered() [2/4]

bool half_float::detail::isunordered ( expr x, half y )

inline

isunordered() [3/4]

bool half_float::detail::isunordered ( half x, expr y )

inline

isunordered() [4/4]

bool half_float::detail::isunordered ( half x, half y )

inline

Check if unordered.

Parameters

x	first operand
y	second operand

Return values

true	if unordered (one or two NaN operands)
false	else

ldexp() [1/2]

half half_float::detail::ldexp ( expr arg, int exp )

inline

ldexp() [2/2]

half half_float::detail::ldexp ( half arg, int exp )

inline

Multiply by power of two.

Parameters

arg	number to modify
exp	power of two to multiply with

Returns

arg multplied by 2 raised to exp

lgamma() [1/2]

expr half_float::detail::lgamma ( expr arg )

inline

lgamma() [2/2]

expr half_float::detail::lgamma ( half arg )

inline

Natural logarithm of gamma function.

Parameters

arg	function argument

Returns

natural logarith of gamma function for arg

log() [1/2]

expr half_float::detail::log ( expr arg )

inline

log() [2/2]

expr half_float::detail::log ( half arg )

inline

Natural logorithm.

Parameters

arg	function argument

Returns

logarithm of arg to base e

log10() [1/2]

expr half_float::detail::log10 ( expr arg )

inline

log10() [2/2]

expr half_float::detail::log10 ( half arg )

inline

Common logorithm.

Parameters

arg	function argument

Returns

logarithm of arg to base 10

log1p() [1/2]

expr half_float::detail::log1p ( expr arg )

inline

log1p() [2/2]

expr half_float::detail::log1p ( half arg )

inline

Natural logorithm.

Parameters

arg	function argument

Returns

logarithm of arg plus 1 to base e

log2() [1/2]

expr half_float::detail::log2 ( expr arg )

inline

log2() [2/2]

expr half_float::detail::log2 ( half arg )

inline

Binary logorithm.

Parameters

arg	function argument

Returns

logarithm of arg to base 2

logb() [1/2]

half half_float::detail::logb ( expr arg )

inline

logb() [2/2]

half half_float::detail::logb ( half arg )

inline

Extract exponent.

Parameters

arg	number to query

Returns

floating point exponent

lrint() [1/2]

long half_float::detail::lrint ( expr arg )

inline

lrint() [2/2]

long half_float::detail::lrint ( half arg )

inline

Nearest integer using half's internal rounding mode.

Parameters

arg	half expression to round

Returns

nearest integer using default rounding mode

lround() [1/2]

long half_float::detail::lround ( expr arg )

inline

lround() [2/2]

long half_float::detail::lround ( half arg )

inline

Nearest integer.

Parameters

arg	half to round

Returns

nearest integer, rounded away from zero in half-way cases

modf() [1/2]

half half_float::detail::modf ( expr arg, half * iptr )

inline

modf() [2/2]

half half_float::detail::modf ( half arg, half * iptr )

inline

Extract integer and fractional parts.

Parameters

arg	number to decompress
iptr	address to store integer part at

Returns

fractional part

nanh()

half half_float::detail::nanh ( const char * )

inline

Get NaN value.

Returns

quiet NaN

nearbyint() [1/2]

half half_float::detail::nearbyint ( expr arg )

inline

nearbyint() [2/2]

half half_float::detail::nearbyint ( half arg )

inline

Nearest integer using half's internal rounding mode.

Parameters

arg	half expression to round

Returns

nearest integer using default rounding mode

nextafter() [1/4]

half half_float::detail::nextafter ( expr from, expr to )

inline

nextafter() [2/4]

half half_float::detail::nextafter ( expr from, half to )

inline

nextafter() [3/4]

half half_float::detail::nextafter ( half from, expr to )

inline

nextafter() [4/4]

half half_float::detail::nextafter ( half from, half to )

inline

Next representable value.

Parameters

from	value to compute next representable value for
to	direction towards which to compute next value

Returns

next representable value after from in direction towards to

nexttoward() [1/2]

half half_float::detail::nexttoward ( expr from, long double to )

inline

nexttoward() [2/2]

half half_float::detail::nexttoward ( half from, long double to )

inline

Next representable value.

Parameters

from	value to compute next representable value for
to	direction towards which to compute next value

Returns

next representable value after from in direction towards to

operator!=()

template<typename T , typename U >

enable< bool, T, U >::type half_float::detail::operator!=	(	T	x,
		U	y )

Comparison for inequality.

Parameters

x	first operand
y	second operand

Return values

true	if operands not equal
false	else

operator*()

template<typename T , typename U >

enable< expr, T, U >::type half_float::detail::operator*	(	T	x,
		U	y )

Multiply halfs.

Parameters

x	left operand
y	right operand

Returns

product of half expressions

operator+() [1/2]

template<typename T >

HALF_CONSTEXPR enable< T, T >::type half_float::detail::operator+

(

T

arg

)

Identity.

Parameters

arg

operand

Returns

uncahnged operand

operator+() [2/2]

template<typename T , typename U >

enable< expr, T, U >::type half_float::detail::operator+	(	T	x,
		U	y )

Add halfs.

Parameters

x	left operand
y	right operand

Returns

sum of half expressions

operator-() [1/2]

template<typename T >

HALF_CONSTEXPR enable< T, T >::type half_float::detail::operator-

(

T

arg

)

Negation.

Parameters

arg

operand

Returns

negated operand

operator-() [2/2]

template<typename T , typename U >

enable< expr, T, U >::type half_float::detail::operator-	(	T	x,
		U	y )

Subtract halfs.

Parameters

x	left operand
y	right operand

Returns

difference of half expressions

operator/()

template<typename T , typename U >

enable< expr, T, U >::type half_float::detail::operator/	(	T	x,
		U	y )

Divide halfs.

Parameters

x	left operand
y	right operand

Returns

quotient of half expressions

operator<()

template<typename T , typename U >

enable< bool, T, U >::type half_float::detail::operator<	(	T	x,
		U	y )

Comparison for less than.

Parameters

x	first operand
y	second operand

Return values

true	if x less than y
false	else

operator<<()

template<typename T , typename charT , typename traits >

enable< std::basic_ostream< charT, traits > &, T >::type half_float::detail::operator<<	(	std::basic_ostream< charT, traits > &	out,
		T	arg )

Output operator.

Parameters

out	output stream to write into
arg	half expression to write

Returns

reference to output stream

operator<=()

template<typename T , typename U >

enable< bool, T, U >::type half_float::detail::operator<=	(	T	x,
		U	y )

Comparison for less equal.

Parameters

x	first operand
y	second operand

Return values

true	if x less equal y
false	else

operator==()

template<typename T , typename U >

enable< bool, T, U >::type half_float::detail::operator==	(	T	x,
		U	y )

Comparison for equality.

Parameters

x	first operand
y	second operand

Return values

true	if operands equal
false	else

operator>()

template<typename T , typename U >

enable< bool, T, U >::type half_float::detail::operator>	(	T	x,
		U	y )

Comparison for greater than.

Parameters

x	first operand
y	second operand

Return values

true	if x greater than y
false	else

operator>=()

template<typename T , typename U >

enable< bool, T, U >::type half_float::detail::operator>=	(	T	x,
		U	y )

Comparison for greater equal.

Parameters

x	first operand
y	second operand

Return values

true	if x greater equal y
false	else

operator>>()

template<typename charT , typename traits >

std::basic_istream< charT, traits > & half_float::detail::operator>>	(	std::basic_istream< charT, traits > &	in,
		half &	arg )

Input operator.

Parameters

in	input stream to read from
arg	half to read into

Returns

reference to input stream

pow() [1/4]

expr half_float::detail::pow ( expr base, expr exp )

inline

pow() [2/4]

expr half_float::detail::pow ( expr base, half exp )

inline

pow() [3/4]

expr half_float::detail::pow ( half base, expr exp )

inline

pow() [4/4]

expr half_float::detail::pow ( half base, half exp )

inline

Power function.

Parameters

base	first argument
exp	second argument

Returns

base raised to exp

remainder() [1/4]

expr half_float::detail::remainder ( expr x, expr y )

inline

remainder() [2/4]

expr half_float::detail::remainder ( expr x, half y )

inline

remainder() [3/4]

expr half_float::detail::remainder ( half x, expr y )

inline

remainder() [4/4]

expr half_float::detail::remainder ( half x, half y )

inline

Remainder of division.

Parameters

x	first operand
y	second operand

Returns

remainder of floating point division.

remquo() [1/4]

expr half_float::detail::remquo ( expr x, expr y, int * quo )

inline

remquo() [2/4]

expr half_float::detail::remquo ( expr x, half y, int * quo )

inline

remquo() [3/4]

expr half_float::detail::remquo ( half x, expr y, int * quo )

inline

remquo() [4/4]

expr half_float::detail::remquo ( half x, half y, int * quo )

inline

Remainder of division.

Parameters

x	first operand
y	second operand
quo	address to store some bits of quotient at

Returns

remainder of floating point division.

rint() [1/2]

half half_float::detail::rint ( expr arg )

inline

rint() [2/2]

half half_float::detail::rint ( half arg )

inline

Nearest integer using half's internal rounding mode.

Parameters

arg	half expression to round

Returns

nearest integer using default rounding mode

round() [1/2]

half half_float::detail::round ( expr arg )

inline

round() [2/2]

half half_float::detail::round ( half arg )

inline

Nearest integer.

Parameters

arg	half to round

Returns

nearest integer, rounded away from zero in half-way cases

round_half()

template<std::float_round_style R>

uint16 half_float::detail::round_half

(

uint16

value

)

Round half-precision number to nearest integer value.

Template Parameters

R	rounding mode to use, std::round_indeterminate for fastest rounding

Parameters

value

binary representation of half-precision value

Returns

half-precision bits for nearest integral value

round_half_impl()

template<std::float_round_style R, bool E>

uint16 half_float::detail::round_half_impl

(

uint16

value

)

Round half-precision number to nearest integer value.

Template Parameters

R	rounding mode to use, std::round_indeterminate for fastest rounding
E	true for round to even, false for round away from zero

Parameters

value

binary representation of half-precision value

Returns

half-precision bits for nearest integral value

round_half_up()

uint16 half_float::detail::round_half_up ( uint16 value )

inline

Round half-precision number to nearest integer value using round-to-nearest-away-from-zero.

Parameters

value

binary representation of half-precision value

Returns

half-precision bits for nearest integral value

scalbln() [1/2]

half half_float::detail::scalbln ( expr arg, long exp )

inline

scalbln() [2/2]

half half_float::detail::scalbln ( half arg, long exp )

inline

Multiply by power of two.

Parameters

arg	number to modify
exp	power of two to multiply with

Returns

arg multplied by 2 raised to exp

scalbn() [1/2]

half half_float::detail::scalbn ( expr arg, int exp )

inline

scalbn() [2/2]

half half_float::detail::scalbn ( half arg, int exp )

inline

Multiply by power of two.

Parameters

arg	number to modify
exp	power of two to multiply with

Returns

arg multplied by 2 raised to exp

signbit() [1/2]

bool half_float::detail::signbit ( expr arg )

inline

signbit() [2/2]

bool half_float::detail::signbit ( half arg )

inline

Check sign.

Parameters

arg	number to check

Return values

true	for negative number
false	for positive number

sin() [1/2]

expr half_float::detail::sin ( expr arg )

inline

sin() [2/2]

expr half_float::detail::sin ( half arg )

inline

Sine function.

Parameters

arg	function argument

Returns

sine value of arg

sinh() [1/2]

expr half_float::detail::sinh ( expr arg )

inline

sinh() [2/2]

expr half_float::detail::sinh ( half arg )

inline

Hyperbolic sine.

Parameters

arg	function argument

Returns

hyperbolic sine value of arg

sqrt() [1/2]

expr half_float::detail::sqrt ( expr arg )

inline

sqrt() [2/2]

expr half_float::detail::sqrt ( half arg )

inline

Square root.

Parameters

arg	function argument

Returns

square root of arg

tan() [1/2]

expr half_float::detail::tan ( expr arg )

inline

tan() [2/2]

expr half_float::detail::tan ( half arg )

inline

Tangent function.

Parameters

arg	function argument

Returns

tangent value of arg

tanh() [1/2]

expr half_float::detail::tanh ( expr arg )

inline

tanh() [2/2]

expr half_float::detail::tanh ( half arg )

inline

Hyperbolic tangent.

Parameters

arg	function argument

Returns

hyperbolic tangent value of arg

tgamma() [1/2]

expr half_float::detail::tgamma ( expr arg )

inline

tgamma() [2/2]

expr half_float::detail::tgamma ( half arg )

inline

Gamma function.

Parameters

arg	function argument

Returns

gamma function value of arg

trunc() [1/2]

half half_float::detail::trunc ( expr arg )

inline

trunc() [2/2]

half half_float::detail::trunc ( half arg )

inline

Nearest integer not greater in magnitude than half value.

Parameters

arg	half to round

Returns

nearest integer not greater in magnitude than arg

Variable Documentation

binary

HALF_CONSTEXPR_CONST binary_t half_float::detail::binary = binary_t()

Tag for binary construction.