Classes
struct	__half_raw

union	float32_bits

struct	half_base

struct	numeric_limits_half_impl

Functions
half	abs (const half &a)

half	acos (const half &a)

half	asin (const half &a)

half	atan (const half &a)

half	atan2 (const half &a, const half &b)

half	atanh (const half &a)

half	ceil (const half &a)

half	cos (const half &a)

half	exp (const half &a)

half	expm1 (const half &a)

__half_raw	float_to_half_rtne (float ff)

half	floor (const half &a)

half	fmod (const half &a, const half &b)

float	half_to_float (__half_raw h)

bool()	isfinite (const half &a)

bool()	isinf (const half &a)

bool()	isnan (const half &a)

half	log (const half &a)

half	log10 (const half &a)

half	log1p (const half &a)

half	log2 (const half &a)

half()	max (const half &a, const half &b)

half()	min (const half &a, const half &b)

bool	operator!= (const half &a, const half &b)

half	operator* (const half &a, const half &b)

half &	operator*= (half &a, const half &b)

half	operator+ (const half &a, const half &b)

half	operator++ (half &a)

half	operator++ (half &a, int)

half &	operator+= (half &a, const half &b)

half	operator- (const half &a)

half	operator- (const half &a, const half &b)

half	operator-- (half &a)

half	operator-- (half &a, int)

half &	operator-= (half &a, const half &b)

half	operator/ (const half &a, const half &b)

half	operator/ (const half &a, Index b)

half &	operator/= (half &a, const half &b)

bool	operator< (const half &a, const half &b)

EIGEN_ALWAYS_INLINE std::ostream &	operator<< (std::ostream &os, const half &v)

bool	operator<= (const half &a, const half &b)

bool	operator== (const half &a, const half &b)

bool	operator> (const half &a, const half &b)

bool	operator>= (const half &a, const half &b)

half	pow (const half &a, const half &b)

numext::uint16_t	raw_half_as_uint16 (const __half_raw &h)

EIGEN_CONSTEXPR __half_raw	raw_uint16_to_half (numext::uint16_t x)

half	rint (const half &a)

half	round (const half &a)

half	sin (const half &a)

half	sqrt (const half &a)

half	tan (const half &a)

half	tanh (const half &a)

Function Documentation

◆ abs()

half Eigen::half_impl::abs ( const half & a )

inline

Definition at line 712 of file Half.h.

                                                               {
 #if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
   return half(vabsh_f16(a.x));
 #else
   half result;
   result.x = a.x & 0x7FFF;
   return result;
 #endif
 }

◆ acos()

half Eigen::half_impl::acos ( const half & a )

inline

Definition at line 779 of file Half.h.

                                                                {
   return half(::acosf(float(a)));
 }

◆ asin()

half Eigen::half_impl::asin ( const half & a )

inline

Definition at line 776 of file Half.h.

                                                                {
   return half(::asinf(float(a)));
 }

◆ atan()

half Eigen::half_impl::atan ( const half & a )

inline

Definition at line 782 of file Half.h.

                                                                {
   return half(::atanf(float(a)));
 }

◆ atan2()

half Eigen::half_impl::atan2	(	const half &	a,
		const half &	b
	)

inline

Definition at line 761 of file Half.h.

                                                                                {
   return half(::atan2f(float(a), float(b)));
 }

◆ atanh()

half Eigen::half_impl::atanh ( const half & a )

inline

Definition at line 785 of file Half.h.

                                                                 {
   return half(::atanhf(float(a)));
 }

◆ ceil()

half Eigen::half_impl::ceil ( const half & a )

inline

Definition at line 796 of file Half.h.

                                                                {
 #if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 300) || \
   defined(EIGEN_HIP_DEVICE_COMPILE)
   return half(hceil(a));
 #else
   return half(::ceilf(float(a)));
 #endif
 }

◆ cos()

half Eigen::half_impl::cos ( const half & a )

inline

Definition at line 767 of file Half.h.

                                                               {
   return half(::cosf(float(a)));
 }

◆ exp()

half Eigen::half_impl::exp ( const half & a )

inline

Definition at line 721 of file Half.h.

                                                               {
 #if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530) || \
   defined(EIGEN_HIP_DEVICE_COMPILE)
   return half(hexp(a));
 #else
    return half(::expf(float(a)));
 #endif
 }

◆ expm1()

half Eigen::half_impl::expm1 ( const half & a )

inline

Definition at line 729 of file Half.h.

                                                                 {
   return half(numext::expm1(float(a)));
 }

◆ float_to_half_rtne()

__half_raw Eigen::half_impl::float_to_half_rtne ( float ff )

inline

Definition at line 585 of file Half.h.

                                                                               {
 #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
   (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
   __half tmp_ff = __float2half(ff);
   return *(__half_raw*)&tmp_ff;
  
 #elif defined(EIGEN_HAS_FP16_C)
   __half_raw h;
   #if EIGEN_COMP_MSVC
     // MSVC does not have scalar instructions.
     h.x =_mm_extract_epi16(_mm_cvtps_ph(_mm_set_ss(ff), 0), 0);
   #else
     h.x = _cvtss_sh(ff, 0);
   #endif
   return h;
  
 #elif defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
   __half_raw h;
   h.x = static_cast<__fp16>(ff);
   return h;
  
 #else
   float32_bits f; f.f = ff;
  
   const float32_bits f32infty = { 255 << 23 };
   const float32_bits f16max = { (127 + 16) << 23 };
   const float32_bits denorm_magic = { ((127 - 15) + (23 - 10) + 1) << 23 };
   unsigned int sign_mask = 0x80000000u;
   __half_raw o;
   o.x = static_cast<numext::uint16_t>(0x0u);
  
   unsigned int sign = f.u & sign_mask;
   f.u ^= sign;
  
   // NOTE all the integer compares in this function can be safely
   // compiled into signed compares since all operands are below
   // 0x80000000. Important if you want fast straight SSE2 code
   // (since there's no unsigned PCMPGTD).
  
   if (f.u >= f16max.u) {  // result is Inf or NaN (all exponent bits set)
     o.x = (f.u > f32infty.u) ? 0x7e00 : 0x7c00; // NaN->qNaN and Inf->Inf
   } else {  // (De)normalized number or zero
     if (f.u < (113 << 23)) {  // resulting FP16 is subnormal or zero
       // use a magic value to align our 10 mantissa bits at the bottom of
       // the float. as long as FP addition is round-to-nearest-even this
       // just works.
       f.f += denorm_magic.f;
  
       // and one integer subtract of the bias later, we have our final float!
       o.x = static_cast<numext::uint16_t>(f.u - denorm_magic.u);
     } else {
       unsigned int mant_odd = (f.u >> 13) & 1; // resulting mantissa is odd
  
       // update exponent, rounding bias part 1
       // Equivalent to `f.u += ((unsigned int)(15 - 127) << 23) + 0xfff`, but
       // without arithmetic overflow.
       f.u += 0xc8000fffU;
       // rounding bias part 2
       f.u += mant_odd;
       // take the bits!
       o.x = static_cast<numext::uint16_t>(f.u >> 13);
     }
   }
  
   o.x |= static_cast<numext::uint16_t>(sign >> 16);
   return o;
 #endif
 }

◆ floor()

half Eigen::half_impl::floor ( const half & a )

inline

Definition at line 788 of file Half.h.

                                                                 {
 #if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 300) || \
   defined(EIGEN_HIP_DEVICE_COMPILE)
   return half(hfloor(a));
 #else
   return half(::floorf(float(a)));
 #endif
 }

◆ fmod()

half Eigen::half_impl::fmod	(	const half &	a,
		const half &	b
	)

inline

Definition at line 810 of file Half.h.

                                                                               {
   return half(::fmodf(float(a), float(b)));
 }

◆ half_to_float()

float Eigen::half_impl::half_to_float ( __half_raw h )

inline

Definition at line 654 of file Half.h.

                                                                         {
 #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \
   (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
   return __half2float(h);
 #elif defined(EIGEN_HAS_FP16_C)
   #if EIGEN_COMP_MSVC
     // MSVC does not have scalar instructions.
     return _mm_cvtss_f32(_mm_cvtph_ps(_mm_set1_epi16(h.x)));
   #else
     return _cvtsh_ss(h.x);
   #endif
 #elif defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
   return static_cast<float>(h.x);
 #else
   const float32_bits magic = { 113 << 23 };
   const unsigned int shifted_exp = 0x7c00 << 13; // exponent mask after shift
   float32_bits o;
  
   o.u = (h.x & 0x7fff) << 13;             // exponent/mantissa bits
   unsigned int exp = shifted_exp & o.u;   // just the exponent
   o.u += (127 - 15) << 23;                // exponent adjust
  
   // handle exponent special cases
   if (exp == shifted_exp) {     // Inf/NaN?
     o.u += (128 - 16) << 23;    // extra exp adjust
   } else if (exp == 0) {        // Zero/Denormal?
     o.u += 1 << 23;             // extra exp adjust
     o.f -= magic.f;             // renormalize
   }
  
   o.u |= (h.x & 0x8000) << 16;    // sign bit
   return o.f;
 #endif
 }

◆ isfinite()

bool() Eigen::half_impl::isfinite ( const half & a )

inline

Definition at line 708 of file Half.h.

                                                                      {
   return !(isinf EIGEN_NOT_A_MACRO (a)) && !(isnan EIGEN_NOT_A_MACRO (a));
 }

◆ isinf()

bool() Eigen::half_impl::isinf ( const half & a )

inline

Definition at line 691 of file Half.h.

                                                                   {
 #ifdef EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC
   return (numext::bit_cast<numext::uint16_t>(a.x) & 0x7fff) == 0x7c00;
 #else
   return (a.x & 0x7fff) == 0x7c00;
 #endif
 }

◆ isnan()

bool() Eigen::half_impl::isnan ( const half & a )

inline

Definition at line 698 of file Half.h.

                                                                   {
 #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
   (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
   return __hisnan(a);
 #elif defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
   return (numext::bit_cast<numext::uint16_t>(a.x) & 0x7fff) > 0x7c00;
 #else
   return (a.x & 0x7fff) > 0x7c00;
 #endif
 }

◆ log()

half Eigen::half_impl::log ( const half & a )

inline

Definition at line 732 of file Half.h.

                                                               {
 #if (defined(EIGEN_HAS_CUDA_FP16) && EIGEN_CUDA_SDK_VER >= 80000 && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
   (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
   return half(::hlog(a));
 #else
   return half(::logf(float(a)));
 #endif
 }

◆ log10()

half Eigen::half_impl::log10 ( const half & a )

inline

Definition at line 743 of file Half.h.

                                                                 {
   return half(::log10f(float(a)));
 }

◆ log1p()

half Eigen::half_impl::log1p ( const half & a )

inline

Definition at line 740 of file Half.h.

                                                                 {
   return half(numext::log1p(float(a)));
 }

◆ log2()

half Eigen::half_impl::log2 ( const half & a )

inline

Definition at line 746 of file Half.h.

                                                                {
   return half(static_cast<float>(EIGEN_LOG2E) * ::logf(float(a)));
 }

◆ max()

half() Eigen::half_impl::max	(	const half &	a,
		const half &	b
	)

inline

Definition at line 824 of file Half.h.

                                                                                {
 #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
   (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
   return __hlt(a, b) ? b : a;
 #else
   const float f1 = static_cast<float>(a);
   const float f2 = static_cast<float>(b);
   return f1 < f2 ? b : a;
 #endif
 }

◆ min()

half() Eigen::half_impl::min	(	const half &	a,
		const half &	b
	)

inline

Definition at line 814 of file Half.h.

                                                                                {
 #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \
   (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE))
   return __hlt(b, a) ? b : a;
 #else
   const float f1 = static_cast<float>(a);
   const float f2 = static_cast<float>(b);
   return f2 < f1 ? b : a;
 #endif
 }

◆ operator!=()

bool Eigen::half_impl::operator!=	(	const half &	a,
		const half &	b
	)

inline

Definition at line 497 of file Half.h.

                                                                                       {
   return numext::not_equal_strict(float(a), float(b));
 }

◆ operator*()

half Eigen::half_impl::operator*	(	const half &	a,
		const half &	b
	)

inline

Definition at line 464 of file Half.h.

                                                                                      {
   return half(float(a) * float(b));
 }

◆ operator*=()

half& Eigen::half_impl::operator*=	(	half &	a,
		const half &	b
	)

inline

Definition at line 482 of file Half.h.

                                                                                  {
   a = half(float(a) * float(b));
   return a;
 }

◆ operator+()

half Eigen::half_impl::operator+	(	const half &	a,
		const half &	b
	)

inline

Definition at line 461 of file Half.h.

                                                                                      {
   return half(float(a) + float(b));
 }

◆ operator++() [1/2]

half Eigen::half_impl::operator++ ( half & a )

inline

Definition at line 524 of file Half.h.

                                                                {
   a += half(1);
   return a;
 }

◆ operator++() [2/2]

half Eigen::half_impl::operator++	(	half &	a,
		int
	)

inline

Definition at line 534 of file Half.h.

                                                                     {
   half original_value = a;
   ++a;
   return original_value;
 }

◆ operator+=()

half& Eigen::half_impl::operator+=	(	half &	a,
		const half &	b
	)

inline

Definition at line 478 of file Half.h.

                                                                                  {
   a = half(float(a) + float(b));
   return a;
 }

◆ operator-() [1/2]

half Eigen::half_impl::operator- ( const half & a )

inline

Definition at line 473 of file Half.h.

                                                                       {
   half result;
   result.x = a.x ^ 0x8000;
   return result;
 }

◆ operator-() [2/2]

half Eigen::half_impl::operator-	(	const half &	a,
		const half &	b
	)

inline

Definition at line 467 of file Half.h.

                                                                                      {
   return half(float(a) - float(b));
 }

◆ operator--() [1/2]

half Eigen::half_impl::operator-- ( half & a )

inline

Definition at line 529 of file Half.h.

                                                                {
   a -= half(1);
   return a;
 }

◆ operator--() [2/2]

half Eigen::half_impl::operator--	(	half &	a,
		int
	)

inline

Definition at line 540 of file Half.h.

                                                                     {
   half original_value = a;
   --a;
   return original_value;
 }

◆ operator-=()

half& Eigen::half_impl::operator-=	(	half &	a,
		const half &	b
	)

inline

Definition at line 486 of file Half.h.

                                                                                  {
   a = half(float(a) - float(b));
   return a;
 }

◆ operator/() [1/2]

half Eigen::half_impl::operator/	(	const half &	a,
		const half &	b
	)

inline

Definition at line 470 of file Half.h.

                                                                                      {
   return half(float(a) / float(b));
 }

◆ operator/() [2/2]

half Eigen::half_impl::operator/	(	const half &	a,
		Index	b
	)

inline

Definition at line 520 of file Half.h.

                                                                                {
   return half(static_cast<float>(a) / static_cast<float>(b));
 }

◆ operator/=()

half& Eigen::half_impl::operator/=	(	half &	a,
		const half &	b
	)

inline

Definition at line 490 of file Half.h.

                                                                                  {
   a = half(float(a) / float(b));
   return a;
 }

◆ operator<()

bool Eigen::half_impl::operator<	(	const half &	a,
		const half &	b
	)

inline

Definition at line 500 of file Half.h.

                                                                                      {
   return float(a) < float(b);
 }

◆ operator<<()

EIGEN_ALWAYS_INLINE std::ostream& Eigen::half_impl::operator<<	(	std::ostream &	os,
		const half &	v
	)

Definition at line 836 of file Half.h.

                                                                             {
   os << static_cast<float>(v);
   return os;
 }

◆ operator<=()

bool Eigen::half_impl::operator<=	(	const half &	a,
		const half &	b
	)

inline

Definition at line 503 of file Half.h.

                                                                                       {
   return float(a) <= float(b);
 }

◆ operator==()

bool Eigen::half_impl::operator==	(	const half &	a,
		const half &	b
	)

inline

Definition at line 494 of file Half.h.

                                                                                       {
   return numext::equal_strict(float(a),float(b));
 }

◆ operator>()

bool Eigen::half_impl::operator>	(	const half &	a,
		const half &	b
	)

inline

Definition at line 506 of file Half.h.

                                                                                      {
   return float(a) > float(b);
 }

◆ operator>=()

bool Eigen::half_impl::operator>=	(	const half &	a,
		const half &	b
	)

inline

Definition at line 509 of file Half.h.

                                                                                       {
   return float(a) >= float(b);
 }

◆ pow()

half Eigen::half_impl::pow	(	const half &	a,
		const half &	b
	)

inline

Definition at line 758 of file Half.h.

                                                                              {
   return half(::powf(float(a), float(b)));
 }

◆ raw_half_as_uint16()

numext::uint16_t Eigen::half_impl::raw_half_as_uint16 ( const __half_raw & h )

inline

Definition at line 567 of file Half.h.

                                                                                              {
   // HIP/CUDA/Default have a member 'x' of type uint16_t.
   // For ARM64 native half, the member 'x' is of type __fp16, so we need to bit-cast.
   // For SYCL, cl::sycl::half is _Float16, so cast directly.
 #if defined(EIGEN_HAS_ARM64_FP16_SCALAR_ARITHMETIC)
   return numext::bit_cast<numext::uint16_t>(h.x);
 #elif defined(SYCL_DEVICE_ONLY)
   return numext::bit_cast<numext::uint16_t>(h);
 #else
   return h.x;
 #endif
 }

◆ raw_uint16_to_half()

EIGEN_CONSTEXPR __half_raw Eigen::half_impl::raw_uint16_to_half ( numext::uint16_t x )

inline

Definition at line 551 of file Half.h.

                                                                                                       {
   // We cannot simply do a "return __half_raw(x)" here, because __half_raw is union type
   // in the hip_fp16 header file, and that will trigger a compile error
   // On the other hand, having anything but a return statement also triggers a compile error
   // because this is constexpr function.
   // Fortunately, since we need to disable EIGEN_CONSTEXPR for GPU anyway, we can get out
   // of this catch22 by having separate bodies for GPU / non GPU
 #if defined(EIGEN_HAS_GPU_FP16)
    __half_raw h;
    h.x = x;
   return h;
 #else
   return __half_raw(x);
 #endif
 }

◆ rint()

half Eigen::half_impl::rint ( const half & a )

inline

Definition at line 804 of file Half.h.

                                                                {
   return half(::rintf(float(a)));
 }

◆ round()

half Eigen::half_impl::round ( const half & a )

inline

Definition at line 807 of file Half.h.

                                                                 {
   return half(::roundf(float(a)));
 }

◆ sin()

half Eigen::half_impl::sin ( const half & a )

inline

Definition at line 764 of file Half.h.

                                                               {
   return half(::sinf(float(a)));
 }

◆ sqrt()

half Eigen::half_impl::sqrt ( const half & a )

inline

Definition at line 750 of file Half.h.

                                                                {
 #if (EIGEN_CUDA_SDK_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530) || \
   defined(EIGEN_HIP_DEVICE_COMPILE)
   return half(hsqrt(a));
 #else
     return half(::sqrtf(float(a)));
 #endif
 }

◆ tan()

half Eigen::half_impl::tan ( const half & a )

inline

Definition at line 770 of file Half.h.

                                                               {
   return half(::tanf(float(a)));
 }

◆ tanh()

half Eigen::half_impl::tanh ( const half & a )

inline

Definition at line 773 of file Half.h.

                                                                {
   return half(::tanhf(float(a)));
 }

Classes

Functions

Function Documentation

◆ abs()

◆ acos()

◆ asin()

◆ atan()

◆ atan2()

◆ atanh()

◆ ceil()

◆ cos()

◆ exp()

◆ expm1()

◆ float_to_half_rtne()

◆ floor()

◆ fmod()

◆ half_to_float()

◆ isfinite()

◆ isinf()

◆ isnan()

◆ log()

◆ log10()

◆ log1p()

◆ log2()

◆ max()

◆ min()

◆ operator!=()

◆ operator*()

◆ operator*=()

◆ operator+()

◆ operator++() [1/2]

◆ operator++() [2/2]

◆ operator+=()

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator--() [1/2]

◆ operator--() [2/2]

◆ operator-=()

◆ operator/() [1/2]

◆ operator/() [2/2]

◆ operator/=()

◆ operator<()

◆ operator<<()

◆ operator<=()

◆ operator==()

◆ operator>()

◆ operator>=()

◆ pow()

◆ raw_half_as_uint16()

◆ raw_uint16_to_half()

◆ rint()

◆ round()

◆ sin()

◆ sqrt()

◆ tan()

◆ tanh()