half_float Namespace Reference

Namespaces
	detail

Classes
class	half

Functions
Comparison operators
HALF_CONSTEXPR_NOERR bool	operator== (half x, half y)
HALF_CONSTEXPR_NOERR bool	operator!= (half x, half y)
HALF_CONSTEXPR_NOERR bool	operator< (half x, half y)
HALF_CONSTEXPR_NOERR bool	operator> (half x, half y)
HALF_CONSTEXPR_NOERR bool	operator<= (half x, half y)
HALF_CONSTEXPR_NOERR bool	operator>= (half x, half y)
Arithmetic operators
HALF_CONSTEXPR half	operator+ (half arg)
HALF_CONSTEXPR half	operator- (half arg)
half	operator+ (half x, half y)
half	operator- (half x, half y)
half	operator* (half x, half y)
half	operator/ (half x, half y)
Basic mathematical operations
HALF_CONSTEXPR half	fabs (half arg)
HALF_CONSTEXPR half	abs (half arg)
half	fmod (half x, half y)
half	remainder (half x, half y)
half	remquo (half x, half y, int *quo)
half	fma (half x, half y, half z)
HALF_CONSTEXPR_NOERR half	fmax (half x, half y)
HALF_CONSTEXPR_NOERR half	fmin (half x, half y)
half	fdim (half x, half y)
half	nanh (const char *arg)
Exponential functions
half	exp (half arg)
half	exp2 (half arg)
half	expm1 (half arg)
half	log (half arg)
half	log10 (half arg)
half	log2 (half arg)
half	log1p (half arg)
Power functions
half	sqrt (half arg)
half	rsqrt (half arg)
half	cbrt (half arg)
half	hypot (half x, half y)
half	hypot (half x, half y, half z)
half	pow (half x, half y)
Trigonometric functions
void	sincos (half arg, half *sin, half *cos)
half	sin (half arg)
half	cos (half arg)
half	tan (half arg)
half	asin (half arg)
half	acos (half arg)
half	atan (half arg)
half	atan2 (half y, half x)
Hyperbolic functions
half	sinh (half arg)
half	cosh (half arg)
half	tanh (half arg)
half	asinh (half arg)
half	acosh (half arg)
half	atanh (half arg)
Error and gamma functions
half	erf (half arg)
half	erfc (half arg)
half	lgamma (half arg)
half	tgamma (half arg)
Rounding
half	ceil (half arg)
half	floor (half arg)
half	trunc (half arg)
half	round (half arg)
long	lround (half arg)
half	rint (half arg)
long	lrint (half arg)
half	nearbyint (half arg)
Floating point manipulation
half	frexp (half arg, int *exp)
half	scalbln (half arg, long exp)
half	scalbn (half arg, int exp)
half	ldexp (half arg, int exp)
half	modf (half arg, half *iptr)
int	ilogb (half arg)
half	logb (half arg)
half	nextafter (half from, half to)
half	nexttoward (half from, long double to)
HALF_CONSTEXPR half	copysign (half x, half y)
Floating point classification
HALF_CONSTEXPR int	fpclassify (half arg)
HALF_CONSTEXPR bool	isfinite (half arg)
HALF_CONSTEXPR bool	isinf (half arg)
HALF_CONSTEXPR bool	isnan (half arg)
HALF_CONSTEXPR bool	isnormal (half arg)
HALF_CONSTEXPR bool	signbit (half arg)
Comparison
HALF_CONSTEXPR bool	isgreater (half x, half y)
HALF_CONSTEXPR bool	isgreaterequal (half x, half y)
HALF_CONSTEXPR bool	isless (half x, half y)
HALF_CONSTEXPR bool	islessequal (half x, half y)
HALF_CONSTEXPR bool	islessgreater (half x, half y)
HALF_CONSTEXPR bool	isunordered (half x, half y)
Casting
template<typename T , typename U >
T	half_cast (U arg)
template<typename T , std::float_round_style R, typename U >
T	half_cast (U arg)
Error handling
int	feclearexcept (int excepts)
int	fetestexcept (int excepts)
int	feraiseexcept (int excepts)
int	fegetexceptflag (int *flagp, int excepts)
int	fesetexceptflag (const int *flagp, int excepts)
void	fethrowexcept ([[maybe_unused]] int excepts, [[maybe_unused]] const char *msg="")

Detailed Description

Main namespace for half-precision functionality. This namespace contains all the functionality provided by the library.

Function Documentation

abs()

HALF_CONSTEXPR half half_float::abs ( half  arg )

inline

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

Parameters

arg

operand

Returns

absolute value of arg

Definition at line 5905 of file half.hpp.

{
    return fabs(arg);
}

acos()

half half_float::acos ( half  arg )

inline

Arc cosine function. This function is exact to rounding for all rounding modes.

See also: Documentation for std::acos.

Parameters

arg	function argument

Returns

arc cosine value of arg

Exceptions

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

inline

Hyperbolic area cosine. This function is exact to rounding for all rounding modes.

See also: Documentation for std::acosh.

Parameters

arg	function argument

Returns

area cosine value of arg

Exceptions

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

inline

Arc sine. This function is exact to rounding for all rounding modes.

See also: Documentation for std::asin.

Parameters

arg	function argument

Returns

arc sine value of arg

Exceptions

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

inline

Hyperbolic area sine. This function is exact to rounding for all rounding modes.

See also: Documentation for std::asinh.

Parameters

arg	function argument

Returns

area sine value of arg

Exceptions

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

inline

Arc tangent function. This function is exact to rounding for all rounding modes.

See also: Documentation for std::atan.

Parameters

arg	function argument

Returns

arc tangent value of arg

Exceptions

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

inline

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

See also: Documentation for std::atan2.

Parameters

y	numerator
x	denominator

Returns

arc tangent value

Exceptions

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

inline

Hyperbolic area tangent. This function is exact to rounding for all rounding modes.

See also: Documentation for std::atanh.

Parameters

arg	function argument

Returns

area tangent value of arg

Exceptions

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

inline

Cubic root. This function is exact to rounding for all rounding modes.

See also: Documentation for std::cbrt.

Parameters

arg	function argument

Returns

cubic root of arg

Exceptions

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

inline

Nearest integer not less than half value. See also: Documentation for std::ceil.

Parameters

arg	half to round

Returns

nearest integer not less than arg

Exceptions

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

inline

Take sign. See also: Documentation for std::copysign.

Parameters

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

Returns

value equal to x in magnitude and to y in sign

Definition at line 7603 of file half.hpp.

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

cos()

half half_float::cos ( half  arg )

inline

Cosine function. This function is exact to rounding for all rounding modes.

See also: Documentation for std::cos.

Parameters

arg	function argument

Returns

cosine value of arg

Exceptions

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

inline

Hyperbolic cosine. This function is exact to rounding for all rounding modes.

See also: Documentation for std::cosh.

Parameters

arg	function argument

Returns

hyperbolic cosine value of arg

Exceptions

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
}

erf()

half half_float::erf ( half  arg )

inline

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

See also: Documentation for std::erf.

Parameters

arg	function argument

Returns

error function value of arg

Exceptions

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

inline

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

See also: Documentation for std::erfc.

Parameters

arg	function argument

Returns

1 minus error function value of arg

Exceptions

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

inline

Exponential function. This function is exact to rounding for all rounding modes.

See also: Documentation for std::exp.

Parameters

arg	function argument

Returns

e raised to arg

Exceptions

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

inline

Binary exponential. This function is exact to rounding for all rounding modes.

See also: Documentation for std::exp2.

Parameters

arg	function argument

Returns

2 raised to arg

Exceptions

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

inline

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

See also: Documentation for std::expm1.

Parameters

arg	function argument

Returns

e raised to arg and subtracted by 1

Exceptions

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

inline

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 half_float::fdim ( half  x, half  y  )

inline

Positive difference. This function is exact to rounding for all rounding modes.

See also: Documentation for std::fdim.

Parameters

x	first operand
y	second operand

Returns

x - y or 0 if difference negative

Exceptions

FE_...

according to operator-(half,half)

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);
}

feclearexcept()

int half_float::feclearexcept ( int  excepts )

inline

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

See also: Documentation for std::feclearexcept.

Parameters

excepts

OR of exceptions to clear

Return values

0	all selected flags cleared successfully

Definition at line 7807 of file half.hpp.

{
    detail::errflags() &= ~excepts;
    return 0;
}

fegetexceptflag()

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

inline

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

See also: Documentation for std::fegetexceptflag.

Parameters

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

Return values

0	for success

Definition at line 7849 of file half.hpp.

{
    *flagp = detail::errflags() & excepts;
    return 0;
}

feraiseexcept()

int half_float::feraiseexcept ( int  excepts )

inline

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

See also: Documentation for std::feraiseexcept.

Parameters

excepts

OR of exceptions to raise

Return values

0	all selected exceptions raised successfully

Definition at line 7834 of file half.hpp.

{
    detail::errflags() |= excepts;
    detail::raise(excepts);
    return 0;
}

fesetexceptflag()

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

inline

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

See also: Documentation for std::fesetexceptflag.

Parameters

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

Return values

0	for success

Definition at line 7864 of file half.hpp.

{
    detail::errflags() = (detail::errflags() | (*flagp & excepts)) & (*flagp | ~excepts);
    return 0;
}

fetestexcept()

int half_float::fetestexcept ( int  excepts )

inline

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

See also: Documentation for std::fetestexcept.

Parameters

excepts

OR of exceptions to test

Returns

OR of selected exceptions if raised

Definition at line 7820 of file half.hpp.

{
    return detail::errflags() & excepts;
}

fethrowexcept()

void half_float::fethrowexcept ( [[maybe_unused] ] int  excepts, [[maybe_unused] ] const char *  msg = ""  )

inline

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

Parameters

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

Exceptions

std::domain_error	if MU_HALF_FE_INVALID or MU_HALF_FE_DIVBYZERO is selected and set
std::overflow_error	if MU_HALF_FE_OVERFLOW is selected and set
std::underflow_error	if MU_HALF_FE_UNDERFLOW is selected and set
std::range_error	if MU_HALF_FE_INEXACT is selected and set

Definition at line 7881 of file half.hpp.

{
    // ERASED
    // excepts &= detail::errflags();
    // if(excepts & (MU_HALF_FE_INVALID|MU_HALF_FE_DIVBYZERO))
    //  throw std::domain_error(msg);
    // if(excepts & MU_HALF_FE_OVERFLOW)
    //  throw std::overflow_error(msg);
    // if(excepts & MU_HALF_FE_UNDERFLOW)
    //  throw std::underflow_error(msg);
    // if(excepts & MU_HALF_FE_INEXACT)
    //  throw std::range_error(msg);
}

floor()

half half_float::floor ( half  arg )

inline

Nearest integer not greater than half value. See also: Documentation for std::floor.

Parameters

arg	half to round

Returns

nearest integer not greater than arg

Exceptions

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

inline

Fused multiply add. This function is exact to rounding for all rounding modes.

See also: Documentation for std::fma.

Parameters

x	first operand
y	second operand
z	third operand

Returns

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

Exceptions

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

inline

Maximum of half expressions. See also: Documentation for std::fmax.

Parameters

x	first operand
y	second operand

Returns

maximum of operands, ignoring quiet NaNs

Exceptions

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

inline

Minimum of half expressions. See also: Documentation for std::fmin.

Parameters

x	first operand
y	second operand

Returns

minimum of operands, ignoring quiet NaNs

Exceptions

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

inline

Remainder of division. See also: Documentation for std::fmod.

Parameters

x	first operand
y	second operand

Returns

remainder of floating-point division.

Exceptions

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

inline

Classify floating-point value. See also: Documentation for std::fpclassify.

Parameters

arg	number to classify

Return values

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

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

inline

Decompress floating-point number. See also: Documentation for std::frexp.

Parameters

arg	number to decompress
exp	address to store exponent at

Returns

significant in range [0.5, 1)

Exceptions

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));
}

half_cast() [1/2]

template<typename T , typename U >

T half_float::half_cast

(

U

arg

)

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

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

Template Parameters

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

Parameters

arg	value to cast

Returns

arg converted to destination type

Exceptions

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

Definition at line 7769 of file half.hpp.

{
    return detail::half_caster<T, U>::cast(arg);
}

half_cast() [2/2]

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

T half_float::half_cast

(

U

arg

)

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

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

Template Parameters

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

Parameters

arg	value to cast

Returns

arg converted to destination type

Exceptions

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

Definition at line 7789 of file half.hpp.

{
    return detail::half_caster<T, U, R>::cast(arg);
}

hypot() [1/2]

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

inline

Hypotenuse function. This function is exact to rounding for all rounding modes.

See also: Documentation for std::hypot.

Parameters

x	first argument
y	second argument

Returns

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

Exceptions

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

inline

Hypotenuse function. This function is exact to rounding for all rounding modes.

See also: Documentation for std::hypot.

Parameters

x	first argument
y	second argument
z	third argument

Returns

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

Exceptions

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

inline

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

Parameters

arg	number to query

Returns

floating-point exponent

Return values

FP_ILOGB0	for zero
FP_ILOGBNAN	for NaN
INT_MAX	for infinity

Exceptions

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

inline

Check if finite number. See also: Documentation for std::isfinite.

Parameters

arg	number to check

Return values

true	if neither infinity nor NaN
false	else

Definition at line 7634 of file half.hpp.

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

isgreater()

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

inline

Quiet comparison for greater than. See also: Documentation for std::isgreater.

Parameters

x	first operand
y	second operand

Return values

true	if x greater than y
false	else

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

inline

Quiet comparison for greater equal. See also: Documentation for std::isgreaterequal.

Parameters

x	first operand
y	second operand

Return values

true	if x greater equal y
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 half_float::isinf ( half  arg )

inline

Check for infinity. See also: Documentation for std::isinf.

Parameters

arg	number to check

Return values

true	for positive or negative infinity
false	else

Definition at line 7644 of file half.hpp.

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

isless()

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

inline

Quiet comparison for less than. See also: Documentation for std::isless.

Parameters

x	first operand
y	second operand

Return values

true	if x less than y
false	else

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

inline

Quiet comparison for less equal. See also: Documentation for std::islessequal.

Parameters

x	first operand
y	second operand

Return values

true	if x less equal y
false	else

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

inline

Quiet comarison for less or greater. See also: Documentation for std::islessgreater.

Parameters

x	first operand
y	second operand

Return values

true	if either less or greater
false	else

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

inline

Check for NaN. See also: Documentation for std::isnan.

Parameters

arg	number to check

Return values

true	for NaNs
false	else

Definition at line 7654 of file half.hpp.

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

isnormal()

HALF_CONSTEXPR bool half_float::isnormal ( half  arg )

inline

Check if normal number. See also: Documentation for std::isnormal.

Parameters

arg	number to check

Return values

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

Definition at line 7664 of file half.hpp.

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

isunordered()

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

inline

Quiet check if unordered. See also: Documentation for std::isunordered.

Parameters

x	first operand
y	second operand

Return values

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

Definition at line 7745 of file half.hpp.

{
    return isnan(x) || isnan(y);
}

ldexp()

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

inline

Multiply by power of two. This function is exact to rounding for all rounding modes.

See also: Documentation for std::ldexp.

Parameters

arg	number to modify
exp	power of two to multiply with

Returns

arg multplied by 2 raised to exp

Exceptions

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

Definition at line 7465 of file half.hpp.

{
    return scalbln(arg, exp);
}

lgamma()

half half_float::lgamma ( half  arg )

inline

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

See also: Documentation for std::lgamma.

Parameters

arg	function argument

Returns

natural logarith of gamma function for arg

Exceptions

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

inline

Natural logarithm. This function is exact to rounding for all rounding modes.

See also: Documentation for std::log.

Parameters

arg	function argument

Returns

logarithm of arg to base e

Exceptions

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

inline

Common logarithm. This function is exact to rounding for all rounding modes.

See also: Documentation for std::log10.

Parameters

arg	function argument

Returns

logarithm of arg to base 10

Exceptions

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

inline

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

See also: Documentation for std::log1p.

Parameters

arg	function argument

Returns

logarithm of arg plus 1 to base e

Exceptions

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

inline

Binary logarithm. This function is exact to rounding for all rounding modes.

See also: Documentation for std::log2.

Parameters

arg	function argument

Returns

logarithm of arg to base 2

Exceptions

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

inline

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

inline

Nearest integer using half's internal rounding mode. See also: Documentation for std::lrint.

Parameters

arg	half expression to round

Returns

nearest integer using default rounding mode

Exceptions

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

inline

Nearest integer. See also: Documentation for std::lround.

Parameters

arg	half to round

Returns

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

Exceptions

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

inline

Extract integer and fractional parts. See also: Documentation for std::modf.

Parameters

arg	number to decompress
iptr	address to store integer part at

Returns

fractional part

Exceptions

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

inline

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 half_float::nearbyint ( half  arg )

inline

Nearest integer using half's internal rounding mode. See also: Documentation for std::nearbyint.

Parameters

arg	half expression to round

Returns

nearest integer using default rounding mode

Exceptions

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

inline

Next representable value. See also: Documentation for std::nextafter.

Parameters

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

Returns

next representable value after from in direction towards to

Exceptions

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

inline

Next representable value. See also: Documentation for std::nexttoward.

Parameters

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

Returns

next representable value after from in direction towards to

Exceptions

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

inline

Comparison for inequality.

Parameters

x	first operand
y	second operand

Return values

true	if operands not equal
false	else

Exceptions

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

inline

Multiplication. This operation is exact to rounding for all rounding modes.

Parameters

x	left operand
y	right operand

Returns

product of half expressions

Exceptions

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+() [1/2]

HALF_CONSTEXPR half half_float::operator+ ( half  arg )

inline

Identity.

Parameters

arg

operand

Returns

unchanged operand

Definition at line 5691 of file half.hpp.

{
    return arg;
}

operator+() [2/2]

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

inline

Addition. This operation is exact to rounding for all rounding modes.

Parameters

x	left operand
y	right operand

Returns

sum of half expressions

Exceptions

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

inline

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

inline

Subtraction. This operation is exact to rounding for all rounding modes.

Parameters

x	left operand
y	right operand

Returns

difference of half expressions

Exceptions

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

inline

Division. This operation is exact to rounding for all rounding modes.

Parameters

x	left operand
y	right operand

Returns

quotient of half expressions

Exceptions

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

inline

Comparison for less than.

Parameters

x	first operand
y	second operand

Return values

true	if x less than y
false	else

Exceptions

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

inline

Comparison for less equal.

Parameters

x	first operand
y	second operand

Return values

true	if x less equal y
false	else

Exceptions

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

inline

Comparison for equality.

Parameters

x	first operand
y	second operand

Return values

true	if operands equal
false	else

Exceptions

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

inline

Comparison for greater than.

Parameters

x	first operand
y	second operand

Return values

true	if x greater than y
false	else

Exceptions

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

inline

Comparison for greater equal.

Parameters

x	first operand
y	second operand

Return values

true	if x greater equal y
false	else

Exceptions

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

inline

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

See also: Documentation for std::pow.

Parameters

x	base
y	exponent

Returns

x raised to y

Exceptions

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

inline

Remainder of division. See also: Documentation for std::remainder.

Parameters

x	first operand
y	second operand

Returns

remainder of floating-point division.

Exceptions

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

inline

Remainder of division. See also: Documentation for std::remquo.

Parameters

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

Returns

remainder of floating-point division.

Exceptions

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

inline

Nearest integer using half's internal rounding mode. See also: Documentation for std::rint.

Parameters

arg	half expression to round

Returns

nearest integer using default rounding mode

Exceptions

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

inline

Nearest integer. See also: Documentation for std::round.

Parameters

arg	half to round

Returns

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

Exceptions

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

inline

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

Parameters

arg	function argument

Returns

reciprocal of square root of arg

Exceptions

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

inline

Multiply by power of two. This function is exact to rounding for all rounding modes.

See also: Documentation for std::scalbln.

Parameters

arg	number to modify
exp	power of two to multiply with

Returns

arg multplied by 2 raised to exp

Exceptions

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));
}

scalbn()

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

inline

Multiply by power of two. This function is exact to rounding for all rounding modes.

See also: Documentation for std::scalbn.

Parameters

arg	number to modify
exp	power of two to multiply with

Returns

arg multplied by 2 raised to exp

Exceptions

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

Definition at line 7451 of file half.hpp.

{
    return scalbln(arg, exp);
}

signbit()

HALF_CONSTEXPR bool half_float::signbit ( half  arg )

inline

Check sign. See also: Documentation for std::signbit.

Parameters

arg	number to check

Return values

true	for negative number
false	for positive number

Definition at line 7674 of file half.hpp.

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

sin()

half half_float::sin ( half  arg )

inline

Sine function. This function is exact to rounding for all rounding modes.

See also: Documentation for std::sin.

Parameters

arg	function argument

Returns

sine value of arg

Exceptions

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

inline

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

This function is exact to rounding for all rounding modes.

Parameters

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

Exceptions

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

inline

Hyperbolic sine. This function is exact to rounding for all rounding modes.

See also: Documentation for std::sinh.

Parameters

arg	function argument

Returns

hyperbolic sine value of arg

Exceptions

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

inline

Square root. This function is exact to rounding for all rounding modes.

See also: Documentation for std::sqrt.

Parameters

arg	function argument

Returns

square root of arg

Exceptions

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
}

tan()

half half_float::tan ( half  arg )

inline

Tangent function. This function is exact to rounding for all rounding modes.

See also: Documentation for std::tan.

Parameters

arg	function argument

Returns

tangent value of arg

Exceptions

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

inline

Hyperbolic tangent. This function is exact to rounding for all rounding modes.

See also: Documentation for std::tanh.

Parameters

arg	function argument

Returns

hyperbolic tangent value of arg

Exceptions

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

inline

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

See also: Documentation for std::tgamma.

Parameters

arg	function argument

Returns

gamma function value of arg

Exceptions

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

inline

Nearest integer not greater in magnitude than half value. See also: Documentation for std::trunc.

Parameters

arg	half to round

Returns

nearest integer not greater in magnitude than arg

Exceptions

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_));
}