Eigen::half_impl Namespace Reference

Classes
struct	__half_raw
struct	half_base
struct	numeric_limits_half_impl
union	float32_bits

Functions
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __half_raw	raw_uint16_to_half (numext::uint16_t x)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw	float_to_half_rtne (float ff)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float	half_to_float (__half_raw h)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	operator+ (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	operator* (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	operator- (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	operator/ (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	operator- (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half &	operator+= (half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half &	operator*= (half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half &	operator-= (half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half &	operator/= (half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	operator== (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	operator!= (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	operator< (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	operator<= (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	operator> (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool	operator>= (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	operator/ (const half &a, Index b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	operator++ (half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	operator-- (half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	operator++ (half &a, int)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	operator-- (half &a, int)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC numext::uint16_t	raw_half_as_uint16 (const __half_raw &h)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool()	isinf (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool()	isnan (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool()	isfinite (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	abs (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	exp (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	exp2 (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	expm1 (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	log (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	log1p (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	log10 (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	log2 (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	sqrt (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	pow (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	atan2 (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	sin (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	cos (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	tan (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	tanh (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	asin (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	acos (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	atan (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	atanh (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	floor (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	ceil (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	rint (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	round (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	trunc (const half &a)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half	fmod (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half()	min (const half &a, const half &b)
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half()	max (const half &a, const half &b)
EIGEN_ALWAYS_INLINE std::ostream &	operator<< (std::ostream &os, const half &v)

Function Documentation

abs()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::abs

(

const half &

a

)

                                                              {
#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
}

References a, and Eigen::half_impl::__half_raw::x.

acos()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::acos

(

const half &

a

)

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

References a.

asin()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::asin

(

const half &

a

)

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

References a.

atan()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::atan

(

const half &

a

)

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

References a.

atan2()

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

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

References a, and b.

atanh()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::atanh

(

const half &

a

)

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

References a.

ceil()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::ceil

(

const half &

a

)

                                                               {
#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
}

References a.

cos()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::cos

(

const half &

a

)

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

References a.

exp()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::exp

(

const half &

a

)

                                                              {
#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
}

References a.

Referenced by half_to_float().

exp2()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::exp2

(

const half &

a

)

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

References a.

expm1()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::expm1

(

const half &

a

)

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

References a.

float_to_half_rtne()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw Eigen::half_impl::float_to_half_rtne

(

float

ff

)

                                                                              {
#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
}

References Eigen::half_impl::float32_bits::f, f(), SYCL::sign(), Eigen::half_impl::float32_bits::u, and Eigen::half_impl::__half_raw::x.

floor()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::floor

(

const half &

a

)

                                                                {
#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
}

References a.

fmod()

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

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

References a, and b.

half_to_float()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC float Eigen::half_impl::half_to_float

(

__half_raw

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
}

References exp(), Eigen::half_impl::float32_bits::f, Eigen::half_impl::float32_bits::u, and Eigen::half_impl::__half_raw::x.

Referenced by Eigen::half::operator float().

isfinite()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool() Eigen::half_impl::isfinite

(

const half &

a

)

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

References a, EIGEN_NOT_A_MACRO, isinf(), and isnan().

isinf()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool() Eigen::half_impl::isinf

(

const half &

a

)

                                                                 {
#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
}

References a.

Referenced by isfinite().

isnan()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool() Eigen::half_impl::isnan

(

const half &

a

)

                                                                 {
#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
}

References a.

Referenced by isfinite().

log()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::log

(

const half &

a

)

                                                              {
#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
}

References a.

log10()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::log10

(

const half &

a

)

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

References a.

log1p()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::log1p

(

const half &

a

)

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

References a.

log2()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::log2

(

const half &

a

)

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

References a, and EIGEN_LOG2E.

max()

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

                                                                              {
#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
}

References a, b, Global_parameters::f1(), and Global_parameters::f2().

min()

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

                                                                              {
#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
}

References a, b, Global_parameters::f1(), and Global_parameters::f2().

operator!=()

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

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

References a, b, and Eigen::numext::not_equal_strict().

operator*()

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

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

References a, and b.

operator*=()

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

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

References a, and b.

operator+()

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

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

References a, and b.

operator++() [1/2]

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::operator++

(

half &

a

)

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

References a.

operator++() [2/2]

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

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

References a.

operator+=()

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

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

References a, and b.

operator-() [1/2]

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::operator-

(

const half &

a

)

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

References a, and Eigen::half_impl::__half_raw::x.

operator-() [2/2]

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

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

References a, and b.

operator--() [1/2]

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::operator--

(

half &

a

)

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

References a.

operator--() [2/2]

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

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

References a.

operator-=()

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

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

References a, and b.

operator/() [1/2]

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

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

References a, and b.

operator/() [2/2]

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

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

References a, and b.

operator/=()

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

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

References a, and b.

operator<()

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

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

References a, and b.

operator<<()

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

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

References v.

operator<=()

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

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

References a, and b.

operator==()

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

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

References a, b, and Eigen::numext::equal_strict().

operator>()

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

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

References a, and b.

operator>=()

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

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

References a, and b.

pow()

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

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

References a, and b.

raw_half_as_uint16()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC numext::uint16_t Eigen::half_impl::raw_half_as_uint16

(

const __half_raw &

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
}

References Eigen::half_impl::__half_raw::x.

Referenced by Eigen::numext::bit_cast< uint16_t, Eigen::half >().

raw_uint16_to_half()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR __half_raw Eigen::half_impl::raw_uint16_to_half

(

numext::uint16_t

x

)

                                                                                                      {
  // 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
}

References plotDoE::x, and Eigen::half_impl::__half_raw::x.

Referenced by Eigen::numext::bit_cast< Eigen::half, uint16_t >(), Eigen::half_impl::numeric_limits_half_impl< typename >::denorm_min(), Eigen::NumTraits< Eigen::half >::dummy_precision(), Eigen::half_impl::numeric_limits_half_impl< typename >::epsilon(), Eigen::NumTraits< Eigen::half >::epsilon(), Eigen::NumTraits< Eigen::half >::highest(), Eigen::half_impl::numeric_limits_half_impl< typename >::infinity(), Eigen::NumTraits< Eigen::half >::infinity(), Eigen::half_impl::numeric_limits_half_impl< typename >::lowest(), Eigen::NumTraits< Eigen::half >::lowest(), Eigen::half_impl::numeric_limits_half_impl< typename >::max(), Eigen::half_impl::numeric_limits_half_impl< typename >::min(), Eigen::internal::pfirst< Packet16h >(), Eigen::internal::pfirst< Packet32h >(), Eigen::half_impl::numeric_limits_half_impl< typename >::quiet_NaN(), Eigen::NumTraits< Eigen::half >::quiet_NaN(), Eigen::half_impl::numeric_limits_half_impl< typename >::round_error(), and Eigen::half_impl::numeric_limits_half_impl< typename >::signaling_NaN().

rint()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::rint

(

const half &

a

)

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

References a.

round()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::round

(

const half &

a

)

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

References a.

sin()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::sin

(

const half &

a

)

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

References a.

sqrt()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::sqrt

(

const half &

a

)

                                                               {
#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
}

References a.

tan()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::tan

(

const half &

a

)

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

References a.

tanh()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::tanh

(

const half &

a

)

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

References a.

trunc()

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half Eigen::half_impl::trunc

(

const half &

a

)

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

References a.