10 #ifndef EIGEN_MATHFUNCTIONS_H
11 #define EIGEN_MATHFUNCTIONS_H
15 #define EIGEN_PI 3.141592653589793238462643383279502884197169399375105820974944592307816406L
22 #if EIGEN_OS_WINCE && EIGEN_COMP_MSVC && EIGEN_COMP_MSVC<=1500
23 long abs(
long x) {
return (labs(x)); }
24 double abs(
double x) {
return (fabs(x)); }
25 float abs(
float x) {
return (fabsf(x)); }
26 long double abs(
long double x) {
return (fabsl(x)); }
51 template<
typename T,
typename dummy =
void>
52 struct global_math_functions_filtering_base
57 template<
typename T>
struct always_void {
typedef void type; };
60 struct global_math_functions_filtering_base
62 typename always_void<typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl>::type
65 typedef typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl type;
68 #define EIGEN_MATHFUNC_IMPL(func, scalar) Eigen::internal::func##_impl<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>
69 #define EIGEN_MATHFUNC_RETVAL(func, scalar) typename Eigen::internal::func##_retval<typename Eigen::internal::global_math_functions_filtering_base<scalar>::type>::type
75 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
76 struct real_default_impl
78 typedef typename NumTraits<Scalar>::Real RealScalar;
80 static inline RealScalar run(
const Scalar& x)
86 template<
typename Scalar>
87 struct real_default_impl<Scalar,true>
89 typedef typename NumTraits<Scalar>::Real RealScalar;
91 static inline RealScalar run(
const Scalar& x)
98 template<
typename Scalar>
struct real_impl : real_default_impl<Scalar> {};
102 struct real_impl<std::complex<T> >
104 typedef T RealScalar;
106 static inline T run(
const std::complex<T>& x)
113 template<
typename Scalar>
116 typedef typename NumTraits<Scalar>::Real type;
123 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
124 struct imag_default_impl
126 typedef typename NumTraits<Scalar>::Real RealScalar;
128 static inline RealScalar run(
const Scalar&)
130 return RealScalar(0);
134 template<
typename Scalar>
135 struct imag_default_impl<Scalar,true>
137 typedef typename NumTraits<Scalar>::Real RealScalar;
139 static inline RealScalar run(
const Scalar& x)
146 template<
typename Scalar>
struct imag_impl : imag_default_impl<Scalar> {};
150 struct imag_impl<std::complex<T> >
152 typedef T RealScalar;
154 static inline T run(
const std::complex<T>& x)
161 template<
typename Scalar>
164 typedef typename NumTraits<Scalar>::Real type;
171 template<
typename Scalar>
174 typedef typename NumTraits<Scalar>::Real RealScalar;
176 static inline RealScalar& run(Scalar& x)
178 return reinterpret_cast<RealScalar*
>(&x)[0];
181 static inline const RealScalar& run(
const Scalar& x)
183 return reinterpret_cast<const RealScalar*
>(&x)[0];
187 template<
typename Scalar>
188 struct real_ref_retval
190 typedef typename NumTraits<Scalar>::Real & type;
197 template<
typename Scalar,
bool IsComplex>
198 struct imag_ref_default_impl
200 typedef typename NumTraits<Scalar>::Real RealScalar;
202 static inline RealScalar& run(Scalar& x)
204 return reinterpret_cast<RealScalar*
>(&x)[1];
207 static inline const RealScalar& run(
const Scalar& x)
209 return reinterpret_cast<RealScalar*
>(&x)[1];
213 template<
typename Scalar>
214 struct imag_ref_default_impl<Scalar, false>
217 static inline Scalar run(Scalar&)
222 static inline const Scalar run(
const Scalar&)
228 template<
typename Scalar>
229 struct imag_ref_impl : imag_ref_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
231 template<
typename Scalar>
232 struct imag_ref_retval
234 typedef typename NumTraits<Scalar>::Real & type;
241 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
245 static inline Scalar run(
const Scalar& x)
251 template<
typename Scalar>
252 struct conj_impl<Scalar,true>
255 static inline Scalar run(
const Scalar& x)
262 template<
typename Scalar>
272 template<
typename Scalar,
bool IsComplex>
273 struct abs2_impl_default
275 typedef typename NumTraits<Scalar>::Real RealScalar;
277 static inline RealScalar run(
const Scalar& x)
283 template<
typename Scalar>
284 struct abs2_impl_default<Scalar, true>
286 typedef typename NumTraits<Scalar>::Real RealScalar;
288 static inline RealScalar run(
const Scalar& x)
290 return x.real()*x.real() + x.imag()*x.imag();
294 template<
typename Scalar>
297 typedef typename NumTraits<Scalar>::Real RealScalar;
299 static inline RealScalar run(
const Scalar& x)
301 return abs2_impl_default<Scalar,NumTraits<Scalar>::IsComplex>::run(x);
305 template<
typename Scalar>
308 typedef typename NumTraits<Scalar>::Real type;
315 template<
typename Scalar,
bool IsComplex>
316 struct norm1_default_impl;
318 template<
typename Scalar>
319 struct norm1_default_impl<Scalar,true>
321 typedef typename NumTraits<Scalar>::Real RealScalar;
323 static inline RealScalar run(
const Scalar& x)
325 EIGEN_USING_STD_MATH(
abs);
326 return abs(x.real()) +
abs(x.imag());
330 template<
typename Scalar>
331 struct norm1_default_impl<Scalar, false>
334 static inline Scalar run(
const Scalar& x)
336 EIGEN_USING_STD_MATH(
abs);
341 template<
typename Scalar>
342 struct norm1_impl : norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
344 template<
typename Scalar>
347 typedef typename NumTraits<Scalar>::Real type;
354 template<
typename Scalar>
struct hypot_impl;
356 template<
typename Scalar>
359 typedef typename NumTraits<Scalar>::Real type;
366 template<
typename OldType,
typename NewType>
370 static inline NewType run(
const OldType& x)
372 return static_cast<NewType
>(x);
378 template<
typename OldType,
typename NewType>
380 inline NewType cast(
const OldType& x)
382 return cast_impl<OldType, NewType>::run(x);
389 #if EIGEN_HAS_CXX11_MATH
390 template<
typename Scalar>
392 static inline Scalar run(
const Scalar& x)
394 EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
400 template<
typename Scalar>
403 static inline Scalar run(
const Scalar& x)
405 EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
406 EIGEN_USING_STD_MATH(
floor);
407 EIGEN_USING_STD_MATH(
ceil);
408 return (x > Scalar(0)) ?
floor(x + Scalar(0.5)) :
ceil(x - Scalar(0.5));
413 template<
typename Scalar>
423 #if EIGEN_HAS_CXX11_MATH
424 template<
typename Scalar>
426 static inline Scalar run(
const Scalar& x)
428 EIGEN_USING_STD_MATH(
arg);
433 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
434 struct arg_default_impl
436 typedef typename NumTraits<Scalar>::Real RealScalar;
438 static inline RealScalar run(
const Scalar& x)
440 return (x < Scalar(0)) ? Scalar(EIGEN_PI) : Scalar(0); }
443 template<
typename Scalar>
444 struct arg_default_impl<Scalar,true>
446 typedef typename NumTraits<Scalar>::Real RealScalar;
448 static inline RealScalar run(
const Scalar& x)
450 EIGEN_USING_STD_MATH(
arg);
455 template<
typename Scalar>
struct arg_impl : arg_default_impl<Scalar> {};
458 template<
typename Scalar>
461 typedef typename NumTraits<Scalar>::Real type;
468 namespace std_fallback {
471 template<
typename Scalar>
472 EIGEN_DEVICE_FUNC
inline Scalar
log1p(
const Scalar& x) {
473 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
474 typedef typename NumTraits<Scalar>::Real RealScalar;
475 EIGEN_USING_STD_MATH(
log);
476 Scalar x1p = RealScalar(1) + x;
477 return numext::equal_strict(x1p, Scalar(1)) ? x : x * (
log(x1p) / (x1p - RealScalar(1)) );
481 template<
typename Scalar>
483 static inline Scalar run(
const Scalar& x)
485 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
486 #if EIGEN_HAS_CXX11_MATH
489 using std_fallback::log1p;
496 template <
typename RealScalar>
497 struct log1p_impl<std::complex<RealScalar> > {
498 EIGEN_DEVICE_FUNC
static inline std::complex<RealScalar> run(
499 const std::complex<RealScalar>& x) {
500 EIGEN_STATIC_ASSERT_NON_INTEGER(RealScalar)
501 return std_fallback::log1p(x);
505 template<
typename Scalar>
515 template<typename ScalarX,typename ScalarY, bool IsInteger = NumTraits<ScalarX>::IsInteger&&NumTraits<ScalarY>::IsInteger>
519 typedef typename ScalarBinaryOpTraits<ScalarX,ScalarY,internal::scalar_pow_op<ScalarX,ScalarY> >::ReturnType result_type;
520 static EIGEN_DEVICE_FUNC
inline result_type run(
const ScalarX& x,
const ScalarY& y)
522 EIGEN_USING_STD_MATH(pow);
527 template<
typename ScalarX,
typename ScalarY>
528 struct pow_impl<ScalarX,ScalarY, true>
530 typedef ScalarX result_type;
531 static EIGEN_DEVICE_FUNC
inline ScalarX run(ScalarX x, ScalarY y)
534 eigen_assert(!NumTraits<ScalarY>::IsSigned || y >= 0);
551 template<
typename Scalar,
554 struct random_default_impl {};
556 template<
typename Scalar>
557 struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
559 template<
typename Scalar>
565 template<
typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(
const Scalar& x,
const Scalar& y);
566 template<
typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random();
568 template<
typename Scalar>
569 struct random_default_impl<Scalar, false, false>
571 static inline Scalar run(
const Scalar& x,
const Scalar& y)
573 return x + (y-x) * Scalar(std::rand()) / Scalar(RAND_MAX);
575 static inline Scalar run()
577 return run(Scalar(NumTraits<Scalar>::IsSigned ? -1 : 0), Scalar(1));
582 meta_floor_log2_terminate,
583 meta_floor_log2_move_up,
584 meta_floor_log2_move_down,
585 meta_floor_log2_bogus
588 template<
unsigned int n,
int lower,
int upper>
struct meta_floor_log2_selector
590 enum { middle = (lower + upper) / 2,
591 value = (upper <= lower + 1) ? int(meta_floor_log2_terminate)
592 : (n < (1 << middle)) ? int(meta_floor_log2_move_down)
593 : (n==0) ? int(meta_floor_log2_bogus)
594 : int(meta_floor_log2_move_up)
598 template<
unsigned int n,
600 int upper =
sizeof(
unsigned int) * CHAR_BIT - 1,
601 int selector = meta_floor_log2_selector<n, lower, upper>::value>
602 struct meta_floor_log2 {};
604 template<
unsigned int n,
int lower,
int upper>
605 struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_down>
607 enum { value = meta_floor_log2<n, lower, meta_floor_log2_selector<n, lower, upper>::middle>::value };
610 template<
unsigned int n,
int lower,
int upper>
611 struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_up>
613 enum { value = meta_floor_log2<n, meta_floor_log2_selector<n, lower, upper>::middle, upper>::value };
616 template<
unsigned int n,
int lower,
int upper>
617 struct meta_floor_log2<n, lower, upper, meta_floor_log2_terminate>
619 enum { value = (n >= ((
unsigned int)(1) << (lower+1))) ? lower+1 : lower };
622 template<
unsigned int n,
int lower,
int upper>
623 struct meta_floor_log2<n, lower, upper, meta_floor_log2_bogus>
628 template<
typename Scalar>
629 struct random_default_impl<Scalar, false, true>
631 static inline Scalar run(
const Scalar& x,
const Scalar& y)
636 typedef typename make_unsigned<Scalar>::type ScalarU;
640 typedef typename conditional<(ScalarU(-1) > unsigned(-1)), ScalarU,
unsigned>::type ScalarX;
644 ScalarX range = ScalarX(y) - ScalarX(x);
647 ScalarX multiplier = 1;
648 const unsigned rand_max = RAND_MAX;
649 if (range <= rand_max) divisor = (rand_max + 1) / (range + 1);
650 else multiplier = 1 + range / (rand_max + 1);
653 offset = (unsigned(std::rand()) * multiplier) / divisor;
654 }
while (offset > range);
655 return Scalar(ScalarX(x) + offset);
658 static inline Scalar run()
660 #ifdef EIGEN_MAKING_DOCS
661 return run(Scalar(NumTraits<Scalar>::IsSigned ? -10 : 0), Scalar(10));
663 enum { rand_bits = meta_floor_log2<(
unsigned int)(RAND_MAX)+1>::value,
664 scalar_bits =
sizeof(Scalar) * CHAR_BIT,
665 shift = EIGEN_PLAIN_ENUM_MAX(0,
int(rand_bits) - int(scalar_bits)),
666 offset = NumTraits<Scalar>::IsSigned ? (1 << (EIGEN_PLAIN_ENUM_MIN(rand_bits,scalar_bits)-1)) : 0
668 return Scalar((std::rand() >> shift) - offset);
673 template<
typename Scalar>
674 struct random_default_impl<Scalar, true, false>
676 static inline Scalar run(
const Scalar& x,
const Scalar& y)
678 return Scalar(random(x.real(), y.real()),
679 random(x.imag(), y.imag()));
681 static inline Scalar run()
683 typedef typename NumTraits<Scalar>::Real RealScalar;
684 return Scalar(random<RealScalar>(), random<RealScalar>());
688 template<
typename Scalar>
689 inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(
const Scalar& x,
const Scalar& y)
691 return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y);
694 template<
typename Scalar>
695 inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random()
697 return EIGEN_MATHFUNC_IMPL(random, Scalar)::run();
703 #if (EIGEN_HAS_CXX11_MATH && !(EIGEN_COMP_GNUC_STRICT && __FINITE_MATH_ONLY__)) || (EIGEN_COMP_MSVC>=1800) || (EIGEN_COMP_CLANG)
704 #define EIGEN_USE_STD_FPCLASSIFY 1
706 #define EIGEN_USE_STD_FPCLASSIFY 0
711 typename internal::enable_if<internal::is_integral<T>::value,
bool>::type
712 isnan_impl(
const T&) {
return false; }
716 typename internal::enable_if<internal::is_integral<T>::value,
bool>::type
717 isinf_impl(
const T&) {
return false; }
721 typename internal::enable_if<internal::is_integral<T>::value,
bool>::type
722 isfinite_impl(
const T&) {
return true; }
726 typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),
bool>::type
727 isfinite_impl(
const T& x)
731 #elif EIGEN_USE_STD_FPCLASSIFY
733 return isfinite EIGEN_NOT_A_MACRO (x);
735 return x<=NumTraits<T>::highest() && x>=NumTraits<T>::lowest();
741 typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),
bool>::type
742 isinf_impl(
const T& x)
746 #elif EIGEN_USE_STD_FPCLASSIFY
748 return isinf EIGEN_NOT_A_MACRO (x);
750 return x>NumTraits<T>::highest() || x<NumTraits<T>::lowest();
756 typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),
bool>::type
757 isnan_impl(
const T& x)
761 #elif EIGEN_USE_STD_FPCLASSIFY
763 return isnan EIGEN_NOT_A_MACRO (x);
769 #if (!EIGEN_USE_STD_FPCLASSIFY)
773 template<
typename T> EIGEN_DEVICE_FUNC
bool isinf_msvc_helper(T x)
775 return _fpclass(x)==_FPCLASS_NINF || _fpclass(x)==_FPCLASS_PINF;
779 EIGEN_DEVICE_FUNC
inline bool isnan_impl(
const long double& x) {
return _isnan(x)!=0; }
780 EIGEN_DEVICE_FUNC
inline bool isnan_impl(
const double& x) {
return _isnan(x)!=0; }
781 EIGEN_DEVICE_FUNC
inline bool isnan_impl(
const float& x) {
return _isnan(x)!=0; }
783 EIGEN_DEVICE_FUNC
inline bool isinf_impl(
const long double& x) {
return isinf_msvc_helper(x); }
784 EIGEN_DEVICE_FUNC
inline bool isinf_impl(
const double& x) {
return isinf_msvc_helper(x); }
785 EIGEN_DEVICE_FUNC
inline bool isinf_impl(
const float& x) {
return isinf_msvc_helper(x); }
787 #elif (defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ && EIGEN_COMP_GNUC)
789 #if EIGEN_GNUC_AT_LEAST(5,0)
790 #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((optimize("no-finite-math-only")))
794 #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((noinline,optimize("no-finite-math-only")))
797 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isnan_impl(
const long double& x) {
return __builtin_isnan(x); }
798 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isnan_impl(
const double& x) {
return __builtin_isnan(x); }
799 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isnan_impl(
const float& x) {
return __builtin_isnan(x); }
800 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isinf_impl(
const double& x) {
return __builtin_isinf(x); }
801 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isinf_impl(
const float& x) {
return __builtin_isinf(x); }
802 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isinf_impl(
const long double& x) {
return __builtin_isinf(x); }
804 #undef EIGEN_TMP_NOOPT_ATTRIB
811 template<
typename T> EIGEN_DEVICE_FUNC
bool isfinite_impl(
const std::complex<T>& x);
812 template<
typename T> EIGEN_DEVICE_FUNC
bool isnan_impl(
const std::complex<T>& x);
813 template<
typename T> EIGEN_DEVICE_FUNC
bool isinf_impl(
const std::complex<T>& x);
815 template<
typename T> T generic_fast_tanh_float(
const T& a_x);
825 #ifndef __CUDA_ARCH__
828 EIGEN_ALWAYS_INLINE T mini(
const T& x,
const T& y)
830 EIGEN_USING_STD_MATH(min);
831 return min EIGEN_NOT_A_MACRO (x,y);
836 EIGEN_ALWAYS_INLINE T maxi(
const T& x,
const T& y)
838 EIGEN_USING_STD_MATH(max);
839 return max EIGEN_NOT_A_MACRO (x,y);
844 EIGEN_ALWAYS_INLINE T mini(
const T& x,
const T& y)
846 return y < x ? y : x;
850 EIGEN_ALWAYS_INLINE
float mini(
const float& x,
const float& y)
856 EIGEN_ALWAYS_INLINE T maxi(
const T& x,
const T& y)
858 return x < y ? y : x;
862 EIGEN_ALWAYS_INLINE
float maxi(
const float& x,
const float& y)
869 template<
typename Scalar>
871 inline EIGEN_MATHFUNC_RETVAL(
real, Scalar)
real(
const Scalar& x)
873 return EIGEN_MATHFUNC_IMPL(
real, Scalar)::run(x);
876 template<
typename Scalar>
878 inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type real_ref(
const Scalar& x)
880 return internal::real_ref_impl<Scalar>::run(x);
883 template<
typename Scalar>
885 inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x)
887 return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x);
890 template<
typename Scalar>
892 inline EIGEN_MATHFUNC_RETVAL(
imag, Scalar)
imag(
const Scalar& x)
894 return EIGEN_MATHFUNC_IMPL(
imag, Scalar)::run(x);
897 template<
typename Scalar>
899 inline EIGEN_MATHFUNC_RETVAL(
arg, Scalar)
arg(
const Scalar& x)
901 return EIGEN_MATHFUNC_IMPL(
arg, Scalar)::run(x);
904 template<
typename Scalar>
906 inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type imag_ref(
const Scalar& x)
908 return internal::imag_ref_impl<Scalar>::run(x);
911 template<
typename Scalar>
913 inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x)
915 return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x);
918 template<
typename Scalar>
920 inline EIGEN_MATHFUNC_RETVAL(
conj, Scalar)
conj(
const Scalar& x)
922 return EIGEN_MATHFUNC_IMPL(
conj, Scalar)::run(x);
925 template<
typename Scalar>
927 inline EIGEN_MATHFUNC_RETVAL(
abs2, Scalar)
abs2(
const Scalar& x)
929 return EIGEN_MATHFUNC_IMPL(
abs2, Scalar)::run(x);
933 inline bool abs2(
bool x) {
return x; }
935 template<
typename Scalar>
937 inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(
const Scalar& x)
939 return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x);
942 template<
typename Scalar>
944 inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(
const Scalar& x,
const Scalar& y)
946 return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y);
949 template<
typename Scalar>
951 inline EIGEN_MATHFUNC_RETVAL(
log1p, Scalar)
log1p(
const Scalar& x)
953 return EIGEN_MATHFUNC_IMPL(
log1p, Scalar)::run(x);
957 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
958 float log1p(
const float &x) { return ::log1pf(x); }
960 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
961 double log1p(
const double &x) { return ::log1p(x); }
964 template<
typename ScalarX,
typename ScalarY>
966 inline typename internal::pow_impl<ScalarX,ScalarY>::result_type pow(
const ScalarX& x,
const ScalarY& y)
968 return internal::pow_impl<ScalarX,ScalarY>::run(x, y);
971 template<
typename T> EIGEN_DEVICE_FUNC bool (
isnan) (
const T &x) {
return internal::isnan_impl(x); }
972 template<
typename T> EIGEN_DEVICE_FUNC bool (
isinf) (
const T &x) {
return internal::isinf_impl(x); }
973 template<
typename T> EIGEN_DEVICE_FUNC bool (
isfinite)(
const T &x) {
return internal::isfinite_impl(x); }
975 template<
typename Scalar>
977 inline EIGEN_MATHFUNC_RETVAL(
round, Scalar)
round(
const Scalar& x)
979 return EIGEN_MATHFUNC_IMPL(
round, Scalar)::run(x);
984 T (
floor)(
const T& x)
986 EIGEN_USING_STD_MATH(
floor);
991 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
992 float floor(
const float &x) { return ::floorf(x); }
994 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
995 double floor(
const double &x) { return ::floor(x); }
1000 T (
ceil)(
const T& x)
1002 EIGEN_USING_STD_MATH(
ceil);
1007 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1008 float ceil(
const float &x) { return ::ceilf(x); }
1010 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1011 double ceil(
const double &x) { return ::ceil(x); }
1017 inline int log2(
int x)
1021 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 };
1027 return table[(v * 0x07C4ACDDU) >> 27];
1039 template<
typename T>
1040 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1043 EIGEN_USING_STD_MATH(
sqrt);
1047 template<
typename T>
1048 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1050 EIGEN_USING_STD_MATH(
log);
1055 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1056 float log(
const float &x) { return ::logf(x); }
1058 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1059 double log(
const double &x) { return ::log(x); }
1062 template<
typename T>
1063 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1064 typename internal::enable_if<NumTraits<T>::IsSigned || NumTraits<T>::IsComplex,
typename NumTraits<T>::Real>::type
1066 EIGEN_USING_STD_MATH(
abs);
1070 template<
typename T>
1071 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1072 typename internal::enable_if<!(NumTraits<T>::IsSigned || NumTraits<T>::IsComplex),
typename NumTraits<T>::Real>::type
1077 #if defined(__SYCL_DEVICE_ONLY__)
1078 EIGEN_ALWAYS_INLINE
float abs(
float x) {
return cl::sycl::fabs(x); }
1079 EIGEN_ALWAYS_INLINE
double abs(
double x) {
return cl::sycl::fabs(x); }
1083 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1084 float abs(
const float &x) { return ::fabsf(x); }
1086 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1087 double abs(
const double &x) { return ::fabs(x); }
1089 template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1090 float abs(
const std::complex<float>& x) {
1091 return ::hypotf(x.real(), x.imag());
1094 template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1095 double abs(
const std::complex<double>& x) {
1096 return ::hypot(x.real(), x.imag());
1100 template<
typename T>
1101 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1103 EIGEN_USING_STD_MATH(
exp);
1108 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1109 float exp(
const float &x) { return ::expf(x); }
1111 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1112 double exp(
const double &x) { return ::exp(x); }
1115 template<
typename T>
1116 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1118 EIGEN_USING_STD_MATH(
cos);
1123 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1124 float cos(
const float &x) { return ::cosf(x); }
1126 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1127 double cos(
const double &x) { return ::cos(x); }
1130 template<
typename T>
1131 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1133 EIGEN_USING_STD_MATH(
sin);
1138 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1139 float sin(
const float &x) { return ::sinf(x); }
1141 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1142 double sin(
const double &x) { return ::sin(x); }
1145 template<
typename T>
1146 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1148 EIGEN_USING_STD_MATH(
tan);
1153 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1154 float tan(
const float &x) { return ::tanf(x); }
1156 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1157 double tan(
const double &x) { return ::tan(x); }
1160 template<
typename T>
1161 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1162 T
acos(
const T &x) {
1163 EIGEN_USING_STD_MATH(
acos);
1168 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1169 float acos(
const float &x) { return ::acosf(x); }
1171 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1172 double acos(
const double &x) { return ::acos(x); }
1175 template<
typename T>
1176 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1177 T
asin(
const T &x) {
1178 EIGEN_USING_STD_MATH(
asin);
1183 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1184 float asin(
const float &x) { return ::asinf(x); }
1186 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1187 double asin(
const double &x) { return ::asin(x); }
1190 template<
typename T>
1191 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1192 T
atan(
const T &x) {
1193 EIGEN_USING_STD_MATH(
atan);
1198 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1199 float atan(
const float &x) { return ::atanf(x); }
1201 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1202 double atan(
const double &x) { return ::atan(x); }
1206 template<
typename T>
1207 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1208 T
cosh(
const T &x) {
1209 EIGEN_USING_STD_MATH(
cosh);
1214 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1215 float cosh(
const float &x) { return ::coshf(x); }
1217 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1218 double cosh(
const double &x) { return ::cosh(x); }
1221 template<
typename T>
1222 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1223 T
sinh(
const T &x) {
1224 EIGEN_USING_STD_MATH(
sinh);
1229 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1230 float sinh(
const float &x) { return ::sinhf(x); }
1232 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1233 double sinh(
const double &x) { return ::sinh(x); }
1236 template<
typename T>
1237 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1238 T
tanh(
const T &x) {
1239 EIGEN_USING_STD_MATH(
tanh);
1243 #if (!defined(__CUDACC__)) && EIGEN_FAST_MATH
1244 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1245 float tanh(
float x) {
return internal::generic_fast_tanh_float(x); }
1249 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1250 float tanh(
const float &x) { return ::tanhf(x); }
1252 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1253 double tanh(
const double &x) { return ::tanh(x); }
1256 template <
typename T>
1257 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1258 T fmod(
const T& a,
const T& b) {
1259 EIGEN_USING_STD_MATH(fmod);
1265 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1266 float fmod(
const float& a,
const float& b) {
1267 return ::fmodf(a, b);
1271 EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1272 double fmod(
const double& a,
const double& b) {
1273 return ::fmod(a, b);
1279 namespace internal {
1281 template<
typename T>
1282 EIGEN_DEVICE_FUNC
bool isfinite_impl(
const std::complex<T>& x)
1284 return (numext::isfinite)(numext::real(x)) && (numext::isfinite)(numext::imag(x));
1287 template<
typename T>
1288 EIGEN_DEVICE_FUNC
bool isnan_impl(
const std::complex<T>& x)
1290 return (numext::isnan)(numext::real(x)) || (numext::isnan)(numext::imag(x));
1293 template<
typename T>
1294 EIGEN_DEVICE_FUNC
bool isinf_impl(
const std::complex<T>& x)
1296 return ((numext::isinf)(numext::real(x)) || (numext::isinf)(numext::imag(x))) && (!(numext::isnan)(x));
1303 template<
typename Scalar,
1306 struct scalar_fuzzy_default_impl {};
1308 template<
typename Scalar>
1309 struct scalar_fuzzy_default_impl<Scalar, false, false>
1311 typedef typename NumTraits<Scalar>::Real RealScalar;
1312 template<
typename OtherScalar> EIGEN_DEVICE_FUNC
1313 static inline bool isMuchSmallerThan(
const Scalar& x,
const OtherScalar& y,
const RealScalar& prec)
1315 return numext::abs(x) <= numext::abs(y) * prec;
1318 static inline bool isApprox(
const Scalar& x,
const Scalar& y,
const RealScalar& prec)
1320 return numext::abs(x - y) <= numext::mini(numext::abs(x), numext::abs(y)) * prec;
1323 static inline bool isApproxOrLessThan(
const Scalar& x,
const Scalar& y,
const RealScalar& prec)
1325 return x <= y || isApprox(x, y, prec);
1329 template<
typename Scalar>
1330 struct scalar_fuzzy_default_impl<Scalar, false, true>
1332 typedef typename NumTraits<Scalar>::Real RealScalar;
1333 template<
typename OtherScalar> EIGEN_DEVICE_FUNC
1334 static inline bool isMuchSmallerThan(
const Scalar& x,
const Scalar&,
const RealScalar&)
1336 return x == Scalar(0);
1339 static inline bool isApprox(
const Scalar& x,
const Scalar& y,
const RealScalar&)
1344 static inline bool isApproxOrLessThan(
const Scalar& x,
const Scalar& y,
const RealScalar&)
1350 template<
typename Scalar>
1351 struct scalar_fuzzy_default_impl<Scalar, true, false>
1353 typedef typename NumTraits<Scalar>::Real RealScalar;
1354 template<
typename OtherScalar> EIGEN_DEVICE_FUNC
1355 static inline bool isMuchSmallerThan(
const Scalar& x,
const OtherScalar& y,
const RealScalar& prec)
1357 return numext::abs2(x) <= numext::abs2(y) * prec * prec;
1360 static inline bool isApprox(
const Scalar& x,
const Scalar& y,
const RealScalar& prec)
1362 return numext::abs2(x - y) <= numext::mini(numext::abs2(x), numext::abs2(y)) * prec * prec;
1366 template<
typename Scalar>
1367 struct scalar_fuzzy_impl : scalar_fuzzy_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
1369 template<
typename Scalar,
typename OtherScalar> EIGEN_DEVICE_FUNC
1370 inline bool isMuchSmallerThan(
const Scalar& x,
const OtherScalar& y,
1371 const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
1373 return scalar_fuzzy_impl<Scalar>::template isMuchSmallerThan<OtherScalar>(x, y, precision);
1376 template<
typename Scalar> EIGEN_DEVICE_FUNC
1377 inline bool isApprox(
const Scalar& x,
const Scalar& y,
1378 const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
1380 return scalar_fuzzy_impl<Scalar>::isApprox(x, y, precision);
1383 template<
typename Scalar> EIGEN_DEVICE_FUNC
1384 inline bool isApproxOrLessThan(
const Scalar& x,
const Scalar& y,
1385 const typename NumTraits<Scalar>::Real &precision = NumTraits<Scalar>::dummy_precision())
1387 return scalar_fuzzy_impl<Scalar>::isApproxOrLessThan(x, y, precision);
1394 template<>
struct random_impl<bool>
1396 static inline bool run()
1398 return random<int>(0,1)==0 ? false :
true;
1402 template<>
struct scalar_fuzzy_impl<bool>
1404 typedef bool RealScalar;
1406 template<
typename OtherScalar> EIGEN_DEVICE_FUNC
1407 static inline bool isMuchSmallerThan(
const bool& x,
const bool&,
const bool&)
1413 static inline bool isApprox(
bool x,
bool y,
bool)
1419 static inline bool isApproxOrLessThan(
const bool& x,
const bool& y,
const bool&)
Namespace containing all symbols from the Eigen library.
Definition: Core:309
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_imag_op< typename Derived::Scalar >, const Derived > imag(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_atan_op< typename Derived::Scalar >, const Derived > atan(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_cosh_op< typename Derived::Scalar >, const Derived > cosh(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_acos_op< typename Derived::Scalar >, const Derived > acos(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_asin_op< typename Derived::Scalar >, const Derived > asin(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_arg_op< typename Derived::Scalar >, const Derived > arg(const Eigen::ArrayBase< Derived > &x)
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_conjugate_op< typename Derived::Scalar >, const Derived > conj(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_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_real_op< typename Derived::Scalar >, const Derived > real(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_round_op< typename Derived::Scalar >, const Derived > round(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_exp_op< typename Derived::Scalar >, const Derived > exp(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_log_op< typename Derived::Scalar >, const Derived > log(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_sqrt_op< typename Derived::Scalar >, const Derived > sqrt(const Eigen::ArrayBase< Derived > &x)