half_float::half Class Reference

#include <half.hpp>

Public Member Functions
Construction and assignment
HALF_CONSTEXPR	half () HALF_NOEXCEPT
	half (float rhs)
	operator float () const
half &	operator= (float rhs)
Arithmetic updates
half &	operator+= (half rhs)
half &	operator-= (half rhs)
half &	operator*= (half rhs)
half &	operator/= (half rhs)
half &	operator+= (float rhs)
half &	operator-= (float rhs)
half &	operator*= (float rhs)
half &	operator/= (float rhs)
Increment and decrement
half &	operator++ ()
half &	operator-- ()
half	operator++ (int)
half	operator-- (int)

Friends
template<typename , typename , std::float_round_style >
struct	detail::half_caster
class	std::numeric_limits< half >
HALF_CONSTEXPR_NOERR bool	operator== (half, half)
HALF_CONSTEXPR_NOERR bool	operator!= (half, half)
HALF_CONSTEXPR_NOERR bool	operator< (half, half)
HALF_CONSTEXPR_NOERR bool	operator> (half, half)
HALF_CONSTEXPR_NOERR bool	operator<= (half, half)
HALF_CONSTEXPR_NOERR bool	operator>= (half, half)
HALF_CONSTEXPR half	operator- (half)
half	operator+ (half, half)
half	operator- (half, half)
half	operator* (half, half)
half	operator/ (half, half)
HALF_CONSTEXPR half	fabs (half)
half	fmod (half, half)
half	remainder (half, half)
half	remquo (half, half, int *)
half	fma (half, half, half)
HALF_CONSTEXPR_NOERR half	fmax (half, half)
HALF_CONSTEXPR_NOERR half	fmin (half, half)
half	fdim (half, half)
half	nanh (const char *)
half	exp (half)
half	exp2 (half)
half	expm1 (half)
half	log (half)
half	log10 (half)
half	log2 (half)
half	log1p (half)
half	sqrt (half)
half	rsqrt (half)
half	cbrt (half)
half	hypot (half, half)
half	hypot (half, half, half)
half	pow (half, half)
void	sincos (half, half *, half *)
half	sin (half)
half	cos (half)
half	tan (half)
half	asin (half)
half	acos (half)
half	atan (half)
half	atan2 (half, half)
half	sinh (half)
half	cosh (half)
half	tanh (half)
half	asinh (half)
half	acosh (half)
half	atanh (half)
half	erf (half)
half	erfc (half)
half	lgamma (half)
half	tgamma (half)
half	ceil (half)
half	floor (half)
half	trunc (half)
half	round (half)
long	lround (half)
half	rint (half)
long	lrint (half)
half	nearbyint (half)
half	frexp (half, int *)
half	scalbln (half, long)
half	modf (half, half *)
int	ilogb (half)
half	logb (half)
half	nextafter (half, half)
half	nexttoward (half, long double)
HALF_CONSTEXPR half	copysign (half, half)
HALF_CONSTEXPR int	fpclassify (half)
HALF_CONSTEXPR bool	isfinite (half)
HALF_CONSTEXPR bool	isinf (half)
HALF_CONSTEXPR bool	isnan (half)
HALF_CONSTEXPR bool	isnormal (half)
HALF_CONSTEXPR bool	signbit (half)
HALF_CONSTEXPR bool	isgreater (half, half)
HALF_CONSTEXPR bool	isgreaterequal (half, half)
HALF_CONSTEXPR bool	isless (half, half)
HALF_CONSTEXPR bool	islessequal (half, half)
HALF_CONSTEXPR bool	islessgreater (half, half)

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.

Definition at line 5090 of file half.hpp.

Constructor & Destructor Documentation

half() [1/2]

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.

Definition at line 5099 of file half.hpp.

                                        : data_()
    {
    }

half() [2/2]

half_float::half::half ( float  rhs )

inlineexplicit

Conversion constructor.

Parameters

rhs	float to convert

Exceptions

MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT

according to rounding

Definition at line 5106 of file half.hpp.

        : data_(static_cast<detail::uint16>(detail::float2half<round_style>(rhs)))
    {
    }

Member Function Documentation

operator float()

half_float::half::operator float ( ) const

inline

Conversion to single-precision.

Returns

single precision value representing expression value

Definition at line 5113 of file half.hpp.

    {
        return detail::half2float<float>(data_);
    }

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

Definition at line 5194 of file half.hpp.

    {
        return *this = *this * rhs;
    }

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)

Definition at line 5157 of file half.hpp.

    {
        return *this = *this * rhs;
    }

operator++() [1/2]

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

inline

Prefix increment.

Returns

incremented half value

Exceptions

FE_...

according to operator+(half,half)

Definition at line 5215 of file half.hpp.

    {
        return *this = *this + half(detail::binary, 0x3C00);
    }

operator++() [2/2]

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

inline

Postfix increment.

Returns

non-incremented half value

Exceptions

FE_...

according to operator+(half,half)

Definition at line 5231 of file half.hpp.

    {
        half out(*this);
        ++*this;
        return out;
    }

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

Definition at line 5176 of file half.hpp.

    {
        return *this = *this + rhs;
    }

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)

Definition at line 5137 of file half.hpp.

    {
        return *this = *this + rhs;
    }

operator--() [1/2]

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

inline

Prefix decrement.

Returns

decremented half value

Exceptions

FE_...

according to operator-(half,half)

Definition at line 5223 of file half.hpp.

    {
        return *this = *this + half(detail::binary, 0xBC00);
    }

operator--() [2/2]

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

inline

Postfix decrement.

Returns

non-decremented half value

Exceptions

FE_...

according to operator-(half,half)

Definition at line 5241 of file half.hpp.

    {
        half out(*this);
        --*this;
        return out;
    }

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

Definition at line 5185 of file half.hpp.

    {
        return *this = *this - rhs;
    }

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)

Definition at line 5147 of file half.hpp.

    {
        return *this = *this - rhs;
    }

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

Definition at line 5203 of file half.hpp.

    {
        return *this = *this / rhs;
    }

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)

Definition at line 5167 of file half.hpp.

    {
        return *this = *this / rhs;
    }

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

MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT

according to rounding

Definition at line 5122 of file half.hpp.

    {
        data_ = static_cast<detail::uint16>(detail::float2half<round_style>(rhs));
        return *this;
    }

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

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

Definition at line 6895 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::acos(detail::half2float<detail::internal_t>(arg.data_))));
#else
    unsigned int abs = arg.data_ & 0x7FFF, sign = arg.data_ >> 15;
    if (!abs)
        return half(detail::binary, detail::rounded<half::round_style, true>(0x3E48, 0, 1));
    if (abs >= 0x3C00)
        return half(detail::binary, (abs > 0x7C00) ? detail::signal(arg.data_) : (abs > 0x3C00) ? detail::invalid()
                                                                             : sign             ? detail::rounded<half::round_style, true>(0x4248, 0, 1)
                                                                                                : 0);
    std::pair<detail::uint32, detail::uint32> cs = detail::atan2_args(abs);
    detail::uint32 m = detail::atan2(cs.second, cs.first, 28);
    return half(detail::binary, detail::fixed2half<half::round_style, 31, false, true, true>(sign ? (0xC90FDAA2 - m) : m, 15, 0, sign));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN or arguments <1
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 7126 of file half.hpp.

{
#if defined(HALF_ARITHMETIC_TYPE) && HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::acosh(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF;
    if ((arg.data_ & 0x8000) || abs < 0x3C00)
        return half(detail::binary, (abs <= 0x7C00) ? detail::invalid() : detail::signal(arg.data_));
    if (abs == 0x3C00)
        return half(detail::binary, 0);
    if (arg.data_ >= 0x7C00)
        return (abs > 0x7C00) ? half(detail::binary, detail::signal(arg.data_)) : arg;
    return half(detail::binary, detail::area<half::round_style, false>(arg.data_));
#endif
}

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

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

Definition at line 6866 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::asin(detail::half2float<detail::internal_t>(arg.data_))));
#else
    unsigned int abs = arg.data_ & 0x7FFF, sign = arg.data_ & 0x8000;
    if (!abs)
        return arg;
    if (abs >= 0x3C00)
        return half(detail::binary, (abs > 0x7C00) ? detail::signal(arg.data_) : (abs > 0x3C00) ? detail::invalid()
                                                                                                : detail::rounded<half::round_style, true>(sign | 0x3E48, 0, 1));
    if (abs < 0x2900)
        return half(detail::binary, detail::rounded<half::round_style, true>(arg.data_, 0, 1));
    if (half::round_style != std::round_to_nearest && (abs == 0x2B44 || abs == 0x2DC3))
        return half(detail::binary, detail::rounded<half::round_style, true>(arg.data_ + 1, 1, 1));
    std::pair<detail::uint32, detail::uint32> sc = detail::atan2_args(abs);
    detail::uint32 m = detail::atan2(sc.first, sc.second, (half::round_style == std::round_to_nearest) ? 27 : 26);
    return half(detail::binary, detail::fixed2half<half::round_style, 30, false, true, true>(m, 14, sign));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 7096 of file half.hpp.

{
#if defined(HALF_ARITHMETIC_TYPE) && HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::asinh(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF;
    if (!abs || abs >= 0x7C00)
        return (abs > 0x7C00) ? half(detail::binary, detail::signal(arg.data_)) : arg;
    if (abs <= 0x2900)
        return half(detail::binary, detail::rounded<half::round_style, true>(arg.data_ - 1, 1, 1));
    if (half::round_style != std::round_to_nearest)
        switch (abs)
        {
            case 0x32D4:
                return half(detail::binary, detail::rounded<half::round_style, true>(arg.data_ - 13, 1, 1));
            case 0x3B5B:
                return half(detail::binary, detail::rounded<half::round_style, true>(arg.data_ - 197, 1, 1));
        }
    return half(detail::binary, detail::area<half::round_style, true>(arg.data_));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6921 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::atan(detail::half2float<detail::internal_t>(arg.data_))));
#else
    unsigned int abs = arg.data_ & 0x7FFF, sign = arg.data_ & 0x8000;
    if (!abs)
        return arg;
    if (abs >= 0x7C00)
        return half(detail::binary, (abs == 0x7C00) ? detail::rounded<half::round_style, true>(sign | 0x3E48, 0, 1) : detail::signal(arg.data_));
    if (abs <= 0x2700)
        return half(detail::binary, detail::rounded<half::round_style, true>(arg.data_ - 1, 1, 1));
    int exp = (abs >> 10) + (abs <= 0x3FF);
    detail::uint32 my = (abs & 0x3FF) | ((abs > 0x3FF) << 10);
    detail::uint32 m = (exp > 15) ? detail::atan2(my << 19, 0x20000000 >> (exp - 15), (half::round_style == std::round_to_nearest) ? 26 : 24) : detail::atan2(my << (exp + 4), 0x20000000, (half::round_style == std::round_to_nearest) ? 30 : 28);
    return half(detail::binary, detail::fixed2half<half::round_style, 30, false, true, true>(m, 14, sign));
#endif
}

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

MU_HALF_FE_INVALID	if x or y is signaling NaN
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6950 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::atan2(detail::half2float<detail::internal_t>(y.data_), detail::half2float<detail::internal_t>(x.data_))));
#else
    unsigned int absx = x.data_ & 0x7FFF, absy = y.data_ & 0x7FFF, signx = x.data_ >> 15, signy = y.data_ & 0x8000;
    if (absx >= 0x7C00 || absy >= 0x7C00)
    {
        if (absx > 0x7C00 || absy > 0x7C00)
            return half(detail::binary, detail::signal(x.data_, y.data_));
        if (absy == 0x7C00)
            return half(detail::binary, (absx < 0x7C00) ? detail::rounded<half::round_style, true>(signy | 0x3E48, 0, 1) : signx ? detail::rounded<half::round_style, true>(signy | 0x40B6, 0, 1)
                                                                                                                                 : detail::rounded<half::round_style, true>(signy | 0x3A48, 0, 1));
        return (x.data_ == 0x7C00) ? half(detail::binary, signy) : half(detail::binary, detail::rounded<half::round_style, true>(signy | 0x4248, 0, 1));
    }
    if (!absy)
        return signx ? half(detail::binary, detail::rounded<half::round_style, true>(signy | 0x4248, 0, 1)) : y;
    if (!absx)
        return half(detail::binary, detail::rounded<half::round_style, true>(signy | 0x3E48, 0, 1));
    int d = (absy >> 10) + (absy <= 0x3FF) - (absx >> 10) - (absx <= 0x3FF);
    if (d > (signx ? 18 : 12))
        return half(detail::binary, detail::rounded<half::round_style, true>(signy | 0x3E48, 0, 1));
    if (signx && d < -11)
        return half(detail::binary, detail::rounded<half::round_style, true>(signy | 0x4248, 0, 1));
    if (!signx && d < ((half::round_style == std::round_toward_zero) ? -15 : -9))
    {
        for (; absy < 0x400; absy <<= 1, --d)
            ;
        detail::uint32 mx = ((absx << 1) & 0x7FF) | 0x800, my = ((absy << 1) & 0x7FF) | 0x800;
        int i = my < mx;
        d -= i;
        if (d < -25)
            return half(detail::binary, detail::underflow<half::round_style>(signy));
        my <<= 11 + i;
        return half(detail::binary, detail::fixed2half<half::round_style, 11, false, false, true>(my / mx, d + 14, signy, my % mx != 0));
    }
    detail::uint32 m = detail::atan2(((absy & 0x3FF) | ((absy > 0x3FF) << 10)) << (19 + ((d < 0) ? d : (d > 0) ? 0
                                                                                                               : -1)),
                                     ((absx & 0x3FF) | ((absx > 0x3FF) << 10)) << (19 - ((d > 0) ? d : (d < 0) ? 0
                                                                                                               : 1)));
    return half(detail::binary, detail::fixed2half<half::round_style, 31, false, true, true>(signx ? (0xC90FDAA2 - m) : m, 15, signy, signx));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN or if abs(arg) > 1
MU_HALF_FE_DIVBYZERO	for +/-1
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 7151 of file half.hpp.

{
#if defined(HALF_ARITHMETIC_TYPE) && HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::atanh(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, exp = 0;
    if (!abs)
        return arg;
    if (abs >= 0x3C00)
        return half(detail::binary, (abs == 0x3C00) ? detail::pole(arg.data_ & 0x8000) : (abs <= 0x7C00) ? detail::invalid()
                                                                                                         : detail::signal(arg.data_));
    if (abs < 0x2700)
        return half(detail::binary, detail::rounded<half::round_style, true>(arg.data_, 0, 1));
    detail::uint32 m = static_cast<detail::uint32>((abs & 0x3FF) | ((abs > 0x3FF) << 10)) << ((abs >> 10) + (abs <= 0x3FF) + 6), my = 0x80000000 + m, mx = 0x80000000 - m;
    for (; mx < 0x80000000; mx <<= 1, ++exp)
        ;
    int i = my >= mx, s;
    return half(detail::binary, detail::log2_post<half::round_style, 0xB8AA3B2A>(detail::log2((detail::divide64(my >> i, mx, s) + 1) >> 1, 27) + 0x10, exp + i - 1, 16, arg.data_ & 0x8000));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_INEXACT	according to rounding

Definition at line 6454 of file half.hpp.

{
#if defined(HALF_ARITHMETIC_TYPE) && HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::cbrt(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, exp = -15;
    if (!abs || abs == 0x3C00 || abs >= 0x7C00)
        return (abs > 0x7C00) ? half(detail::binary, detail::signal(arg.data_)) : arg;
    for (; abs < 0x400; abs <<= 1, --exp)
        ;
    detail::uint32 ilog = exp + (abs >> 10), sign = detail::sign_mask(ilog), f, m = (((ilog << 27) + (detail::log2(static_cast<detail::uint32>((abs & 0x3FF) | 0x400) << 20, 24) >> 4)) ^ sign) - sign;
    for (exp = 2; m < 0x80000000; m <<= 1, --exp)
        ;
    m = detail::multiply64(m, 0xAAAAAAAB);
    int i = m >> 31, s;
    exp += i;
    m <<= 1 - i;
    if (exp < 0)
    {
        f = m >> -exp;
        exp = 0;
    }
    else
    {
        f = (m << exp) & 0x7FFFFFFF;
        exp = m >> (31 - exp);
    }
    m = detail::exp2(f, (half::round_style == std::round_to_nearest) ? 29 : 26);
    if (sign)
    {
        if (m > 0x80000000)
        {
            m = detail::divide64(0x80000000, m, s);
            ++exp;
        }
        exp = -exp;
    }
    return half(detail::binary, (half::round_style == std::round_to_nearest) ? detail::fixed2half<half::round_style, 31, false, false, false>(m, exp + 14, arg.data_ & 0x8000) : detail::fixed2half<half::round_style, 23, false, false, false>((m + 0x80) >> 8, exp + 14, arg.data_ & 0x8000));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_INEXACT	if value had to be rounded

Definition at line 7290 of file half.hpp.

{
    return half(detail::binary, detail::integral<std::round_toward_infinity, true, true>(arg.data_));
}

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

Definition at line 7603 of file half.hpp.

{
    return half(detail::binary, x.data_ ^ ((x.data_ ^ y.data_) & 0x8000));
}

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

MU_HALF_FE_INVALID	for signaling NaN or infinity
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6797 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::cos(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, k;
    if (!abs)
        return half(detail::binary, 0x3C00);
    if (abs >= 0x7C00)
        return half(detail::binary, (abs == 0x7C00) ? detail::invalid() : detail::signal(arg.data_));
    if (abs < 0x2500)
        return half(detail::binary, detail::rounded<half::round_style, true>(0x3BFF, 1, 1));
    if (half::round_style != std::round_to_nearest && abs == 0x598C)
        return half(detail::binary, detail::rounded<half::round_style, true>(0x80FC, 1, 1));
    std::pair<detail::uint32, detail::uint32> sc = detail::sincos(detail::angle_arg(abs, k), 28);
    detail::uint32 sign = -static_cast<detail::uint32>(((k >> 1) ^ k) & 1);
    return half(detail::binary, detail::fixed2half<half::round_style, 30, true, true, true>((((k & 1) ? sc.first : sc.second) ^ sign) - sign));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 7036 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::cosh(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, exp;
    if (!abs)
        return half(detail::binary, 0x3C00);
    if (abs >= 0x7C00)
        return half(detail::binary, (abs > 0x7C00) ? detail::signal(arg.data_) : 0x7C00);
    std::pair<detail::uint32, detail::uint32> mm = detail::hyperbolic_args(abs, exp, (half::round_style == std::round_to_nearest) ? 23 : 26);
    detail::uint32 m = mm.first + mm.second, i = (~m & 0xFFFFFFFF) >> 31;
    m = (m >> i) | (m & i) | 0x80000000;
    if ((exp += 13 + i) > 29)
        return half(detail::binary, detail::overflow<half::round_style>());
    return half(detail::binary, detail::fixed2half<half::round_style, 31, false, false, true>(m, exp));
#endif
}

detail::half_caster

template<typename , typename , std::float_round_style >

friend struct detail::half_caster

friend

Definition at line 5350 of file half.hpp.

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 7185 of file half.hpp.

{
#if defined(HALF_ARITHMETIC_TYPE) && HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::erf(detail::half2float<detail::internal_t>(arg.data_))));
#else
    unsigned int abs = arg.data_ & 0x7FFF;
    if (!abs || abs >= 0x7C00)
        return (abs >= 0x7C00) ? half(detail::binary, (abs == 0x7C00) ? (arg.data_ - 0x4000) : detail::signal(arg.data_)) : arg;
    if (abs >= 0x4200)
        return half(detail::binary, detail::rounded<half::round_style, true>((arg.data_ & 0x8000) | 0x3BFF, 1, 1));
    return half(detail::binary, detail::erf<half::round_style, false>(arg.data_));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 7207 of file half.hpp.

{
#if defined(HALF_ARITHMETIC_TYPE) && HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::erfc(detail::half2float<detail::internal_t>(arg.data_))));
#else
    unsigned int abs = arg.data_ & 0x7FFF, sign = arg.data_ & 0x8000;
    if (abs >= 0x7C00)
        return (abs >= 0x7C00) ? half(detail::binary, (abs == 0x7C00) ? (sign >> 1) : detail::signal(arg.data_)) : arg;
    if (!abs)
        return half(detail::binary, 0x3C00);
    if (abs >= 0x4400)
        return half(detail::binary, detail::rounded<half::round_style, true>((sign >> 1) - (sign >> 15), sign >> 15, 1));
    return half(detail::binary, detail::erf<half::round_style, true>(arg.data_));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6111 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::exp(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, e = (abs >> 10) + (abs <= 0x3FF), exp;
    if (!abs)
        return half(detail::binary, 0x3C00);
    if (abs >= 0x7C00)
        return half(detail::binary, (abs == 0x7C00) ? (0x7C00 & ((arg.data_ >> 15) - 1U)) : detail::signal(arg.data_));
    if (abs >= 0x4C80)
        return half(detail::binary, (arg.data_ & 0x8000) ? detail::underflow<half::round_style>() : detail::overflow<half::round_style>());
    detail::uint32 m = detail::multiply64(static_cast<detail::uint32>((abs & 0x3FF) + ((abs > 0x3FF) << 10)) << 21, 0xB8AA3B29);
    if (e < 14)
    {
        exp = 0;
        m >>= 14 - e;
    }
    else
    {
        exp = m >> (45 - e);
        m = (m << (e - 14)) & 0x7FFFFFFF;
    }
    return half(detail::binary, detail::exp2_post<half::round_style>(m, exp, (arg.data_ & 0x8000) != 0, 0, 26));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6146 of file half.hpp.

{
#if defined(HALF_ARITHMETIC_TYPE) && HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::exp2(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, e = (abs >> 10) + (abs <= 0x3FF), exp = (abs & 0x3FF) + ((abs > 0x3FF) << 10);
    if (!abs)
        return half(detail::binary, 0x3C00);
    if (abs >= 0x7C00)
        return half(detail::binary, (abs == 0x7C00) ? (0x7C00 & ((arg.data_ >> 15) - 1U)) : detail::signal(arg.data_));
    if (abs >= 0x4E40)
        return half(detail::binary, (arg.data_ & 0x8000) ? detail::underflow<half::round_style>() : detail::overflow<half::round_style>());
    return half(detail::binary, detail::exp2_post<half::round_style>((static_cast<detail::uint32>(exp) << (6 + e)) & 0x7FFFFFFF, exp >> (25 - e), (arg.data_ & 0x8000) != 0, 0, 28));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6171 of file half.hpp.

{
#if defined(HALF_ARITHMETIC_TYPE) && HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::expm1(detail::half2float<detail::internal_t>(arg.data_))));
#else
    unsigned int abs = arg.data_ & 0x7FFF, sign = arg.data_ & 0x8000, e = (abs >> 10) + (abs <= 0x3FF), exp;
    if (!abs)
        return arg;
    if (abs >= 0x7C00)
        return half(detail::binary, (abs == 0x7C00) ? (0x7C00 + (sign >> 1)) : detail::signal(arg.data_));
    if (abs >= 0x4A00)
        return half(detail::binary, (arg.data_ & 0x8000) ? detail::rounded<half::round_style, true>(0xBBFF, 1, 1) : detail::overflow<half::round_style>());
    detail::uint32 m = detail::multiply64(static_cast<detail::uint32>((abs & 0x3FF) + ((abs > 0x3FF) << 10)) << 21, 0xB8AA3B29);
    if (e < 14)
    {
        exp = 0;
        m >>= 14 - e;
    }
    else
    {
        exp = m >> (45 - e);
        m = (m << (e - 14)) & 0x7FFFFFFF;
    }
    m = detail::exp2(m);
    if (sign)
    {
        int s = 0;
        if (m > 0x80000000)
        {
            ++exp;
            m = detail::divide64(0x80000000, m, s);
        }
        m = 0x80000000 - ((m >> exp) | ((m & ((static_cast<detail::uint32>(1) << exp) - 1)) != 0) | s);
        exp = 0;
    }
    else
        m -= (exp < 31) ? (0x80000000 >> exp) : 1;
    for (exp += 14; m < 0x80000000 && exp; m <<= 1, --exp)
        ;
    if (exp > 29)
        return half(detail::binary, detail::overflow<half::round_style>());
    return half(detail::binary, detail::rounded<half::round_style, true>(sign + (exp << 10) + (m >> 21), (m >> 20) & 1, (m & 0xFFFFF) != 0));
#endif
}

fabs

HALF_CONSTEXPR half fabs ( half  arg )

friend

Absolute value. See also: Documentation for std::fabs.

Parameters

arg

operand

Returns

absolute value of arg

Definition at line 5896 of file half.hpp.

{
    return half(detail::binary, arg.data_ & 0x7FFF);
}

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)

Definition at line 6079 of file half.hpp.

{
    if (isnan(x) || isnan(y))
        return half(detail::binary, detail::signal(x.data_, y.data_));
    return (x.data_ ^ (0x8000 | (0x8000 - (x.data_ >> 15)))) <= (y.data_ ^ (0x8000 | (0x8000 - (y.data_ >> 15)))) ? half(detail::binary, 0) : (x - y);
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_INEXACT	if value had to be rounded

Definition at line 7301 of file half.hpp.

{
    return half(detail::binary, detail::integral<std::round_toward_neg_infinity, true, true>(arg.data_));
}

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

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

Definition at line 5982 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    detail::internal_t fx = detail::half2float<detail::internal_t>(x.data_), fy = detail::half2float<detail::internal_t>(y.data_), fz = detail::half2float<detail::internal_t>(z.data_);
#if HALF_ENABLE_CPP11_CMATH && FP_FAST_FMA
    return half(detail::binary, detail::float2half<half::round_style>(std::fma(fx, fy, fz)));
#else
    return half(detail::binary, detail::float2half<half::round_style>(fx * fy + fz));
#endif
#else
    int absx = x.data_ & 0x7FFF, absy = y.data_ & 0x7FFF, absz = z.data_ & 0x7FFF, exp = -15;
    unsigned int sign = (x.data_ ^ y.data_) & 0x8000;
    bool sub = ((sign ^ z.data_) & 0x8000) != 0;
    if (absx >= 0x7C00 || absy >= 0x7C00 || absz >= 0x7C00)
        return (absx > 0x7C00 || absy > 0x7C00 || absz > 0x7C00) ? half(detail::binary, detail::signal(x.data_, y.data_, z.data_)) : (absx == 0x7C00) ? half(detail::binary, (!absy || (sub && absz == 0x7C00)) ? detail::invalid() : (sign | 0x7C00))
                                                                                                                                 : (absy == 0x7C00) ? half(detail::binary, (!absx || (sub && absz == 0x7C00)) ? detail::invalid() : (sign | 0x7C00))
                                                                                                                                                    : z;
    if (!absx || !absy)
        return absz ? z : half(detail::binary, (half::round_style == std::round_toward_neg_infinity) ? (z.data_ | sign) : (z.data_ & sign));
    for (; absx < 0x400; absx <<= 1, --exp)
        ;
    for (; absy < 0x400; absy <<= 1, --exp)
        ;
    detail::uint32 m = static_cast<detail::uint32>((absx & 0x3FF) | 0x400) * static_cast<detail::uint32>((absy & 0x3FF) | 0x400);
    int i = m >> 21;
    exp += (absx >> 10) + (absy >> 10) + i;
    m <<= 3 - i;
    if (absz)
    {
        int expz = 0;
        for (; absz < 0x400; absz <<= 1, --expz)
            ;
        expz += absz >> 10;
        detail::uint32 mz = static_cast<detail::uint32>((absz & 0x3FF) | 0x400) << 13;
        if (expz > exp || (expz == exp && mz > m))
        {
            std::swap(m, mz);
            std::swap(exp, expz);
            if (sub)
                sign = z.data_ & 0x8000;
        }
        int d = exp - expz;
        mz = (d < 23) ? ((mz >> d) | ((mz & ((static_cast<detail::uint32>(1) << d) - 1)) != 0)) : 1;
        if (sub)
        {
            m = m - mz;
            if (!m)
                return half(detail::binary, static_cast<unsigned>(half::round_style == std::round_toward_neg_infinity) << 15);
            for (; m < 0x800000; m <<= 1, --exp)
                ;
        }
        else
        {
            m += mz;
            i = m >> 24;
            m = (m >> i) | (m & i);
            exp += i;
        }
    }
    if (exp > 30)
        return half(detail::binary, detail::overflow<half::round_style>(sign));
    else if (exp < -10)
        return half(detail::binary, detail::underflow<half::round_style>(sign));
    return half(detail::binary, detail::fixed2half<half::round_style, 23, false, false, false>(m, exp - 1, sign));
#endif
}

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

MU_HALF_FE_INVALID

if x or y is signaling NaN

Definition at line 6055 of file half.hpp.

{
    return half(detail::binary, (!isnan(y) && (isnan(x) || (x.data_ ^ (0x8000 | (0x8000 - (x.data_ >> 15)))) < (y.data_ ^ (0x8000 | (0x8000 - (y.data_ >> 15)))))) ? detail::select(y.data_, x.data_) : detail::select(x.data_, y.data_));
}

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

MU_HALF_FE_INVALID

if x or y is signaling NaN

Definition at line 6066 of file half.hpp.

{
    return half(detail::binary, (!isnan(y) && (isnan(x) || (x.data_ ^ (0x8000 | (0x8000 - (x.data_ >> 15)))) > (y.data_ ^ (0x8000 | (0x8000 - (y.data_ >> 15)))))) ? detail::select(y.data_, x.data_) : detail::select(x.data_, y.data_));
}

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

MU_HALF_FE_INVALID

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

Definition at line 5916 of file half.hpp.

{
    unsigned int absx = x.data_ & 0x7FFF, absy = y.data_ & 0x7FFF, sign = x.data_ & 0x8000;
    if (absx >= 0x7C00 || absy >= 0x7C00)
        return half(detail::binary, (absx > 0x7C00 || absy > 0x7C00) ? detail::signal(x.data_, y.data_) : (absx == 0x7C00) ? detail::invalid()
                                                                                                                           : x.data_);
    if (!absy)
        return half(detail::binary, detail::invalid());
    if (!absx)
        return x;
    if (absx == absy)
        return half(detail::binary, sign);
    return half(detail::binary, sign | detail::mod<false, false>(absx, absy));
}

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

Definition at line 7621 of file half.hpp.

{
    return !(arg.data_ & 0x7FFF) ? FP_ZERO : ((arg.data_ & 0x7FFF) < 0x400) ? FP_SUBNORMAL
                                         : ((arg.data_ & 0x7FFF) < 0x7C00)  ? FP_NORMAL
                                         : ((arg.data_ & 0x7FFF) == 0x7C00) ? FP_INFINITE
                                                                            : FP_NAN;
}

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

MU_HALF_FE_INVALID

for signaling NaN

Definition at line 7403 of file half.hpp.

{
    *exp = 0;
    unsigned int abs = arg.data_ & 0x7FFF;
    if (abs >= 0x7C00 || !abs)
        return (abs > 0x7C00) ? half(detail::binary, detail::signal(arg.data_)) : arg;
    for (; abs < 0x400; abs <<= 1, --*exp)
        ;
    *exp += (abs >> 10) - 14;
    return half(detail::binary, (arg.data_ & 0x8000) | 0x3800 | (abs & 0x3FF));
}

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

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

Definition at line 6504 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    detail::internal_t fx = detail::half2float<detail::internal_t>(x.data_), fy = detail::half2float<detail::internal_t>(y.data_);
#if HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::hypot(fx, fy)));
#else
    return half(detail::binary, detail::float2half<half::round_style>(std::sqrt(fx * fx + fy * fy)));
#endif
#else
    int absx = x.data_ & 0x7FFF, absy = y.data_ & 0x7FFF, expx = 0, expy = 0;
    if (absx >= 0x7C00 || absy >= 0x7C00)
        return half(detail::binary, (absx == 0x7C00) ? detail::select(0x7C00, y.data_) : (absy == 0x7C00) ? detail::select(0x7C00, x.data_)
                                                                                                          : detail::signal(x.data_, y.data_));
    if (!absx)
        return half(detail::binary, absy ? detail::check_underflow(absy) : 0);
    if (!absy)
        return half(detail::binary, detail::check_underflow(absx));
    if (absy > absx)
        std::swap(absx, absy);
    for (; absx < 0x400; absx <<= 1, --expx)
        ;
    for (; absy < 0x400; absy <<= 1, --expy)
        ;
    detail::uint32 mx = (absx & 0x3FF) | 0x400, my = (absy & 0x3FF) | 0x400;
    mx *= mx;
    my *= my;
    int ix = mx >> 21, iy = my >> 21;
    expx = 2 * (expx + (absx >> 10)) - 15 + ix;
    expy = 2 * (expy + (absy >> 10)) - 15 + iy;
    mx <<= 10 - ix;
    my <<= 10 - iy;
    int d = expx - expy;
    my = (d < 30) ? ((my >> d) | ((my & ((static_cast<detail::uint32>(1) << d) - 1)) != 0)) : 1;
    return half(detail::binary, detail::hypot_post<half::round_style>(mx + my, expx));
#endif
}

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

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

Definition at line 6552 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    detail::internal_t fx = detail::half2float<detail::internal_t>(x.data_), fy = detail::half2float<detail::internal_t>(y.data_), fz = detail::half2float<detail::internal_t>(z.data_);
    return half(detail::binary, detail::float2half<half::round_style>(std::sqrt(fx * fx + fy * fy + fz * fz)));
#else
    int absx = x.data_ & 0x7FFF, absy = y.data_ & 0x7FFF, absz = z.data_ & 0x7FFF, expx = 0, expy = 0, expz = 0;
    if (!absx)
        return hypot(y, z);
    if (!absy)
        return hypot(x, z);
    if (!absz)
        return hypot(x, y);
    if (absx >= 0x7C00 || absy >= 0x7C00 || absz >= 0x7C00)
        return half(detail::binary, (absx == 0x7C00) ? detail::select(0x7C00, detail::select(y.data_, z.data_)) : (absy == 0x7C00) ? detail::select(0x7C00, detail::select(x.data_, z.data_))
                                                                                                              : (absz == 0x7C00)   ? detail::select(0x7C00, detail::select(x.data_, y.data_))
                                                                                                                                   : detail::signal(x.data_, y.data_, z.data_));
    if (absz > absy)
        std::swap(absy, absz);
    if (absy > absx)
        std::swap(absx, absy);
    if (absz > absy)
        std::swap(absy, absz);
    for (; absx < 0x400; absx <<= 1, --expx)
        ;
    for (; absy < 0x400; absy <<= 1, --expy)
        ;
    for (; absz < 0x400; absz <<= 1, --expz)
        ;
    detail::uint32 mx = (absx & 0x3FF) | 0x400, my = (absy & 0x3FF) | 0x400, mz = (absz & 0x3FF) | 0x400;
    mx *= mx;
    my *= my;
    mz *= mz;
    int ix = mx >> 21, iy = my >> 21, iz = mz >> 21;
    expx = 2 * (expx + (absx >> 10)) - 15 + ix;
    expy = 2 * (expy + (absy >> 10)) - 15 + iy;
    expz = 2 * (expz + (absz >> 10)) - 15 + iz;
    mx <<= 10 - ix;
    my <<= 10 - iy;
    mz <<= 10 - iz;
    int d = expy - expz;
    mz = (d < 30) ? ((mz >> d) | ((mz & ((static_cast<detail::uint32>(1) << d) - 1)) != 0)) : 1;
    my += mz;
    if (my & 0x80000000)
    {
        my = (my >> 1) | (my & 1);
        if (++expy > expx)
        {
            std::swap(mx, my);
            std::swap(expx, expy);
        }
    }
    d = expx - expy;
    my = (d < 30) ? ((my >> d) | ((my & ((static_cast<detail::uint32>(1) << d) - 1)) != 0)) : 1;
    return half(detail::binary, detail::hypot_post<half::round_style>(mx + my, expx));
#endif
}

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

MU_HALF_FE_INVALID

for 0 or infinite values

Definition at line 7505 of file half.hpp.

{
    int abs = arg.data_ & 0x7FFF, exp;
    if (!abs || abs >= 0x7C00)
    {
        detail::raise(MU_HALF_FE_INVALID);
        return !abs ? FP_ILOGB0 : (abs == 0x7C00) ? INT_MAX
                                                  : FP_ILOGBNAN;
    }
    for (exp = (abs >> 10) - 15; abs < 0x200; abs <<= 1, --exp)
        ;
    return exp;
}

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

Definition at line 7634 of file half.hpp.

{
    return (arg.data_ & 0x7C00) != 0x7C00;
}

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

Definition at line 7690 of file half.hpp.

{
    return ((x.data_ ^ (0x8000 | (0x8000 - (x.data_ >> 15)))) + (x.data_ >> 15)) > ((y.data_ ^ (0x8000 | (0x8000 - (y.data_ >> 15)))) + (y.data_ >> 15)) && !isnan(x) && !isnan(y);
}

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
false	else

Definition at line 7701 of file half.hpp.

{
    return ((x.data_ ^ (0x8000 | (0x8000 - (x.data_ >> 15)))) + (x.data_ >> 15)) >= ((y.data_ ^ (0x8000 | (0x8000 - (y.data_ >> 15)))) + (y.data_ >> 15)) && !isnan(x) && !isnan(y);
}

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

Definition at line 7644 of file half.hpp.

{
    return (arg.data_ & 0x7FFF) == 0x7C00;
}

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

Definition at line 7712 of file half.hpp.

{
    return ((x.data_ ^ (0x8000 | (0x8000 - (x.data_ >> 15)))) + (x.data_ >> 15)) < ((y.data_ ^ (0x8000 | (0x8000 - (y.data_ >> 15)))) + (y.data_ >> 15)) && !isnan(x) && !isnan(y);
}

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

Definition at line 7723 of file half.hpp.

{
    return ((x.data_ ^ (0x8000 | (0x8000 - (x.data_ >> 15)))) + (x.data_ >> 15)) <= ((y.data_ ^ (0x8000 | (0x8000 - (y.data_ >> 15)))) + (y.data_ >> 15)) && !isnan(x) && !isnan(y);
}

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

Definition at line 7734 of file half.hpp.

{
    return x.data_ != y.data_ && ((x.data_ | y.data_) & 0x7FFF) && !isnan(x) && !isnan(y);
}

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

Definition at line 7654 of file half.hpp.

{
    return (arg.data_ & 0x7FFF) > 0x7C00;
}

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

Definition at line 7664 of file half.hpp.

{
    return ((arg.data_ & 0x7C00) != 0) && ((arg.data_ & 0x7C00) != 0x7C00);
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_DIVBYZERO	for 0 or negative integer arguments
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 7232 of file half.hpp.

{
#if defined(HALF_ARITHMETIC_TYPE) && HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::lgamma(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF;
    if (abs >= 0x7C00)
        return half(detail::binary, (abs == 0x7C00) ? 0x7C00 : detail::signal(arg.data_));
    if (!abs || arg.data_ >= 0xE400 || (arg.data_ >= 0xBC00 && !(abs & ((1 << (25 - (abs >> 10))) - 1))))
        return half(detail::binary, detail::pole());
    if (arg.data_ == 0x3C00 || arg.data_ == 0x4000)
        return half(detail::binary, 0);
    return half(detail::binary, detail::gamma<half::round_style, true>(arg.data_));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN or negative argument
MU_HALF_FE_DIVBYZERO	for 0
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6225 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::log(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, exp = -15;
    if (!abs)
        return half(detail::binary, detail::pole(0x8000));
    if (arg.data_ & 0x8000)
        return half(detail::binary, (arg.data_ <= 0xFC00) ? detail::invalid() : detail::signal(arg.data_));
    if (abs >= 0x7C00)
        return (abs == 0x7C00) ? arg : half(detail::binary, detail::signal(arg.data_));
    for (; abs < 0x400; abs <<= 1, --exp)
        ;
    exp += abs >> 10;
    return half(detail::binary, detail::log2_post<half::round_style, 0xB8AA3B2A>(detail::log2(static_cast<detail::uint32>((abs & 0x3FF) | 0x400) << 20, 27) + 8, exp, 17));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN or negative argument
MU_HALF_FE_DIVBYZERO	for 0
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6253 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::log10(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, exp = -15;
    if (!abs)
        return half(detail::binary, detail::pole(0x8000));
    if (arg.data_ & 0x8000)
        return half(detail::binary, (arg.data_ <= 0xFC00) ? detail::invalid() : detail::signal(arg.data_));
    if (abs >= 0x7C00)
        return (abs == 0x7C00) ? arg : half(detail::binary, detail::signal(arg.data_));
    switch (abs)
    {
        case 0x4900:
            return half(detail::binary, 0x3C00);
        case 0x5640:
            return half(detail::binary, 0x4000);
        case 0x63D0:
            return half(detail::binary, 0x4200);
        case 0x70E2:
            return half(detail::binary, 0x4400);
    }
    for (; abs < 0x400; abs <<= 1, --exp)
        ;
    exp += abs >> 10;
    return half(detail::binary, detail::log2_post<half::round_style, 0xD49A784C>(detail::log2(static_cast<detail::uint32>((abs & 0x3FF) | 0x400) << 20, 27) + 8, exp, 16));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN or argument <-1
MU_HALF_FE_DIVBYZERO	for -1
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6337 of file half.hpp.

{
#if defined(HALF_ARITHMETIC_TYPE) && HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::log1p(detail::half2float<detail::internal_t>(arg.data_))));
#else
    if (arg.data_ >= 0xBC00)
        return half(detail::binary, (arg.data_ == 0xBC00) ? detail::pole(0x8000) : (arg.data_ <= 0xFC00) ? detail::invalid()
                                                                                                         : detail::signal(arg.data_));
    int abs = arg.data_ & 0x7FFF, exp = -15;
    if (!abs || abs >= 0x7C00)
        return (abs > 0x7C00) ? half(detail::binary, detail::signal(arg.data_)) : arg;
    for (; abs < 0x400; abs <<= 1, --exp)
        ;
    exp += abs >> 10;
    detail::uint32 m = static_cast<detail::uint32>((abs & 0x3FF) | 0x400) << 20;
    if (arg.data_ & 0x8000)
    {
        m = 0x40000000 - (m >> -exp);
        for (exp = 0; m < 0x40000000; m <<= 1, --exp)
            ;
    }
    else
    {
        if (exp < 0)
        {
            m = 0x40000000 + (m >> -exp);
            exp = 0;
        }
        else
        {
            m += 0x40000000 >> exp;
            int i = m >> 31;
            m >>= i;
            exp += i;
        }
    }
    return half(detail::binary, detail::log2_post<half::round_style, 0xB8AA3B2A>(detail::log2(m), exp, 17));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN or negative argument
MU_HALF_FE_DIVBYZERO	for 0
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6292 of file half.hpp.

{
#if defined(HALF_ARITHMETIC_TYPE) && HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::log2(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, exp = -15, s = 0;
    if (!abs)
        return half(detail::binary, detail::pole(0x8000));
    if (arg.data_ & 0x8000)
        return half(detail::binary, (arg.data_ <= 0xFC00) ? detail::invalid() : detail::signal(arg.data_));
    if (abs >= 0x7C00)
        return (abs == 0x7C00) ? arg : half(detail::binary, detail::signal(arg.data_));
    if (abs == 0x3C00)
        return half(detail::binary, 0);
    for (; abs < 0x400; abs <<= 1, --exp)
        ;
    exp += (abs >> 10);
    if (!(abs & 0x3FF))
    {
        unsigned int value = static_cast<unsigned>(exp < 0) << 15, m = std::abs(exp) << 6;
        for (exp = 18; m < 0x400; m <<= 1, --exp)
            ;
        return half(detail::binary, value + (exp << 10) + m);
    }
    detail::uint32 ilog = exp, sign = detail::sign_mask(ilog), m = (((ilog << 27) + (detail::log2(static_cast<detail::uint32>((abs & 0x3FF) | 0x400) << 20, 28) >> 4)) ^ sign) - sign;
    if (!m)
        return half(detail::binary, 0);
    for (exp = 14; m < 0x8000000 && exp; m <<= 1, --exp)
        ;
    for (; m > 0xFFFFFFF; m >>= 1, ++exp)
        s |= m & 1;
    return half(detail::binary, detail::fixed2half<half::round_style, 27, false, false, true>(m, exp, sign & 0x8000, s));
#endif
}

logb

half logb ( half  arg )

friend

Extract exponent. See also: Documentation for std::logb.

Parameters

arg	number to query

Returns

floating-point exponent

Exceptions

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_DIVBYZERO	for 0

Definition at line 7525 of file half.hpp.

{
    int abs = arg.data_ & 0x7FFF, exp;
    if (!abs)
        return half(detail::binary, detail::pole(0x8000));
    if (abs >= 0x7C00)
        return half(detail::binary, (abs == 0x7C00) ? 0x7C00 : detail::signal(arg.data_));
    for (exp = (abs >> 10) - 15; abs < 0x200; abs <<= 1, --exp)
        ;
    unsigned int value = static_cast<unsigned>(exp < 0) << 15;
    if (exp)
    {
        unsigned int m = std::abs(exp) << 6;
        for (exp = 18; m < 0x400; m <<= 1, --exp)
            ;
        value |= (exp << 10) + m;
    }
    return half(detail::binary, value);
}

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

MU_HALF_FE_INVALID	if value is not representable as long
MU_HALF_FE_INEXACT	if value had to be rounded

Definition at line 7355 of file half.hpp.

{
    return detail::half2int<half::round_style, true, true, long>(arg.data_);
}

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

MU_HALF_FE_INVALID

if value is not representable as long

Definition at line 7333 of file half.hpp.

{
    return detail::half2int<std::round_to_nearest, false, false, long>(arg.data_);
}

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

MU_HALF_FE_INVALID

for signaling NaN

Definition at line 7476 of file half.hpp.

{
    unsigned int abs = arg.data_ & 0x7FFF;
    if (abs > 0x7C00)
    {
        arg = half(detail::binary, detail::signal(arg.data_));
        return *iptr = arg, arg;
    }
    if (abs >= 0x6400)
        return *iptr = arg, half(detail::binary, arg.data_ & 0x8000);
    if (abs < 0x3C00)
        return iptr->data_ = arg.data_ & 0x8000, arg;
    unsigned int exp = abs >> 10, mask = (1 << (25 - exp)) - 1, m = arg.data_ & mask;
    iptr->data_ = arg.data_ & ~mask;
    if (!m)
        return half(detail::binary, arg.data_ & 0x8000);
    for (; m < 0x400; m <<= 1, --exp)
        ;
    return half(detail::binary, (arg.data_ & 0x8000) | (exp << 10) | (m & 0x3FF));
}

nanh

half nanh ( const char *  arg )

friend

Get NaN value. See also: Documentation for std::nan.

Parameters

arg	string code

Returns

quiet NaN

Definition at line 6090 of file half.hpp.

{
    unsigned int value = 0x7FFF;
    while (*arg)
        value ^= static_cast<unsigned>(*arg++) & 0xFF;
    return half(detail::binary, value);
}

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

MU_HALF_FE_INVALID

for signaling NaN

Definition at line 7365 of file half.hpp.

{
    return half(detail::binary, detail::integral<half::round_style, true, false>(arg.data_));
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW	for infinite result from finite argument
MU_HALF_FE_UNDERFLOW	for subnormal result

Definition at line 7553 of file half.hpp.

{
    int fabs = from.data_ & 0x7FFF, tabs = to.data_ & 0x7FFF;
    if (fabs > 0x7C00 || tabs > 0x7C00)
        return half(detail::binary, detail::signal(from.data_, to.data_));
    if (from.data_ == to.data_ || !(fabs | tabs))
        return to;
    if (!fabs)
    {
        detail::raise(MU_HALF_FE_UNDERFLOW, !HALF_ERRHANDLING_UNDERFLOW_TO_INEXACT);
        return half(detail::binary, (to.data_ & 0x8000) + 1);
    }
    unsigned int out = from.data_ + (((from.data_ >> 15) ^ static_cast<unsigned>((from.data_ ^ (0x8000 | (0x8000 - (from.data_ >> 15)))) < (to.data_ ^ (0x8000 | (0x8000 - (to.data_ >> 15)))))) << 1) - 1;
    detail::raise(MU_HALF_FE_OVERFLOW, fabs < 0x7C00 && (out & 0x7C00) == 0x7C00);
    detail::raise(MU_HALF_FE_UNDERFLOW, !HALF_ERRHANDLING_UNDERFLOW_TO_INEXACT && (out & 0x7C00) < 0x400);
    return half(detail::binary, out);
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW	for infinite result from finite argument
MU_HALF_FE_UNDERFLOW	for subnormal result

Definition at line 7579 of file half.hpp.

{
    int fabs = from.data_ & 0x7FFF;
    if (fabs > 0x7C00)
        return half(detail::binary, detail::signal(from.data_));
    long double lfrom = static_cast<long double>(from);
    if (detail::builtin_isnan(to) || lfrom == to)
        return half(static_cast<float>(to));
    if (!fabs)
    {
        detail::raise(MU_HALF_FE_UNDERFLOW, !HALF_ERRHANDLING_UNDERFLOW_TO_INEXACT);
        return half(detail::binary, (static_cast<unsigned>(detail::builtin_signbit(to)) << 15) + 1);
    }
    unsigned int out = from.data_ + (((from.data_ >> 15) ^ static_cast<unsigned>(lfrom < to)) << 1) - 1;
    detail::raise(MU_HALF_FE_OVERFLOW, (out & 0x7FFF) == 0x7C00);
    detail::raise(MU_HALF_FE_UNDERFLOW, !HALF_ERRHANDLING_UNDERFLOW_TO_INEXACT && (out & 0x7FFF) < 0x400);
    return half(detail::binary, out);
}

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

MU_HALF_FE_INVALID

if x or y is NaN

Definition at line 5630 of file half.hpp.

{
    return detail::compsignal(x.data_, y.data_) || (x.data_ != y.data_ && ((x.data_ | y.data_) & 0x7FFF));
}

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

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

Definition at line 5779 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(detail::half2float<detail::internal_t>(x.data_) * detail::half2float<detail::internal_t>(y.data_)));
#else
    int absx = x.data_ & 0x7FFF, absy = y.data_ & 0x7FFF, exp = -16;
    unsigned int sign = (x.data_ ^ y.data_) & 0x8000;
    if (absx >= 0x7C00 || absy >= 0x7C00)
        return half(detail::binary, (absx > 0x7C00 || absy > 0x7C00) ? detail::signal(x.data_, y.data_) : ((absx == 0x7C00 && !absy) || (absy == 0x7C00 && !absx)) ? detail::invalid()
                                                                                                                                                                   : (sign | 0x7C00));
    if (!absx || !absy)
        return half(detail::binary, sign);
    for (; absx < 0x400; absx <<= 1, --exp)
        ;
    for (; absy < 0x400; absy <<= 1, --exp)
        ;
    detail::uint32 m = static_cast<detail::uint32>((absx & 0x3FF) | 0x400) * static_cast<detail::uint32>((absy & 0x3FF) | 0x400);
    int i = m >> 21, s = m & i;
    exp += (absx >> 10) + (absy >> 10) + i;
    if (exp > 29)
        return half(detail::binary, detail::overflow<half::round_style>(sign));
    else if (exp < -11)
        return half(detail::binary, detail::underflow<half::round_style>(sign));
    return half(detail::binary, detail::fixed2half<half::round_style, 20, false, false, false>(m >> i, exp, sign, s));
#endif
}

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

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

Definition at line 5711 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(detail::half2float<detail::internal_t>(x.data_) + detail::half2float<detail::internal_t>(y.data_)));
#else
    int absx = x.data_ & 0x7FFF, absy = y.data_ & 0x7FFF;
    bool sub = ((x.data_ ^ y.data_) & 0x8000) != 0;
    if (absx >= 0x7C00 || absy >= 0x7C00)
        return half(detail::binary, (absx > 0x7C00 || absy > 0x7C00) ? detail::signal(x.data_, y.data_) : (absy != 0x7C00)      ? x.data_
                                                                                                      : (sub && absx == 0x7C00) ? detail::invalid()
                                                                                                                                : y.data_);
    if (!absx)
        return absy ? y : half(detail::binary, (half::round_style == std::round_toward_neg_infinity) ? (x.data_ | y.data_) : (x.data_ & y.data_));
    if (!absy)
        return x;
    unsigned int sign = ((sub && absy > absx) ? y.data_ : x.data_) & 0x8000;
    if (absy > absx)
        std::swap(absx, absy);
    int exp = (absx >> 10) + (absx <= 0x3FF), d = exp - (absy >> 10) - (absy <= 0x3FF), mx = ((absx & 0x3FF) | ((absx > 0x3FF) << 10)) << 3, my;
    if (d < 13)
    {
        my = ((absy & 0x3FF) | ((absy > 0x3FF) << 10)) << 3;
        my = (my >> d) | ((my & ((1 << d) - 1)) != 0);
    }
    else
        my = 1;
    if (sub)
    {
        if (!(mx -= my))
            return half(detail::binary, static_cast<unsigned>(half::round_style == std::round_toward_neg_infinity) << 15);
        for (; mx < 0x2000 && exp > 1; mx <<= 1, --exp)
            ;
    }
    else
    {
        mx += my;
        int i = mx >> 14;
        if ((exp += i) > 30)
            return half(detail::binary, detail::overflow<half::round_style>(sign));
        mx = (mx >> i) | (mx & i);
    }
    return half(detail::binary, detail::rounded<half::round_style, false>(sign + ((exp - 1) << 10) + (mx >> 3), (mx >> 2) & 1, (mx & 0x3) != 0));
#endif
}

operator- [1/2]

HALF_CONSTEXPR half operator- ( half  arg )

friend

Negation.

Parameters

arg

operand

Returns

negated operand

Definition at line 5699 of file half.hpp.

{
    return half(detail::binary, arg.data_ ^ 0x8000);
}

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

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

Definition at line 5763 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(detail::half2float<detail::internal_t>(x.data_) - detail::half2float<detail::internal_t>(y.data_)));
#else
    return x + -y;
#endif
}

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

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

Definition at line 5814 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(detail::half2float<detail::internal_t>(x.data_) / detail::half2float<detail::internal_t>(y.data_)));
#else
    int absx = x.data_ & 0x7FFF, absy = y.data_ & 0x7FFF, exp = 14;
    unsigned int sign = (x.data_ ^ y.data_) & 0x8000;
    if (absx >= 0x7C00 || absy >= 0x7C00)
        return half(detail::binary, (absx > 0x7C00 || absy > 0x7C00) ? detail::signal(x.data_, y.data_) : (absx == absy) ? detail::invalid()
                                                                                                                         : (sign | ((absx == 0x7C00) ? 0x7C00 : 0)));
    if (!absx)
        return half(detail::binary, absy ? sign : detail::invalid());
    if (!absy)
        return half(detail::binary, detail::pole(sign));
    for (; absx < 0x400; absx <<= 1, --exp)
        ;
    for (; absy < 0x400; absy <<= 1, ++exp)
        ;
    detail::uint32 mx = (absx & 0x3FF) | 0x400, my = (absy & 0x3FF) | 0x400;
    int i = mx < my;
    exp += (absx >> 10) - (absy >> 10) - i;
    if (exp > 29)
        return half(detail::binary, detail::overflow<half::round_style>(sign));
    else if (exp < -11)
        return half(detail::binary, detail::underflow<half::round_style>(sign));
    mx <<= 12 + i;
    my <<= 1;
    return half(detail::binary, detail::fixed2half<half::round_style, 11, false, false, false>(mx / my, exp, sign, mx % my != 0));
#endif
}

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

MU_HALF_FE_INVALID

if x or y is NaN

Definition at line 5641 of file half.hpp.

{
    return !detail::compsignal(x.data_, y.data_) &&
           ((x.data_ ^ (0x8000 | (0x8000 - (x.data_ >> 15)))) + (x.data_ >> 15)) < ((y.data_ ^ (0x8000 | (0x8000 - (y.data_ >> 15)))) + (y.data_ >> 15));
}

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

MU_HALF_FE_INVALID

if x or y is NaN

Definition at line 5665 of file half.hpp.

{
    return !detail::compsignal(x.data_, y.data_) &&
           ((x.data_ ^ (0x8000 | (0x8000 - (x.data_ >> 15)))) + (x.data_ >> 15)) <= ((y.data_ ^ (0x8000 | (0x8000 - (y.data_ >> 15)))) + (y.data_ >> 15));
}

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

MU_HALF_FE_INVALID

if x or y is NaN

Definition at line 5619 of file half.hpp.

{
    return !detail::compsignal(x.data_, y.data_) && (x.data_ == y.data_ || !((x.data_ | y.data_) & 0x7FFF));
}

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

MU_HALF_FE_INVALID

if x or y is NaN

Definition at line 5653 of file half.hpp.

{
    return !detail::compsignal(x.data_, y.data_) &&
           ((x.data_ ^ (0x8000 | (0x8000 - (x.data_ >> 15)))) + (x.data_ >> 15)) > ((y.data_ ^ (0x8000 | (0x8000 - (y.data_ >> 15)))) + (y.data_ >> 15));
}

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

MU_HALF_FE_INVALID

if x or y is NaN

Definition at line 5677 of file half.hpp.

{
    return !detail::compsignal(x.data_, y.data_) &&
           ((x.data_ ^ (0x8000 | (0x8000 - (x.data_ >> 15)))) + (x.data_ >> 15)) >= ((y.data_ ^ (0x8000 | (0x8000 - (y.data_ >> 15)))) + (y.data_ >> 15));
}

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

MU_HALF_FE_INVALID	if x or y is signaling NaN or if x is finite an negative and y is finite and not integral
MU_HALF_FE_DIVBYZERO	if x is 0 and y is negative
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6620 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::pow(detail::half2float<detail::internal_t>(x.data_), detail::half2float<detail::internal_t>(y.data_))));
#else
    int absx = x.data_ & 0x7FFF, absy = y.data_ & 0x7FFF, exp = -15;
    if (!absy || x.data_ == 0x3C00)
        return half(detail::binary, detail::select(0x3C00, (x.data_ == 0x3C00) ? y.data_ : x.data_));
    bool is_int = absy >= 0x6400 || (absy >= 0x3C00 && !(absy & ((1 << (25 - (absy >> 10))) - 1)));
    unsigned int sign = x.data_ & (static_cast<unsigned>((absy < 0x6800) && is_int && ((absy >> (25 - (absy >> 10))) & 1)) << 15);
    if (absx >= 0x7C00 || absy >= 0x7C00)
        return half(detail::binary, (absx > 0x7C00 || absy > 0x7C00) ? detail::signal(x.data_, y.data_) : (absy == 0x7C00) ? ((absx == 0x3C00) ? 0x3C00 : (!absx && y.data_ == 0xFC00) ? detail::pole()
                                                                                                                                                                                       : (0x7C00 & -((y.data_ >> 15) ^ (absx > 0x3C00))))
                                                                                                                           : (sign | (0x7C00 & ((y.data_ >> 15) - 1U))));
    if (!absx)
        return half(detail::binary, (y.data_ & 0x8000) ? detail::pole(sign) : sign);
    if ((x.data_ & 0x8000) && !is_int)
        return half(detail::binary, detail::invalid());
    if (x.data_ == 0xBC00)
        return half(detail::binary, sign | 0x3C00);
    switch (y.data_)
    {
        case 0x3800:
            return sqrt(x);
        case 0x3C00:
            return half(detail::binary, detail::check_underflow(x.data_));
        case 0x4000:
            return x * x;
        case 0xBC00:
            return half(detail::binary, 0x3C00) / x;
    }
    for (; absx < 0x400; absx <<= 1, --exp)
        ;
    detail::uint32 ilog = exp + (absx >> 10), msign = detail::sign_mask(ilog), f, m = (((ilog << 27) + ((detail::log2(static_cast<detail::uint32>((absx & 0x3FF) | 0x400) << 20) + 8) >> 4)) ^ msign) - msign;
    for (exp = -11; m < 0x80000000; m <<= 1, --exp)
        ;
    for (; absy < 0x400; absy <<= 1, --exp)
        ;
    m = detail::multiply64(m, static_cast<detail::uint32>((absy & 0x3FF) | 0x400) << 21);
    int i = m >> 31;
    exp += (absy >> 10) + i;
    m <<= 1 - i;
    if (exp < 0)
    {
        f = m >> -exp;
        exp = 0;
    }
    else
    {
        f = (m << exp) & 0x7FFFFFFF;
        exp = m >> (31 - exp);
    }
    return half(detail::binary, detail::exp2_post<half::round_style>(f, exp, ((msign & 1) ^ (y.data_ >> 15)) != 0, sign));
#endif
}

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

MU_HALF_FE_INVALID

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

Definition at line 5937 of file half.hpp.

{
    unsigned int absx = x.data_ & 0x7FFF, absy = y.data_ & 0x7FFF, sign = x.data_ & 0x8000;
    if (absx >= 0x7C00 || absy >= 0x7C00)
        return half(detail::binary, (absx > 0x7C00 || absy > 0x7C00) ? detail::signal(x.data_, y.data_) : (absx == 0x7C00) ? detail::invalid()
                                                                                                                           : x.data_);
    if (!absy)
        return half(detail::binary, detail::invalid());
    if (absx == absy)
        return half(detail::binary, sign);
    return half(detail::binary, sign ^ detail::mod<false, true>(absx, absy));
}

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

MU_HALF_FE_INVALID

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

Definition at line 5957 of file half.hpp.

{
    unsigned int absx = x.data_ & 0x7FFF, absy = y.data_ & 0x7FFF, value = x.data_ & 0x8000;
    if (absx >= 0x7C00 || absy >= 0x7C00)
        return half(detail::binary, (absx > 0x7C00 || absy > 0x7C00) ? detail::signal(x.data_, y.data_) : (absx == 0x7C00) ? detail::invalid()
                                                                                                                           : (*quo = 0, x.data_));
    if (!absy)
        return half(detail::binary, detail::invalid());
    bool qsign = ((value ^ y.data_) & 0x8000) != 0;
    int q = 1;
    if (absx != absy)
        value ^= detail::mod<true, true>(absx, absy, &q);
    return *quo = qsign ? -q : q, half(detail::binary, value);
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_INEXACT	if value had to be rounded

Definition at line 7344 of file half.hpp.

{
    return half(detail::binary, detail::integral<half::round_style, true, true>(arg.data_));
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_INEXACT	if value had to be rounded

Definition at line 7323 of file half.hpp.

{
    return half(detail::binary, detail::integral<std::round_to_nearest, false, true>(arg.data_));
}

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

MU_HALF_FE_INVALID	for signaling NaN and negative arguments
MU_HALF_FE_INEXACT	according to rounding

Definition at line 6413 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(detail::internal_t(1) / std::sqrt(detail::half2float<detail::internal_t>(arg.data_))));
#else
    unsigned int abs = arg.data_ & 0x7FFF, bias = 0x4000;
    if (!abs || arg.data_ >= 0x7C00)
        return half(detail::binary, (abs > 0x7C00) ? detail::signal(arg.data_) : (arg.data_ > 0x8000) ? detail::invalid()
                                                                             : !abs                   ? detail::pole(arg.data_ & 0x8000)
                                                                                                      : 0);
    for (; abs < 0x400; abs <<= 1, bias -= 0x400)
        ;
    unsigned int frac = (abs += bias) & 0x7FF;
    if (frac == 0x400)
        return half(detail::binary, 0x7A00 - (abs >> 1));
    if ((half::round_style == std::round_to_nearest && (frac == 0x3FE || frac == 0x76C)) ||
        (half::round_style != std::round_to_nearest && (frac == 0x15A || frac == 0x3FC || frac == 0x401 || frac == 0x402 || frac == 0x67B)))
        return pow(arg, half(detail::binary, 0xB800));
    detail::uint32 f = 0x17376 - abs, mx = (abs & 0x3FF) | 0x400, my = ((f >> 1) & 0x3FF) | 0x400, mz = my * my;
    int expy = (f >> 11) - 31, expx = 32 - (abs >> 10), i = mz >> 21;
    for (mz = 0x60000000 - (((mz >> i) * mx) >> (expx - 2 * expy - i)); mz < 0x40000000; mz <<= 1, --expy)
        ;
    i = (my *= mz >> 10) >> 31;
    expy += i;
    my = (my >> (20 + i)) + 1;
    i = (mz = my * my) >> 21;
    for (mz = 0x60000000 - (((mz >> i) * mx) >> (expx - 2 * expy - i)); mz < 0x40000000; mz <<= 1, --expy)
        ;
    i = (my *= (mz >> 10) + 1) >> 31;
    return half(detail::binary, detail::fixed2half<half::round_style, 30, false, false, true>(my >> i, expy + i + 14));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 7424 of file half.hpp.

{
    unsigned int abs = arg.data_ & 0x7FFF, sign = arg.data_ & 0x8000;
    if (abs >= 0x7C00 || !abs)
        return (abs > 0x7C00) ? half(detail::binary, detail::signal(arg.data_)) : arg;
    for (; abs < 0x400; abs <<= 1, --exp)
        ;
    exp += abs >> 10;
    if (exp > 30)
        return half(detail::binary, detail::overflow<half::round_style>(sign));
    else if (exp < -10)
        return half(detail::binary, detail::underflow<half::round_style>(sign));
    else if (exp > 0)
        return half(detail::binary, sign | (exp << 10) | (abs & 0x3FF));
    unsigned int m = (abs & 0x3FF) | 0x400;
    return half(detail::binary, detail::rounded<half::round_style, false>(sign | (m >> (1 - exp)), (m >> -exp) & 1, (m & ((1 << -exp) - 1)) != 0));
}

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

Definition at line 7674 of file half.hpp.

{
    return (arg.data_ & 0x8000) != 0;
}

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

MU_HALF_FE_INVALID	for signaling NaN or infinity
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6761 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::sin(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, k;
    if (!abs)
        return arg;
    if (abs >= 0x7C00)
        return half(detail::binary, (abs == 0x7C00) ? detail::invalid() : detail::signal(arg.data_));
    if (abs < 0x2900)
        return half(detail::binary, detail::rounded<half::round_style, true>(arg.data_ - 1, 1, 1));
    if (half::round_style != std::round_to_nearest)
        switch (abs)
        {
            case 0x48B7:
                return half(detail::binary, detail::rounded<half::round_style, true>((~arg.data_ & 0x8000) | 0x1D07, 1, 1));
            case 0x6A64:
                return half(detail::binary, detail::rounded<half::round_style, true>((~arg.data_ & 0x8000) | 0x3BFE, 1, 1));
            case 0x6D8C:
                return half(detail::binary, detail::rounded<half::round_style, true>((arg.data_ & 0x8000) | 0x0FE6, 1, 1));
        }
    std::pair<detail::uint32, detail::uint32> sc = detail::sincos(detail::angle_arg(abs, k), 28);
    detail::uint32 sign = -static_cast<detail::uint32>(((k >> 1) & 1) ^ (arg.data_ >> 15));
    return half(detail::binary, detail::fixed2half<half::round_style, 30, true, true, true>((((k & 1) ? sc.second : sc.first) ^ sign) - sign));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN or infinity
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6690 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    detail::internal_t f = detail::half2float<detail::internal_t>(arg.data_);
    *sin = half(detail::binary, detail::float2half<half::round_style>(std::sin(f)));
    *cos = half(detail::binary, detail::float2half<half::round_style>(std::cos(f)));
#else
    int abs = arg.data_ & 0x7FFF, sign = arg.data_ >> 15, k;
    if (abs >= 0x7C00)
        *sin = *cos = half(detail::binary, (abs == 0x7C00) ? detail::invalid() : detail::signal(arg.data_));
    else if (!abs)
    {
        *sin = arg;
        *cos = half(detail::binary, 0x3C00);
    }
    else if (abs < 0x2500)
    {
        *sin = half(detail::binary, detail::rounded<half::round_style, true>(arg.data_ - 1, 1, 1));
        *cos = half(detail::binary, detail::rounded<half::round_style, true>(0x3BFF, 1, 1));
    }
    else
    {
        if (half::round_style != std::round_to_nearest)
        {
            switch (abs)
            {
                case 0x48B7:
                    *sin = half(detail::binary, detail::rounded<half::round_style, true>((~arg.data_ & 0x8000) | 0x1D07, 1, 1));
                    *cos = half(detail::binary, detail::rounded<half::round_style, true>(0xBBFF, 1, 1));
                    return;
                case 0x598C:
                    *sin = half(detail::binary, detail::rounded<half::round_style, true>((arg.data_ & 0x8000) | 0x3BFF, 1, 1));
                    *cos = half(detail::binary, detail::rounded<half::round_style, true>(0x80FC, 1, 1));
                    return;
                case 0x6A64:
                    *sin = half(detail::binary, detail::rounded<half::round_style, true>((~arg.data_ & 0x8000) | 0x3BFE, 1, 1));
                    *cos = half(detail::binary, detail::rounded<half::round_style, true>(0x27FF, 1, 1));
                    return;
                case 0x6D8C:
                    *sin = half(detail::binary, detail::rounded<half::round_style, true>((arg.data_ & 0x8000) | 0x0FE6, 1, 1));
                    *cos = half(detail::binary, detail::rounded<half::round_style, true>(0x3BFF, 1, 1));
                    return;
            }
        }
        std::pair<detail::uint32, detail::uint32> sc = detail::sincos(detail::angle_arg(abs, k), 28);
        switch (k & 3)
        {
            case 1:
                sc = std::make_pair(sc.second, -sc.first);
                break;
            case 2:
                sc = std::make_pair(-sc.first, -sc.second);
                break;
            case 3:
                sc = std::make_pair(-sc.second, sc.first);
                break;
        }
        *sin = half(detail::binary, detail::fixed2half<half::round_style, 30, true, true, true>((sc.first ^ -static_cast<detail::uint32>(sign)) + sign));
        *cos = half(detail::binary, detail::fixed2half<half::round_style, 30, true, true, true>(sc.second));
    }
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 7007 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::sinh(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, exp;
    if (!abs || abs >= 0x7C00)
        return (abs > 0x7C00) ? half(detail::binary, detail::signal(arg.data_)) : arg;
    if (abs <= 0x2900)
        return half(detail::binary, detail::rounded<half::round_style, true>(arg.data_, 0, 1));
    std::pair<detail::uint32, detail::uint32> mm = detail::hyperbolic_args(abs, exp, (half::round_style == std::round_to_nearest) ? 29 : 27);
    detail::uint32 m = mm.first - mm.second;
    for (exp += 13; m < 0x80000000 && exp; m <<= 1, --exp)
        ;
    unsigned int sign = arg.data_ & 0x8000;
    if (exp > 29)
        return half(detail::binary, detail::overflow<half::round_style>(sign));
    return half(detail::binary, detail::fixed2half<half::round_style, 31, false, false, true>(m, exp, sign));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN and negative arguments
MU_HALF_FE_INEXACT	according to rounding

Definition at line 6390 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::sqrt(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, exp = 15;
    if (!abs || arg.data_ >= 0x7C00)
        return half(detail::binary, (abs > 0x7C00) ? detail::signal(arg.data_) : (arg.data_ > 0x8000) ? detail::invalid()
                                                                                                      : arg.data_);
    for (; abs < 0x400; abs <<= 1, --exp)
        ;
    detail::uint32 r = static_cast<detail::uint32>((abs & 0x3FF) | 0x400) << 10, m = detail::sqrt<20>(r, exp += abs >> 10);
    return half(detail::binary, detail::rounded<half::round_style, false>((exp << 10) + (m & 0x3FF), r > m, r != 0));
#endif
}

std::numeric_limits< half >

friend class std::numeric_limits< half >

friend

Definition at line 5350 of file half.hpp.

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

MU_HALF_FE_INVALID	for signaling NaN or infinity
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 6825 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::tan(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, exp = 13, k;
    if (!abs)
        return arg;
    if (abs >= 0x7C00)
        return half(detail::binary, (abs == 0x7C00) ? detail::invalid() : detail::signal(arg.data_));
    if (abs < 0x2700)
        return half(detail::binary, detail::rounded<half::round_style, true>(arg.data_, 0, 1));
    if (half::round_style != std::round_to_nearest)
        switch (abs)
        {
            case 0x658C:
                return half(detail::binary, detail::rounded<half::round_style, true>((arg.data_ & 0x8000) | 0x07E6, 1, 1));
            case 0x7330:
                return half(detail::binary, detail::rounded<half::round_style, true>((~arg.data_ & 0x8000) | 0x4B62, 1, 1));
        }
    std::pair<detail::uint32, detail::uint32> sc = detail::sincos(detail::angle_arg(abs, k), 30);
    if (k & 1)
        sc = std::make_pair(-sc.second, sc.first);
    detail::uint32 signy = detail::sign_mask(sc.first), signx = detail::sign_mask(sc.second);
    detail::uint32 my = (sc.first ^ signy) - signy, mx = (sc.second ^ signx) - signx;
    for (; my < 0x80000000; my <<= 1, --exp)
        ;
    for (; mx < 0x80000000; mx <<= 1, ++exp)
        ;
    return half(detail::binary, detail::tangent_post<half::round_style>(my, mx, exp, (signy ^ signx ^ arg.data_) & 0x8000));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 7063 of file half.hpp.

{
#ifdef HALF_ARITHMETIC_TYPE
    return half(detail::binary, detail::float2half<half::round_style>(std::tanh(detail::half2float<detail::internal_t>(arg.data_))));
#else
    int abs = arg.data_ & 0x7FFF, exp;
    if (!abs)
        return arg;
    if (abs >= 0x7C00)
        return half(detail::binary, (abs > 0x7C00) ? detail::signal(arg.data_) : (arg.data_ - 0x4000));
    if (abs >= 0x4500)
        return half(detail::binary, detail::rounded<half::round_style, true>((arg.data_ & 0x8000) | 0x3BFF, 1, 1));
    if (abs < 0x2700)
        return half(detail::binary, detail::rounded<half::round_style, true>(arg.data_ - 1, 1, 1));
    if (half::round_style != std::round_to_nearest && abs == 0x2D3F)
        return half(detail::binary, detail::rounded<half::round_style, true>(arg.data_ - 3, 0, 1));
    std::pair<detail::uint32, detail::uint32> mm = detail::hyperbolic_args(abs, exp, 27);
    detail::uint32 my = mm.first - mm.second - (half::round_style != std::round_to_nearest), mx = mm.first + mm.second, i = (~mx & 0xFFFFFFFF) >> 31;
    for (exp = 13; my < 0x80000000; my <<= 1, --exp)
        ;
    mx = (mx >> i) | 0x80000000;
    return half(detail::binary, detail::tangent_post<half::round_style>(my, mx, exp - i, arg.data_ & 0x8000));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN, negative infinity or negative integer arguments
MU_HALF_FE_DIVBYZERO	for 0
MU_HALF_FE_OVERFLOW,...UNDERFLOW,...INEXACT	according to rounding

Definition at line 7257 of file half.hpp.

{
#if defined(HALF_ARITHMETIC_TYPE) && HALF_ENABLE_CPP11_CMATH
    return half(detail::binary, detail::float2half<half::round_style>(std::tgamma(detail::half2float<detail::internal_t>(arg.data_))));
#else
    unsigned int abs = arg.data_ & 0x7FFF;
    if (!abs)
        return half(detail::binary, detail::pole(arg.data_));
    if (abs >= 0x7C00)
        return (arg.data_ == 0x7C00) ? arg : half(detail::binary, detail::signal(arg.data_));
    if (arg.data_ >= 0xE400 || (arg.data_ >= 0xBC00 && !(abs & ((1 << (25 - (abs >> 10))) - 1))))
        return half(detail::binary, detail::invalid());
    if (arg.data_ >= 0xCA80)
        return half(detail::binary, detail::underflow<half::round_style>((1 - ((abs >> (25 - (abs >> 10))) & 1)) << 15));
    if (arg.data_ <= 0x100 || (arg.data_ >= 0x4900 && arg.data_ < 0x8000))
        return half(detail::binary, detail::overflow<half::round_style>());
    if (arg.data_ == 0x3C00)
        return arg;
    return half(detail::binary, detail::gamma<half::round_style, false>(arg.data_));
#endif
}

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

MU_HALF_FE_INVALID	for signaling NaN
MU_HALF_FE_INEXACT	if value had to be rounded

Definition at line 7312 of file half.hpp.

{
    return half(detail::binary, detail::integral<std::round_toward_zero, true, true>(arg.data_));
}

---

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

• half.hpp