half.hpp File Reference
#include <utility>#include <algorithm>#include <climits>#include <cmath>#include <cstdlib>#include <cstring>#include <limits>#include <stdexcept>
Include dependency graph for half.hpp:
Go to the source code of this file.
Namespaces | |
| half_float | |
| half_float::detail | |
| std | |
| Extensions to the C++ standard library. | |
Typedefs | |
| typedef bool_type< true > | half_float::detail::true_type |
| typedef bool_type< false > | half_float::detail::false_type |
| typedef unsigned short | half_float::detail::uint16 |
| Unsigned integer of (at least) 16 bits width. More... | |
| typedef unsigned long | half_float::detail::uint32 |
| Fastest unsigned integer of (at least) 32 bits width. More... | |
| typedef long | half_float::detail::int32 |
| Fastest unsigned integer of (at least) 32 bits width. More... | |
Functions | |
Implementation defined classification and arithmetic | |
| template<typename T > | |
| bool | half_float::detail::builtin_isinf (T arg) |
| template<typename T > | |
| bool | half_float::detail::builtin_isnan (T arg) |
| template<typename T > | |
| bool | half_float::detail::builtin_signbit (T arg) |
| uint32 | half_float::detail::sign_mask (uint32 arg) |
| uint32 | half_float::detail::arithmetic_shift (uint32 arg, int i) |
Error handling | |
| int & | half_float::detail::errflags () |
| void | half_float::detail::raise (int HALF_UNUSED_NOERR(flags), bool HALF_UNUSED_NOERR(cond)=true) |
| HALF_CONSTEXPR_NOERR bool | half_float::detail::compsignal (unsigned int x, unsigned int y) |
| HALF_CONSTEXPR_NOERR unsigned int | half_float::detail::signal (unsigned int nan) |
| HALF_CONSTEXPR_NOERR unsigned int | half_float::detail::signal (unsigned int x, unsigned int y) |
| HALF_CONSTEXPR_NOERR unsigned int | half_float::detail::signal (unsigned int x, unsigned int y, unsigned int z) |
| HALF_CONSTEXPR_NOERR unsigned int | half_float::detail::select (unsigned int x, unsigned int HALF_UNUSED_NOERR(y)) |
| HALF_CONSTEXPR_NOERR unsigned int | half_float::detail::invalid () |
| HALF_CONSTEXPR_NOERR unsigned int | half_float::detail::pole (unsigned int sign=0) |
| HALF_CONSTEXPR_NOERR unsigned int | half_float::detail::check_underflow (unsigned int arg) |
Conversion and rounding | |
| template<std::float_round_style R> | |
| HALF_CONSTEXPR_NOERR unsigned int | half_float::detail::overflow (unsigned int sign=0) |
| template<std::float_round_style R> | |
| HALF_CONSTEXPR_NOERR unsigned int | half_float::detail::underflow (unsigned int sign=0) |
| template<std::float_round_style R, bool I> | |
| HALF_CONSTEXPR_NOERR unsigned int | half_float::detail::rounded (unsigned int value, int g, int s) |
| template<std::float_round_style R, bool E, bool I> | |
| unsigned int | half_float::detail::integral (unsigned int value) |
| template<std::float_round_style R, unsigned int F, bool S, bool N, bool I> | |
| unsigned int | half_float::detail::fixed2half (uint32 m, int exp=14, unsigned int sign=0, int s=0) |
| template<std::float_round_style R> | |
| unsigned int | half_float::detail::float2half_impl (float value, true_type) |
| template<std::float_round_style R> | |
| unsigned int | half_float::detail::float2half_impl (double value, true_type) |
| template<std::float_round_style R, typename T > | |
| unsigned int | half_float::detail::float2half_impl (T value,...) |
| template<std::float_round_style R, typename T > | |
| unsigned int | half_float::detail::float2half (T value) |
| template<std::float_round_style R, typename T > | |
| unsigned int | half_float::detail::int2half (T value) |
| float | half_float::detail::half2float_impl (unsigned int value, float, true_type) |
| double | half_float::detail::half2float_impl (unsigned int value, double, true_type) |
| template<typename T > | |
| T | half_float::detail::half2float_impl (unsigned int value, T,...) |
| template<typename T > | |
| T | half_float::detail::half2float (unsigned int value) |
| template<std::float_round_style R, bool E, bool I, typename T > | |
| T | half_float::detail::half2int (unsigned int value) |
Mathematics | |
| template<std::float_round_style R> | |
| uint32 | half_float::detail::mulhi (uint32 x, uint32 y) |
| uint32 | half_float::detail::multiply64 (uint32 x, uint32 y) |
| uint32 | half_float::detail::divide64 (uint32 x, uint32 y, int &s) |
| template<bool Q, bool R> | |
| unsigned int | half_float::detail::mod (unsigned int x, unsigned int y, int *quo=NULL) |
| template<unsigned int F> | |
| uint32 | half_float::detail::sqrt (uint32 &r, int &exp) |
| uint32 | half_float::detail::exp2 (uint32 m, unsigned int n=32) |
| uint32 | half_float::detail::log2 (uint32 m, unsigned int n=32) |
| std::pair< uint32, uint32 > | half_float::detail::sincos (uint32 mz, unsigned int n=31) |
| uint32 | half_float::detail::atan2 (uint32 my, uint32 mx, unsigned int n=31) |
| uint32 | half_float::detail::angle_arg (unsigned int abs, int &k) |
| std::pair< uint32, uint32 > | half_float::detail::atan2_args (unsigned int abs) |
| std::pair< uint32, uint32 > | half_float::detail::hyperbolic_args (unsigned int abs, int &exp, unsigned int n=32) |
| template<std::float_round_style R> | |
| unsigned int | half_float::detail::exp2_post (uint32 m, int exp, bool esign, unsigned int sign=0, unsigned int n=32) |
| template<std::float_round_style R, uint32 L> | |
| unsigned int | half_float::detail::log2_post (uint32 m, int ilog, int exp, unsigned int sign=0) |
| template<std::float_round_style R> | |
| unsigned int | half_float::detail::hypot_post (uint32 r, int exp) |
| template<std::float_round_style R> | |
| unsigned int | half_float::detail::tangent_post (uint32 my, uint32 mx, int exp, unsigned int sign=0) |
| template<std::float_round_style R, bool S> | |
| unsigned int | half_float::detail::area (unsigned int arg) |
| template<std::float_round_style R, bool C> | |
| unsigned int | half_float::detail::erf (unsigned int arg) |
| template<std::float_round_style R, bool L> | |
| unsigned int | half_float::detail::gamma (unsigned int arg) |
Comparison operators | |
| HALF_CONSTEXPR_NOERR bool | half_float::operator== (half x, half y) |
| HALF_CONSTEXPR_NOERR bool | half_float::operator!= (half x, half y) |
| HALF_CONSTEXPR_NOERR bool | half_float::operator< (half x, half y) |
| HALF_CONSTEXPR_NOERR bool | half_float::operator> (half x, half y) |
| HALF_CONSTEXPR_NOERR bool | half_float::operator<= (half x, half y) |
| HALF_CONSTEXPR_NOERR bool | half_float::operator>= (half x, half y) |
Arithmetic operators | |
| HALF_CONSTEXPR half | half_float::operator+ (half arg) |
| HALF_CONSTEXPR half | half_float::operator- (half arg) |
| half | half_float::operator+ (half x, half y) |
| half | half_float::operator- (half x, half y) |
| half | half_float::operator* (half x, half y) |
| half | half_float::operator/ (half x, half y) |
Basic mathematical operations | |
| HALF_CONSTEXPR half | half_float::fabs (half arg) |
| HALF_CONSTEXPR half | half_float::abs (half arg) |
| half | half_float::fmod (half x, half y) |
| half | half_float::remainder (half x, half y) |
| half | half_float::remquo (half x, half y, int *quo) |
| half | half_float::fma (half x, half y, half z) |
| HALF_CONSTEXPR_NOERR half | half_float::fmax (half x, half y) |
| HALF_CONSTEXPR_NOERR half | half_float::fmin (half x, half y) |
| half | half_float::fdim (half x, half y) |
| half | half_float::nanh (const char *arg) |
Exponential functions | |
| half | half_float::exp (half arg) |
| half | half_float::exp2 (half arg) |
| half | half_float::expm1 (half arg) |
| half | half_float::log (half arg) |
| half | half_float::log10 (half arg) |
| half | half_float::log2 (half arg) |
| half | half_float::log1p (half arg) |
Power functions | |
| half | half_float::sqrt (half arg) |
| half | half_float::rsqrt (half arg) |
| half | half_float::cbrt (half arg) |
| half | half_float::hypot (half x, half y) |
| half | half_float::hypot (half x, half y, half z) |
| half | half_float::pow (half x, half y) |
Trigonometric functions | |
| void | half_float::sincos (half arg, half *sin, half *cos) |
| half | half_float::sin (half arg) |
| half | half_float::cos (half arg) |
| half | half_float::tan (half arg) |
| half | half_float::asin (half arg) |
| half | half_float::acos (half arg) |
| half | half_float::atan (half arg) |
| half | half_float::atan2 (half y, half x) |
Hyperbolic functions | |
| half | half_float::sinh (half arg) |
| half | half_float::cosh (half arg) |
| half | half_float::tanh (half arg) |
| half | half_float::asinh (half arg) |
| half | half_float::acosh (half arg) |
| half | half_float::atanh (half arg) |
Error and gamma functions | |
| half | half_float::erf (half arg) |
| half | half_float::erfc (half arg) |
| half | half_float::lgamma (half arg) |
| half | half_float::tgamma (half arg) |
Rounding | |
| half | half_float::ceil (half arg) |
| half | half_float::floor (half arg) |
| half | half_float::trunc (half arg) |
| half | half_float::round (half arg) |
| long | half_float::lround (half arg) |
| half | half_float::rint (half arg) |
| long | half_float::lrint (half arg) |
| half | half_float::nearbyint (half arg) |
Floating point manipulation | |
| half | half_float::frexp (half arg, int *exp) |
| half | half_float::scalbln (half arg, long exp) |
| half | half_float::scalbn (half arg, int exp) |
| half | half_float::ldexp (half arg, int exp) |
| half | half_float::modf (half arg, half *iptr) |
| int | half_float::ilogb (half arg) |
| half | half_float::logb (half arg) |
| half | half_float::nextafter (half from, half to) |
| half | half_float::nexttoward (half from, long double to) |
| HALF_CONSTEXPR half | half_float::copysign (half x, half y) |
Floating point classification | |
| HALF_CONSTEXPR int | half_float::fpclassify (half arg) |
| HALF_CONSTEXPR bool | half_float::isfinite (half arg) |
| HALF_CONSTEXPR bool | half_float::isinf (half arg) |
| HALF_CONSTEXPR bool | half_float::isnan (half arg) |
| HALF_CONSTEXPR bool | half_float::isnormal (half arg) |
| HALF_CONSTEXPR bool | half_float::signbit (half arg) |
Comparison | |
| HALF_CONSTEXPR bool | half_float::isgreater (half x, half y) |
| HALF_CONSTEXPR bool | half_float::isgreaterequal (half x, half y) |
| HALF_CONSTEXPR bool | half_float::isless (half x, half y) |
| HALF_CONSTEXPR bool | half_float::islessequal (half x, half y) |
| HALF_CONSTEXPR bool | half_float::islessgreater (half x, half y) |
| HALF_CONSTEXPR bool | half_float::isunordered (half x, half y) |
Casting | |
| template<typename T , typename U > | |
| T | half_float::half_cast (U arg) |
| template<typename T , std::float_round_style R, typename U > | |
| T | half_float::half_cast (U arg) |
Error handling | |
| int | half_float::feclearexcept (int excepts) |
| int | half_float::fetestexcept (int excepts) |
| int | half_float::feraiseexcept (int excepts) |
| int | half_float::fegetexceptflag (int *flagp, int excepts) |
| int | half_float::fesetexceptflag (const int *flagp, int excepts) |
| void | half_float::fethrowexcept ([[maybe_unused]] int excepts, [[maybe_unused]] const char *msg="") |
Variables | |
| HALF_CONSTEXPR_CONST binary_t | half_float::detail::binary = binary_t() |
| Tag for binary construction. More... | |
Detailed Description
Main header file for half-precision functionality.
Definition in file half.hpp.
Macro Definition Documentation
◆ FP_FAST_FMAH
| #define FP_FAST_FMAH 1 |
Fast half-precision fma function. This symbol is defined if the fma() function generally executes as fast as, or faster than, a separate half-precision multiplication followed by an addition, which is always the case.
See also: Documentation for FP_FAST_FMA
◆ FP_ILOGB0
◆ FP_ILOGBNAN
◆ FP_INFINITE
◆ FP_NAN
◆ FP_NORMAL
◆ FP_SUBNORMAL
◆ FP_ZERO
◆ HALF_CONSTEXPR
◆ HALF_CONSTEXPR_CONST
◆ HALF_CONSTEXPR_NOERR
◆ HALF_ENABLE_F16C_INTRINSICS
| #define HALF_ENABLE_F16C_INTRINSICS __F16C__ |
Enable F16C intruction set intrinsics. Defining this to 1 enables the use of F16C compiler intrinsics for converting between half-precision and single-precision values which may result in improved performance. This will not perform additional checks for support of the F16C instruction set, so an appropriate target platform is required when enabling this feature.
Unless predefined it will be enabled automatically when the __F16C__ symbol is defined, which some compilers do on supporting platforms.
◆ HALF_ERRHANDLING
| #define HALF_ERRHANDLING (HALF_ERRHANDLING_FLAGS || HALF_ERRHANDLING_ERRNO || HALF_ERRHANDLING_FENV || HALF_ERRHANDLING_THROWS) |
◆ HALF_ERRHANDLING_OVERFLOW_TO_INEXACT
| #define HALF_ERRHANDLING_OVERFLOW_TO_INEXACT 1 |
◆ HALF_ERRHANDLING_UNDERFLOW_TO_INEXACT
| #define HALF_ERRHANDLING_UNDERFLOW_TO_INEXACT 1 |
Raise INEXACT exception on underflow. Defining this to 1 (default) causes underflow errors to automatically raise inexact exceptions in addition. These will be raised after any possible handling of the underflow exception.
Note: This will actually cause underflow (and the accompanying inexact) exceptions to be raised only when the result is inexact, while if disabled bare underflow errors will be raised for any (possibly exact) subnormal result.
◆ HALF_GCC_VERSION
◆ HALF_ICC_VERSION
◆ HALF_NOEXCEPT
◆ HALF_NOTHROW
◆ HALF_ROUND_STYLE
| #define HALF_ROUND_STYLE 1 |
Default rounding mode. This specifies the rounding mode used for all conversions between halfs and more precise types (unless using half_cast() and specifying the rounding mode directly) as well as in arithmetic operations and mathematical functions. It can be redefined (before including half.hpp) to one of the standard rounding modes using their respective constants or the equivalent values of std::float_round_style:
std::float_round_style | value | rounding |
|---|---|---|
std::round_indeterminate | -1 | fastest |
std::round_toward_zero | 0 | toward zero |
std::round_to_nearest | 1 | to nearest (default) |
std::round_toward_infinity | 2 | toward positive infinity |
std::round_toward_neg_infinity | 3 | toward negative infinity |
By default this is set to 1 (std::round_to_nearest), which rounds results to the nearest representable value. It can even be set to std::numeric_limits<float>::round_style to synchronize the rounding mode with that of the built-in single-precision implementation (which is likely std::round_to_nearest, though).
◆ HALF_THREAD_LOCAL
◆ HALF_UNUSED_NOERR
◆ HLF_ROUNDS
| #define HLF_ROUNDS HALF_ROUND_STYLE |
Half rounding mode. In correspondence with FLT_ROUNDS from <cfloat> this symbol expands to the rounding mode used for half-precision operations. It is an alias for HALF_ROUND_STYLE.
See also: Documentation for FLT_ROUNDS
◆ HUGE_VALH
| #define HUGE_VALH std::numeric_limits<half_float::half>::infinity() |
◆ MU_HALF_FE_ALL_EXCEPT
| #define MU_HALF_FE_ALL_EXCEPT (MU_HALF_FE_INEXACT | MU_HALF_FE_DIVBYZERO | MU_HALF_FE_UNDERFLOW | MU_HALF_FE_OVERFLOW | MU_HALF_FE_INVALID) |
