36 #ifndef EIGEN_HALF_CUDA_H 37 #define EIGEN_HALF_CUDA_H 39 #if __cplusplus > 199711L 40 #define EIGEN_EXPLICIT_CAST(tgt_type) explicit operator tgt_type() 42 #define EIGEN_EXPLICIT_CAST(tgt_type) operator tgt_type() 53 #if !defined(EIGEN_HAS_CUDA_FP16) 56 EIGEN_DEVICE_FUNC __half_raw() : x(0) {}
57 explicit EIGEN_DEVICE_FUNC __half_raw(
unsigned short raw) : x(raw) {}
60 #elif defined(EIGEN_CUDACC_VER) && EIGEN_CUDACC_VER < 90000 62 typedef __half __half_raw;
65 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw raw_uint16_to_half(
unsigned short x);
66 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw float_to_half_rtne(
float ff);
67 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
float half_to_float(__half_raw h);
69 struct half_base :
public __half_raw {
70 EIGEN_DEVICE_FUNC half_base() {}
71 EIGEN_DEVICE_FUNC half_base(
const half_base& h) : __half_raw(h) {}
72 EIGEN_DEVICE_FUNC half_base(
const __half_raw& h) : __half_raw(h) {}
73 #if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDACC_VER) && EIGEN_CUDACC_VER >= 90000 74 EIGEN_DEVICE_FUNC half_base(
const __half& h) : __half_raw(*(__half_raw*)&h) {}
81 struct half :
public half_impl::half_base {
82 #if !defined(EIGEN_HAS_CUDA_FP16) || (defined(EIGEN_CUDACC_VER) && EIGEN_CUDACC_VER < 90000) 83 typedef half_impl::__half_raw __half_raw;
86 EIGEN_DEVICE_FUNC half() {}
88 EIGEN_DEVICE_FUNC half(
const __half_raw& h) : half_impl::half_base(h) {}
89 EIGEN_DEVICE_FUNC half(
const half& h) : half_impl::half_base(h) {}
90 #if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDACC_VER) && EIGEN_CUDACC_VER >= 90000 91 EIGEN_DEVICE_FUNC half(
const __half& h) : half_impl::half_base(h) {}
94 explicit EIGEN_DEVICE_FUNC half(
bool b)
95 : half_impl::half_base(half_impl::raw_uint16_to_half(b ? 0x3c00 : 0)) {}
97 explicit EIGEN_DEVICE_FUNC half(
const T& val)
98 : half_impl::half_base(half_impl::float_to_half_rtne(static_cast<float>(val))) {}
99 explicit EIGEN_DEVICE_FUNC half(
float f)
100 : half_impl::half_base(half_impl::float_to_half_rtne(f)) {}
102 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
bool)
const {
104 return (x & 0x7fff) != 0;
106 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
signed char)
const {
107 return static_cast<signed char>(half_impl::half_to_float(*
this));
109 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
unsigned char)
const {
110 return static_cast<unsigned char>(half_impl::half_to_float(*
this));
112 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
short)
const {
113 return static_cast<short>(half_impl::half_to_float(*
this));
115 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
unsigned short)
const {
116 return static_cast<unsigned short>(half_impl::half_to_float(*
this));
118 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
int)
const {
119 return static_cast<int>(half_impl::half_to_float(*
this));
121 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
unsigned int)
const {
122 return static_cast<unsigned int>(half_impl::half_to_float(*
this));
124 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
long)
const {
125 return static_cast<long>(half_impl::half_to_float(*
this));
127 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
unsigned long)
const {
128 return static_cast<unsigned long>(half_impl::half_to_float(*
this));
130 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
long long)
const {
131 return static_cast<long long>(half_impl::half_to_float(*
this));
133 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
unsigned long long)
const {
134 return static_cast<unsigned long long>(half_to_float(*
this));
136 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
float)
const {
137 return half_impl::half_to_float(*
this);
139 EIGEN_DEVICE_FUNC EIGEN_EXPLICIT_CAST(
double)
const {
140 return static_cast<double>(half_impl::half_to_float(*
this));
143 EIGEN_DEVICE_FUNC half& operator=(
const half& other) {
153 struct numeric_limits<
Eigen::half> {
154 static const bool is_specialized =
true;
155 static const bool is_signed =
true;
156 static const bool is_integer =
false;
157 static const bool is_exact =
false;
158 static const bool has_infinity =
true;
159 static const bool has_quiet_NaN =
true;
160 static const bool has_signaling_NaN =
true;
161 static const float_denorm_style has_denorm = denorm_present;
162 static const bool has_denorm_loss =
false;
163 static const std::float_round_style round_style = std::round_to_nearest;
164 static const bool is_iec559 =
false;
165 static const bool is_bounded =
false;
166 static const bool is_modulo =
false;
167 static const int digits = 11;
168 static const int digits10 = 3;
169 static const int max_digits10 = 5;
170 static const int radix = 2;
171 static const int min_exponent = -13;
172 static const int min_exponent10 = -4;
173 static const int max_exponent = 16;
174 static const int max_exponent10 = 4;
175 static const bool traps =
true;
176 static const bool tinyness_before =
false;
178 static Eigen::half (min)() {
return Eigen::half_impl::raw_uint16_to_half(0x400); }
179 static Eigen::half lowest() {
return Eigen::half_impl::raw_uint16_to_half(0xfbff); }
180 static Eigen::half (max)() {
return Eigen::half_impl::raw_uint16_to_half(0x7bff); }
181 static Eigen::half epsilon() {
return Eigen::half_impl::raw_uint16_to_half(0x0800); }
182 static Eigen::half round_error() {
return Eigen::half(0.5); }
183 static Eigen::half infinity() {
return Eigen::half_impl::raw_uint16_to_half(0x7c00); }
184 static Eigen::half quiet_NaN() {
return Eigen::half_impl::raw_uint16_to_half(0x7e00); }
185 static Eigen::half signaling_NaN() {
return Eigen::half_impl::raw_uint16_to_half(0x7e00); }
186 static Eigen::half denorm_min() {
return Eigen::half_impl::raw_uint16_to_half(0x1); }
194 struct numeric_limits<const
Eigen::half> : numeric_limits<Eigen::half> {};
196 struct numeric_limits<volatile
Eigen::half> : numeric_limits<Eigen::half> {};
198 struct numeric_limits<const volatile
Eigen::half> : numeric_limits<Eigen::half> {};
203 namespace half_impl {
205 #if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530 212 EIGEN_STRONG_INLINE __device__ half operator + (
const half& a,
const half& b) {
215 EIGEN_STRONG_INLINE __device__ half
operator * (
const half& a,
const half& b) {
218 EIGEN_STRONG_INLINE __device__ half operator - (
const half& a,
const half& b) {
221 EIGEN_STRONG_INLINE __device__ half operator / (
const half& a,
const half& b) {
222 float num = __half2float(a);
223 float denom = __half2float(b);
224 return __float2half(num / denom);
226 EIGEN_STRONG_INLINE __device__ half operator - (
const half& a) {
229 EIGEN_STRONG_INLINE __device__ half& operator += (half& a,
const half& b) {
233 EIGEN_STRONG_INLINE __device__ half& operator *= (half& a,
const half& b) {
237 EIGEN_STRONG_INLINE __device__ half& operator -= (half& a,
const half& b) {
241 EIGEN_STRONG_INLINE __device__ half& operator /= (half& a,
const half& b) {
245 EIGEN_STRONG_INLINE __device__
bool operator == (
const half& a,
const half& b) {
248 EIGEN_STRONG_INLINE __device__
bool operator != (
const half& a,
const half& b) {
251 EIGEN_STRONG_INLINE __device__
bool operator < (
const half& a,
const half& b) {
254 EIGEN_STRONG_INLINE __device__
bool operator <= (
const half& a,
const half& b) {
257 EIGEN_STRONG_INLINE __device__
bool operator > (
const half& a,
const half& b) {
260 EIGEN_STRONG_INLINE __device__
bool operator >= (
const half& a,
const half& b) {
264 #else // Emulate support for half floats 269 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator + (
const half& a,
const half& b) {
270 return half(
float(a) +
float(b));
272 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
operator * (
const half& a,
const half& b) {
273 return half(
float(a) *
float(b));
275 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator - (
const half& a,
const half& b) {
276 return half(
float(a) -
float(b));
278 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator / (
const half& a,
const half& b) {
279 return half(
float(a) /
float(b));
281 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator - (
const half& a) {
283 result.x = a.x ^ 0x8000;
286 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator += (half& a,
const half& b) {
287 a = half(
float(a) +
float(b));
290 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator *= (half& a,
const half& b) {
291 a = half(
float(a) *
float(b));
294 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator -= (half& a,
const half& b) {
295 a = half(
float(a) -
float(b));
298 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half& operator /= (half& a,
const half& b) {
299 a = half(
float(a) /
float(b));
302 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
bool operator == (
const half& a,
const half& b) {
303 return numext::equal_strict(
float(a),
float(b));
305 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
bool operator != (
const half& a,
const half& b) {
306 return numext::not_equal_strict(
float(a),
float(b));
308 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
bool operator < (
const half& a,
const half& b) {
309 return float(a) < float(b);
311 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
bool operator <= (
const half& a,
const half& b) {
312 return float(a) <= float(b);
314 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
bool operator > (
const half& a,
const half& b) {
315 return float(a) > float(b);
317 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
bool operator >= (
const half& a,
const half& b) {
318 return float(a) >= float(b);
321 #endif // Emulate support for half floats 325 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half operator / (
const half& a,
Index b) {
326 return half(static_cast<float>(a) / static_cast<float>(b));
334 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw raw_uint16_to_half(
unsigned short x) {
345 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC __half_raw float_to_half_rtne(
float ff) {
346 #if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300 347 __half tmp_ff = __float2half(ff);
348 return *(__half_raw*)&tmp_ff;
350 #elif defined(EIGEN_HAS_FP16_C) 352 h.x = _cvtss_sh(ff, 0);
356 float32_bits f; f.f = ff;
358 const float32_bits f32infty = { 255 << 23 };
359 const float32_bits f16max = { (127 + 16) << 23 };
360 const float32_bits denorm_magic = { ((127 - 15) + (23 - 10) + 1) << 23 };
361 unsigned int sign_mask = 0x80000000u;
363 o.x =
static_cast<unsigned short>(0x0u);
365 unsigned int sign = f.u & sign_mask;
373 if (f.u >= f16max.u) {
374 o.x = (f.u > f32infty.u) ? 0x7e00 : 0x7c00;
376 if (f.u < (113 << 23)) {
380 f.f += denorm_magic.f;
383 o.x =
static_cast<unsigned short>(f.u - denorm_magic.u);
385 unsigned int mant_odd = (f.u >> 13) & 1;
388 f.u += ((
unsigned int)(15 - 127) << 23) + 0xfff;
392 o.x =
static_cast<unsigned short>(f.u >> 13);
396 o.x |=
static_cast<unsigned short>(
sign >> 16);
401 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC
float half_to_float(__half_raw h) {
402 #if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300 403 return __half2float(h);
405 #elif defined(EIGEN_HAS_FP16_C) 406 return _cvtsh_ss(h.x);
409 const float32_bits magic = { 113 << 23 };
410 const unsigned int shifted_exp = 0x7c00 << 13;
413 o.u = (h.x & 0x7fff) << 13;
414 unsigned int exp = shifted_exp & o.u;
415 o.u += (127 - 15) << 23;
418 if (
exp == shifted_exp) {
419 o.u += (128 - 16) << 23;
420 }
else if (
exp == 0) {
425 o.u |= (h.x & 0x8000) << 16;
432 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (
isinf)(
const half& a) {
433 return (a.x & 0x7fff) == 0x7c00;
435 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (
isnan)(
const half& a) {
436 #if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530 439 return (a.x & 0x7fff) > 0x7c00;
442 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bool (
isfinite)(
const half& a) {
443 return !(
isinf EIGEN_NOT_A_MACRO (a)) && !(
isnan EIGEN_NOT_A_MACRO (a));
446 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
abs(
const half& a) {
448 result.x = a.x & 0x7FFF;
451 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
exp(
const half& a) {
452 #if EIGEN_CUDACC_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530 453 return half(hexp(a));
455 return half(::expf(
float(a)));
458 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
log(
const half& a) {
459 #if defined(EIGEN_HAS_CUDA_FP16) && EIGEN_CUDACC_VER >= 80000 && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530 460 return half(::hlog(a));
462 return half(::logf(
float(a)));
465 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
log1p(
const half& a) {
466 return half(numext::log1p(
float(a)));
468 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
log10(
const half& a) {
469 return half(::log10f(
float(a)));
471 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
sqrt(
const half& a) {
472 #if EIGEN_CUDACC_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 530 473 return half(hsqrt(a));
475 return half(::sqrtf(
float(a)));
478 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half pow(
const half& a,
const half& b) {
479 return half(::powf(
float(a),
float(b)));
481 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
sin(
const half& a) {
482 return half(::sinf(
float(a)));
484 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
cos(
const half& a) {
485 return half(::cosf(
float(a)));
487 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
tan(
const half& a) {
488 return half(::tanf(
float(a)));
490 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
tanh(
const half& a) {
491 return half(::tanhf(
float(a)));
493 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
floor(
const half& a) {
494 #if EIGEN_CUDACC_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 300 495 return half(hfloor(a));
497 return half(::floorf(
float(a)));
500 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half
ceil(
const half& a) {
501 #if EIGEN_CUDACC_VER >= 80000 && defined EIGEN_CUDA_ARCH && EIGEN_CUDA_ARCH >= 300 502 return half(hceil(a));
504 return half(::ceilf(
float(a)));
508 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half (min)(
const half& a,
const half& b) {
509 #if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530 510 return __hlt(b, a) ? b : a;
512 const float f1 =
static_cast<float>(a);
513 const float f2 =
static_cast<float>(b);
514 return f2 < f1 ? b : a;
517 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half (max)(
const half& a,
const half& b) {
518 #if defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530 519 return __hlt(a, b) ? b : a;
521 const float f1 =
static_cast<float>(a);
522 const float f2 =
static_cast<float>(b);
523 return f1 < f2 ? b : a;
527 EIGEN_ALWAYS_INLINE std::ostream& operator << (std::ostream& os,
const half& v) {
528 os << static_cast<float>(v);
540 struct random_default_impl<half, false, false>
542 static inline half run(
const half& x,
const half& y)
544 return x + (y-x) * half(
float(std::rand()) / float(RAND_MAX));
546 static inline half run()
548 return run(half(-1.f), half(1.f));
552 template<>
struct is_arithmetic<half> {
enum { value =
true }; };
556 template<>
struct NumTraits<
Eigen::half>
557 : GenericNumTraits<Eigen::half>
563 RequireInitialization =
false 566 EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Eigen::half epsilon() {
567 return half_impl::raw_uint16_to_half(0x0800);
569 EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Eigen::half dummy_precision() {
return Eigen::half(1e-2f); }
570 EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Eigen::half highest() {
571 return half_impl::raw_uint16_to_half(0x7bff);
573 EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Eigen::half lowest() {
574 return half_impl::raw_uint16_to_half(0xfbff);
576 EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Eigen::half infinity() {
577 return half_impl::raw_uint16_to_half(0x7c00);
579 EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Eigen::half quiet_NaN() {
580 return half_impl::raw_uint16_to_half(0x7c01);
587 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half fabsh(
const Eigen::half& a) {
589 result.x = a.x & 0x7FFF;
592 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half exph(
const Eigen::half& a) {
593 return Eigen::half(::expf(
float(a)));
595 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half logh(
const Eigen::half& a) {
596 #if EIGEN_CUDACC_VER >= 80000 && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530 597 return Eigen::half(::hlog(a));
599 return Eigen::half(::logf(
float(a)));
602 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half sqrth(
const Eigen::half& a) {
603 return Eigen::half(::sqrtf(
float(a)));
605 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half powh(
const Eigen::half& a,
const Eigen::half& b) {
606 return Eigen::half(::powf(
float(a),
float(b)));
608 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half floorh(
const Eigen::half& a) {
609 return Eigen::half(::floorf(
float(a)));
611 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half ceilh(
const Eigen::half& a) {
612 return Eigen::half(::ceilf(
float(a)));
617 #if __cplusplus > 199711L 619 struct hash<
Eigen::half> {
620 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::size_t operator()(
const Eigen::half& a)
const {
621 return static_cast<std::size_t
>(a.x);
630 #if defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300 631 __device__ EIGEN_STRONG_INLINE Eigen::half __shfl_xor(Eigen::half var,
int laneMask,
int width=warpSize) {
632 #if EIGEN_CUDACC_VER < 90000 633 return static_cast<Eigen::half
>(__shfl_xor(static_cast<float>(var), laneMask, width));
635 return static_cast<Eigen::half
>(__shfl_xor_sync(0xFFFFFFFF, static_cast<float>(var), laneMask, width));
641 #if defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 350 642 EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Eigen::half __ldg(
const Eigen::half* ptr) {
643 return Eigen::half_impl::raw_uint16_to_half(
644 __ldg(reinterpret_cast<const unsigned short*>(ptr)));
649 #if defined(EIGEN_CUDA_ARCH) 654 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
655 bool (
isnan)(
const Eigen::half& h) {
656 return (half_impl::isnan)(h);
660 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
661 bool (
isinf)(
const Eigen::half& h) {
662 return (half_impl::isinf)(h);
666 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
667 bool (
isfinite)(
const Eigen::half& h) {
668 return (half_impl::isfinite)(h);
675 #endif // EIGEN_HALF_CUDA_H const Eigen::CwiseUnaryOp< Eigen::internal::scalar_tanh_op< typename Derived::Scalar >, const Derived > tanh(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_isfinite_op< typename Derived::Scalar >, const Derived > isfinite(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sqrt_op< typename Derived::Scalar >, const Derived > sqrt(const Eigen::ArrayBase< Derived > &x)
Namespace containing all symbols from the Eigen library.
Definition: Core:309
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_ceil_op< typename Derived::Scalar >, const Derived > ceil(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_isnan_op< typename Derived::Scalar >, const Derived > isnan(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_cos_op< typename Derived::Scalar >, const Derived > cos(const Eigen::ArrayBase< Derived > &x)
const Product< MatrixDerived, PermutationDerived, AliasFreeProduct > operator*(const MatrixBase< MatrixDerived > &matrix, const PermutationBase< PermutationDerived > &permutation)
Definition: PermutationMatrix.h:515
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_floor_op< typename Derived::Scalar >, const Derived > floor(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log1p_op< typename Derived::Scalar >, const Derived > log1p(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_isinf_op< typename Derived::Scalar >, const Derived > isinf(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs_op< typename Derived::Scalar >, const Derived > abs(const Eigen::ArrayBase< Derived > &x)
Definition: Eigen_Colamd.h:50
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log_op< typename Derived::Scalar >, const Derived > log(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_tan_op< typename Derived::Scalar >, const Derived > tan(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sign_op< typename Derived::Scalar >, const Derived > sign(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_sin_op< typename Derived::Scalar >, const Derived > sin(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_exp_op< typename Derived::Scalar >, const Derived > exp(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log10_op< typename Derived::Scalar >, const Derived > log10(const Eigen::ArrayBase< Derived > &x)