Main header file for half-precision functionality. More...

#include <utility>
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <istream>
#include <limits>
#include <ostream>
#include <stdexcept>

Include dependency graph for half.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	half_float::detail::conditional< bool, T, typename >
	Conditional type. More...

struct	half_float::detail::conditional< false, T, F >

struct	half_float::detail::bool_type< bool >
	Helper for tag dispatching. More...

struct	half_float::detail::is_float< typename >
	Type traits for floating-point types. More...

struct	half_float::detail::is_float< const T >

struct	half_float::detail::is_float< volatile T >

struct	half_float::detail::is_float< const volatile T >

struct	half_float::detail::is_float< float >

struct	half_float::detail::is_float< double >

struct	half_float::detail::is_float< long double >

struct	half_float::detail::bits< T >
	Type traits for floating-point bits. More...

struct	half_float::detail::bits< const T >

struct	half_float::detail::bits< volatile T >

struct	half_float::detail::bits< const volatile T >

struct	half_float::detail::bits< float >
	Unsigned integer of (at least) 32 bits width. More...

struct	half_float::detail::bits< double >
	Unsigned integer of (at least) 64 bits width. More...

struct	half_float::detail::binary_t
	Tag type for binary construction. More...

struct	half_float::detail::f31
	Class for 1.31 unsigned floating-point computation. More...

class	half_float::half
	Half-precision floating-point type. More...

struct	half_float::detail::half_caster< T, U, R >
	Helper class for half casts. More...

struct	half_float::detail::half_caster< half, U, R >

struct	half_float::detail::half_caster< T, half, R >

struct	half_float::detail::half_caster< half, half, R >

class	std::numeric_limits< half_float::half >
	Numeric limits for half-precision floats. More...

Namespaces
	half_float
	Main namespace for half-precision functionality.

	half_float::detail

	std
	Extensions to the C++ standard library.

Macros
#define	HALF_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)

#define	HALF_ICC_VERSION 0

#define	HALF_ERRHANDLING (HALF_ERRHANDLING_FLAGS \|\| HALF_ERRHANDLING_ERRNO \|\| HALF_ERRHANDLING_FENV \|\| HALF_ERRHANDLING_THROWS)

#define	HALF_UNUSED_NOERR(name)

#define	HALF_CONSTEXPR

#define	HALF_CONSTEXPR_CONST const

#define	HALF_CONSTEXPR_NOERR

#define	HALF_NOEXCEPT

#define	HALF_NOTHROW throw()

#define	HALF_THREAD_LOCAL static

#define	HALF_ENABLE_F16C_INTRINSICS __F16C__
	Enable F16C intruction set intrinsics. More...

#define	HALF_ERRHANDLING_OVERFLOW_TO_INEXACT 1
	Raise INEXACT exception on overflow. More...

#define	HALF_ERRHANDLING_UNDERFLOW_TO_INEXACT 1
	Raise INEXACT exception on underflow. More...

#define	HALF_ROUND_STYLE 1
	Default rounding mode. More...

#define	HUGE_VALH std::numeric_limits<half_float::half>::infinity()
	Value signaling overflow. More...

#define	FP_FAST_FMAH 1
	Fast half-precision fma function. More...

#define	HLF_ROUNDS HALF_ROUND_STYLE
	Half rounding mode. More...

#define	FP_ILOGB0 INT_MIN

#define	FP_ILOGBNAN INT_MAX

#define	FP_SUBNORMAL 0

#define	FP_ZERO 1

#define	FP_NAN 2

#define	FP_INFINITE 3

#define	FP_NORMAL 4

#define	FE_INVALID 0x10

#define	FE_DIVBYZERO 0x08

#define	FE_OVERFLOW 0x04

#define	FE_UNDERFLOW 0x02

#define	FE_INEXACT 0x01

#define	FE_ALL_EXCEPT (FE_INVALID \| FE_DIVBYZERO \| FE_OVERFLOW \| FE_UNDERFLOW \| FE_INEXACT)

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)
	Check for infinity. More...

template<typename T >
bool	half_float::detail::builtin_isnan (T arg)
	Check for NaN. More...

template<typename T >
bool	half_float::detail::builtin_signbit (T arg)
	Check sign. More...

uint32	half_float::detail::sign_mask (uint32 arg)
	Platform-independent sign mask. More...

uint32	half_float::detail::arithmetic_shift (uint32 arg, int i)
	Platform-independent arithmetic right shift. More...

Error handling
int &	half_float::detail::errflags ()
	Internal exception flags. More...

void	half_float::detail::raise (int HALF_UNUSED_NOERR(flags), bool HALF_UNUSED_NOERR(cond)=true)
	Raise floating-point exception. More...

HALF_CONSTEXPR_NOERR bool	half_float::detail::compsignal (unsigned int x, unsigned int y)
	Check and signal for any NaN. More...

HALF_CONSTEXPR_NOERR unsigned int	half_float::detail::signal (unsigned int nan)
	Signal and silence signaling NaN. More...

HALF_CONSTEXPR_NOERR unsigned int	half_float::detail::signal (unsigned int x, unsigned int y)
	Signal and silence signaling NaNs. More...

HALF_CONSTEXPR_NOERR unsigned int	half_float::detail::signal (unsigned int x, unsigned int y, unsigned int z)
	Signal and silence signaling NaNs. More...

HALF_CONSTEXPR_NOERR unsigned int	half_float::detail::select (unsigned int x, unsigned int HALF_UNUSED_NOERR(y))
	Select value or signaling NaN. More...

HALF_CONSTEXPR_NOERR unsigned int	half_float::detail::invalid ()
	Raise domain error and return NaN. More...

HALF_CONSTEXPR_NOERR unsigned int	half_float::detail::pole (unsigned int sign=0)
	Raise pole error and return infinity. More...

HALF_CONSTEXPR_NOERR unsigned int	half_float::detail::check_underflow (unsigned int arg)
	Check value for underflow. More...

Conversion and rounding
template<std::float_round_style R>
HALF_CONSTEXPR_NOERR unsigned int	half_float::detail::overflow (unsigned int sign=0)
	Half-precision overflow. More...

template<std::float_round_style R>
HALF_CONSTEXPR_NOERR unsigned int	half_float::detail::underflow (unsigned int sign=0)
	Half-precision underflow. More...

template<std::float_round_style R, bool I>
HALF_CONSTEXPR_NOERR unsigned int	half_float::detail::rounded (unsigned int value, int g, int s)
	Round half-precision number. More...

template<std::float_round_style R, bool E, bool I>
unsigned int	half_float::detail::integral (unsigned int value)
	Round half-precision number to nearest integer value. More...

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)
	Convert fixed point to half-precision floating-point. More...

template<std::float_round_style R>
unsigned int	half_float::detail::float2half_impl (float value, true_type)
	Convert IEEE single-precision to half-precision. More...

template<std::float_round_style R>
unsigned int	half_float::detail::float2half_impl (double value, true_type)
	Convert IEEE double-precision to half-precision. More...

template<std::float_round_style R, typename T >
unsigned int	half_float::detail::float2half_impl (T value,...)
	Convert non-IEEE floating-point to half-precision. More...

template<std::float_round_style R, typename T >
unsigned int	half_float::detail::float2half (T value)
	Convert floating-point to half-precision. More...

template<std::float_round_style R, typename T >
unsigned int	half_float::detail::int2half (T value)
	Convert integer to half-precision floating-point. More...

float	half_float::detail::half2float_impl (unsigned int value, float, true_type)
	Convert half-precision to IEEE single-precision. More...

double	half_float::detail::half2float_impl (unsigned int value, double, true_type)
	Convert half-precision to IEEE double-precision. More...

template<typename T >
T	half_float::detail::half2float_impl (unsigned int value, T,...)
	Convert half-precision to non-IEEE floating-point. More...

template<typename T >
T	half_float::detail::half2float (unsigned int value)
	Convert half-precision to floating-point. More...

template<std::float_round_style R, bool E, bool I, typename T >
T	half_float::detail::half2int (unsigned int value)
	Convert half-precision floating-point to integer. More...

Mathematics
template<std::float_round_style R>
uint32	half_float::detail::mulhi (uint32 x, uint32 y)
	upper part of 64-bit multiplication. More...

uint32	half_float::detail::multiply64 (uint32 x, uint32 y)
	64-bit multiplication. More...

uint32	half_float::detail::divide64 (uint32 x, uint32 y, int &s)
	64-bit division. More...

template<bool Q, bool R>
unsigned int	half_float::detail::mod (unsigned int x, unsigned int y, int *quo=NULL)
	Half precision positive modulus. More...

template<unsigned int F>
uint32	half_float::detail::sqrt (uint32 &r, int &exp)
	Fixed point square root. More...

uint32	half_float::detail::exp2 (uint32 m, unsigned int n=32)
	Fixed point binary exponential. More...

uint32	half_float::detail::log2 (uint32 m, unsigned int n=32)
	Fixed point binary logarithm. More...

std::pair< uint32, uint32 >	half_float::detail::sincos (uint32 mz, unsigned int n=31)
	Fixed point sine and cosine. More...

uint32	half_float::detail::atan2 (uint32 my, uint32 mx, unsigned int n=31)
	Fixed point arc tangent. More...

uint32	half_float::detail::angle_arg (unsigned int abs, int &k)
	Reduce argument for trigonometric functions. More...

std::pair< uint32, uint32 >	half_float::detail::atan2_args (unsigned int abs)
	Get arguments for atan2 function. More...

std::pair< uint32, uint32 >	half_float::detail::hyperbolic_args (unsigned int abs, int &exp, unsigned int n=32)
	Get exponentials for hyperbolic computation. More...

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)
	Postprocessing for binary exponential. More...

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)
	Postprocessing for binary logarithm. More...

template<std::float_round_style R>
unsigned int	half_float::detail::hypot_post (uint32 r, int exp)
	Hypotenuse square root and postprocessing. More...

template<std::float_round_style R>
unsigned int	half_float::detail::tangent_post (uint32 my, uint32 mx, int exp, unsigned int sign=0)
	Division and postprocessing for tangents. More...

template<std::float_round_style R, bool S>
unsigned int	half_float::detail::area (unsigned int arg)
	Area function and postprocessing. More...

template<std::float_round_style R, bool C>
unsigned int	half_float::detail::erf (unsigned int arg)
	Error function and postprocessing. More...

template<std::float_round_style R, bool L>
unsigned int	half_float::detail::gamma (unsigned int arg)
	Gamma function and postprocessing. More...

Comparison operators

HALF_CONSTEXPR_NOERR bool	half_float::operator== (half x, half y)
	Comparison for equality. More...

HALF_CONSTEXPR_NOERR bool	half_float::operator!= (half x, half y)
	Comparison for inequality. More...

HALF_CONSTEXPR_NOERR bool	half_float::operator< (half x, half y)
	Comparison for less than. More...

HALF_CONSTEXPR_NOERR bool	half_float::operator> (half x, half y)
	Comparison for greater than. More...

HALF_CONSTEXPR_NOERR bool	half_float::operator<= (half x, half y)
	Comparison for less equal. More...

HALF_CONSTEXPR_NOERR bool	half_float::operator>= (half x, half y)
	Comparison for greater equal. More...

Arithmetic operators

HALF_CONSTEXPR half	half_float::operator+ (half arg)
	Identity. More...

HALF_CONSTEXPR half	half_float::operator- (half arg)
	Negation. More...

half	half_float::operator+ (half x, half y)
	Addition. More...

half	half_float::operator- (half x, half y)
	Subtraction. More...

half	half_float::operator* (half x, half y)
	Multiplication. More...

half	half_float::operator/ (half x, half y)
	Division. More...

Input and output

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

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

Basic mathematical operations

HALF_CONSTEXPR half	half_float::fabs (half arg)
	Absolute value. More...

HALF_CONSTEXPR half	half_float::abs (half arg)
	Absolute value. More...

half	half_float::fmod (half x, half y)
	Remainder of division. More...

half	half_float::remainder (half x, half y)
	Remainder of division. More...

half	half_float::remquo (half x, half y, int *quo)
	Remainder of division. More...

half	half_float::fma (half x, half y, half z)
	Fused multiply add. More...

HALF_CONSTEXPR_NOERR half	half_float::fmax (half x, half y)
	Maximum of half expressions. More...

HALF_CONSTEXPR_NOERR half	half_float::fmin (half x, half y)
	Minimum of half expressions. More...

half	half_float::fdim (half x, half y)
	Positive difference. More...

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

Exponential functions

half	half_float::exp (half arg)
	Exponential function. More...

half	half_float::exp2 (half arg)
	Binary exponential. More...

half	half_float::expm1 (half arg)
	Exponential minus one. More...

half	half_float::log (half arg)
	Natural logarithm. More...

half	half_float::log10 (half arg)
	Common logarithm. More...

half	half_float::log2 (half arg)
	Binary logarithm. More...

half	half_float::log1p (half arg)
	Natural logarithm plus one. More...

Power functions

half	half_float::sqrt (half arg)
	Square root. More...

half	half_float::rsqrt (half arg)
	Inverse square root. More...

half	half_float::cbrt (half arg)
	Cubic root. More...

half	half_float::hypot (half x, half y)
	Hypotenuse function. More...

half	half_float::hypot (half x, half y, half z)
	Hypotenuse function. More...

half	half_float::pow (half x, half y)
	Power function. More...

Trigonometric functions

void	half_float::sincos (half arg, half sin, half cos)
	Compute sine and cosine simultaneously. More...

half	half_float::sin (half arg)
	Sine function. More...

half	half_float::cos (half arg)
	Cosine function. More...

half	half_float::tan (half arg)
	Tangent function. More...

half	half_float::asin (half arg)
	Arc sine. More...

half	half_float::acos (half arg)
	Arc cosine function. More...

half	half_float::atan (half arg)
	Arc tangent function. More...

half	half_float::atan2 (half y, half x)
	Arc tangent function. More...

Hyperbolic functions

half	half_float::sinh (half arg)
	Hyperbolic sine. More...

half	half_float::cosh (half arg)
	Hyperbolic cosine. More...

half	half_float::tanh (half arg)
	Hyperbolic tangent. More...

half	half_float::asinh (half arg)
	Hyperbolic area sine. More...

half	half_float::acosh (half arg)
	Hyperbolic area cosine. More...

half	half_float::atanh (half arg)
	Hyperbolic area tangent. More...

Error and gamma functions

half	half_float::erf (half arg)
	Error function. More...

half	half_float::erfc (half arg)
	Complementary error function. More...

half	half_float::lgamma (half arg)
	Natural logarithm of gamma function. More...

half	half_float::tgamma (half arg)
	Gamma function. More...

Rounding

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

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

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

half	half_float::round (half arg)
	Nearest integer. More...

long	half_float::lround (half arg)
	Nearest integer. More...

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

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

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

Floating point manipulation

half	half_float::frexp (half arg, int *exp)
	Decompress floating-point number. More...

half	half_float::scalbln (half arg, long exp)
	Multiply by power of two. More...

half	half_float::scalbn (half arg, int exp)
	Multiply by power of two. More...

half	half_float::ldexp (half arg, int exp)
	Multiply by power of two. More...

half	half_float::modf (half arg, half *iptr)
	Extract integer and fractional parts. More...

int	half_float::ilogb (half arg)
	Extract exponent. More...

half	half_float::logb (half arg)
	Extract exponent. More...

half	half_float::nextafter (half from, half to)
	Next representable value. More...

half	half_float::nexttoward (half from, long double to)
	Next representable value. More...

HALF_CONSTEXPR half	half_float::copysign (half x, half y)
	Take sign. More...

Floating point classification

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

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

HALF_CONSTEXPR bool	half_float::isinf (half arg)
	Check for infinity. More...

HALF_CONSTEXPR bool	half_float::isnan (half arg)
	Check for NaN. More...

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

HALF_CONSTEXPR bool	half_float::signbit (half arg)
	Check sign. More...

Comparison

HALF_CONSTEXPR bool	half_float::isgreater (half x, half y)
	Quiet comparison for greater than. More...

HALF_CONSTEXPR bool	half_float::isgreaterequal (half x, half y)
	Quiet comparison for greater equal. More...

HALF_CONSTEXPR bool	half_float::isless (half x, half y)
	Quiet comparison for less than. More...

HALF_CONSTEXPR bool	half_float::islessequal (half x, half y)
	Quiet comparison for less equal. More...

HALF_CONSTEXPR bool	half_float::islessgreater (half x, half y)
	Quiet comarison for less or greater. More...

HALF_CONSTEXPR bool	half_float::isunordered (half x, half y)
	Quiet check if unordered. More...

Casting

template<typename T , typename U >
T	half_float::half_cast (U arg)
	Cast to or from half-precision floating-point number. More...

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. More...

Error handling

int	half_float::feclearexcept (int excepts)
	Clear exception flags. More...

int	half_float::fetestexcept (int excepts)
	Test exception flags. More...

int	half_float::feraiseexcept (int excepts)
	Raise exception flags. More...

int	half_float::fegetexceptflag (int *flagp, int excepts)
	Save exception flags. More...

int	half_float::fesetexceptflag (const int *flagp, int excepts)
	Restore exception flags. More...

void	half_float::fethrowexcept (int excepts, const char *msg="")
	Throw C++ exceptions based on set exception flags. More...

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.

Macro Definition Documentation

◆ FE_ALL_EXCEPT

#define FE_ALL_EXCEPT (FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW | FE_INEXACT)

◆ FE_DIVBYZERO

#define FE_DIVBYZERO 0x08

◆ FE_INEXACT

#define FE_INEXACT 0x01

◆ FE_INVALID

#define FE_INVALID 0x10

◆ FE_OVERFLOW

#define FE_OVERFLOW 0x04

◆ FE_UNDERFLOW

#define FE_UNDERFLOW 0x02

◆ 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

#define FP_ILOGB0 INT_MIN

◆ FP_ILOGBNAN

#define FP_ILOGBNAN INT_MAX

◆ FP_INFINITE

#define FP_INFINITE 3

◆ FP_NAN

#define FP_NAN 2

◆ FP_NORMAL

#define FP_NORMAL 4

◆ FP_SUBNORMAL

#define FP_SUBNORMAL 0

◆ FP_ZERO

#define FP_ZERO 1

◆ HALF_CONSTEXPR

#define HALF_CONSTEXPR

◆ HALF_CONSTEXPR_CONST

#define HALF_CONSTEXPR_CONST const

◆ HALF_CONSTEXPR_NOERR

#define 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

Raise INEXACT exception on overflow.

Defining this to 1 (default) causes overflow errors to automatically raise inexact exceptions in addition. These will be raised after any possible handling of the underflow exception.

◆ 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

#define HALF_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)

◆ HALF_ICC_VERSION

#define HALF_ICC_VERSION 0

◆ HALF_NOEXCEPT

#define HALF_NOEXCEPT

◆ HALF_NOTHROW

#define HALF_NOTHROW throw()

◆ 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

#define HALF_THREAD_LOCAL static

◆ HALF_UNUSED_NOERR

#define HALF_UNUSED_NOERR ( name )

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

Value signaling overflow.

In correspondence with HUGE_VAL[F|L] from <cmath> this symbol expands to a positive value signaling the overflow of an operation, in particular it just evaluates to positive infinity.

See also: Documentation for HUGE_VAL

Classes

Namespaces

Macros

Typedefs

Functions

Variables