Main namespace for half-precision functionality. More...

Namespaces
	detail

Classes
class	half
	Half-precision floating-point type. More...

Functions
Comparison operators

HALF_CONSTEXPR_NOERR bool	operator== (half x, half y)
	Comparison for equality. More...

HALF_CONSTEXPR_NOERR bool	operator!= (half x, half y)
	Comparison for inequality. More...

HALF_CONSTEXPR_NOERR bool	operator< (half x, half y)
	Comparison for less than. More...

HALF_CONSTEXPR_NOERR bool	operator> (half x, half y)
	Comparison for greater than. More...

HALF_CONSTEXPR_NOERR bool	operator<= (half x, half y)
	Comparison for less equal. More...

HALF_CONSTEXPR_NOERR bool	operator>= (half x, half y)
	Comparison for greater equal. More...

Arithmetic operators

HALF_CONSTEXPR half	operator+ (half arg)
	Identity. More...

HALF_CONSTEXPR half	operator- (half arg)
	Negation. More...

half	operator+ (half x, half y)
	Addition. More...

half	operator- (half x, half y)
	Subtraction. More...

half	operator* (half x, half y)
	Multiplication. More...

half	operator/ (half x, half y)
	Division. More...

Input and output

template<typename charT , typename traits >
std::basic_ostream< charT, traits > &	operator<< (std::basic_ostream< charT, traits > &out, half arg)
	Output operator. More...

template<typename charT , typename traits >
std::basic_istream< charT, traits > &	operator>> (std::basic_istream< charT, traits > &in, half &arg)
	Input operator. More...

Basic mathematical operations

HALF_CONSTEXPR half	fabs (half arg)
	Absolute value. More...

HALF_CONSTEXPR half	abs (half arg)
	Absolute value. More...

half	fmod (half x, half y)
	Remainder of division. More...

half	remainder (half x, half y)
	Remainder of division. More...

half	remquo (half x, half y, int *quo)
	Remainder of division. More...

half	fma (half x, half y, half z)
	Fused multiply add. More...

HALF_CONSTEXPR_NOERR half	fmax (half x, half y)
	Maximum of half expressions. More...

HALF_CONSTEXPR_NOERR half	fmin (half x, half y)
	Minimum of half expressions. More...

half	fdim (half x, half y)
	Positive difference. More...

half	nanh (const char *arg)
	Get NaN value. More...

Exponential functions

half	exp (half arg)
	Exponential function. More...

half	exp2 (half arg)
	Binary exponential. More...

half	expm1 (half arg)
	Exponential minus one. More...

half	log (half arg)
	Natural logarithm. More...

half	log10 (half arg)
	Common logarithm. More...

half	log2 (half arg)
	Binary logarithm. More...

half	log1p (half arg)
	Natural logarithm plus one. More...

Power functions

half	sqrt (half arg)
	Square root. More...

half	rsqrt (half arg)
	Inverse square root. More...

half	cbrt (half arg)
	Cubic root. More...

half	hypot (half x, half y)
	Hypotenuse function. More...

half	hypot (half x, half y, half z)
	Hypotenuse function. More...

half	pow (half x, half y)
	Power function. More...

Trigonometric functions

void	sincos (half arg, half sin, half cos)
	Compute sine and cosine simultaneously. More...

half	sin (half arg)
	Sine function. More...

half	cos (half arg)
	Cosine function. More...

half	tan (half arg)
	Tangent function. More...

half	asin (half arg)
	Arc sine. More...

half	acos (half arg)
	Arc cosine function. More...

half	atan (half arg)
	Arc tangent function. More...

half	atan2 (half y, half x)
	Arc tangent function. More...

Hyperbolic functions

half	sinh (half arg)
	Hyperbolic sine. More...

half	cosh (half arg)
	Hyperbolic cosine. More...

half	tanh (half arg)
	Hyperbolic tangent. More...

half	asinh (half arg)
	Hyperbolic area sine. More...

half	acosh (half arg)
	Hyperbolic area cosine. More...

half	atanh (half arg)
	Hyperbolic area tangent. More...

Error and gamma functions

half	erf (half arg)
	Error function. More...

half	erfc (half arg)
	Complementary error function. More...

half	lgamma (half arg)
	Natural logarithm of gamma function. More...

half	tgamma (half arg)
	Gamma function. More...

Rounding

half	ceil (half arg)
	Nearest integer not less than half value. More...

half	floor (half arg)
	Nearest integer not greater than half value. More...

half	trunc (half arg)
	Nearest integer not greater in magnitude than half value. More...

half	round (half arg)
	Nearest integer. More...

long	lround (half arg)
	Nearest integer. More...

half	rint (half arg)
	Nearest integer using half's internal rounding mode. More...

long	lrint (half arg)
	Nearest integer using half's internal rounding mode. More...

half	nearbyint (half arg)
	Nearest integer using half's internal rounding mode. More...

Floating point manipulation

half	frexp (half arg, int *exp)
	Decompress floating-point number. More...

half	scalbln (half arg, long exp)
	Multiply by power of two. More...

half	scalbn (half arg, int exp)
	Multiply by power of two. More...

half	ldexp (half arg, int exp)
	Multiply by power of two. More...

half	modf (half arg, half *iptr)
	Extract integer and fractional parts. More...

int	ilogb (half arg)
	Extract exponent. More...

half	logb (half arg)
	Extract exponent. More...

half	nextafter (half from, half to)
	Next representable value. More...

half	nexttoward (half from, long double to)
	Next representable value. More...

HALF_CONSTEXPR half	copysign (half x, half y)
	Take sign. More...

Floating point classification

HALF_CONSTEXPR int	fpclassify (half arg)
	Classify floating-point value. More...

HALF_CONSTEXPR bool	isfinite (half arg)
	Check if finite number. More...

HALF_CONSTEXPR bool	isinf (half arg)
	Check for infinity. More...

HALF_CONSTEXPR bool	isnan (half arg)
	Check for NaN. More...

HALF_CONSTEXPR bool	isnormal (half arg)
	Check if normal number. More...

HALF_CONSTEXPR bool	signbit (half arg)
	Check sign. More...

Comparison

HALF_CONSTEXPR bool	isgreater (half x, half y)
	Quiet comparison for greater than. More...

HALF_CONSTEXPR bool	isgreaterequal (half x, half y)
	Quiet comparison for greater equal. More...

HALF_CONSTEXPR bool	isless (half x, half y)
	Quiet comparison for less than. More...

HALF_CONSTEXPR bool	islessequal (half x, half y)
	Quiet comparison for less equal. More...

HALF_CONSTEXPR bool	islessgreater (half x, half y)
	Quiet comarison for less or greater. More...

HALF_CONSTEXPR bool	isunordered (half x, half y)
	Quiet check if unordered. More...

Casting

template<typename T , typename U >
T	half_cast (U arg)
	Cast to or from half-precision floating-point number. More...

template<typename T , std::float_round_style R, typename U >
T	half_cast (U arg)
	Cast to or from half-precision floating-point number. More...

Error handling

int	feclearexcept (int excepts)
	Clear exception flags. More...

int	fetestexcept (int excepts)
	Test exception flags. More...

int	feraiseexcept (int excepts)
	Raise exception flags. More...

int	fegetexceptflag (int *flagp, int excepts)
	Save exception flags. More...

int	fesetexceptflag (const int *flagp, int excepts)
	Restore exception flags. More...

void	fethrowexcept (int excepts, const char *msg="")
	Throw C++ exceptions based on set exception flags. More...

Detailed Description

Main namespace for half-precision functionality.

This namespace contains all the functionality provided by the library.

Function Documentation

◆ abs()

HALF_CONSTEXPR half half_float::abs ( half arg )

inline

Absolute value.

See also: Documentation for std::abs.

Parameters

arg operand

Returns: absolute value of arg

◆ acos()

half half_float::acos ( half arg )

inline

Arc cosine function.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::acos.

Parameters

arg	function argument

Returns: arc cosine value of arg

Exceptions

FE_INVALID	for signaling NaN or if abs(arg) > 1
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ acosh()

half half_float::acosh ( half arg )

inline

Hyperbolic area cosine.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::acosh.

Parameters

arg	function argument

Returns: area cosine value of arg

Exceptions

FE_INVALID	for signaling NaN or arguments <1
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ asin()

half half_float::asin ( half arg )

inline

Arc sine.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::asin.

Parameters

arg	function argument

Returns: arc sine value of arg

Exceptions

FE_INVALID	for signaling NaN or if abs(arg) > 1
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ asinh()

half half_float::asinh ( half arg )

inline

Hyperbolic area sine.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::asinh.

Parameters

arg	function argument

Returns: area sine value of arg

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ atan()

half half_float::atan ( half arg )

inline

Arc tangent function.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::atan.

Parameters

arg	function argument

Returns: arc tangent value of arg

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ atan2()

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

inline

Arc tangent function.

This function may be 1 ULP off the correctly rounded exact result in ~0.005% of inputs for std::round_to_nearest, in ~0.1% of inputs for std::round_toward_zero and in ~0.02% of inputs for any other rounding mode.

See also: Documentation for std::atan2.

Parameters

y	numerator
x	denominator

Returns: arc tangent value

Exceptions

FE_INVALID	if x or y is signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ atanh()

half half_float::atanh ( half arg )

inline

Hyperbolic area tangent.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::atanh.

Parameters

arg	function argument

Returns: area tangent value of arg

Exceptions

FE_INVALID	for signaling NaN or if abs(arg) > 1
FE_DIVBYZERO	for +/-1
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ cbrt()

half half_float::cbrt ( half arg )

inline

Cubic root.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::cbrt.

Parameters

arg	function argument

Returns: cubic root of arg

Exceptions

FE_INVALID	for signaling NaN
FE_INEXACT	according to rounding

◆ ceil()

half half_float::ceil ( half arg )

inline

Nearest integer not less than half value.

See also: Documentation for std::ceil.

Parameters

arg	half to round

Returns: nearest integer not less than arg

Exceptions

FE_INVALID	for signaling NaN
FE_INEXACT	if value had to be rounded

◆ copysign()

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

inline

Take sign.

See also: Documentation for std::copysign.

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()

half half_float::cos ( half arg )

inline

Cosine function.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::cos.

Parameters

arg	function argument

Returns: cosine value of arg

Exceptions

FE_INVALID	for signaling NaN or infinity
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ cosh()

half half_float::cosh ( half arg )

inline

Hyperbolic cosine.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::cosh.

Parameters

arg	function argument

Returns: hyperbolic cosine value of arg

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ erf()

half half_float::erf ( half arg )

inline

Error function.

This function may be 1 ULP off the correctly rounded exact result for any rounding mode in <0.5% of inputs.

See also: Documentation for std::erf.

Parameters

arg	function argument

Returns: error function value of arg

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ erfc()

half half_float::erfc ( half arg )

inline

Complementary error function.

This function may be 1 ULP off the correctly rounded exact result for any rounding mode in <0.5% of inputs.

See also: Documentation for std::erfc.

Parameters

arg	function argument

Returns: 1 minus error function value of arg

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ exp()

half half_float::exp ( half arg )

inline

Exponential function.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::exp.

Parameters

arg	function argument

Returns: e raised to arg

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ exp2()

half half_float::exp2 ( half arg )

inline

Binary exponential.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::exp2.

Parameters

arg	function argument

Returns: 2 raised to arg

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ expm1()

half half_float::expm1 ( half arg )

inline

Exponential minus one.

This function may be 1 ULP off the correctly rounded exact result in <0.05% of inputs for std::round_to_nearest and in <1% of inputs for any other rounding mode.

See also: Documentation for std::expm1.

Parameters

arg	function argument

Returns: e raised to arg and subtracted by 1

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ fabs()

HALF_CONSTEXPR half half_float::fabs ( half arg )

inline

Absolute value.

See also: Documentation for std::fabs.

Parameters

arg operand

Returns: absolute value of arg

◆ fdim()

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

inline

Positive difference.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::fdim.

Parameters

x	first operand
y	second operand

Returns: x - y or 0 if difference negative

Exceptions

FE_... according to operator-(half,half)

◆ feclearexcept()

int half_float::feclearexcept ( int excepts )

inline

Clear exception flags.

This function works even if automatic exception flag handling is disabled, but in that case manual flag management is the only way to raise flags.

See also: Documentation for std::feclearexcept.

Parameters

excepts OR of exceptions to clear

Return values

0	all selected flags cleared successfully

◆ fegetexceptflag()

int half_float::fegetexceptflag	(	int *	flagp,
		int	excepts
	)

inline

Save exception flags.

This function works even if automatic exception flag handling is disabled, but in that case manual flag management is the only way to raise flags.

See also: Documentation for std::fegetexceptflag.

Parameters

flagp	adress to store flag state at
excepts	OR of flags to save

Return values

0	for success

◆ feraiseexcept()

int half_float::feraiseexcept ( int excepts )

inline

Raise exception flags.

This raises the specified floating point exceptions and also invokes any additional automatic exception handling as configured with the HALF_ERRHANDLIG_... preprocessor symbols. This function works even if automatic exception flag handling is disabled, but in that case manual flag management is the only way to raise flags.

See also: Documentation for std::feraiseexcept.

Parameters

excepts OR of exceptions to raise

Return values

0	all selected exceptions raised successfully

◆ fesetexceptflag()

int half_float::fesetexceptflag	(	const int *	flagp,
		int	excepts
	)

inline

Restore exception flags.

This only copies the specified exception state (including unset flags) without incurring any additional exception handling. This function works even if automatic exception flag handling is disabled, but in that case manual flag management is the only way to raise flags.

See also: Documentation for std::fesetexceptflag.

Parameters

flagp	adress to take flag state from
excepts	OR of flags to restore

Return values

0	for success

◆ fetestexcept()

int half_float::fetestexcept ( int excepts )

inline

Test exception flags.

This function works even if automatic exception flag handling is disabled, but in that case manual flag management is the only way to raise flags.

See also: Documentation for std::fetestexcept.

Parameters

excepts OR of exceptions to test

Returns: OR of selected exceptions if raised

◆ fethrowexcept()

void half_float::fethrowexcept	(	int	excepts,
		const char *	msg = `""`
	)

inline

Throw C++ exceptions based on set exception flags.

This function manually throws a corresponding C++ exception if one of the specified flags is set, no matter if automatic throwing (via HALF_ERRHANDLING_THROW_...) is enabled or not. This function works even if automatic exception flag handling is disabled, but in that case manual flag management is the only way to raise flags.

Parameters

excepts	OR of exceptions to test
msg	error message to use for exception description

Exceptions

std::domain_error	if `FE_INVALID` or `FE_DIVBYZERO` is selected and set
std::overflow_error	if `FE_OVERFLOW` is selected and set
std::underflow_error	if `FE_UNDERFLOW` is selected and set
std::range_error	if `FE_INEXACT` is selected and set

◆ floor()

half half_float::floor ( half arg )

inline

Nearest integer not greater than half value.

See also: Documentation for std::floor.

Parameters

arg	half to round

Returns: nearest integer not greater than arg

Exceptions

FE_INVALID	for signaling NaN
FE_INEXACT	if value had to be rounded

◆ fma()

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

inline

Fused multiply add.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::fma.

Parameters

x	first operand
y	second operand
z	third operand

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

Exceptions

FE_INVALID	according to operator*() and operator+() unless any argument is a quiet NaN and no argument is a signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding the final addition

◆ fmax()

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

inline

Maximum of half expressions.

See also: Documentation for std::fmax.

Parameters

x	first operand
y	second operand

Returns: maximum of operands, ignoring quiet NaNs

Exceptions

FE_INVALID if x or y is signaling NaN

◆ fmin()

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

inline

Minimum of half expressions.

See also: Documentation for std::fmin.

Parameters

x	first operand
y	second operand

Returns: minimum of operands, ignoring quiet NaNs

Exceptions

FE_INVALID if x or y is signaling NaN

◆ fmod()

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

inline

Remainder of division.

See also: Documentation for std::fmod.

Parameters

x	first operand
y	second operand

Returns: remainder of floating-point division.

Exceptions

FE_INVALID if x is infinite or y is 0 or if x or y is signaling NaN

◆ fpclassify()

HALF_CONSTEXPR int half_float::fpclassify ( half arg )

inline

Classify floating-point value.

See also: Documentation for std::fpclassify.

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()

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

inline

Decompress floating-point number.

See also: Documentation for std::frexp.

Parameters

arg	number to decompress
exp	address to store exponent at

Returns: significant in range [0.5, 1)

Exceptions

FE_INVALID for signaling NaN

◆ half_cast() [1/2]

template<typename T , typename U >

T half_float::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 default 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 returns the argument unmodified.

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

Exceptions

FE_INVALID	if T is integer type and result is not representable as T
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ half_cast() [2/2]

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

T half_float::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 specified 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 returns the argument unmodified.

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

Exceptions

FE_INVALID	if T is integer type and result is not representable as T
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ hypot() [1/2]

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

inline

Hypotenuse function.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::hypot.

Parameters

x	first argument
y	second argument

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

Exceptions

FE_INVALID	if x or y is signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding of the final square root

◆ hypot() [2/2]

half half_float::hypot	(	half	x,
		half	y,
		half	z
	)

inline

Hypotenuse function.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::hypot.

Parameters

x	first argument
y	second argument
z	third argument

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

Exceptions

FE_INVALID	if x, y or z is signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding of the final square root

◆ ilogb()

int half_float::ilogb ( half arg )

inline

Extract exponent.

See also: Documentation for std::ilogb.

Parameters

arg	number to query

Returns: floating-point exponent

Return values

FP_ILOGB0	for zero
FP_ILOGBNAN	for NaN
INT_MAX	for infinity

Exceptions

FE_INVALID for 0 or infinite values

◆ isfinite()

HALF_CONSTEXPR bool half_float::isfinite ( half arg )

inline

Check if finite number.

See also: Documentation for std::isfinite.

Parameters

arg	number to check

Return values

true	if neither infinity nor NaN
false	else

◆ isgreater()

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

inline

Quiet comparison for greater than.

See also: Documentation for std::isgreater.

Parameters

x	first operand
y	second operand

Return values

true	if x greater than y
false	else

◆ isgreaterequal()

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

inline

Quiet comparison for greater equal.

See also: Documentation for std::isgreaterequal.

Parameters

x	first operand
y	second operand

Return values

true	if x greater equal y@retval false else

◆ isinf()

HALF_CONSTEXPR bool half_float::isinf ( half arg )

inline

Check for infinity.

See also: Documentation for std::isinf.

Parameters

arg	number to check

Return values

true	for positive or negative infinity
false	else

◆ isless()

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

inline

Quiet comparison for less than.

See also: Documentation for std::isless.

Parameters

x	first operand
y	second operand

Return values

true	if x less than y
false	else

◆ islessequal()

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

inline

Quiet comparison for less equal.

See also: Documentation for std::islessequal.

Parameters

x	first operand
y	second operand

Return values

true	if x less equal y
false	else

◆ islessgreater()

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

inline

Quiet comarison for less or greater.

See also: Documentation for std::islessgreater.

Parameters

x	first operand
y	second operand

Return values

true	if either less or greater
false	else

◆ isnan()

HALF_CONSTEXPR bool half_float::isnan ( half arg )

inline

Check for NaN.

See also: Documentation for std::isnan.

Parameters

arg	number to check

Return values

true	for NaNs
false	else

◆ isnormal()

HALF_CONSTEXPR bool half_float::isnormal ( half arg )

inline

Check if normal number.

See also: Documentation for std::isnormal.

Parameters

arg	number to check

Return values

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

◆ isunordered()

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

inline

Quiet check if unordered.

See also: Documentation for std::isunordered.

Parameters

x	first operand
y	second operand

Return values

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

◆ ldexp()

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

inline

Multiply by power of two.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::ldexp.

Parameters

arg	number to modify
exp	power of two to multiply with

Returns: arg multplied by 2 raised to exp

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ lgamma()

half half_float::lgamma ( half arg )

inline

Natural logarithm of gamma function.

This function may be 1 ULP off the correctly rounded exact result for any rounding mode in ~0.025% of inputs.

See also: Documentation for std::lgamma.

Parameters

arg	function argument

Returns: natural logarith of gamma function for arg

Exceptions

FE_INVALID	for signaling NaN
FE_DIVBYZERO	for 0 or negative integer arguments
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ log()

half half_float::log ( half arg )

inline

Natural logarithm.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::log.

Parameters

arg	function argument

Returns: logarithm of arg to base e

Exceptions

FE_INVALID	for signaling NaN or negative argument
FE_DIVBYZERO	for 0
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ log10()

half half_float::log10 ( half arg )

inline

Common logarithm.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::log10.

Parameters

arg	function argument

Returns: logarithm of arg to base 10

Exceptions

FE_INVALID	for signaling NaN or negative argument
FE_DIVBYZERO	for 0
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ log1p()

half half_float::log1p ( half arg )

inline

Natural logarithm plus one.

This function may be 1 ULP off the correctly rounded exact result in <0.05% of inputs for std::round_to_nearest and in ~1% of inputs for any other rounding mode.

See also: Documentation for std::log1p.

Parameters

arg	function argument

Returns: logarithm of arg plus 1 to base e

Exceptions

FE_INVALID	for signaling NaN or argument <-1
FE_DIVBYZERO	for -1
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ log2()

half half_float::log2 ( half arg )

inline

Binary logarithm.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::log2.

Parameters

arg	function argument

Returns: logarithm of arg to base 2

Exceptions

FE_INVALID	for signaling NaN or negative argument
FE_DIVBYZERO	for 0
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ logb()

half half_float::logb ( half arg )

inline

Extract exponent.

See also: Documentation for std::logb.

Parameters

arg	number to query

Returns: floating-point exponent

Exceptions

FE_INVALID	for signaling NaN
FE_DIVBYZERO	for 0

◆ lrint()

long half_float::lrint ( half arg )

inline

Nearest integer using half's internal rounding mode.

See also: Documentation for std::lrint.

Parameters

arg	half expression to round

Returns: nearest integer using default rounding mode

Exceptions

FE_INVALID	if value is not representable as `long`
FE_INEXACT	if value had to be rounded

◆ lround()

long half_float::lround ( half arg )

inline

Nearest integer.

See also: Documentation for std::lround.

Parameters

arg	half to round

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

Exceptions

FE_INVALID if value is not representable as long

◆ modf()

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

inline

Extract integer and fractional parts.

See also: Documentation for std::modf.

Parameters

arg	number to decompress
iptr	address to store integer part at

Returns: fractional part

Exceptions

FE_INVALID for signaling NaN

◆ nanh()

half half_float::nanh ( const char * arg )

inline

Get NaN value.

See also: Documentation for std::nan.

Parameters

arg	string code

Returns: quiet NaN

◆ nearbyint()

half half_float::nearbyint ( half arg )

inline

Nearest integer using half's internal rounding mode.

See also: Documentation for std::nearbyint.

Parameters

arg	half expression to round

Returns: nearest integer using default rounding mode

Exceptions

FE_INVALID for signaling NaN

◆ nextafter()

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

inline

Next representable value.

See also: Documentation for std::nextafter.

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

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW	for infinite result from finite argument
FE_UNDERFLOW	for subnormal result

◆ nexttoward()

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

inline

Next representable value.

See also: Documentation for std::nexttoward.

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

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW	for infinite result from finite argument
FE_UNDERFLOW	for subnormal result

◆ operator!=()

HALF_CONSTEXPR_NOERR bool half_float::operator!=	(	half	x,
		half	y
	)

inline

Comparison for inequality.

Parameters

x	first operand
y	second operand

Return values

true	if operands not equal
false	else

Exceptions

FE_INVALID if x or y is NaN

◆ operator*()

half half_float::operator*	(	half	x,
		half	y
	)

inline

Multiplication.

This operation is exact to rounding for all rounding modes.

Parameters

x	left operand
y	right operand

Returns: product of half expressions

Exceptions

FE_INVALID	if multiplying 0 with infinity or if x or y is signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ operator+() [1/2]

HALF_CONSTEXPR half half_float::operator+ ( half arg )

inline

Identity.

Parameters

arg operand

Returns: unchanged operand

◆ operator+() [2/2]

half half_float::operator+	(	half	x,
		half	y
	)

inline

Addition.

This operation is exact to rounding for all rounding modes.

Parameters

x	left operand
y	right operand

Returns: sum of half expressions

Exceptions

FE_INVALID	if x and y are infinities with different signs or signaling NaNs
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ operator-() [1/2]

HALF_CONSTEXPR half half_float::operator- ( half arg )

inline

Negation.

Parameters

arg operand

Returns: negated operand

◆ operator-() [2/2]

half half_float::operator-	(	half	x,
		half	y
	)

inline

Subtraction.

This operation is exact to rounding for all rounding modes.

Parameters

x	left operand
y	right operand

Returns: difference of half expressions

Exceptions

FE_INVALID	if x and y are infinities with equal signs or signaling NaNs
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ operator/()

half half_float::operator/	(	half	x,
		half	y
	)

inline

Division.

This operation is exact to rounding for all rounding modes.

Parameters

x	left operand
y	right operand

Returns: quotient of half expressions

Exceptions

FE_INVALID	if dividing 0s or infinities with each other or if x or y is signaling NaN
FE_DIVBYZERO	if dividing finite value by 0
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ operator<()

HALF_CONSTEXPR_NOERR bool half_float::operator<	(	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

Exceptions

FE_INVALID if x or y is NaN

◆ operator<<()

template<typename charT , typename traits >

std::basic_ostream<charT, traits>& half_float::operator<<	(	std::basic_ostream< charT, traits > &	out,
		half	arg
	)

Output operator.

This uses the built-in functionality for streaming out floating-point numbers.

Parameters

out	output stream to write into
arg	half expression to write

Returns: reference to output stream

◆ operator<=()

HALF_CONSTEXPR_NOERR bool half_float::operator<=	(	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

Exceptions

FE_INVALID if x or y is NaN

◆ operator==()

HALF_CONSTEXPR_NOERR bool half_float::operator==	(	half	x,
		half	y
	)

inline

Comparison for equality.

Parameters

x	first operand
y	second operand

Return values

true	if operands equal
false	else

Exceptions

FE_INVALID if x or y is NaN

◆ operator>()

HALF_CONSTEXPR_NOERR bool half_float::operator>	(	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

Exceptions

FE_INVALID if x or y is NaN

◆ operator>=()

HALF_CONSTEXPR_NOERR bool half_float::operator>=	(	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

Exceptions

FE_INVALID if x or y is NaN

◆ operator>>()

template<typename charT , typename traits >

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

Input operator.

This uses the built-in functionality for streaming in floating-point numbers, specifically double precision floating point numbers (unless overridden with HALF_ARITHMETIC_TYPE). So the input string is first rounded to double precision using the underlying platform's current floating-point rounding mode before being rounded to half-precision using the library's half-precision rounding mode.

Parameters

in	input stream to read from
arg	half to read into

Returns: reference to input stream

Exceptions

FE_OVERFLOW,...UNDERFLOW,...INEXACT according to rounding

◆ pow()

half half_float::pow	(	half	x,
		half	y
	)

inline

Power function.

This function may be 1 ULP off the correctly rounded exact result for any rounding mode in ~0.00025% of inputs.

See also: Documentation for std::pow.

Parameters

x	base
y	exponent

Returns: x raised to y

Exceptions

FE_INVALID	if x or y is signaling NaN or if x is finite an negative and y is finite and not integral
FE_DIVBYZERO	if x is 0 and y is negative
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ remainder()

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

inline

Remainder of division.

See also: Documentation for std::remainder.

Parameters

x	first operand
y	second operand

Returns: remainder of floating-point division.

Exceptions

FE_INVALID if x is infinite or y is 0 or if x or y is signaling NaN

◆ remquo()

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

inline

Remainder of division.

See also: Documentation for std::remquo.

Parameters

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

Returns: remainder of floating-point division.

Exceptions

FE_INVALID if x is infinite or y is 0 or if x or y is signaling NaN

◆ rint()

half half_float::rint ( half arg )

inline

Nearest integer using half's internal rounding mode.

See also: Documentation for std::rint.

Parameters

arg	half expression to round

Returns: nearest integer using default rounding mode

Exceptions

FE_INVALID	for signaling NaN
FE_INEXACT	if value had to be rounded

◆ round()

half half_float::round ( half arg )

inline

Nearest integer.

See also: Documentation for std::round.

Parameters

arg	half to round

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

Exceptions

FE_INVALID	for signaling NaN
FE_INEXACT	if value had to be rounded

◆ rsqrt()

half half_float::rsqrt ( half arg )

inline

Inverse square root.

This function is exact to rounding for all rounding modes and thus generally more accurate than directly computing 1 / sqrt(arg) in half-precision, in addition to also being faster.

Parameters

arg	function argument

Returns: reciprocal of square root of arg

Exceptions

FE_INVALID	for signaling NaN and negative arguments
FE_INEXACT	according to rounding

◆ scalbln()

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

inline

Multiply by power of two.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::scalbln.

Parameters

arg	number to modify
exp	power of two to multiply with

Returns: arg multplied by 2 raised to exp

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ scalbn()

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

inline

Multiply by power of two.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::scalbn.

Parameters

arg	number to modify
exp	power of two to multiply with

Returns: arg multplied by 2 raised to exp

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ signbit()

HALF_CONSTEXPR bool half_float::signbit ( half arg )

inline

Check sign.

See also: Documentation for std::signbit.

Parameters

arg	number to check

Return values

true	for negative number
false	for positive number

◆ sin()

half half_float::sin ( half arg )

inline

Sine function.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::sin.

Parameters

arg	function argument

Returns: sine value of arg

Exceptions

FE_INVALID	for signaling NaN or infinity
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ sincos()

void half_float::sincos	(	half	arg,
		half *	sin,
		half *	cos
	)

inline

Compute sine and cosine simultaneously.

This returns the same results as sin() and cos() but is faster than calling each function individually.

This function is exact to rounding for all rounding modes.

Parameters

arg	function argument
sin	variable to take sine of arg
cos	variable to take cosine of arg

Exceptions

FE_INVALID	for signaling NaN or infinity
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ sinh()

half half_float::sinh ( half arg )

inline

Hyperbolic sine.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::sinh.

Parameters

arg	function argument

Returns: hyperbolic sine value of arg

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ sqrt()

half half_float::sqrt ( half arg )

inline

Square root.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::sqrt.

Parameters

arg	function argument

Returns: square root of arg

Exceptions

FE_INVALID	for signaling NaN and negative arguments
FE_INEXACT	according to rounding

◆ tan()

half half_float::tan ( half arg )

inline

Tangent function.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::tan.

Parameters

arg	function argument

Returns: tangent value of arg

Exceptions

FE_INVALID	for signaling NaN or infinity
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ tanh()

half half_float::tanh ( half arg )

inline

Hyperbolic tangent.

This function is exact to rounding for all rounding modes.

See also: Documentation for std::tanh.

Parameters

arg	function argument

Returns: hyperbolic tangent value of arg

Exceptions

FE_INVALID	for signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ tgamma()

half half_float::tgamma ( half arg )

inline

Gamma function.

This function may be 1 ULP off the correctly rounded exact result for any rounding mode in <0.25% of inputs.

See also: Documentation for std::tgamma.

Parameters

arg	function argument

Returns: gamma function value of arg

Exceptions

FE_INVALID	for signaling NaN, negative infinity or negative integer arguments
FE_DIVBYZERO	for 0
FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

◆ trunc()

half half_float::trunc ( half arg )

inline

Nearest integer not greater in magnitude than half value.

See also: Documentation for std::trunc.

Parameters

arg	half to round

Returns: nearest integer not greater in magnitude than arg

Exceptions

FE_INVALID	for signaling NaN
FE_INEXACT	if value had to be rounded

Namespaces

Classes

Functions

Detailed Description

Function Documentation

◆ abs()

◆ acos()

◆ acosh()

◆ asin()

◆ asinh()

◆ atan()

◆ atan2()

◆ atanh()

◆ cbrt()

◆ ceil()

◆ copysign()

◆ cos()

◆ cosh()

◆ erf()

◆ erfc()

◆ exp()

◆ exp2()

◆ expm1()

◆ fabs()

◆ fdim()

◆ feclearexcept()

◆ fegetexceptflag()

◆ feraiseexcept()

◆ fesetexceptflag()

◆ fetestexcept()

◆ fethrowexcept()

◆ floor()

◆ fma()

◆ fmax()

◆ fmin()

◆ fmod()

◆ fpclassify()

◆ frexp()

◆ half_cast() [1/2]

◆ half_cast() [2/2]

◆ hypot() [1/2]

◆ hypot() [2/2]

◆ ilogb()

◆ isfinite()

◆ isgreater()

◆ isgreaterequal()

◆ isinf()

◆ isless()

◆ islessequal()

◆ islessgreater()

◆ isnan()

◆ isnormal()

◆ isunordered()

◆ ldexp()

◆ lgamma()

◆ log()

◆ log10()

◆ log1p()

◆ log2()

◆ logb()

◆ lrint()

◆ lround()

◆ modf()

◆ nanh()

◆ nearbyint()

◆ nextafter()

◆ nexttoward()

◆ operator!=()

◆ operator*()

◆ operator+() [1/2]

◆ operator+() [2/2]

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator/()

◆ operator<()

◆ operator<<()

◆ operator<=()

◆ operator==()

◆ operator>()

◆ operator>=()