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
25long abs(
long x) {
return (labs(x)); }
26double abs(
double x) {
return (fabs(x)); }
27float abs(
float x) {
return (fabsf(x)); }
28long double abs(
long double x) {
return (fabsl(x)); }
53template<
typename T,
typename dummy =
void>
54struct global_math_functions_filtering_base
59template<
typename T>
struct always_void {
typedef void type; };
62struct 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
77template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
78struct real_default_impl
80 typedef typename NumTraits<Scalar>::Real RealScalar;
82 static inline RealScalar run(
const Scalar& x)
88template<
typename Scalar>
89struct real_default_impl<Scalar,true>
91 typedef typename NumTraits<Scalar>::Real RealScalar;
93 static inline RealScalar run(
const Scalar& x)
100template<
typename Scalar>
struct real_impl : real_default_impl<Scalar> {};
102#if defined(EIGEN_GPU_COMPILE_PHASE)
104struct real_impl<std::complex<T> >
106 typedef T RealScalar;
108 static inline T run(
const std::complex<T>& x)
115template<
typename Scalar>
118 typedef typename NumTraits<Scalar>::Real type;
125template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
126struct imag_default_impl
128 typedef typename NumTraits<Scalar>::Real RealScalar;
130 static inline RealScalar run(
const Scalar&)
132 return RealScalar(0);
136template<
typename Scalar>
137struct imag_default_impl<Scalar,true>
139 typedef typename NumTraits<Scalar>::Real RealScalar;
141 static inline RealScalar run(
const Scalar& x)
148template<
typename Scalar>
struct imag_impl : imag_default_impl<Scalar> {};
150#if defined(EIGEN_GPU_COMPILE_PHASE)
152struct imag_impl<std::complex<T> >
154 typedef T RealScalar;
156 static inline T run(
const std::complex<T>& x)
163template<
typename Scalar>
166 typedef typename NumTraits<Scalar>::Real type;
173template<
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];
189template<
typename Scalar>
190struct real_ref_retval
192 typedef typename NumTraits<Scalar>::Real & type;
199template<
typename Scalar,
bool IsComplex>
200struct 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];
215template<
typename Scalar>
216struct 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&)
230template<
typename Scalar>
231struct imag_ref_impl : imag_ref_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
233template<
typename Scalar>
234struct imag_ref_retval
236 typedef typename NumTraits<Scalar>::Real & type;
243template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
244struct conj_default_impl
247 static inline Scalar run(
const Scalar& x)
253template<
typename Scalar>
254struct conj_default_impl<Scalar,true>
257 static inline Scalar run(
const Scalar& x)
264template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
265struct conj_impl : conj_default_impl<Scalar, IsComplex> {};
267template<
typename Scalar>
277template<
typename Scalar,
bool IsComplex>
278struct abs2_impl_default
280 typedef typename NumTraits<Scalar>::Real RealScalar;
282 static inline RealScalar run(
const Scalar& x)
288template<
typename Scalar>
289struct 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();
299template<
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);
310template<
typename Scalar>
313 typedef typename NumTraits<Scalar>::Real type;
320template<
typename Scalar>
324 static EIGEN_ALWAYS_INLINE Scalar run(
const Scalar& x)
326 EIGEN_USING_STD(sqrt);
332template<
typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_sqrt(
const std::complex<T>& a_x);
337struct 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);
346template<
typename Scalar>
357template<
typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_rsqrt(
const std::complex<T>& a_x);
360struct 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);
369template<
typename Scalar>
379template<
typename Scalar,
bool IsComplex>
380struct norm1_default_impl;
382template<
typename Scalar>
383struct 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());
394template<
typename Scalar>
395struct norm1_default_impl<Scalar, false>
398 static inline Scalar run(
const Scalar& x)
400 EIGEN_USING_STD(abs);
405template<
typename Scalar>
406struct norm1_impl : norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
408template<
typename Scalar>
411 typedef typename NumTraits<Scalar>::Real type;
418template<
typename Scalar>
struct hypot_impl;
420template<
typename Scalar>
423 typedef typename NumTraits<Scalar>::Real type;
430template<
typename OldType,
typename NewType,
typename EnableIf =
void>
434 static inline NewType run(
const OldType& x)
436 return static_cast<NewType
>(x);
442template<
typename OldType,
typename NewType>
443struct cast_impl<OldType, NewType,
444 typename internal::enable_if<
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));
458template<
typename OldType,
typename NewType>
460inline NewType cast(
const OldType& x)
462 return cast_impl<OldType, NewType>::run(x);
469template<
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
487struct round_impl<float> {
489 static inline float run(
const float& x)
495template<
typename Scalar>
496struct 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)));
516struct round_impl<float> : round_using_floor_ceil_impl<float> {};
519struct round_impl<double> : round_using_floor_ceil_impl<double> {};
523template<
typename Scalar>
533template<
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
548struct rint_impl<double> {
550 static inline double run(
const double& x)
556struct rint_impl<float> {
558 static inline float run(
const float& x)
565template<
typename Scalar>
577#if EIGEN_HAS_CXX11_MATH && (!EIGEN_COMP_MSVC || EIGEN_COMP_MSVC >= 1920)
579template<
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 >
583struct arg_default_impl;
585template<
typename Scalar>
586struct 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));
602template<
typename Scalar>
603struct 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);
612template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
613struct 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);
623template<
typename Scalar>
624struct 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);
635template<
typename Scalar>
struct arg_impl : arg_default_impl<Scalar> {};
637template<
typename Scalar>
640 typedef typename NumTraits<Scalar>::Real type;
648namespace 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;
673template<
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;
687template<
typename Scalar>
698template<
typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_log(
const std::complex<T>& z);
700template<
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));
709template<
typename Scalar>
710struct 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);
721namespace 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)));
737template<
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;
752template <
typename RealScalar>
753struct 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);
761template<
typename Scalar>
771template<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);
783template<
typename ScalarX,
typename ScalarY>
784struct 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);
807template<
typename Scalar,
810struct random_default_impl {};
812template<
typename Scalar>
813struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
815template<
typename Scalar>
821template<
typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(
const Scalar& x,
const Scalar& y);
822template<
typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random();
824template<
typename Scalar>
825struct 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
844template<
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)
854template<
unsigned int n,
856 int upper =
sizeof(
unsigned int) * CHAR_BIT - 1,
857 int selector = meta_floor_log2_selector<n, lower, upper>::value>
858struct meta_floor_log2 {};
860template<
unsigned int n,
int lower,
int upper>
861struct 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 };
866template<
unsigned int n,
int lower,
int upper>
867struct 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 };
872template<
unsigned int n,
int lower,
int upper>
873struct meta_floor_log2<n, lower, upper, meta_floor_log2_terminate>
875 enum { value = (n >= ((
unsigned int)(1) << (lower+1))) ? lower+1 : lower };
878template<
unsigned int n,
int lower,
int upper>
879struct meta_floor_log2<n, lower, upper, meta_floor_log2_bogus>
884template<
typename Scalar>
885struct 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);
929template<
typename Scalar>
930struct 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>());
944template<
typename Scalar>
945inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(
const Scalar& x,
const Scalar& y)
947 return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y);
950template<
typename Scalar>
951inline 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
967typename internal::enable_if<internal::is_integral<T>::value,
bool>::type
968isnan_impl(
const T&) {
return false; }
972typename internal::enable_if<internal::is_integral<T>::value,
bool>::type
973isinf_impl(
const T&) {
return false; }
977typename internal::enable_if<internal::is_integral<T>::value,
bool>::type
978isfinite_impl(
const T&) {
return true; }
982typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),
bool>::type
983isfinite_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();
997typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),
bool>::type
998isinf_impl(
const T& x)
1000 #if defined(EIGEN_GPU_COMPILE_PHASE)
1002 #elif EIGEN_USE_STD_FPCLASSIFY
1004 return isinf EIGEN_NOT_A_MACRO (x);
1006 return x>NumTraits<T>::highest() || x<NumTraits<T>::lowest();
1012typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),
bool>::type
1013isnan_impl(
const T& x)
1015 #if defined(EIGEN_GPU_COMPILE_PHASE)
1017 #elif EIGEN_USE_STD_FPCLASSIFY
1019 return isnan EIGEN_NOT_A_MACRO (x);
1025#if (!EIGEN_USE_STD_FPCLASSIFY)
1029template<
typename T> EIGEN_DEVICE_FUNC
bool isinf_msvc_helper(T x)
1031 return _fpclass(x)==_FPCLASS_NINF || _fpclass(x)==_FPCLASS_PINF;
1035EIGEN_DEVICE_FUNC
inline bool isnan_impl(
const long double& x) {
return _isnan(x)!=0; }
1036EIGEN_DEVICE_FUNC
inline bool isnan_impl(
const double& x) {
return _isnan(x)!=0; }
1037EIGEN_DEVICE_FUNC
inline bool isnan_impl(
const float& x) {
return _isnan(x)!=0; }
1039EIGEN_DEVICE_FUNC
inline bool isinf_impl(
const long double& x) {
return isinf_msvc_helper(x); }
1040EIGEN_DEVICE_FUNC
inline bool isinf_impl(
const double& x) {
return isinf_msvc_helper(x); }
1041EIGEN_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")))
1053template<> EIGEN_TMP_NOOPT_ATTRIB
bool isnan_impl(
const long double& x) {
return __builtin_isnan(x); }
1054template<> EIGEN_TMP_NOOPT_ATTRIB
bool isnan_impl(
const double& x) {
return __builtin_isnan(x); }
1055template<> EIGEN_TMP_NOOPT_ATTRIB
bool isnan_impl(
const float& x) {
return __builtin_isnan(x); }
1056template<> EIGEN_TMP_NOOPT_ATTRIB
bool isinf_impl(
const double& x) {
return __builtin_isinf(x); }
1057template<> EIGEN_TMP_NOOPT_ATTRIB
bool isinf_impl(
const float& x) {
return __builtin_isinf(x); }
1058template<> EIGEN_TMP_NOOPT_ATTRIB
bool isinf_impl(
const long double& x) {
return __builtin_isinf(x); }
1060#undef EIGEN_TMP_NOOPT_ATTRIB
1067template<
typename T> EIGEN_DEVICE_FUNC
bool isfinite_impl(
const std::complex<T>& x);
1068template<
typename T> EIGEN_DEVICE_FUNC
bool isnan_impl(
const std::complex<T>& x);
1069template<
typename T> EIGEN_DEVICE_FUNC
bool isinf_impl(
const std::complex<T>& x);
1071template<
typename T> T generic_fast_tanh_float(
const T& a_x);
1080#if (!defined(EIGEN_GPUCC) || defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC))
1083EIGEN_ALWAYS_INLINE T mini(
const T& x,
const T& y)
1085 EIGEN_USING_STD(min)
1086 return min EIGEN_NOT_A_MACRO (x,y);
1091EIGEN_ALWAYS_INLINE T maxi(
const T& x,
const T& y)
1093 EIGEN_USING_STD(max)
1094 return max EIGEN_NOT_A_MACRO (x,y);
1099EIGEN_ALWAYS_INLINE T mini(
const T& x,
const T& y)
1101 return y < x ? y : x;
1105EIGEN_ALWAYS_INLINE
float mini(
const float& x,
const float& y)
1111EIGEN_ALWAYS_INLINE
double mini(
const double& x,
const double& y)
1117EIGEN_ALWAYS_INLINE
long double mini(
const long double& x,
const long double& y)
1119#if defined(EIGEN_HIPCC)
1121 return (x < y) ? x : y;
1129EIGEN_ALWAYS_INLINE T maxi(
const T& x,
const T& y)
1131 return x < y ? y : x;
1135EIGEN_ALWAYS_INLINE
float maxi(
const float& x,
const float& y)
1141EIGEN_ALWAYS_INLINE
double maxi(
const double& x,
const double& y)
1147EIGEN_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)
1220SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(mini, min)
1221SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(mini, fmin)
1222SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(maxi, max)
1223SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(maxi, fmax)
1228template<
typename Scalar>
1230inline EIGEN_MATHFUNC_RETVAL(real, Scalar)
real(
const Scalar& x)
1232 return EIGEN_MATHFUNC_IMPL(real, Scalar)::run(x);
1235template<
typename Scalar>
1237inline 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);
1242template<
typename Scalar>
1244inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x)
1246 return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x);
1249template<
typename Scalar>
1251inline EIGEN_MATHFUNC_RETVAL(imag, Scalar)
imag(
const Scalar& x)
1253 return EIGEN_MATHFUNC_IMPL(imag, Scalar)::run(x);
1256template<
typename Scalar>
1258inline EIGEN_MATHFUNC_RETVAL(arg, Scalar)
arg(
const Scalar& x)
1260 return EIGEN_MATHFUNC_IMPL(arg, Scalar)::run(x);
1263template<
typename Scalar>
1265inline 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);
1270template<
typename Scalar>
1272inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x)
1274 return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x);
1277template<
typename Scalar>
1279inline EIGEN_MATHFUNC_RETVAL(conj, Scalar)
conj(
const Scalar& x)
1281 return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x);
1284template<
typename Scalar>
1286inline EIGEN_MATHFUNC_RETVAL(abs2, Scalar)
abs2(
const Scalar& x)
1288 return EIGEN_MATHFUNC_IMPL(abs2, Scalar)::run(x);
1292inline bool abs2(
bool x) {
return x; }
1296EIGEN_ALWAYS_INLINE T absdiff(
const T& x,
const T& y)
1298 return x > y ? x - y : y - x;
1302EIGEN_ALWAYS_INLINE
float absdiff(
const float& x,
const float& y)
1304 return fabsf(x - y);
1308EIGEN_ALWAYS_INLINE
double absdiff(
const double& x,
const double& y)
1313#if !defined(EIGEN_GPUCC)
1317EIGEN_ALWAYS_INLINE
long double absdiff(
const long double& x,
const long double& y) {
1318 return fabsl(x - y);
1322template<
typename Scalar>
1324inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(
const Scalar& x)
1326 return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x);
1329template<
typename Scalar>
1331inline 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)
1340template<
typename Scalar>
1342inline EIGEN_MATHFUNC_RETVAL(log1p, Scalar) log1p(
const Scalar& x)
1344 return EIGEN_MATHFUNC_IMPL(log1p, Scalar)::run(x);
1347#if defined(SYCL_DEVICE_ONLY)
1348SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(log1p, log1p)
1351#if defined(EIGEN_GPUCC)
1352template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1353float log1p(
const float &x) { return ::log1pf(x); }
1355template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1356double log1p(
const double &x) { return ::log1p(x); }
1359template<
typename ScalarX,
typename ScalarY>
1361inline 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)
1367SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(pow, pow)
1370template<
typename T> EIGEN_DEVICE_FUNC bool (isnan) (
const T &x) {
return internal::isnan_impl(x); }
1371template<
typename T> EIGEN_DEVICE_FUNC bool (isinf) (
const T &x) {
return internal::isinf_impl(x); }
1372template<
typename T> EIGEN_DEVICE_FUNC bool (isfinite)(
const T &x) {
return internal::isfinite_impl(x); }
1374#if defined(SYCL_DEVICE_ONLY)
1375SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(isnan, isnan,
bool)
1376SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(isinf, isinf,
bool)
1377SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(isfinite, isfinite,
bool)
1380template<
typename Scalar>
1382inline EIGEN_MATHFUNC_RETVAL(rint, Scalar) rint(
const Scalar& x)
1384 return EIGEN_MATHFUNC_IMPL(rint, Scalar)::run(x);
1387template<
typename Scalar>
1389inline EIGEN_MATHFUNC_RETVAL(round, Scalar) round(
const Scalar& x)
1391 return EIGEN_MATHFUNC_IMPL(round, Scalar)::run(x);
1394#if defined(SYCL_DEVICE_ONLY)
1395SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(round, round)
1400T (floor)(
const T& x)
1402 EIGEN_USING_STD(floor)
1406#if defined(SYCL_DEVICE_ONLY)
1407SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(floor, floor)
1410#if defined(EIGEN_GPUCC)
1411template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1412float floor(
const float &x) { return ::floorf(x); }
1414template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1415double floor(
const double &x) { return ::floor(x); }
1422 EIGEN_USING_STD(ceil);
1426#if defined(SYCL_DEVICE_ONLY)
1427SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(ceil, ceil)
1430#if defined(EIGEN_GPUCC)
1431template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1432float ceil(
const float &x) { return ::ceilf(x); }
1434template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1435double ceil(
const double &x) { return ::ceil(x); }
1441inline 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];
1463template<
typename Scalar>
1465EIGEN_ALWAYS_INLINE EIGEN_MATHFUNC_RETVAL(sqrt, Scalar) sqrt(
const Scalar& x)
1467 return EIGEN_MATHFUNC_IMPL(sqrt, Scalar)::run(x);
1472EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC
1473bool sqrt<bool>(
const bool &x) {
return x; }
1475#if defined(SYCL_DEVICE_ONLY)
1476SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(sqrt, sqrt)
1481EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1484 return internal::rsqrt_impl<T>::run(x);
1488EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1490 return internal::log_impl<T>::run(x);
1493#if defined(SYCL_DEVICE_ONLY)
1494SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(log, log)
1498#if defined(EIGEN_GPUCC)
1499template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1500float log(
const float &x) { return ::logf(x); }
1502template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1503double log(
const double &x) { return ::log(x); }
1507EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1508typename internal::enable_if<NumTraits<T>::IsSigned || NumTraits<T>::IsComplex,
typename NumTraits<T>::Real>::type
1510 EIGEN_USING_STD(abs);
1515EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1516typename internal::enable_if<!(NumTraits<T>::IsSigned || NumTraits<T>::IsComplex),
typename NumTraits<T>::Real>::type
1521#if defined(SYCL_DEVICE_ONLY)
1522SYCL_SPECIALIZE_INTEGER_TYPES_UNARY(abs, abs)
1523SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(abs, fabs)
1526#if defined(EIGEN_GPUCC)
1527template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1528float abs(
const float &x) { return ::fabsf(x); }
1530template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1531double abs(
const double &x) { return ::fabs(x); }
1533template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1534float abs(
const std::complex<float>& x) {
1535 return ::hypotf(x.real(), x.imag());
1538template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1539double abs(
const std::complex<double>& x) {
1540 return ::hypot(x.real(), x.imag());
1545EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1547 EIGEN_USING_STD(exp);
1551#if defined(SYCL_DEVICE_ONLY)
1552SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(exp, exp)
1555#if defined(EIGEN_GPUCC)
1556template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1557float exp(
const float &x) { return ::expf(x); }
1559template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1560double exp(
const double &x) { return ::exp(x); }
1562template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1563std::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);
1570template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1571std::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);
1579template<
typename Scalar>
1581inline EIGEN_MATHFUNC_RETVAL(expm1, Scalar) expm1(
const Scalar& x)
1583 return EIGEN_MATHFUNC_IMPL(expm1, Scalar)::run(x);
1586#if defined(SYCL_DEVICE_ONLY)
1587SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(expm1, expm1)
1590#if defined(EIGEN_GPUCC)
1591template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1592float expm1(
const float &x) { return ::expm1f(x); }
1594template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1595double expm1(
const double &x) { return ::expm1(x); }
1599EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1601 EIGEN_USING_STD(cos);
1605#if defined(SYCL_DEVICE_ONLY)
1606SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(cos,cos)
1609#if defined(EIGEN_GPUCC)
1610template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1611float cos(
const float &x) { return ::cosf(x); }
1613template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1614double cos(
const double &x) { return ::cos(x); }
1618EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1620 EIGEN_USING_STD(sin);
1624#if defined(SYCL_DEVICE_ONLY)
1625SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(sin, sin)
1628#if defined(EIGEN_GPUCC)
1629template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1630float sin(
const float &x) { return ::sinf(x); }
1632template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1633double sin(
const double &x) { return ::sin(x); }
1637EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1639 EIGEN_USING_STD(tan);
1643#if defined(SYCL_DEVICE_ONLY)
1644SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(tan, tan)
1647#if defined(EIGEN_GPUCC)
1648template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1649float tan(
const float &x) { return ::tanf(x); }
1651template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1652double tan(
const double &x) { return ::tan(x); }
1656EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1658 EIGEN_USING_STD(acos);
1662#if EIGEN_HAS_CXX11_MATH
1664EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1665T acosh(
const T &x) {
1666 EIGEN_USING_STD(acosh);
1667 return static_cast<T
>(acosh(x));
1671#if defined(SYCL_DEVICE_ONLY)
1672SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(acos, acos)
1673SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(acosh, acosh)
1676#if defined(EIGEN_GPUCC)
1677template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1678float acos(
const float &x) { return ::acosf(x); }
1680template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1681double acos(
const double &x) { return ::acos(x); }
1685EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1687 EIGEN_USING_STD(asin);
1691#if EIGEN_HAS_CXX11_MATH
1693EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1694T asinh(
const T &x) {
1695 EIGEN_USING_STD(asinh);
1696 return static_cast<T
>(asinh(x));
1700#if defined(SYCL_DEVICE_ONLY)
1701SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(asin, asin)
1702SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(asinh, asinh)
1705#if defined(EIGEN_GPUCC)
1706template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1707float asin(
const float &x) { return ::asinf(x); }
1709template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1710double asin(
const double &x) { return ::asin(x); }
1714EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1716 EIGEN_USING_STD(atan);
1717 return static_cast<T
>(atan(x));
1720#if EIGEN_HAS_CXX11_MATH
1722EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1723T atanh(
const T &x) {
1724 EIGEN_USING_STD(atanh);
1725 return static_cast<T
>(atanh(x));
1729#if defined(SYCL_DEVICE_ONLY)
1730SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(atan, atan)
1731SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(atanh, atanh)
1734#if defined(EIGEN_GPUCC)
1735template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1736float atan(
const float &x) { return ::atanf(x); }
1738template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1739double atan(
const double &x) { return ::atan(x); }
1744EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1746 EIGEN_USING_STD(cosh);
1747 return static_cast<T
>(cosh(x));
1750#if defined(SYCL_DEVICE_ONLY)
1751SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(cosh, cosh)
1754#if defined(EIGEN_GPUCC)
1755template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1756float cosh(
const float &x) { return ::coshf(x); }
1758template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1759double cosh(
const double &x) { return ::cosh(x); }
1763EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1765 EIGEN_USING_STD(sinh);
1766 return static_cast<T
>(sinh(x));
1769#if defined(SYCL_DEVICE_ONLY)
1770SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(sinh, sinh)
1773#if defined(EIGEN_GPUCC)
1774template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1775float sinh(
const float &x) { return ::sinhf(x); }
1777template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1778double sinh(
const double &x) { return ::sinh(x); }
1782EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1784 EIGEN_USING_STD(tanh);
1788#if (!defined(EIGEN_GPUCC)) && EIGEN_FAST_MATH && !defined(SYCL_DEVICE_ONLY)
1789EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1790float tanh(
float x) {
return internal::generic_fast_tanh_float(x); }
1793#if defined(SYCL_DEVICE_ONLY)
1794SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(tanh, tanh)
1797#if defined(EIGEN_GPUCC)
1798template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1799float tanh(
const float &x) { return ::tanhf(x); }
1801template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1802double tanh(
const double &x) { return ::tanh(x); }
1805template <
typename T>
1806EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1807T fmod(
const T& a,
const T& b) {
1808 EIGEN_USING_STD(fmod);
1812#if defined(SYCL_DEVICE_ONLY)
1813SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(fmod, fmod)
1816#if defined(EIGEN_GPUCC)
1818EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1819float fmod(
const float& a,
const float& b) {
1820 return ::fmodf(a, b);
1824EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1825double 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
1852EIGEN_DEVICE_FUNC
bool isfinite_impl(
const std::complex<T>& x)
1854 return (numext::isfinite)(numext::real(x)) && (numext::isfinite)(numext::imag(x));
1858EIGEN_DEVICE_FUNC
bool isnan_impl(
const std::complex<T>& x)
1860 return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x));
1864EIGEN_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));
1873template<
typename Scalar,
1876struct scalar_fuzzy_default_impl {};
1878template<
typename Scalar>
1879struct 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);
1899template<
typename Scalar>
1900struct 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&)
1920template<
typename Scalar>
1921struct 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;
1936template<
typename Scalar>
1937struct scalar_fuzzy_impl : scalar_fuzzy_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
1939template<
typename Scalar,
typename OtherScalar> EIGEN_DEVICE_FUNC
1940inline 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);
1946template<
typename Scalar> EIGEN_DEVICE_FUNC
1947inline 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);
1953template<
typename Scalar> EIGEN_DEVICE_FUNC
1954inline 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);
1964template<>
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;
1977template<>
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&)
2007template <
typename RealScalar>
2008struct 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);
2036 static EIGEN_ALWAYS_INLINE T run(
const T& x) {
2037 return T(1)/numext::sqrt(x);
2041#if defined(EIGEN_GPU_COMPILE_PHASE)
2043struct 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));
Namespace containing all symbols from the Eigen library.
Definition: Core:141
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_conjugate_op< typename Derived::Scalar >, const Derived > conj(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_abs2_op< typename Derived::Scalar >, const Derived > abs2(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_imag_op< typename Derived::Scalar >, const Derived > imag(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_arg_op< typename Derived::Scalar >, const Derived > arg(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_isnan_op< typename Derived::Scalar >, const Derived > isnan(const Eigen::ArrayBase< Derived > &x)