11 #ifndef EIGEN_MATHFUNCTIONS_H 12 #define EIGEN_MATHFUNCTIONS_H 16 #define EIGEN_PI 3.141592653589793238462643383279502884197169399375105820974944592307816406L 17 #define EIGEN_LOG2E 1.442695040888963407359924681001892137426645954152985934135449406931109219L 18 #define EIGEN_LN2 0.693147180559945309417232121458176568075500134360255254120680009493393621L 24 #if EIGEN_OS_WINCE && EIGEN_COMP_MSVC && EIGEN_COMP_MSVC<=1500 25 long abs(
long x) {
return (labs(x)); }
26 double abs(
double x) {
return (fabs(x)); }
27 float abs(
float x) {
return (fabsf(x)); }
28 long double abs(
long double x) {
return (fabsl(x)); }
53 template<
typename T,
typename dummy =
void>
54 struct global_math_functions_filtering_base
59 template<
typename T>
struct always_void {
typedef void type; };
62 struct global_math_functions_filtering_base
64 typename always_void<typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl>::type
67 typedef typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl type;
70 #define EIGEN_MATHFUNC_IMPL(func, scalar) Eigen::internal::func##_impl<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type> 71 #define EIGEN_MATHFUNC_RETVAL(func, scalar) typename Eigen::internal::func##_retval<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>::type 77 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
78 struct real_default_impl
80 typedef typename NumTraits<Scalar>::Real RealScalar;
82 static inline RealScalar run(
const Scalar& x)
88 template<
typename Scalar>
89 struct real_default_impl<Scalar,true>
91 typedef typename NumTraits<Scalar>::Real RealScalar;
93 static inline RealScalar run(
const Scalar& x)
100 template<
typename Scalar>
struct real_impl : real_default_impl<Scalar> {};
102 #if defined(EIGEN_GPU_COMPILE_PHASE) 104 struct real_impl<
std::complex<T> >
106 typedef T RealScalar;
108 static inline T run(
const std::complex<T>& x)
115 template<
typename Scalar>
118 typedef typename NumTraits<Scalar>::Real type;
125 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
126 struct imag_default_impl
128 typedef typename NumTraits<Scalar>::Real RealScalar;
130 static inline RealScalar run(
const Scalar&)
132 return RealScalar(0);
136 template<
typename Scalar>
137 struct imag_default_impl<Scalar,true>
139 typedef typename NumTraits<Scalar>::Real RealScalar;
141 static inline RealScalar run(
const Scalar& x)
148 template<
typename Scalar>
struct imag_impl : imag_default_impl<Scalar> {};
150 #if defined(EIGEN_GPU_COMPILE_PHASE) 152 struct imag_impl<
std::complex<T> >
154 typedef T RealScalar;
156 static inline T run(
const std::complex<T>& x)
163 template<
typename Scalar>
166 typedef typename NumTraits<Scalar>::Real type;
173 template<
typename Scalar>
176 typedef typename NumTraits<Scalar>::Real RealScalar;
178 static inline RealScalar& run(Scalar& x)
180 return reinterpret_cast<RealScalar*
>(&x)[0];
183 static inline const RealScalar& run(
const Scalar& x)
185 return reinterpret_cast<const RealScalar*
>(&x)[0];
189 template<
typename Scalar>
190 struct real_ref_retval
192 typedef typename NumTraits<Scalar>::Real & type;
199 template<
typename Scalar,
bool IsComplex>
200 struct imag_ref_default_impl
202 typedef typename NumTraits<Scalar>::Real RealScalar;
204 static inline RealScalar& run(Scalar& x)
206 return reinterpret_cast<RealScalar*
>(&x)[1];
209 static inline const RealScalar& run(
const Scalar& x)
211 return reinterpret_cast<RealScalar*
>(&x)[1];
215 template<
typename Scalar>
216 struct imag_ref_default_impl<Scalar, false>
218 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
219 static inline Scalar run(Scalar&)
223 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
224 static inline const Scalar run(
const Scalar&)
230 template<
typename Scalar>
231 struct imag_ref_impl : imag_ref_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
233 template<
typename Scalar>
234 struct imag_ref_retval
236 typedef typename NumTraits<Scalar>::Real & type;
243 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
244 struct conj_default_impl
247 static inline Scalar run(
const Scalar& x)
253 template<
typename Scalar>
254 struct conj_default_impl<Scalar,true>
257 static inline Scalar run(
const Scalar& x)
264 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
265 struct conj_impl : conj_default_impl<Scalar, IsComplex> {};
267 template<
typename Scalar>
277 template<
typename Scalar,
bool IsComplex>
278 struct abs2_impl_default
280 typedef typename NumTraits<Scalar>::Real RealScalar;
282 static inline RealScalar run(
const Scalar& x)
288 template<
typename Scalar>
289 struct abs2_impl_default<Scalar, true>
291 typedef typename NumTraits<Scalar>::Real RealScalar;
293 static inline RealScalar run(
const Scalar& x)
295 return x.real()*x.real() + x.imag()*x.imag();
299 template<
typename Scalar>
302 typedef typename NumTraits<Scalar>::Real RealScalar;
304 static inline RealScalar run(
const Scalar& x)
306 return abs2_impl_default<Scalar,NumTraits<Scalar>::IsComplex>::run(x);
310 template<
typename Scalar>
313 typedef typename NumTraits<Scalar>::Real type;
320 template<
typename Scalar>
324 static EIGEN_ALWAYS_INLINE Scalar run(
const Scalar& x)
326 EIGEN_USING_STD(
sqrt);
332 template<
typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_sqrt(
const std::complex<T>& a_x);
337 struct sqrt_impl<
std::complex<T> >
340 static EIGEN_ALWAYS_INLINE std::complex<T> run(
const std::complex<T>& x)
342 return complex_sqrt<T>(x);
346 template<
typename Scalar>
357 template<
typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_rsqrt(
const std::complex<T>& a_x);
360 struct rsqrt_impl<
std::complex<T> >
363 static EIGEN_ALWAYS_INLINE std::complex<T> run(
const std::complex<T>& x)
365 return complex_rsqrt<T>(x);
369 template<
typename Scalar>
379 template<
typename Scalar,
bool IsComplex>
380 struct norm1_default_impl;
382 template<
typename Scalar>
383 struct norm1_default_impl<Scalar,true>
385 typedef typename NumTraits<Scalar>::Real RealScalar;
387 static inline RealScalar run(
const Scalar& x)
389 EIGEN_USING_STD(
abs);
390 return abs(x.real()) +
abs(x.imag());
394 template<
typename Scalar>
395 struct norm1_default_impl<Scalar, false>
398 static inline Scalar run(
const Scalar& x)
400 EIGEN_USING_STD(
abs);
405 template<
typename Scalar>
406 struct norm1_impl : norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
408 template<
typename Scalar>
411 typedef typename NumTraits<Scalar>::Real type;
418 template<
typename Scalar>
struct hypot_impl;
420 template<
typename Scalar>
423 typedef typename NumTraits<Scalar>::Real type;
430 template<
typename OldType,
typename NewType,
typename EnableIf =
void>
434 static inline NewType run(
const OldType& x)
436 return static_cast<NewType
>(x);
442 template<
typename OldType,
typename NewType>
443 struct cast_impl<OldType, NewType,
445 !NumTraits<OldType>::IsComplex && NumTraits<NewType>::IsComplex
449 static inline NewType run(
const OldType& x)
451 typedef typename NumTraits<NewType>::Real NewReal;
452 return static_cast<NewType
>(
static_cast<NewReal
>(x));
458 template<
typename OldType,
typename NewType>
460 inline NewType cast(
const OldType& x)
462 return cast_impl<OldType, NewType>::run(x);
469 template<
typename Scalar>
473 static inline Scalar run(
const Scalar& x)
475 EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
476 #if EIGEN_HAS_CXX11_MATH 477 EIGEN_USING_STD(
round);
479 return Scalar(
round(x));
483 #if !EIGEN_HAS_CXX11_MATH 484 #if EIGEN_HAS_C99_MATH 487 struct round_impl<float> {
489 static inline float run(
const float& x)
495 template<
typename Scalar>
496 struct round_using_floor_ceil_impl
499 static inline Scalar run(
const Scalar& x)
501 EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
503 EIGEN_USING_STD(
floor);
504 EIGEN_USING_STD(
ceil);
507 const Scalar limit = Scalar(1ull << (NumTraits<Scalar>::digits() - 1));
508 if (x >= limit || x <= -limit) {
511 return (x > Scalar(0)) ? Scalar(
floor(x + Scalar(0.5))) : Scalar(
ceil(x - Scalar(0.5)));
516 struct round_impl<float> : round_using_floor_ceil_impl<float> {};
519 struct round_impl<double> : round_using_floor_ceil_impl<double> {};
520 #endif // EIGEN_HAS_C99_MATH 521 #endif // !EIGEN_HAS_CXX11_MATH 523 template<
typename Scalar>
533 template<
typename Scalar>
536 static inline Scalar run(
const Scalar& x)
538 EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
539 #if EIGEN_HAS_CXX11_MATH 540 EIGEN_USING_STD(
rint);
546 #if !EIGEN_HAS_CXX11_MATH 548 struct rint_impl<double> {
550 static inline double run(
const double& x)
556 struct rint_impl<float> {
558 static inline float run(
const float& x)
565 template<
typename Scalar>
577 #if EIGEN_HAS_CXX11_MATH && (!EIGEN_COMP_MSVC || EIGEN_COMP_MSVC >= 1920) 579 template<
typename Scalar,
580 bool HasStdImpl = NumTraits<Scalar>::IsComplex || is_integral<Scalar>::value
581 || is_same<Scalar, float>::value || is_same<Scalar, double>::value
582 || is_same<Scalar, long double>::value >
583 struct arg_default_impl;
585 template<
typename Scalar>
586 struct arg_default_impl<Scalar, true> {
587 typedef typename NumTraits<Scalar>::Real RealScalar;
589 static inline RealScalar run(
const Scalar& x)
591 #if defined(EIGEN_HIP_DEVICE_COMPILE) 595 EIGEN_USING_STD(
arg);
597 return static_cast<RealScalar
>(
arg(x));
602 template<
typename Scalar>
603 struct arg_default_impl<Scalar, false> {
604 typedef typename NumTraits<Scalar>::Real RealScalar;
606 static inline RealScalar run(
const Scalar& x)
608 return (x < Scalar(0)) ? RealScalar(EIGEN_PI) : RealScalar(0);
612 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
613 struct arg_default_impl
615 typedef typename NumTraits<Scalar>::Real RealScalar;
617 static inline RealScalar run(
const Scalar& x)
619 return (x < RealScalar(0)) ? RealScalar(EIGEN_PI) : RealScalar(0);
623 template<
typename Scalar>
624 struct arg_default_impl<Scalar,true>
626 typedef typename NumTraits<Scalar>::Real RealScalar;
628 static inline RealScalar run(
const Scalar& x)
630 EIGEN_USING_STD(
arg);
635 template<
typename Scalar>
struct arg_impl : arg_default_impl<Scalar> {};
637 template<
typename Scalar>
640 typedef typename NumTraits<Scalar>::Real type;
648 namespace std_fallback {
652 template<
typename Scalar>
653 EIGEN_DEVICE_FUNC
inline Scalar
expm1(
const Scalar& x) {
654 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
655 typedef typename NumTraits<Scalar>::Real RealScalar;
657 EIGEN_USING_STD(
exp);
659 if (numext::equal_strict(u, Scalar(1))) {
662 Scalar um1 = u - RealScalar(1);
663 if (numext::equal_strict(um1, Scalar(-1))) {
664 return RealScalar(-1);
667 EIGEN_USING_STD(
log);
668 Scalar logu =
log(u);
669 return numext::equal_strict(u, logu) ? u : (u - RealScalar(1)) * x / logu;
673 template<
typename Scalar>
675 EIGEN_DEVICE_FUNC
static inline Scalar run(
const Scalar& x)
677 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
678 #if EIGEN_HAS_CXX11_MATH 681 using std_fallback::expm1;
687 template<
typename Scalar>
698 template<
typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_log(
const std::complex<T>& z);
700 template<
typename Scalar>
702 EIGEN_DEVICE_FUNC
static inline Scalar run(
const Scalar& x)
704 EIGEN_USING_STD(
log);
705 return static_cast<Scalar
>(
log(x));
709 template<
typename Scalar>
710 struct log_impl<
std::complex<Scalar> > {
711 EIGEN_DEVICE_FUNC
static inline std::complex<Scalar> run(
const std::complex<Scalar>& z)
713 return complex_log(z);
721 namespace std_fallback {
724 template<
typename Scalar>
725 EIGEN_DEVICE_FUNC
inline Scalar
log1p(
const Scalar& x) {
726 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
727 typedef typename NumTraits<Scalar>::Real RealScalar;
728 EIGEN_USING_STD(
log);
729 Scalar x1p = RealScalar(1) + x;
730 Scalar log_1p = log_impl<Scalar>::run(x1p);
731 const bool is_small = numext::equal_strict(x1p, Scalar(1));
732 const bool is_inf = numext::equal_strict(x1p, log_1p);
733 return (is_small || is_inf) ? x : x * (log_1p / (x1p - RealScalar(1)));
737 template<
typename Scalar>
739 EIGEN_DEVICE_FUNC
static inline Scalar run(
const Scalar& x)
741 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
742 #if EIGEN_HAS_CXX11_MATH 745 using std_fallback::log1p;
752 template <
typename RealScalar>
753 struct log1p_impl<
std::complex<RealScalar> > {
754 EIGEN_DEVICE_FUNC
static inline std::complex<RealScalar> run(
755 const std::complex<RealScalar>& x) {
756 EIGEN_STATIC_ASSERT_NON_INTEGER(RealScalar)
757 return std_fallback::log1p(x);
761 template<
typename Scalar>
771 template<typename ScalarX,typename ScalarY, bool IsInteger = NumTraits<ScalarX>::IsInteger&&NumTraits<ScalarY>::IsInteger>
775 typedef typename ScalarBinaryOpTraits<ScalarX,ScalarY,internal::scalar_pow_op<ScalarX,ScalarY> >::ReturnType result_type;
776 static EIGEN_DEVICE_FUNC
inline result_type run(
const ScalarX& x,
const ScalarY& y)
778 EIGEN_USING_STD(pow);
783 template<
typename ScalarX,
typename ScalarY>
784 struct pow_impl<ScalarX,ScalarY, true>
786 typedef ScalarX result_type;
787 static EIGEN_DEVICE_FUNC
inline ScalarX run(ScalarX x, ScalarY y)
790 eigen_assert(!NumTraits<ScalarY>::IsSigned || y >= 0);
807 template<
typename Scalar,
810 struct random_default_impl {};
812 template<
typename Scalar>
813 struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
815 template<
typename Scalar>
821 template<
typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(
const Scalar& x,
const Scalar& y);
822 template<
typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random();
824 template<
typename Scalar>
825 struct random_default_impl<Scalar, false, false>
827 static inline Scalar run(
const Scalar& x,
const Scalar& y)
829 return x + (y-x) * Scalar(std::rand()) / Scalar(RAND_MAX);
831 static inline Scalar run()
833 return run(Scalar(NumTraits<Scalar>::IsSigned ? -1 : 0), Scalar(1));
838 meta_floor_log2_terminate,
839 meta_floor_log2_move_up,
840 meta_floor_log2_move_down,
841 meta_floor_log2_bogus
844 template<
unsigned int n,
int lower,
int upper>
struct meta_floor_log2_selector
846 enum { middle = (lower + upper) / 2,
847 value = (upper <= lower + 1) ? int(meta_floor_log2_terminate)
848 : (n < (1 << middle)) ? int(meta_floor_log2_move_down)
849 : (n==0) ? int(meta_floor_log2_bogus)
850 : int(meta_floor_log2_move_up)
854 template<
unsigned int n,
856 int upper =
sizeof(
unsigned int) * CHAR_BIT - 1,
857 int selector = meta_floor_log2_selector<n, lower, upper>::value>
858 struct meta_floor_log2 {};
860 template<
unsigned int n,
int lower,
int upper>
861 struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_down>
863 enum { value = meta_floor_log2<n, lower, meta_floor_log2_selector<n, lower, upper>::middle>::value };
866 template<
unsigned int n,
int lower,
int upper>
867 struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_up>
869 enum { value = meta_floor_log2<n, meta_floor_log2_selector<n, lower, upper>::middle, upper>::value };
872 template<
unsigned int n,
int lower,
int upper>
873 struct meta_floor_log2<n, lower, upper, meta_floor_log2_terminate>
875 enum { value = (n >= ((
unsigned int)(1) << (lower+1))) ? lower+1 : lower };
878 template<
unsigned int n,
int lower,
int upper>
879 struct meta_floor_log2<n, lower, upper, meta_floor_log2_bogus>
884 template<
typename Scalar>
885 struct random_default_impl<Scalar, false, true>
887 static inline Scalar run(
const Scalar& x,
const Scalar& y)
892 typedef typename make_unsigned<Scalar>::type ScalarU;
896 typedef typename conditional<(ScalarU(-1) > unsigned(-1)), ScalarU,
unsigned>::type ScalarX;
900 ScalarX range = ScalarX(y) - ScalarX(x);
903 ScalarX multiplier = 1;
904 const unsigned rand_max = RAND_MAX;
905 if (range <= rand_max) divisor = (rand_max + 1) / (range + 1);
906 else multiplier = 1 + range / (rand_max + 1);
909 offset = (unsigned(std::rand()) * multiplier) / divisor;
910 }
while (offset > range);
911 return Scalar(ScalarX(x) + offset);
914 static inline Scalar run()
916 #ifdef EIGEN_MAKING_DOCS 917 return run(Scalar(NumTraits<Scalar>::IsSigned ? -10 : 0), Scalar(10));
919 enum { rand_bits = meta_floor_log2<(unsigned int)(RAND_MAX)+1>::value,
920 scalar_bits =
sizeof(Scalar) * CHAR_BIT,
921 shift = EIGEN_PLAIN_ENUM_MAX(0,
int(rand_bits) - int(scalar_bits)),
922 offset = NumTraits<Scalar>::IsSigned ? (1 << (EIGEN_PLAIN_ENUM_MIN(rand_bits,scalar_bits)-1)) : 0
924 return Scalar((std::rand() >> shift) - offset);
929 template<
typename Scalar>
930 struct random_default_impl<Scalar, true, false>
932 static inline Scalar run(
const Scalar& x,
const Scalar& y)
934 return Scalar(random(x.real(), y.real()),
935 random(x.imag(), y.imag()));
937 static inline Scalar run()
939 typedef typename NumTraits<Scalar>::Real RealScalar;
940 return Scalar(random<RealScalar>(), random<RealScalar>());
944 template<
typename Scalar>
945 inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(
const Scalar& x,
const Scalar& y)
947 return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y);
950 template<
typename Scalar>
951 inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random()
953 return EIGEN_MATHFUNC_IMPL(random, Scalar)::run();
959 #if (EIGEN_HAS_CXX11_MATH && !(EIGEN_COMP_GNUC_STRICT && __FINITE_MATH_ONLY__)) || (EIGEN_COMP_MSVC>=1800) || (EIGEN_COMP_CLANG) 960 #define EIGEN_USE_STD_FPCLASSIFY 1 962 #define EIGEN_USE_STD_FPCLASSIFY 0 967 typename internal::enable_if<internal::is_integral<T>::value,
bool>::type
968 isnan_impl(
const T&) {
return false; }
972 typename internal::enable_if<internal::is_integral<T>::value,
bool>::type
973 isinf_impl(
const T&) {
return false; }
977 typename internal::enable_if<internal::is_integral<T>::value,
bool>::type
978 isfinite_impl(
const T&) {
return true; }
982 typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),
bool>::type
983 isfinite_impl(
const T& x)
985 #if defined(EIGEN_GPU_COMPILE_PHASE) 987 #elif EIGEN_USE_STD_FPCLASSIFY 989 return isfinite EIGEN_NOT_A_MACRO (x);
991 return x<=NumTraits<T>::highest() && x>=NumTraits<T>::lowest();
997 typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),
bool>::type
998 isinf_impl(
const T& x)
1000 #if defined(EIGEN_GPU_COMPILE_PHASE) 1001 return (::
isinf)(x);
1002 #elif EIGEN_USE_STD_FPCLASSIFY 1004 return isinf EIGEN_NOT_A_MACRO (x);
1006 return x>NumTraits<T>::highest() || x<NumTraits<T>::lowest();
1010 template<
typename T>
1012 typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),
bool>::type
1013 isnan_impl(
const T& x)
1015 #if defined(EIGEN_GPU_COMPILE_PHASE) 1016 return (::
isnan)(x);
1017 #elif EIGEN_USE_STD_FPCLASSIFY 1019 return isnan EIGEN_NOT_A_MACRO (x);
1025 #if (!EIGEN_USE_STD_FPCLASSIFY) 1029 template<
typename T> EIGEN_DEVICE_FUNC
bool isinf_msvc_helper(T x)
1031 return _fpclass(x)==_FPCLASS_NINF || _fpclass(x)==_FPCLASS_PINF;
1035 EIGEN_DEVICE_FUNC
inline bool isnan_impl(
const long double& x) {
return _isnan(x)!=0; }
1036 EIGEN_DEVICE_FUNC
inline bool isnan_impl(
const double& x) {
return _isnan(x)!=0; }
1037 EIGEN_DEVICE_FUNC
inline bool isnan_impl(
const float& x) {
return _isnan(x)!=0; }
1039 EIGEN_DEVICE_FUNC
inline bool isinf_impl(
const long double& x) {
return isinf_msvc_helper(x); }
1040 EIGEN_DEVICE_FUNC
inline bool isinf_impl(
const double& x) {
return isinf_msvc_helper(x); }
1041 EIGEN_DEVICE_FUNC
inline bool isinf_impl(
const float& x) {
return isinf_msvc_helper(x); }
1043 #elif (defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ && EIGEN_COMP_GNUC) 1045 #if EIGEN_GNUC_AT_LEAST(5,0) 1046 #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((optimize("no-finite-math-only"))) 1050 #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((noinline,optimize("no-finite-math-only"))) 1053 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isnan_impl(
const long double& x) {
return __builtin_isnan(x); }
1054 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isnan_impl(
const double& x) {
return __builtin_isnan(x); }
1055 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isnan_impl(
const float& x) {
return __builtin_isnan(x); }
1056 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isinf_impl(
const double& x) {
return __builtin_isinf(x); }
1057 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isinf_impl(
const float& x) {
return __builtin_isinf(x); }
1058 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isinf_impl(
const long double& x) {
return __builtin_isinf(x); }
1060 #undef EIGEN_TMP_NOOPT_ATTRIB 1067 template<
typename T> EIGEN_DEVICE_FUNC
bool isfinite_impl(
const std::complex<T>& x);
1068 template<
typename T> EIGEN_DEVICE_FUNC
bool isnan_impl(
const std::complex<T>& x);
1069 template<
typename T> EIGEN_DEVICE_FUNC
bool isinf_impl(
const std::complex<T>& x);
1071 template<
typename T> T generic_fast_tanh_float(
const T& a_x);
1080 #if (!defined(EIGEN_GPUCC) || defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC)) 1081 template<
typename T>
1083 EIGEN_ALWAYS_INLINE T mini(
const T& x,
const T& y)
1085 EIGEN_USING_STD(min)
1086 return min EIGEN_NOT_A_MACRO (x,y);
1089 template<
typename T>
1091 EIGEN_ALWAYS_INLINE T maxi(
const T& x,
const T& y)
1093 EIGEN_USING_STD(max)
1094 return max EIGEN_NOT_A_MACRO (x,y);
1097 template<
typename T>
1099 EIGEN_ALWAYS_INLINE T mini(
const T& x,
const T& y)
1101 return y < x ? y : x;
1105 EIGEN_ALWAYS_INLINE
float mini(
const float& x,
const float& y)
1111 EIGEN_ALWAYS_INLINE
double mini(
const double& x,
const double& y)
1117 EIGEN_ALWAYS_INLINE
long double mini(
const long double& x,
const long double& y)
1119 #if defined(EIGEN_HIPCC) 1121 return (x < y) ? x : y;
1127 template<
typename T>
1129 EIGEN_ALWAYS_INLINE T maxi(
const T& x,
const T& y)
1131 return x < y ? y : x;
1135 EIGEN_ALWAYS_INLINE
float maxi(
const float& x,
const float& y)
1141 EIGEN_ALWAYS_INLINE
double maxi(
const double& x,
const double& y)
1147 EIGEN_ALWAYS_INLINE
long double maxi(
const long double& x,
const long double& y)
1149 #if defined(EIGEN_HIPCC) 1151 return (x > y) ? x : y;
1158 #if defined(SYCL_DEVICE_ONLY) 1161 #define SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_BINARY(NAME, FUNC) \ 1162 SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_char) \ 1163 SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_short) \ 1164 SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_int) \ 1165 SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_long) 1166 #define SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_UNARY(NAME, FUNC) \ 1167 SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_char) \ 1168 SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_short) \ 1169 SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_int) \ 1170 SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_long) 1171 #define SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_BINARY(NAME, FUNC) \ 1172 SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_uchar) \ 1173 SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_ushort) \ 1174 SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_uint) \ 1175 SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_ulong) 1176 #define SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY(NAME, FUNC) \ 1177 SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_uchar) \ 1178 SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_ushort) \ 1179 SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_uint) \ 1180 SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_ulong) 1181 #define SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(NAME, FUNC) \ 1182 SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_BINARY(NAME, FUNC) \ 1183 SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_BINARY(NAME, FUNC) 1184 #define SYCL_SPECIALIZE_INTEGER_TYPES_UNARY(NAME, FUNC) \ 1185 SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_UNARY(NAME, FUNC) \ 1186 SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY(NAME, FUNC) 1187 #define SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(NAME, FUNC) \ 1188 SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, cl::sycl::cl_float) \ 1189 SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC,cl::sycl::cl_double) 1190 #define SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(NAME, FUNC) \ 1191 SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, cl::sycl::cl_float) \ 1192 SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC,cl::sycl::cl_double) 1193 #define SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(NAME, FUNC, RET_TYPE) \ 1194 SYCL_SPECIALIZE_GEN_UNARY_FUNC(NAME, FUNC, RET_TYPE, cl::sycl::cl_float) \ 1195 SYCL_SPECIALIZE_GEN_UNARY_FUNC(NAME, FUNC, RET_TYPE, cl::sycl::cl_double) 1197 #define SYCL_SPECIALIZE_GEN_UNARY_FUNC(NAME, FUNC, RET_TYPE, ARG_TYPE) \ 1200 EIGEN_ALWAYS_INLINE RET_TYPE NAME(const ARG_TYPE& x) { \ 1201 return cl::sycl::FUNC(x); \ 1204 #define SYCL_SPECIALIZE_UNARY_FUNC(NAME, FUNC, TYPE) \ 1205 SYCL_SPECIALIZE_GEN_UNARY_FUNC(NAME, FUNC, TYPE, TYPE) 1207 #define SYCL_SPECIALIZE_GEN1_BINARY_FUNC(NAME, FUNC, RET_TYPE, ARG_TYPE1, ARG_TYPE2) \ 1210 EIGEN_ALWAYS_INLINE RET_TYPE NAME(const ARG_TYPE1& x, const ARG_TYPE2& y) { \ 1211 return cl::sycl::FUNC(x, y); \ 1214 #define SYCL_SPECIALIZE_GEN2_BINARY_FUNC(NAME, FUNC, RET_TYPE, ARG_TYPE) \ 1215 SYCL_SPECIALIZE_GEN1_BINARY_FUNC(NAME, FUNC, RET_TYPE, ARG_TYPE, ARG_TYPE) 1217 #define SYCL_SPECIALIZE_BINARY_FUNC(NAME, FUNC, TYPE) \ 1218 SYCL_SPECIALIZE_GEN2_BINARY_FUNC(NAME, FUNC, TYPE, TYPE) 1220 SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(mini, min)
1221 SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(mini, fmin)
1222 SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(maxi, max)
1223 SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(maxi, fmax)
1228 template<
typename Scalar>
1230 inline EIGEN_MATHFUNC_RETVAL(
real, Scalar)
real(
const Scalar& x)
1232 return EIGEN_MATHFUNC_IMPL(
real, Scalar)::run(x);
1235 template<
typename Scalar>
1237 inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type real_ref(
const Scalar& x)
1239 return internal::real_ref_impl<Scalar>::run(x);
1242 template<
typename Scalar>
1244 inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x)
1246 return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x);
1249 template<
typename Scalar>
1251 inline EIGEN_MATHFUNC_RETVAL(
imag, Scalar)
imag(
const Scalar& x)
1253 return EIGEN_MATHFUNC_IMPL(
imag, Scalar)::run(x);
1256 template<
typename Scalar>
1258 inline EIGEN_MATHFUNC_RETVAL(
arg, Scalar)
arg(
const Scalar& x)
1260 return EIGEN_MATHFUNC_IMPL(
arg, Scalar)::run(x);
1263 template<
typename Scalar>
1265 inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type imag_ref(
const Scalar& x)
1267 return internal::imag_ref_impl<Scalar>::run(x);
1270 template<
typename Scalar>
1272 inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x)
1274 return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x);
1277 template<
typename Scalar>
1279 inline EIGEN_MATHFUNC_RETVAL(
conj, Scalar)
conj(
const Scalar& x)
1281 return EIGEN_MATHFUNC_IMPL(
conj, Scalar)::run(x);
1284 template<
typename Scalar>
1286 inline EIGEN_MATHFUNC_RETVAL(
abs2, Scalar)
abs2(
const Scalar& x)
1288 return EIGEN_MATHFUNC_IMPL(
abs2, Scalar)::run(x);
1292 inline bool abs2(
bool x) {
return x; }
1294 template<
typename T>
1296 EIGEN_ALWAYS_INLINE T absdiff(
const T& x,
const T& y)
1298 return x > y ? x - y : y - x;
1302 EIGEN_ALWAYS_INLINE
float absdiff(
const float& x,
const float& y)
1304 return fabsf(x - y);
1308 EIGEN_ALWAYS_INLINE
double absdiff(
const double& x,
const double& y)
1313 #if !defined(EIGEN_GPUCC) 1317 EIGEN_ALWAYS_INLINE
long double absdiff(
const long double& x,
const long double& y) {
1318 return fabsl(x - y);
1322 template<
typename Scalar>
1324 inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(
const Scalar& x)
1326 return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x);
1329 template<
typename Scalar>
1331 inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(
const Scalar& x,
const Scalar& y)
1333 return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y);
1336 #if defined(SYCL_DEVICE_ONLY) 1337 SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(hypot, hypot)
1340 template<
typename Scalar>
1342 inline EIGEN_MATHFUNC_RETVAL(
log1p, Scalar)
log1p(
const Scalar& x)
1344 return EIGEN_MATHFUNC_IMPL(
log1p, Scalar)::run(x);
1347 #if defined(SYCL_DEVICE_ONLY) 1348 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
log1p,
log1p)
1351 #if defined(EIGEN_GPUCC) 1352 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1353 float log1p(
const float &x) { return ::log1pf(x); }
1355 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1356 double log1p(
const double &x) { return ::log1p(x); }
1359 template<
typename ScalarX,
typename ScalarY>
1361 inline typename internal::pow_impl<ScalarX,ScalarY>::result_type pow(
const ScalarX& x,
const ScalarY& y)
1363 return internal::pow_impl<ScalarX,ScalarY>::run(x, y);
1366 #if defined(SYCL_DEVICE_ONLY) 1367 SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(pow, pow)
1370 template<
typename T> EIGEN_DEVICE_FUNC bool (
isnan) (
const T &x) {
return internal::isnan_impl(x); }
1371 template<
typename T> EIGEN_DEVICE_FUNC bool (
isinf) (
const T &x) {
return internal::isinf_impl(x); }
1372 template<
typename T> EIGEN_DEVICE_FUNC bool (
isfinite)(
const T &x) {
return internal::isfinite_impl(x); }
1374 #if defined(SYCL_DEVICE_ONLY) 1375 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(
isnan,
isnan,
bool)
1376 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(
isinf,
isinf,
bool)
1377 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(
isfinite,
isfinite,
bool)
1380 template<
typename Scalar>
1382 inline EIGEN_MATHFUNC_RETVAL(
rint, Scalar)
rint(
const Scalar& x)
1384 return EIGEN_MATHFUNC_IMPL(
rint, Scalar)::run(x);
1387 template<
typename Scalar>
1389 inline EIGEN_MATHFUNC_RETVAL(
round, Scalar)
round(
const Scalar& x)
1391 return EIGEN_MATHFUNC_IMPL(
round, Scalar)::run(x);
1394 #if defined(SYCL_DEVICE_ONLY) 1395 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
round,
round)
1398 template<
typename T>
1400 T (
floor)(
const T& x)
1402 EIGEN_USING_STD(
floor)
1406 #if defined(SYCL_DEVICE_ONLY) 1407 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
floor,
floor)
1410 #if defined(EIGEN_GPUCC) 1411 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1412 float floor(
const float &x) { return ::floorf(x); }
1414 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1415 double floor(
const double &x) { return ::floor(x); }
1418 template<
typename T>
1420 T (
ceil)(
const T& x)
1422 EIGEN_USING_STD(
ceil);
1426 #if defined(SYCL_DEVICE_ONLY) 1427 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
ceil,
ceil)
1430 #if defined(EIGEN_GPUCC) 1431 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1432 float ceil(
const float &x) { return ::ceilf(x); }
1434 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1435 double ceil(
const double &x) { return ::ceil(x); }
1441 inline int log2(
int x)
1445 static const int table[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
1451 return table[(v * 0x07C4ACDDU) >> 27];
1463 template<
typename Scalar>
1465 EIGEN_ALWAYS_INLINE EIGEN_MATHFUNC_RETVAL(
sqrt, Scalar)
sqrt(
const Scalar& x)
1467 return EIGEN_MATHFUNC_IMPL(
sqrt, Scalar)::run(x);
1472 EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC
1473 bool sqrt<bool>(
const bool &x) {
return x; }
1475 #if defined(SYCL_DEVICE_ONLY) 1476 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
sqrt,
sqrt)
1480 template<
typename T>
1481 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1484 return internal::rsqrt_impl<T>::run(x);
1487 template<
typename T>
1488 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1490 return internal::log_impl<T>::run(x);
1493 #if defined(SYCL_DEVICE_ONLY) 1494 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
log,
log)
1498 #if defined(EIGEN_GPUCC) 1499 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1500 float log(
const float &x) { return ::logf(x); }
1502 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1503 double log(
const double &x) { return ::log(x); }
1506 template<
typename T>
1507 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1508 typename internal::enable_if<NumTraits<T>::IsSigned || NumTraits<T>::IsComplex,
typename NumTraits<T>::Real>::type
1510 EIGEN_USING_STD(
abs);
1514 template<
typename T>
1515 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1516 typename internal::enable_if<!(NumTraits<T>::IsSigned || NumTraits<T>::IsComplex),
typename NumTraits<T>::Real>::type
1521 #if defined(SYCL_DEVICE_ONLY) 1522 SYCL_SPECIALIZE_INTEGER_TYPES_UNARY(
abs,
abs)
1523 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
abs, fabs)
1526 #if defined(EIGEN_GPUCC) 1527 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1528 float abs(
const float &x) { return ::fabsf(x); }
1530 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1531 double abs(
const double &x) { return ::fabs(x); }
1533 template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1534 float abs(
const std::complex<float>& x) {
1535 return ::hypotf(x.real(), x.imag());
1538 template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1539 double abs(
const std::complex<double>& x) {
1540 return ::hypot(x.real(), x.imag());
1544 template<
typename T>
1545 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1547 EIGEN_USING_STD(
exp);
1551 #if defined(SYCL_DEVICE_ONLY) 1552 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
exp,
exp)
1555 #if defined(EIGEN_GPUCC) 1556 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1557 float exp(
const float &x) { return ::expf(x); }
1559 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1560 double exp(
const double &x) { return ::exp(x); }
1562 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1563 std::complex<float>
exp(
const std::complex<float>& x) {
1564 float com = ::expf(x.real());
1565 float res_real = com * ::cosf(x.imag());
1566 float res_imag = com * ::sinf(x.imag());
1567 return std::complex<float>(res_real, res_imag);
1570 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1571 std::complex<double>
exp(
const std::complex<double>& x) {
1572 double com =
::exp(x.real());
1573 double res_real = com *
::cos(x.imag());
1574 double res_imag = com *
::sin(x.imag());
1575 return std::complex<double>(res_real, res_imag);
1579 template<
typename Scalar>
1581 inline EIGEN_MATHFUNC_RETVAL(
expm1, Scalar)
expm1(
const Scalar& x)
1583 return EIGEN_MATHFUNC_IMPL(
expm1, Scalar)::run(x);
1586 #if defined(SYCL_DEVICE_ONLY) 1587 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
expm1,
expm1)
1590 #if defined(EIGEN_GPUCC) 1591 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1592 float expm1(
const float &x) { return ::expm1f(x); }
1594 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1595 double expm1(
const double &x) { return ::expm1(x); }
1598 template<
typename T>
1599 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1601 EIGEN_USING_STD(
cos);
1605 #if defined(SYCL_DEVICE_ONLY) 1606 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
cos,
cos)
1609 #if defined(EIGEN_GPUCC) 1610 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1611 float cos(
const float &x) { return ::cosf(x); }
1613 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1614 double cos(
const double &x) { return ::cos(x); }
1617 template<
typename T>
1618 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1620 EIGEN_USING_STD(
sin);
1624 #if defined(SYCL_DEVICE_ONLY) 1625 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
sin,
sin)
1628 #if defined(EIGEN_GPUCC) 1629 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1630 float sin(
const float &x) { return ::sinf(x); }
1632 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1633 double sin(
const double &x) { return ::sin(x); }
1636 template<
typename T>
1637 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1639 EIGEN_USING_STD(
tan);
1643 #if defined(SYCL_DEVICE_ONLY) 1644 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
tan,
tan)
1647 #if defined(EIGEN_GPUCC) 1648 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1649 float tan(
const float &x) { return ::tanf(x); }
1651 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1652 double tan(
const double &x) { return ::tan(x); }
1655 template<
typename T>
1656 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1657 T
acos(
const T &x) {
1658 EIGEN_USING_STD(
acos);
1662 #if EIGEN_HAS_CXX11_MATH 1663 template<
typename T>
1664 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1665 T
acosh(
const T &x) {
1666 EIGEN_USING_STD(
acosh);
1667 return static_cast<T
>(
acosh(x));
1671 #if defined(SYCL_DEVICE_ONLY) 1672 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
acos,
acos)
1673 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
acosh,
acosh)
1676 #if defined(EIGEN_GPUCC) 1677 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1678 float acos(
const float &x) { return ::acosf(x); }
1680 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1681 double acos(
const double &x) { return ::acos(x); }
1684 template<
typename T>
1685 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1686 T
asin(
const T &x) {
1687 EIGEN_USING_STD(
asin);
1691 #if EIGEN_HAS_CXX11_MATH 1692 template<
typename T>
1693 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1694 T
asinh(
const T &x) {
1695 EIGEN_USING_STD(
asinh);
1696 return static_cast<T
>(
asinh(x));
1700 #if defined(SYCL_DEVICE_ONLY) 1701 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
asin,
asin)
1702 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
asinh,
asinh)
1705 #if defined(EIGEN_GPUCC) 1706 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1707 float asin(
const float &x) { return ::asinf(x); }
1709 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1710 double asin(
const double &x) { return ::asin(x); }
1713 template<
typename T>
1714 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1715 T
atan(
const T &x) {
1716 EIGEN_USING_STD(
atan);
1717 return static_cast<T
>(
atan(x));
1720 #if EIGEN_HAS_CXX11_MATH 1721 template<
typename T>
1722 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1723 T
atanh(
const T &x) {
1724 EIGEN_USING_STD(
atanh);
1725 return static_cast<T
>(
atanh(x));
1729 #if defined(SYCL_DEVICE_ONLY) 1730 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
atan,
atan)
1731 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
atanh,
atanh)
1734 #if defined(EIGEN_GPUCC) 1735 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1736 float atan(
const float &x) { return ::atanf(x); }
1738 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1739 double atan(
const double &x) { return ::atan(x); }
1743 template<
typename T>
1744 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1745 T
cosh(
const T &x) {
1746 EIGEN_USING_STD(
cosh);
1747 return static_cast<T
>(
cosh(x));
1750 #if defined(SYCL_DEVICE_ONLY) 1751 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
cosh,
cosh)
1754 #if defined(EIGEN_GPUCC) 1755 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1756 float cosh(
const float &x) { return ::coshf(x); }
1758 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1759 double cosh(
const double &x) { return ::cosh(x); }
1762 template<
typename T>
1763 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1764 T
sinh(
const T &x) {
1765 EIGEN_USING_STD(
sinh);
1766 return static_cast<T
>(
sinh(x));
1769 #if defined(SYCL_DEVICE_ONLY) 1770 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
sinh,
sinh)
1773 #if defined(EIGEN_GPUCC) 1774 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1775 float sinh(
const float &x) { return ::sinhf(x); }
1777 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1778 double sinh(
const double &x) { return ::sinh(x); }
1781 template<
typename T>
1782 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1783 T
tanh(
const T &x) {
1784 EIGEN_USING_STD(
tanh);
1788 #if (!defined(EIGEN_GPUCC)) && EIGEN_FAST_MATH && !defined(SYCL_DEVICE_ONLY) 1789 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1790 float tanh(
float x) {
return internal::generic_fast_tanh_float(x); }
1793 #if defined(SYCL_DEVICE_ONLY) 1794 SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(
tanh,
tanh)
1797 #if defined(EIGEN_GPUCC) 1798 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1799 float tanh(
const float &x) { return ::tanhf(x); }
1801 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1802 double tanh(
const double &x) { return ::tanh(x); }
1805 template <
typename T>
1806 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1807 T fmod(
const T& a,
const T& b) {
1808 EIGEN_USING_STD(fmod);
1812 #if defined(SYCL_DEVICE_ONLY) 1813 SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(fmod, fmod)
1816 #if defined(EIGEN_GPUCC) 1818 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1819 float fmod(
const float& a,
const float& b) {
1820 return ::fmodf(a, b);
1824 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1825 double fmod(
const double& a,
const double& b) {
1826 return ::fmod(a, b);
1830 #if defined(SYCL_DEVICE_ONLY) 1831 #undef SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_BINARY 1832 #undef SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_UNARY 1833 #undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_BINARY 1834 #undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY 1835 #undef SYCL_SPECIALIZE_INTEGER_TYPES_BINARY 1836 #undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY 1837 #undef SYCL_SPECIALIZE_FLOATING_TYPES_BINARY 1838 #undef SYCL_SPECIALIZE_FLOATING_TYPES_UNARY 1839 #undef SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE 1840 #undef SYCL_SPECIALIZE_GEN_UNARY_FUNC 1841 #undef SYCL_SPECIALIZE_UNARY_FUNC 1842 #undef SYCL_SPECIALIZE_GEN1_BINARY_FUNC 1843 #undef SYCL_SPECIALIZE_GEN2_BINARY_FUNC 1844 #undef SYCL_SPECIALIZE_BINARY_FUNC 1851 template<
typename T>
1852 EIGEN_DEVICE_FUNC
bool isfinite_impl(
const std::complex<T>& x)
1854 return (numext::isfinite)(numext::real(x)) && (numext::isfinite)(numext::imag(x));
1857 template<
typename T>
1858 EIGEN_DEVICE_FUNC
bool isnan_impl(
const std::complex<T>& x)
1860 return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x));
1863 template<
typename T>
1864 EIGEN_DEVICE_FUNC
bool isinf_impl(
const std::complex<T>& x)
1866 return ((numext::isinf)(numext::real(x)) || (numext::isinf)(numext::imag(x))) && (!(numext::isnan)(x));
1873 template<
typename Scalar,
1876 struct scalar_fuzzy_default_impl {};
1878 template<
typename Scalar>
1879 struct scalar_fuzzy_default_impl<Scalar, false, false>
1881 typedef typename NumTraits<Scalar>::Real RealScalar;
1882 template<
typename OtherScalar> EIGEN_DEVICE_FUNC
1883 static inline bool isMuchSmallerThan(
const Scalar& x,
const OtherScalar& y,
const RealScalar& prec)
1885 return numext::abs(x) <= numext::abs(y) * prec;
1888 static inline bool isApprox(
const Scalar& x,
const Scalar& y,
const RealScalar& prec)
1890 return numext::abs(x - y) <= numext::mini(numext::abs(x), numext::abs(y)) * prec;
1893 static inline bool isApproxOrLessThan(
const Scalar& x,
const Scalar& y,
const RealScalar& prec)
1895 return x <= y || isApprox(x, y, prec);
1899 template<
typename Scalar>
1900 struct scalar_fuzzy_default_impl<Scalar, false, true>
1902 typedef typename NumTraits<Scalar>::Real RealScalar;
1903 template<
typename OtherScalar> EIGEN_DEVICE_FUNC
1904 static inline bool isMuchSmallerThan(
const Scalar& x,
const Scalar&,
const RealScalar&)
1906 return x == Scalar(0);
1909 static inline bool isApprox(
const Scalar& x,
const Scalar& y,
const RealScalar&)
1914 static inline bool isApproxOrLessThan(
const Scalar& x,
const Scalar& y,
const RealScalar&)
1920 template<
typename Scalar>
1921 struct scalar_fuzzy_default_impl<Scalar, true, false>
1923 typedef typename NumTraits<Scalar>::Real RealScalar;
1924 template<
typename OtherScalar> EIGEN_DEVICE_FUNC
1925 static inline bool isMuchSmallerThan(
const Scalar& x,
const OtherScalar& y,
const RealScalar& prec)
1927 return numext::abs2(x) <= numext::abs2(y) * prec * prec;
1930 static inline bool isApprox(
const Scalar& x,
const Scalar& y,
const RealScalar& prec)
1932 return numext::abs2(x - y) <= numext::mini(numext::abs2(x), numext::abs2(y)) * prec * prec;
1936 template<
typename Scalar>
1937 struct scalar_fuzzy_impl : scalar_fuzzy_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
1939 template<
typename Scalar,
typename OtherScalar> EIGEN_DEVICE_FUNC
1940 inline bool isMuchSmallerThan(
const Scalar& x,
const OtherScalar& y,
1941 const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
1943 return scalar_fuzzy_impl<Scalar>::template isMuchSmallerThan<OtherScalar>(x, y, precision);
1946 template<
typename Scalar> EIGEN_DEVICE_FUNC
1947 inline bool isApprox(
const Scalar& x,
const Scalar& y,
1948 const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
1950 return scalar_fuzzy_impl<Scalar>::isApprox(x, y, precision);
1953 template<
typename Scalar> EIGEN_DEVICE_FUNC
1954 inline bool isApproxOrLessThan(
const Scalar& x,
const Scalar& y,
1955 const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
1957 return scalar_fuzzy_impl<Scalar>::isApproxOrLessThan(x, y, precision);
1964 template<>
struct random_impl<bool>
1966 static inline bool run()
1968 return random<int>(0,1)==0 ?
false :
true;
1971 static inline bool run(
const bool& a,
const bool& b)
1973 return random<int>(a, b)==0 ?
false :
true;
1977 template<>
struct scalar_fuzzy_impl<bool>
1979 typedef bool RealScalar;
1981 template<
typename OtherScalar> EIGEN_DEVICE_FUNC
1982 static inline bool isMuchSmallerThan(
const bool& x,
const bool&,
const bool&)
1988 static inline bool isApprox(
bool x,
bool y,
bool)
1994 static inline bool isApproxOrLessThan(
const bool& x,
const bool& y,
const bool&)
2007 template <
typename RealScalar>
2008 struct expm1_impl<
std::complex<RealScalar> > {
2009 EIGEN_DEVICE_FUNC
static inline std::complex<RealScalar> run(
2010 const std::complex<RealScalar>& x) {
2011 EIGEN_STATIC_ASSERT_NON_INTEGER(RealScalar)
2012 RealScalar xr = x.real();
2013 RealScalar xi = x.imag();
2023 RealScalar erm1 = numext::expm1<RealScalar>(xr);
2024 RealScalar er = erm1 + RealScalar(1.);
2025 RealScalar sin2 = numext::sin(xi / RealScalar(2.));
2027 RealScalar s = numext::sin(xi);
2028 RealScalar real_part = erm1 - RealScalar(2.) * er * sin2;
2029 return std::complex<RealScalar>(real_part, er * s);
2033 template<
typename T>
2036 static EIGEN_ALWAYS_INLINE T run(
const T& x) {
2037 return T(1)/numext::sqrt(x);
2041 #if defined(EIGEN_GPU_COMPILE_PHASE) 2042 template<
typename T>
2043 struct conj_impl<
std::complex<T>, true>
2046 static inline std::complex<T> run(
const std::complex<T>& x)
2048 return std::complex<T>(numext::real(x), -numext::imag(x));
2057 #endif // EIGEN_MATHFUNCTIONS_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_sinh_op< typename Derived::Scalar >, const Derived > sinh(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)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_conjugate_op< typename Derived::Scalar >, const Derived > conj(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_arg_op< typename Derived::Scalar >, const Derived > arg(const Eigen::ArrayBase< Derived > &x)
Namespace containing all symbols from the Eigen library.
Definition: Core:141
Definition: BFloat16.h:88
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_asin_op< typename Derived::Scalar >, const Derived > asin(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs2_op< typename Derived::Scalar >, const Derived > abs2(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_acos_op< typename Derived::Scalar >, const Derived > acos(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 Eigen::CwiseUnaryOp< Eigen::internal::scalar_imag_op< typename Derived::Scalar >, const Derived > imag(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_round_op< typename Derived::Scalar >, const Derived > round(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_rint_op< typename Derived::Scalar >, const Derived > rint(const Eigen::ArrayBase< Derived > &x)
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_real_op< typename Derived::Scalar >, const Derived > real(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_rsqrt_op< typename Derived::Scalar >, const Derived > rsqrt(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_abs_op< typename Derived::Scalar >, const Derived > abs(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_cosh_op< typename Derived::Scalar >, const Derived > cosh(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_expm1_op< typename Derived::Scalar >, const Derived > expm1(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_atanh_op< typename Derived::Scalar >, const Derived > atanh(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log2_op< typename Derived::Scalar >, const Derived > log2(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_atan_op< typename Derived::Scalar >, const Derived > atan(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_acosh_op< typename Derived::Scalar >, const Derived > acosh(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_asinh_op< typename Derived::Scalar >, const Derived > asinh(const Eigen::ArrayBase< Derived > &x)