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)
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 typedef typename NumTraits<Scalar>::Real RealScalar;
320 static inline RealScalar run(
const Scalar& x)
322 EIGEN_USING_STD_MATH(
abs);
327 template<
typename Scalar>
328 struct norm1_default_impl<Scalar, false>
331 static inline Scalar run(
const Scalar& x)
333 EIGEN_USING_STD_MATH(
abs);
338 template<
typename Scalar>
339 struct norm1_impl : norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {};
341 template<
typename Scalar>
344 typedef typename NumTraits<Scalar>::Real type;
351 template<
typename Scalar>
354 typedef typename NumTraits<Scalar>::Real RealScalar;
355 static inline RealScalar run(
const Scalar& x,
const Scalar& y)
357 EIGEN_USING_STD_MATH(
abs);
358 EIGEN_USING_STD_MATH(
sqrt);
359 RealScalar _x =
abs(x);
360 RealScalar _y =
abs(y);
372 if(p==RealScalar(0))
return RealScalar(0);
373 return p *
sqrt(RealScalar(1) + qp*qp);
377 template<
typename Scalar>
380 typedef typename NumTraits<Scalar>::Real type;
387 template<
typename OldType,
typename NewType>
391 static inline NewType run(
const OldType& x)
393 return static_cast<NewType
>(x);
399 template<
typename OldType,
typename NewType>
401 inline NewType cast(
const OldType& x)
403 return cast_impl<OldType, NewType>::run(x);
410 #if EIGEN_HAS_CXX11_MATH 411 template<
typename Scalar>
413 static inline Scalar run(
const Scalar& x)
415 EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
421 template<
typename Scalar>
424 static inline Scalar run(
const Scalar& x)
426 EIGEN_STATIC_ASSERT((!NumTraits<Scalar>::IsComplex), NUMERIC_TYPE_MUST_BE_REAL)
427 EIGEN_USING_STD_MATH(
floor);
428 EIGEN_USING_STD_MATH(
ceil);
429 return (x > Scalar(0)) ?
floor(x + Scalar(0.5)) :
ceil(x - Scalar(0.5));
434 template<
typename Scalar>
444 #if EIGEN_HAS_CXX11_MATH 445 template<
typename Scalar>
447 static inline Scalar run(
const Scalar& x)
449 EIGEN_USING_STD_MATH(
arg);
454 template<typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex>
455 struct arg_default_impl
457 typedef typename NumTraits<Scalar>::Real RealScalar;
459 static inline RealScalar run(
const Scalar& x)
461 return (x < Scalar(0)) ? Scalar(EIGEN_PI) : Scalar(0); }
464 template<
typename Scalar>
465 struct arg_default_impl<Scalar,true>
467 typedef typename NumTraits<Scalar>::Real RealScalar;
469 static inline RealScalar run(
const Scalar& x)
471 EIGEN_USING_STD_MATH(
arg);
476 template<
typename Scalar>
struct arg_impl : arg_default_impl<Scalar> {};
479 template<
typename Scalar>
482 typedef typename NumTraits<Scalar>::Real type;
489 namespace std_fallback {
492 template<
typename Scalar>
493 EIGEN_DEVICE_FUNC
inline Scalar
log1p(
const Scalar& x) {
494 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
495 typedef typename NumTraits<Scalar>::Real RealScalar;
496 EIGEN_USING_STD_MATH(
log);
497 Scalar x1p = RealScalar(1) + x;
498 return ( x1p == Scalar(1) ) ? x : x * (
log(x1p) / (x1p - RealScalar(1)) );
502 template<
typename Scalar>
504 static inline Scalar run(
const Scalar& x)
506 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar)
507 #if EIGEN_HAS_CXX11_MATH 510 using std_fallback::log1p;
516 template<
typename Scalar>
526 template<typename ScalarX,typename ScalarY, bool IsInteger = NumTraits<ScalarX>::IsInteger&&NumTraits<ScalarY>::IsInteger>
530 typedef typename ScalarBinaryOpTraits<ScalarX,ScalarY,internal::scalar_pow_op<ScalarX,ScalarY> >::ReturnType result_type;
531 static EIGEN_DEVICE_FUNC
inline result_type run(
const ScalarX& x,
const ScalarY& y)
533 EIGEN_USING_STD_MATH(pow);
538 template<
typename ScalarX,
typename ScalarY>
539 struct pow_impl<ScalarX,ScalarY, true>
541 typedef ScalarX result_type;
542 static EIGEN_DEVICE_FUNC
inline ScalarX run(ScalarX x, ScalarY y)
545 eigen_assert(!NumTraits<ScalarY>::IsSigned || y >= 0);
562 template<
typename Scalar,
565 struct random_default_impl {};
567 template<
typename Scalar>
568 struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {};
570 template<
typename Scalar>
576 template<
typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(
const Scalar& x,
const Scalar& y);
577 template<
typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random();
579 template<
typename Scalar>
580 struct random_default_impl<Scalar, false, false>
582 static inline Scalar run(
const Scalar& x,
const Scalar& y)
584 return x + (y-x) * Scalar(std::rand()) / Scalar(RAND_MAX);
586 static inline Scalar run()
588 return run(Scalar(NumTraits<Scalar>::IsSigned ? -1 : 0), Scalar(1));
593 meta_floor_log2_terminate,
594 meta_floor_log2_move_up,
595 meta_floor_log2_move_down,
596 meta_floor_log2_bogus
599 template<
unsigned int n,
int lower,
int upper>
struct meta_floor_log2_selector
601 enum { middle = (lower + upper) / 2,
602 value = (upper <= lower + 1) ? int(meta_floor_log2_terminate)
603 : (n < (1 << middle)) ? int(meta_floor_log2_move_down)
604 : (n==0) ? int(meta_floor_log2_bogus)
605 : int(meta_floor_log2_move_up)
609 template<
unsigned int n,
611 int upper =
sizeof(
unsigned int) * CHAR_BIT - 1,
612 int selector = meta_floor_log2_selector<n, lower, upper>::value>
613 struct meta_floor_log2 {};
615 template<
unsigned int n,
int lower,
int upper>
616 struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_down>
618 enum { value = meta_floor_log2<n, lower, meta_floor_log2_selector<n, lower, upper>::middle>::value };
621 template<
unsigned int n,
int lower,
int upper>
622 struct meta_floor_log2<n, lower, upper, meta_floor_log2_move_up>
624 enum { value = meta_floor_log2<n, meta_floor_log2_selector<n, lower, upper>::middle, upper>::value };
627 template<
unsigned int n,
int lower,
int upper>
628 struct meta_floor_log2<n, lower, upper, meta_floor_log2_terminate>
630 enum { value = (n >= ((
unsigned int)(1) << (lower+1))) ? lower+1 : lower };
633 template<
unsigned int n,
int lower,
int upper>
634 struct meta_floor_log2<n, lower, upper, meta_floor_log2_bogus>
639 template<
typename Scalar>
640 struct random_default_impl<Scalar, false, true>
642 static inline Scalar run(
const Scalar& x,
const Scalar& y)
644 typedef typename conditional<NumTraits<Scalar>::IsSigned,std::ptrdiff_t,std::size_t>::type ScalarX;
649 std::size_t range = ScalarX(y)-ScalarX(x);
650 std::size_t offset = 0;
652 std::size_t divisor = 1;
653 std::size_t multiplier = 1;
654 if(range<RAND_MAX) divisor = (std::size_t(RAND_MAX)+1)/(range+1);
655 else multiplier = 1 + range/(std::size_t(RAND_MAX)+1);
657 offset = (std::size_t(std::rand()) * multiplier) / divisor;
658 }
while (offset > range);
659 return Scalar(ScalarX(x) + offset);
662 static inline Scalar run()
664 #ifdef EIGEN_MAKING_DOCS 665 return run(Scalar(NumTraits<Scalar>::IsSigned ? -10 : 0), Scalar(10));
667 enum { rand_bits = meta_floor_log2<(unsigned int)(RAND_MAX)+1>::value,
668 scalar_bits =
sizeof(Scalar) * CHAR_BIT,
669 shift = EIGEN_PLAIN_ENUM_MAX(0,
int(rand_bits) - int(scalar_bits)),
670 offset = NumTraits<Scalar>::IsSigned ? (1 << (EIGEN_PLAIN_ENUM_MIN(rand_bits,scalar_bits)-1)) : 0
672 return Scalar((std::rand() >> shift) - offset);
677 template<
typename Scalar>
678 struct random_default_impl<Scalar, true, false>
680 static inline Scalar run(
const Scalar& x,
const Scalar& y)
682 return Scalar(random(
real(x),
real(y)),
685 static inline Scalar run()
687 typedef typename NumTraits<Scalar>::Real RealScalar;
688 return Scalar(random<RealScalar>(), random<RealScalar>());
692 template<
typename Scalar>
693 inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(
const Scalar& x,
const Scalar& y)
695 return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y);
698 template<
typename Scalar>
699 inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random()
701 return EIGEN_MATHFUNC_IMPL(random, Scalar)::run();
707 #if (EIGEN_HAS_CXX11_MATH && !(EIGEN_COMP_GNUC_STRICT && __FINITE_MATH_ONLY__)) || (EIGEN_COMP_MSVC>=1800) || (EIGEN_COMP_CLANG) 708 #define EIGEN_USE_STD_FPCLASSIFY 1 710 #define EIGEN_USE_STD_FPCLASSIFY 0 715 typename internal::enable_if<internal::is_integral<T>::value,
bool>::type
716 isnan_impl(
const T&) {
return false; }
720 typename internal::enable_if<internal::is_integral<T>::value,
bool>::type
721 isinf_impl(
const T&) {
return false; }
725 typename internal::enable_if<internal::is_integral<T>::value,
bool>::type
726 isfinite_impl(
const T&) {
return true; }
730 typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),
bool>::type
731 isfinite_impl(
const T& x)
735 #elif EIGEN_USE_STD_FPCLASSIFY 737 return isfinite EIGEN_NOT_A_MACRO (x);
739 return x<=NumTraits<T>::highest() && x>=NumTraits<T>::lowest();
745 typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),
bool>::type
746 isinf_impl(
const T& x)
750 #elif EIGEN_USE_STD_FPCLASSIFY 752 return isinf EIGEN_NOT_A_MACRO (x);
754 return x>NumTraits<T>::highest() || x<NumTraits<T>::lowest();
760 typename internal::enable_if<(!internal::is_integral<T>::value)&&(!NumTraits<T>::IsComplex),
bool>::type
761 isnan_impl(
const T& x)
765 #elif EIGEN_USE_STD_FPCLASSIFY 767 return isnan EIGEN_NOT_A_MACRO (x);
773 #if (!EIGEN_USE_STD_FPCLASSIFY) 777 template<
typename T> EIGEN_DEVICE_FUNC
bool isinf_msvc_helper(T x)
779 return _fpclass(x)==_FPCLASS_NINF || _fpclass(x)==_FPCLASS_PINF;
783 EIGEN_DEVICE_FUNC
inline bool isnan_impl(
const long double& x) {
return _isnan(x)!=0; }
784 EIGEN_DEVICE_FUNC
inline bool isnan_impl(
const double& x) {
return _isnan(x)!=0; }
785 EIGEN_DEVICE_FUNC
inline bool isnan_impl(
const float& x) {
return _isnan(x)!=0; }
787 EIGEN_DEVICE_FUNC
inline bool isinf_impl(
const long double& x) {
return isinf_msvc_helper(x); }
788 EIGEN_DEVICE_FUNC
inline bool isinf_impl(
const double& x) {
return isinf_msvc_helper(x); }
789 EIGEN_DEVICE_FUNC
inline bool isinf_impl(
const float& x) {
return isinf_msvc_helper(x); }
791 #elif (defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ && EIGEN_COMP_GNUC) 793 #if EIGEN_GNUC_AT_LEAST(5,0) 794 #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((optimize("no-finite-math-only"))) 798 #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((noinline,optimize("no-finite-math-only"))) 801 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isnan_impl(
const long double& x) {
return __builtin_isnan(x); }
802 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isnan_impl(
const double& x) {
return __builtin_isnan(x); }
803 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isnan_impl(
const float& x) {
return __builtin_isnan(x); }
804 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isinf_impl(
const double& x) {
return __builtin_isinf(x); }
805 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isinf_impl(
const float& x) {
return __builtin_isinf(x); }
806 template<> EIGEN_TMP_NOOPT_ATTRIB
bool isinf_impl(
const long double& x) {
return __builtin_isinf(x); }
808 #undef EIGEN_TMP_NOOPT_ATTRIB 815 template<
typename T> EIGEN_DEVICE_FUNC
bool isfinite_impl(
const std::complex<T>& x);
816 template<
typename T> EIGEN_DEVICE_FUNC
bool isnan_impl(
const std::complex<T>& x);
817 template<
typename T> EIGEN_DEVICE_FUNC
bool isinf_impl(
const std::complex<T>& x);
819 template<
typename T> T generic_fast_tanh_float(
const T& a_x);
829 #ifndef __CUDA_ARCH__ 832 EIGEN_ALWAYS_INLINE T mini(
const T& x,
const T& y)
834 EIGEN_USING_STD_MATH(min);
835 return min EIGEN_NOT_A_MACRO (x,y);
840 EIGEN_ALWAYS_INLINE T maxi(
const T& x,
const T& y)
842 EIGEN_USING_STD_MATH(max);
843 return max EIGEN_NOT_A_MACRO (x,y);
848 EIGEN_ALWAYS_INLINE T mini(
const T& x,
const T& y)
850 return y < x ? y : x;
854 EIGEN_ALWAYS_INLINE
float mini(
const float& x,
const float& y)
860 EIGEN_ALWAYS_INLINE T maxi(
const T& x,
const T& y)
862 return x < y ? y : x;
866 EIGEN_ALWAYS_INLINE
float maxi(
const float& x,
const float& y)
873 template<
typename Scalar>
875 inline EIGEN_MATHFUNC_RETVAL(
real, Scalar)
real(
const Scalar& x)
877 return EIGEN_MATHFUNC_IMPL(
real, Scalar)::run(x);
880 template<
typename Scalar>
882 inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type real_ref(
const Scalar& x)
884 return internal::real_ref_impl<Scalar>::run(x);
887 template<
typename Scalar>
889 inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x)
891 return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x);
894 template<
typename Scalar>
896 inline EIGEN_MATHFUNC_RETVAL(
imag, Scalar)
imag(
const Scalar& x)
898 return EIGEN_MATHFUNC_IMPL(
imag, Scalar)::run(x);
901 template<
typename Scalar>
903 inline EIGEN_MATHFUNC_RETVAL(
arg, Scalar)
arg(
const Scalar& x)
905 return EIGEN_MATHFUNC_IMPL(
arg, Scalar)::run(x);
908 template<
typename Scalar>
910 inline typename internal::add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type imag_ref(
const Scalar& x)
912 return internal::imag_ref_impl<Scalar>::run(x);
915 template<
typename Scalar>
917 inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x)
919 return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x);
922 template<
typename Scalar>
924 inline EIGEN_MATHFUNC_RETVAL(
conj, Scalar)
conj(
const Scalar& x)
926 return EIGEN_MATHFUNC_IMPL(
conj, Scalar)::run(x);
929 template<
typename Scalar>
931 inline EIGEN_MATHFUNC_RETVAL(
abs2, Scalar)
abs2(
const Scalar& x)
933 return EIGEN_MATHFUNC_IMPL(
abs2, Scalar)::run(x);
936 template<
typename Scalar>
938 inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(
const Scalar& x)
940 return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x);
943 template<
typename Scalar>
945 inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(
const Scalar& x,
const Scalar& y)
947 return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y);
950 template<
typename Scalar>
952 inline EIGEN_MATHFUNC_RETVAL(
log1p, Scalar)
log1p(
const Scalar& x)
954 return EIGEN_MATHFUNC_IMPL(
log1p, Scalar)::run(x);
958 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
959 float log1p(
const float &x) { return ::log1pf(x); }
961 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
962 double log1p(
const double &x) { return ::log1p(x); }
965 template<
typename ScalarX,
typename ScalarY>
967 inline typename internal::pow_impl<ScalarX,ScalarY>::result_type pow(
const ScalarX& x,
const ScalarY& y)
969 return internal::pow_impl<ScalarX,ScalarY>::run(x, y);
972 template<
typename T> EIGEN_DEVICE_FUNC bool (
isnan) (
const T &x) {
return internal::isnan_impl(x); }
973 template<
typename T> EIGEN_DEVICE_FUNC bool (
isinf) (
const T &x) {
return internal::isinf_impl(x); }
974 template<
typename T> EIGEN_DEVICE_FUNC bool (
isfinite)(
const T &x) {
return internal::isfinite_impl(x); }
976 template<
typename Scalar>
978 inline EIGEN_MATHFUNC_RETVAL(
round, Scalar)
round(
const Scalar& x)
980 return EIGEN_MATHFUNC_IMPL(
round, Scalar)::run(x);
985 T (
floor)(
const T& x)
987 EIGEN_USING_STD_MATH(
floor);
992 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
993 float floor(
const float &x) { return ::floorf(x); }
995 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
996 double floor(
const double &x) { return ::floor(x); }
1001 T (
ceil)(
const T& x)
1003 EIGEN_USING_STD_MATH(
ceil);
1008 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1009 float ceil(
const float &x) { return ::ceilf(x); }
1011 template<> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE
1012 double ceil(
const double &x) { return ::ceil(x); }
1018 inline int log2(
int x)
1022 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 };
1028 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); }
1080 #endif // defined(__SYCL_DEVICE_ONLY__) 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);
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&)
1431 #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:287
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_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_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_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)