Half-precision floating-point type. More...

#include <half.hpp>

Public Member Functions
Construction and assignment
HALF_CONSTEXPR	half () HALF_NOEXCEPT
	Default constructor. More...

	half (float rhs)
	Conversion constructor. More...

	operator float () const
	Conversion to single-precision. More...

half &	operator= (float rhs)
	Assignment operator. More...

Arithmetic updates
half &	operator+= (half rhs)
	Arithmetic assignment. More...

half &	operator-= (half rhs)
	Arithmetic assignment. More...

half &	operator*= (half rhs)
	Arithmetic assignment. More...

half &	operator/= (half rhs)
	Arithmetic assignment. More...

half &	operator+= (float rhs)
	Arithmetic assignment. More...

half &	operator-= (float rhs)
	Arithmetic assignment. More...

half &	operator*= (float rhs)
	Arithmetic assignment. More...

half &	operator/= (float rhs)
	Arithmetic assignment. More...

Increment and decrement
half &	operator++ ()
	Prefix increment. More...

half &	operator-- ()
	Prefix decrement. More...

half	operator++ (int)
	Postfix increment. More...

half	operator-- (int)
	Postfix decrement. More...

Private Member Functions
HALF_CONSTEXPR	half (detail::binary_t, unsigned int bits) HALF_NOEXCEPT
	Constructor. More...

Private Attributes
detail::uint16	data_
	Internal binary representation. More...

Static Private Attributes
static const std::float_round_style	round_style = (std::float_round_style)(HALF_ROUND_STYLE)
	Rounding mode to use. More...

Friends
template<typename , typename , std::float_round_style >
struct	detail::half_caster

class	std::numeric_limits< half >

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

half	fma (half, half, half)
	Fused multiply add. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Detailed Description

Half-precision floating-point type.

This class implements an IEEE-conformant half-precision floating-point type with the usual arithmetic operators and conversions. It is implicitly convertible to single-precision floating-point, which makes artihmetic expressions and functions with mixed-type operands to be of the most precise operand type.

According to the C++98/03 definition, the half type is not a POD type. But according to C++11's less strict and extended definitions it is both a standard layout type and a trivially copyable type (even if not a POD type), which means it can be standard-conformantly copied using raw binary copies. But in this context some more words about the actual size of the type. Although the half is representing an IEEE 16-bit type, it does not neccessarily have to be of exactly 16-bits size. But on any reasonable implementation the actual binary representation of this type will most probably not ivolve any additional "magic" or padding beyond the simple binary representation of the underlying 16-bit IEEE number, even if not strictly guaranteed by the standard. But even then it only has an actual size of 16 bits if your C++ implementation supports an unsigned integer type of exactly 16 bits width. But this should be the case on nearly any reasonable platform.

So if your C++ implementation is not totally exotic or imposes special alignment requirements, it is a reasonable assumption that the data of a half is just comprised of the 2 bytes of the underlying IEEE representation.

Constructor & Destructor Documentation

◆ half() [1/3]

HALF_CONSTEXPR half_float::half::half ( )

inline

Default constructor.

This initializes the half to 0. Although this does not match the builtin types' default-initialization semantics and may be less efficient than no initialization, it is needed to provide proper value-initialization semantics.

◆ half() [2/3]

half_float::half::half ( float rhs )

inlineexplicit

Conversion constructor.

Parameters

rhs	float to convert

Exceptions

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

◆ half() [3/3]

HALF_CONSTEXPR half_float::half::half	(	detail::binary_t	,
		unsigned int	bits
	)

inlineprivate

Constructor.

Parameters

bits	binary representation to set half to

Member Function Documentation

◆ operator float()

half_float::half::operator float ( ) const

inline

Conversion to single-precision.

Returns: single precision value representing expression value

◆ operator*=() [1/2]

half& half_float::half::operator*= ( float rhs )

inline

Arithmetic assignment.

Parameters

rhs	single-precision value to multiply with

Returns: reference to this half

Exceptions

FE_... according to operator=()

◆ operator*=() [2/2]

half& half_float::half::operator*= ( half rhs )

inline

Arithmetic assignment.

Template Parameters

T	type of concrete half expression

Parameters

rhs	half expression to multiply with

Returns: reference to this half

Exceptions

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

◆ operator++() [1/2]

half& half_float::half::operator++ ( )

inline

Prefix increment.

Returns: incremented half value

Exceptions

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

◆ operator++() [2/2]

half half_float::half::operator++ ( int )

inline

Postfix increment.

Returns: non-incremented half value

Exceptions

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

◆ operator+=() [1/2]

half& half_float::half::operator+= ( float rhs )

inline

Arithmetic assignment.

Parameters

rhs	single-precision value to add

Returns: reference to this half

Exceptions

FE_... according to operator=()

◆ operator+=() [2/2]

half& half_float::half::operator+= ( half rhs )

inline

Arithmetic assignment.

Template Parameters

T	type of concrete half expression

Parameters

rhs	half expression to add

Returns: reference to this half

Exceptions

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

◆ operator--() [1/2]

half& half_float::half::operator-- ( )

inline

Prefix decrement.

Returns: decremented half value

Exceptions

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

◆ operator--() [2/2]

half half_float::half::operator-- ( int )

inline

Postfix decrement.

Returns: non-decremented half value

Exceptions

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

◆ operator-=() [1/2]

half& half_float::half::operator-= ( float rhs )

inline

Arithmetic assignment.

Parameters

rhs	single-precision value to subtract

Returns: reference to this half

Exceptions

FE_... according to operator=()

◆ operator-=() [2/2]

half& half_float::half::operator-= ( half rhs )

inline

Arithmetic assignment.

Template Parameters

T	type of concrete half expression

Parameters

rhs	half expression to subtract

Returns: reference to this half

Exceptions

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

◆ operator/=() [1/2]

half& half_float::half::operator/= ( float rhs )

inline

Arithmetic assignment.

Parameters

rhs	single-precision value to divide by

Returns: reference to this half

Exceptions

FE_... according to operator=()

◆ operator/=() [2/2]

half& half_float::half::operator/= ( half rhs )

inline

Arithmetic assignment.

Template Parameters

T	type of concrete half expression

Parameters

rhs	half expression to divide by

Returns: reference to this half

Exceptions

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

◆ operator=()

half& half_float::half::operator= ( float rhs )

inline

Assignment operator.

Parameters

rhs	single-precision value to copy from

Returns: reference to this half

Exceptions

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

Friends And Related Function Documentation

◆ acos

half acos ( half arg )

friend

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 acosh ( half arg )

friend

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 asin ( half arg )

friend

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 asinh ( half arg )

friend

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 atan ( half arg )

friend

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 atan2	(	half	y,
		half	x
	)

friend

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 atanh ( half arg )

friend

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 cbrt ( half arg )

friend

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 ceil ( half arg )

friend

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 copysign	(	half	x,
		half	y
	)

friend

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 cos ( half arg )

friend

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 cosh ( half arg )

friend

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

◆ detail::half_caster

template<typename , typename , std::float_round_style >

friend struct detail::half_caster

friend

◆ erf

half erf ( half arg )

friend

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 erfc ( half arg )

friend

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 exp ( half arg )

friend

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 exp2 ( half arg )

friend

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 expm1 ( half arg )

friend

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 fabs ( half arg )

friend

Absolute value.

See also: Documentation for std::fabs.

Parameters

arg operand

Returns: absolute value of arg

◆ fdim

half fdim	(	half	x,
		half	y
	)

friend

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)

◆ floor

half floor ( half arg )

friend

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 fma	(	half	x,
		half	y,
		half	z
	)

friend

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 fmax	(	half	x,
		half	y
	)

friend

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 fmin	(	half	x,
		half	y
	)

friend

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 fmod	(	half	x,
		half	y
	)

friend

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 fpclassify ( half arg )

friend

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 frexp	(	half	arg,
		int *	exp
	)

friend

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

◆ hypot [1/2]

half hypot	(	half	x,
		half	y
	)

friend

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 hypot	(	half	x,
		half	y,
		half	z
	)

friend

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 ilogb ( half arg )

friend

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 isfinite ( half arg )

friend

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 isgreater	(	half	x,
		half	y
	)

friend

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 isgreaterequal	(	half	x,
		half	y
	)

friend

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 isinf ( half arg )

friend

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 isless	(	half	x,
		half	y
	)

friend

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 islessequal	(	half	x,
		half	y
	)

friend

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 islessgreater	(	half	x,
		half	y
	)

friend

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 isnan ( half arg )

friend

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 isnormal ( half arg )

friend

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

◆ lgamma

half lgamma ( half arg )

friend

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 log ( half arg )

friend

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 log10 ( half arg )

friend

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 log1p ( half arg )

friend

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 log2 ( half arg )

friend

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 logb ( half arg )

friend

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 lrint ( half arg )

friend

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 lround ( half arg )

friend

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 modf	(	half	arg,
		half *	iptr
	)

friend

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 nanh ( const char * arg )

friend

Get NaN value.

See also: Documentation for std::nan.

Parameters

arg	string code

Returns: quiet NaN

◆ nearbyint

half nearbyint ( half arg )

friend

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 nextafter	(	half	from,
		half	to
	)

friend

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 nexttoward	(	half	from,
		long double	to
	)

friend

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 operator!=	(	half	x,
		half	y
	)

friend

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 operator*	(	half	x,
		half	y
	)

friend

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+

half operator+	(	half	x,
		half	y
	)

friend

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 operator- ( half arg )

friend

Negation.

Parameters

arg operand

Returns: negated operand

◆ operator- [2/2]

half operator-	(	half	x,
		half	y
	)

friend

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 operator/	(	half	x,
		half	y
	)

friend

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 operator<	(	half	x,
		half	y
	)

friend

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>& operator<<	(	std::basic_ostream< charT, traits > &	out,
		half	arg
	)

friend

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 operator<=	(	half	x,
		half	y
	)

friend

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 operator==	(	half	x,
		half	y
	)

friend

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 operator>	(	half	x,
		half	y
	)

friend

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 operator>=	(	half	x,
		half	y
	)

friend

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>& operator>>	(	std::basic_istream< charT, traits > &	in,
		half &	arg
	)

friend

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 pow	(	half	x,
		half	y
	)

friend

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 remainder	(	half	x,
		half	y
	)

friend

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 remquo	(	half	x,
		half	y,
		int *	quo
	)

friend

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 rint ( half arg )

friend

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 round ( half arg )

friend

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 rsqrt ( half arg )

friend

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 scalbln	(	half	arg,
		long	exp
	)

friend

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

◆ signbit

HALF_CONSTEXPR bool signbit ( half arg )

friend

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 sin ( half arg )

friend

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 sincos	(	half	arg,
		half *	sin,
		half *	cos
	)

friend

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 sinh ( half arg )

friend

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 sqrt ( half arg )

friend

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

◆ std::numeric_limits< half >

friend class std::numeric_limits< half >

friend

◆ tan

half tan ( half arg )

friend

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 tanh ( half arg )

friend

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 tgamma ( half arg )

friend

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 trunc ( half arg )

friend

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

Member Data Documentation

◆ data_

detail::uint16 half_float::half::data_

private

Internal binary representation.

◆ round_style

const std::float_round_style half_float::half::round_style = (std::float_round_style)(HALF_ROUND_STYLE)

staticprivate

Rounding mode to use.

The documentation for this class was generated from the following file:

include/common/half.hpp

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ half() [1/3]

◆ half() [2/3]

◆ half() [3/3]

Member Function Documentation

◆ operator float()

◆ operator*=() [1/2]

◆ operator*=() [2/2]

◆ operator++() [1/2]

◆ operator++() [2/2]

◆ operator+=() [1/2]

◆ operator+=() [2/2]

◆ operator--() [1/2]

◆ operator--() [2/2]

◆ operator-=() [1/2]

◆ operator-=() [2/2]

◆ operator/=() [1/2]

◆ operator/=() [2/2]

◆ operator=()

Friends And Related Function Documentation

◆ acos

◆ acosh

◆ asin

◆ asinh

◆ atan

◆ atan2

◆ atanh

◆ cbrt

◆ ceil

◆ copysign

◆ cos

◆ cosh

◆ detail::half_caster

◆ erf

◆ erfc

◆ exp

◆ exp2

◆ expm1

◆ fabs

◆ fdim

◆ floor

◆ fma

◆ fmax

◆ fmin

◆ fmod

◆ fpclassify

◆ frexp

◆ hypot [1/2]

◆ hypot [2/2]

◆ ilogb

◆ isfinite

◆ isgreater

◆ isgreaterequal

◆ isinf

◆ isless

◆ islessequal

◆ islessgreater

◆ isnan

◆ isnormal

◆ lgamma

◆ log

◆ log10

◆ log1p

◆ log2

◆ logb

◆ lrint

◆ lround

◆ modf

◆ nanh

◆ nearbyint

◆ nextafter

◆ nexttoward

◆ operator!=

◆ operator*