Qrack  9.9
General classical-emulating-quantum development framework
Private Member Functions | Private Attributes | Static Private Attributes | Friends | List of all members
half_float::half Class Reference

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...
 
halfoperator= (float rhs)
 Assignment operator. More...
 
Arithmetic updates
halfoperator+= (half rhs)
 Arithmetic assignment. More...
 
halfoperator-= (half rhs)
 Arithmetic assignment. More...
 
halfoperator*= (half rhs)
 Arithmetic assignment. More...
 
halfoperator/= (half rhs)
 Arithmetic assignment. More...
 
halfoperator+= (float rhs)
 Arithmetic assignment. More...
 
halfoperator-= (float rhs)
 Arithmetic assignment. More...
 
halfoperator*= (float rhs)
 Arithmetic assignment. More...
 
halfoperator/= (float rhs)
 Arithmetic assignment. More...
 
Increment and decrement
halfoperator++ ()
 Prefix increment. More...
 
halfoperator-- ()
 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
rhsfloat to convert
Exceptions
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding

◆ half() [3/3]

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

Constructor.

Parameters
bitsbinary 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
rhssingle-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
Ttype of concrete half expression
Parameters
rhshalf 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
rhssingle-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
Ttype of concrete half expression
Parameters
rhshalf 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
rhssingle-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
Ttype of concrete half expression
Parameters
rhshalf 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
rhssingle-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
Ttype of concrete half expression
Parameters
rhshalf 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
rhssingle-precision value to copy from
Returns
reference to this half
Exceptions
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
arc cosine value of arg
Exceptions
FE_INVALIDfor signaling NaN or if abs(arg) > 1
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
area cosine value of arg
Exceptions
FE_INVALIDfor signaling NaN or arguments <1
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
arc sine value of arg
Exceptions
FE_INVALIDfor signaling NaN or if abs(arg) > 1
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
area sine value of arg
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
arc tangent value of arg
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
ynumerator
xdenominator
Returns
arc tangent value
Exceptions
FE_INVALIDif x or y is signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
area tangent value of arg
Exceptions
FE_INVALIDfor signaling NaN or if abs(arg) > 1
FE_DIVBYZEROfor +/-1
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
cubic root of arg
Exceptions
FE_INVALIDfor signaling NaN
FE_INEXACTaccording to rounding

◆ ceil

half ceil ( half  arg)
friend

Nearest integer not less than half value.

See also: Documentation for std::ceil.

Parameters
arghalf to round
Returns
nearest integer not less than arg
Exceptions
FE_INVALIDfor signaling NaN
FE_INEXACTif value had to be rounded

◆ copysign

HALF_CONSTEXPR half copysign ( half  x,
half  y 
)
friend

Take sign.

See also: Documentation for std::copysign.

Parameters
xvalue to change sign for
yvalue 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
argfunction argument
Returns
cosine value of arg
Exceptions
FE_INVALIDfor signaling NaN or infinity
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
hyperbolic cosine value of arg
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
error function value of arg
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
1 minus error function value of arg
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
e raised to arg
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
2 raised to arg
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
e raised to arg and subtracted by 1
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding

◆ fabs

HALF_CONSTEXPR half fabs ( half  arg)
friend

Absolute value.

See also: Documentation for std::fabs.

Parameters
argoperand
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
xfirst operand
ysecond 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
arghalf to round
Returns
nearest integer not greater than arg
Exceptions
FE_INVALIDfor signaling NaN
FE_INEXACTif 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
xfirst operand
ysecond operand
zthird operand
Returns
( x * y ) + z rounded as one operation.
Exceptions
FE_INVALIDaccording to operator*() and operator+() unless any argument is a quiet NaN and no argument is a signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
xfirst operand
ysecond operand
Returns
maximum of operands, ignoring quiet NaNs
Exceptions
FE_INVALIDif 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
xfirst operand
ysecond operand
Returns
minimum of operands, ignoring quiet NaNs
Exceptions
FE_INVALIDif x or y is signaling NaN

◆ fmod

half fmod ( half  x,
half  y 
)
friend

Remainder of division.

See also: Documentation for std::fmod.

Parameters
xfirst operand
ysecond operand
Returns
remainder of floating-point division.
Exceptions
FE_INVALIDif 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
argnumber to classify
Return values
FP_ZEROfor positive and negative zero
FP_SUBNORMALfor subnormal numbers
FP_INFINITYfor positive and negative infinity
FP_NANfor NaNs
FP_NORMALfor all other (normal) values

◆ frexp

half frexp ( half  arg,
int *  exp 
)
friend

Decompress floating-point number.

See also: Documentation for std::frexp.

Parameters
argnumber to decompress
expaddress to store exponent at
Returns
significant in range [0.5, 1)
Exceptions
FE_INVALIDfor 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
xfirst argument
ysecond argument
Returns
square root of sum of squares without internal over- or underflows
Exceptions
FE_INVALIDif x or y is signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
xfirst argument
ysecond argument
zthird argument
Returns
square root of sum of squares without internal over- or underflows
Exceptions
FE_INVALIDif x, y or z is signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding of the final square root

◆ ilogb

int ilogb ( half  arg)
friend

Extract exponent.

See also: Documentation for std::ilogb.

Parameters
argnumber to query
Returns
floating-point exponent
Return values
FP_ILOGB0for zero
FP_ILOGBNANfor NaN
INT_MAXfor infinity
Exceptions
FE_INVALIDfor 0 or infinite values

◆ isfinite

HALF_CONSTEXPR bool isfinite ( half  arg)
friend

Check if finite number.

See also: Documentation for std::isfinite.

Parameters
argnumber to check
Return values
trueif neither infinity nor NaN
falseelse

◆ isgreater

HALF_CONSTEXPR bool isgreater ( half  x,
half  y 
)
friend

Quiet comparison for greater than.

See also: Documentation for std::isgreater.

Parameters
xfirst operand
ysecond operand
Return values
trueif x greater than y
falseelse

◆ isgreaterequal

HALF_CONSTEXPR bool isgreaterequal ( half  x,
half  y 
)
friend

Quiet comparison for greater equal.

See also: Documentation for std::isgreaterequal.

Parameters
xfirst operand
ysecond operand
Return values
trueif 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
argnumber to check
Return values
truefor positive or negative infinity
falseelse

◆ isless

HALF_CONSTEXPR bool isless ( half  x,
half  y 
)
friend

Quiet comparison for less than.

See also: Documentation for std::isless.

Parameters
xfirst operand
ysecond operand
Return values
trueif x less than y
falseelse

◆ islessequal

HALF_CONSTEXPR bool islessequal ( half  x,
half  y 
)
friend

Quiet comparison for less equal.

See also: Documentation for std::islessequal.

Parameters
xfirst operand
ysecond operand
Return values
trueif x less equal y
falseelse

◆ islessgreater

HALF_CONSTEXPR bool islessgreater ( half  x,
half  y 
)
friend

Quiet comarison for less or greater.

See also: Documentation for std::islessgreater.

Parameters
xfirst operand
ysecond operand
Return values
trueif either less or greater
falseelse

◆ isnan

HALF_CONSTEXPR bool isnan ( half  arg)
friend

Check for NaN.

See also: Documentation for std::isnan.

Parameters
argnumber to check
Return values
truefor NaNs
falseelse

◆ isnormal

HALF_CONSTEXPR bool isnormal ( half  arg)
friend

Check if normal number.

See also: Documentation for std::isnormal.

Parameters
argnumber to check
Return values
trueif normal number
falseif 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
argfunction argument
Returns
natural logarith of gamma function for arg
Exceptions
FE_INVALIDfor signaling NaN
FE_DIVBYZEROfor 0 or negative integer arguments
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
logarithm of arg to base e
Exceptions
FE_INVALIDfor signaling NaN or negative argument
FE_DIVBYZEROfor 0
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
logarithm of arg to base 10
Exceptions
FE_INVALIDfor signaling NaN or negative argument
FE_DIVBYZEROfor 0
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
logarithm of arg plus 1 to base e
Exceptions
FE_INVALIDfor signaling NaN or argument <-1
FE_DIVBYZEROfor -1
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
logarithm of arg to base 2
Exceptions
FE_INVALIDfor signaling NaN or negative argument
FE_DIVBYZEROfor 0
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding

◆ logb

half logb ( half  arg)
friend

Extract exponent.

See also: Documentation for std::logb.

Parameters
argnumber to query
Returns
floating-point exponent
Exceptions
FE_INVALIDfor signaling NaN
FE_DIVBYZEROfor 0

◆ lrint

long lrint ( half  arg)
friend

Nearest integer using half's internal rounding mode.

See also: Documentation for std::lrint.

Parameters
arghalf expression to round
Returns
nearest integer using default rounding mode
Exceptions
FE_INVALIDif value is not representable as long
FE_INEXACTif value had to be rounded

◆ lround

long lround ( half  arg)
friend

Nearest integer.

See also: Documentation for std::lround.

Parameters
arghalf to round
Returns
nearest integer, rounded away from zero in half-way cases
Exceptions
FE_INVALIDif 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
argnumber to decompress
iptraddress to store integer part at
Returns
fractional part
Exceptions
FE_INVALIDfor signaling NaN

◆ nanh

half nanh ( const char *  arg)
friend

Get NaN value.

See also: Documentation for std::nan.

Parameters
argstring 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
arghalf expression to round
Returns
nearest integer using default rounding mode
Exceptions
FE_INVALIDfor signaling NaN

◆ nextafter

half nextafter ( half  from,
half  to 
)
friend

Next representable value.

See also: Documentation for std::nextafter.

Parameters
fromvalue to compute next representable value for
todirection towards which to compute next value
Returns
next representable value after from in direction towards to
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOWfor infinite result from finite argument
FE_UNDERFLOWfor subnormal result

◆ nexttoward

half nexttoward ( half  from,
long double  to 
)
friend

Next representable value.

See also: Documentation for std::nexttoward.

Parameters
fromvalue to compute next representable value for
todirection towards which to compute next value
Returns
next representable value after from in direction towards to
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOWfor infinite result from finite argument
FE_UNDERFLOWfor subnormal result

◆ operator!=

HALF_CONSTEXPR_NOERR bool operator!= ( half  x,
half  y 
)
friend

Comparison for inequality.

Parameters
xfirst operand
ysecond operand
Return values
trueif operands not equal
falseelse
Exceptions
FE_INVALIDif 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
xleft operand
yright operand
Returns
product of half expressions
Exceptions
FE_INVALIDif multiplying 0 with infinity or if x or y is signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding

◆ operator+

half operator+ ( half  x,
half  y 
)
friend

Addition.

This operation is exact to rounding for all rounding modes.

Parameters
xleft operand
yright operand
Returns
sum of half expressions
Exceptions
FE_INVALIDif x and y are infinities with different signs or signaling NaNs
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding

◆ operator- [1/2]

HALF_CONSTEXPR half operator- ( half  arg)
friend

Negation.

Parameters
argoperand
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
xleft operand
yright operand
Returns
difference of half expressions
Exceptions
FE_INVALIDif x and y are infinities with equal signs or signaling NaNs
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding

◆ operator/

half operator/ ( half  x,
half  y 
)
friend

Division.

This operation is exact to rounding for all rounding modes.

Parameters
xleft operand
yright operand
Returns
quotient of half expressions
Exceptions
FE_INVALIDif dividing 0s or infinities with each other or if x or y is signaling NaN
FE_DIVBYZEROif dividing finite value by 0
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding

◆ operator<

HALF_CONSTEXPR_NOERR bool operator< ( half  x,
half  y 
)
friend

Comparison for less than.

Parameters
xfirst operand
ysecond operand
Return values
trueif x less than y
falseelse
Exceptions
FE_INVALIDif 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
outoutput stream to write into
arghalf expression to write
Returns
reference to output stream

◆ operator<=

HALF_CONSTEXPR_NOERR bool operator<= ( half  x,
half  y 
)
friend

Comparison for less equal.

Parameters
xfirst operand
ysecond operand
Return values
trueif x less equal y
falseelse
Exceptions
FE_INVALIDif x or y is NaN

◆ operator==

HALF_CONSTEXPR_NOERR bool operator== ( half  x,
half  y 
)
friend

Comparison for equality.

Parameters
xfirst operand
ysecond operand
Return values
trueif operands equal
falseelse
Exceptions
FE_INVALIDif x or y is NaN

◆ operator>

HALF_CONSTEXPR_NOERR bool operator> ( half  x,
half  y 
)
friend

Comparison for greater than.

Parameters
xfirst operand
ysecond operand
Return values
trueif x greater than y
falseelse
Exceptions
FE_INVALIDif x or y is NaN

◆ operator>=

HALF_CONSTEXPR_NOERR bool operator>= ( half  x,
half  y 
)
friend

Comparison for greater equal.

Parameters
xfirst operand
ysecond operand
Return values
trueif x greater equal y
falseelse
Exceptions
FE_INVALIDif 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
ininput stream to read from
arghalf to read into
Returns
reference to input stream
Exceptions
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
xbase
yexponent
Returns
x raised to y
Exceptions
FE_INVALIDif x or y is signaling NaN or if x is finite an negative and y is finite and not integral
FE_DIVBYZEROif x is 0 and y is negative
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding

◆ remainder

half remainder ( half  x,
half  y 
)
friend

Remainder of division.

See also: Documentation for std::remainder.

Parameters
xfirst operand
ysecond operand
Returns
remainder of floating-point division.
Exceptions
FE_INVALIDif 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
xfirst operand
ysecond operand
quoaddress to store some bits of quotient at
Returns
remainder of floating-point division.
Exceptions
FE_INVALIDif 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
arghalf expression to round
Returns
nearest integer using default rounding mode
Exceptions
FE_INVALIDfor signaling NaN
FE_INEXACTif value had to be rounded

◆ round

half round ( half  arg)
friend

Nearest integer.

See also: Documentation for std::round.

Parameters
arghalf to round
Returns
nearest integer, rounded away from zero in half-way cases
Exceptions
FE_INVALIDfor signaling NaN
FE_INEXACTif 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
argfunction argument
Returns
reciprocal of square root of arg
Exceptions
FE_INVALIDfor signaling NaN and negative arguments
FE_INEXACTaccording 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
argnumber to modify
exppower of two to multiply with
Returns
arg multplied by 2 raised to exp
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding

◆ signbit

HALF_CONSTEXPR bool signbit ( half  arg)
friend

Check sign.

See also: Documentation for std::signbit.

Parameters
argnumber to check
Return values
truefor negative number
falsefor 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
argfunction argument
Returns
sine value of arg
Exceptions
FE_INVALIDfor signaling NaN or infinity
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
sinvariable to take sine of arg
cosvariable to take cosine of arg
Exceptions
FE_INVALIDfor signaling NaN or infinity
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
hyperbolic sine value of arg
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
square root of arg
Exceptions
FE_INVALIDfor signaling NaN and negative arguments
FE_INEXACTaccording 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
argfunction argument
Returns
tangent value of arg
Exceptions
FE_INVALIDfor signaling NaN or infinity
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
hyperbolic tangent value of arg
Exceptions
FE_INVALIDfor signaling NaN
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording 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
argfunction argument
Returns
gamma function value of arg
Exceptions
FE_INVALIDfor signaling NaN, negative infinity or negative integer arguments
FE_DIVBYZEROfor 0
FE_OVERFLOW,...UNDERFLOW,...INEXACTaccording to rounding

◆ trunc

half trunc ( half  arg)
friend

Nearest integer not greater in magnitude than half value.

See also: Documentation for std::trunc.

Parameters
arghalf to round
Returns
nearest integer not greater in magnitude than arg
Exceptions
FE_INVALIDfor signaling NaN
FE_INEXACTif 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: