// This file is part of Eigen, a lightweight C++ template library // for linear algebra. // // Copyright (C) 2006-2010 Benoit Jacob <[email protected]> // Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. // // This Source Code Form is subject to the terms of the Mozilla // Public License v. 2.0. If a copy of the MPL was not distributed // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. #ifndef EIGEN_MATHFUNCTIONS_H #define EIGEN_MATHFUNCTIONS_H // TODO this should better be moved to NumTraits // Source: WolframAlpha #define EIGEN_PI … #define EIGEN_LOG2E … #define EIGEN_LN2 … // IWYU pragma: private #include "./InternalHeaderCheck.h" namespace Eigen { namespace internal { /** \internal \class global_math_functions_filtering_base * * What it does: * Defines a typedef 'type' as follows: * - if type T has a member typedef Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl, then * global_math_functions_filtering_base<T>::type is a typedef for it. * - otherwise, global_math_functions_filtering_base<T>::type is a typedef for T. * * How it's used: * To allow to defined the global math functions (like sin...) in certain cases, like the Array expressions. * When you do sin(array1+array2), the object array1+array2 has a complicated expression type, all what you want to know * is that it inherits ArrayBase. So we implement a partial specialization of sin_impl for ArrayBase<Derived>. * So we must make sure to use sin_impl<ArrayBase<Derived> > and not sin_impl<Derived>, otherwise our partial * specialization won't be used. How does sin know that? That's exactly what global_math_functions_filtering_base tells * it. * * How it's implemented: * SFINAE in the style of enable_if. Highly susceptible of breaking compilers. With GCC, it sure does work, but if you * replace the typename dummy by an integer template parameter, it doesn't work anymore! */ template <typename T, typename dummy = void> struct global_math_functions_filtering_base { … }; template <typename T> struct always_void { … }; global_math_functions_filtering_base<T, typename always_void<typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl>::type>; #define EIGEN_MATHFUNC_IMPL(func, scalar) … #define EIGEN_MATHFUNC_RETVAL(func, scalar) … /**************************************************************************** * Implementation of real * ****************************************************************************/ template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex> struct real_default_impl { … }; real_default_impl<Scalar, true>; template <typename Scalar> struct real_impl : real_default_impl<Scalar> { … }; #if defined(EIGEN_GPU_COMPILE_PHASE) template <typename T> struct real_impl<std::complex<T>> { typedef T RealScalar; EIGEN_DEVICE_FUNC static inline T run(const std::complex<T>& x) { return x.real(); } }; #endif template <typename Scalar> struct real_retval { … }; /**************************************************************************** * Implementation of imag * ****************************************************************************/ template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex> struct imag_default_impl { … }; imag_default_impl<Scalar, true>; template <typename Scalar> struct imag_impl : imag_default_impl<Scalar> { … }; #if defined(EIGEN_GPU_COMPILE_PHASE) template <typename T> struct imag_impl<std::complex<T>> { typedef T RealScalar; EIGEN_DEVICE_FUNC static inline T run(const std::complex<T>& x) { return x.imag(); } }; #endif template <typename Scalar> struct imag_retval { … }; /**************************************************************************** * Implementation of real_ref * ****************************************************************************/ template <typename Scalar> struct real_ref_impl { … }; template <typename Scalar> struct real_ref_retval { … }; /**************************************************************************** * Implementation of imag_ref * ****************************************************************************/ template <typename Scalar, bool IsComplex> struct imag_ref_default_impl { … }; imag_ref_default_impl<Scalar, false>; template <typename Scalar> struct imag_ref_impl : imag_ref_default_impl<Scalar, NumTraits<Scalar>::IsComplex> { … }; template <typename Scalar> struct imag_ref_retval { … }; /**************************************************************************** * Implementation of conj * ****************************************************************************/ template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex> struct conj_default_impl { … }; conj_default_impl<Scalar, true>; template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex> struct conj_impl : conj_default_impl<Scalar, IsComplex> { … }; template <typename Scalar> struct conj_retval { … }; /**************************************************************************** * Implementation of abs2 * ****************************************************************************/ template <typename Scalar, bool IsComplex> struct abs2_impl_default { … }; abs2_impl_default<Scalar, true>; template <typename Scalar> struct abs2_impl { … }; template <typename Scalar> struct abs2_retval { … }; /**************************************************************************** * Implementation of sqrt/rsqrt * ****************************************************************************/ template <typename Scalar> struct sqrt_impl { … }; // Complex sqrt defined in MathFunctionsImpl.h. template <typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_sqrt(const std::complex<T>& a_x); // Custom implementation is faster than `std::sqrt`, works on // GPU, and correctly handles special cases (unlike MSVC). sqrt_impl<std::complex<T>>; template <typename Scalar> struct sqrt_retval { … }; // Default implementation relies on numext::sqrt, at bottom of file. template <typename T> struct rsqrt_impl; // Complex rsqrt defined in MathFunctionsImpl.h. template <typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_rsqrt(const std::complex<T>& a_x); rsqrt_impl<std::complex<T>>; template <typename Scalar> struct rsqrt_retval { … }; /**************************************************************************** * Implementation of norm1 * ****************************************************************************/ template <typename Scalar, bool IsComplex> struct norm1_default_impl; norm1_default_impl<Scalar, true>; norm1_default_impl<Scalar, false>; template <typename Scalar> struct norm1_impl : norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> { … }; template <typename Scalar> struct norm1_retval { … }; /**************************************************************************** * Implementation of hypot * ****************************************************************************/ template <typename Scalar> struct hypot_impl; template <typename Scalar> struct hypot_retval { … }; /**************************************************************************** * Implementation of cast * ****************************************************************************/ template <typename OldType, typename NewType, typename EnableIf = void> struct cast_impl { … }; cast_impl<OldType, bool>; // Casting from S -> Complex<T> leads to an implicit conversion from S to T, // generating warnings on clang. Here we explicitly cast the real component. cast_impl<OldType, NewType, typename std::enable_if_t<!NumTraits<OldType>::IsComplex && NumTraits<NewType>::IsComplex>>; // here, for once, we're plainly returning NewType: we don't want cast to do weird things. template <typename OldType, typename NewType> EIGEN_DEVICE_FUNC inline NewType cast(const OldType& x) { … } /**************************************************************************** * Implementation of arg * ****************************************************************************/ // Visual Studio 2017 has a bug where arg(float) returns 0 for negative inputs. // This seems to be fixed in VS 2019. #if (!EIGEN_COMP_MSVC || EIGEN_COMP_MSVC >= 1920) // std::arg is only defined for types of std::complex, or integer types or float/double/long double template <typename Scalar, bool HasStdImpl = NumTraits<Scalar>::IsComplex || is_integral<Scalar>::value || is_same<Scalar, float>::value || is_same<Scalar, double>::value || is_same<Scalar, long double>::value> struct arg_default_impl; arg_default_impl<Scalar, true>; // Must be non-complex floating-point type (e.g. half/bfloat16). arg_default_impl<Scalar, false>; #else template <typename Scalar, bool IsComplex = NumTraits<Scalar>::IsComplex> struct arg_default_impl { typedef typename NumTraits<Scalar>::Real RealScalar; EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) { return (x < RealScalar(0)) ? RealScalar(EIGEN_PI) : RealScalar(0); } }; template <typename Scalar> struct arg_default_impl<Scalar, true> { typedef typename NumTraits<Scalar>::Real RealScalar; EIGEN_DEVICE_FUNC static inline RealScalar run(const Scalar& x) { EIGEN_USING_STD(arg); return arg(x); } }; #endif template <typename Scalar> struct arg_impl : arg_default_impl<Scalar> { … }; template <typename Scalar> struct arg_retval { … }; /**************************************************************************** * Implementation of expm1 * ****************************************************************************/ // This implementation is based on GSL Math's expm1. namespace std_fallback { // fallback expm1 implementation in case there is no expm1(Scalar) function in namespace of Scalar, // or that there is no suitable std::expm1 function available. Implementation // attributed to Kahan. See: http://www.plunk.org/~hatch/rightway.php. template <typename Scalar> EIGEN_DEVICE_FUNC inline Scalar expm1(const Scalar& x) { … } } // namespace std_fallback template <typename Scalar> struct expm1_impl { … }; template <typename Scalar> struct expm1_retval { … }; /**************************************************************************** * Implementation of log * ****************************************************************************/ // Complex log defined in MathFunctionsImpl.h. template <typename T> EIGEN_DEVICE_FUNC std::complex<T> complex_log(const std::complex<T>& z); template <typename Scalar> struct log_impl { … }; log_impl<std::complex<Scalar>>; /**************************************************************************** * Implementation of log1p * ****************************************************************************/ namespace std_fallback { // fallback log1p implementation in case there is no log1p(Scalar) function in namespace of Scalar, // or that there is no suitable std::log1p function available template <typename Scalar> EIGEN_DEVICE_FUNC inline Scalar log1p(const Scalar& x) { … } } // namespace std_fallback template <typename Scalar> struct log1p_impl { … }; // Specialization for complex types that are not supported by std::log1p. log1p_impl<std::complex<RealScalar>>; template <typename Scalar> struct log1p_retval { … }; /**************************************************************************** * Implementation of pow * ****************************************************************************/ template <typename ScalarX, typename ScalarY, bool IsInteger = NumTraits<ScalarX>::IsInteger && NumTraits<ScalarY>::IsInteger> struct pow_impl { … }; pow_impl<ScalarX, ScalarY, true>; enum { … }; template <unsigned int n, int lower, int upper> struct meta_floor_log2_selector { … }; template <unsigned int n, int lower = 0, int upper = sizeof(unsigned int) * CHAR_BIT - 1, int selector = meta_floor_log2_selector<n, lower, upper>::value> struct meta_floor_log2 { … }; meta_floor_log2<n, lower, upper, meta_floor_log2_move_down>; meta_floor_log2<n, lower, upper, meta_floor_log2_move_up>; meta_floor_log2<n, lower, upper, meta_floor_log2_terminate>; meta_floor_log2<n, lower, upper, meta_floor_log2_bogus>; template <typename BitsType, typename EnableIf = void> struct count_bits_impl { … }; // Count leading zeros. template <typename BitsType> EIGEN_DEVICE_FUNC inline int clz(BitsType bits) { … } // Count trailing zeros. template <typename BitsType> EIGEN_DEVICE_FUNC inline int ctz(BitsType bits) { … } #if EIGEN_COMP_GNUC || EIGEN_COMP_CLANG count_bits_impl<BitsType, std::enable_if_t<std::is_integral<BitsType>::value && sizeof(BitsType) <= sizeof(unsigned int)>>; count_bits_impl<BitsType, std::enable_if_t<std::is_integral<BitsType>::value && sizeof(unsigned int) < sizeof(BitsType) && sizeof(BitsType) <= sizeof(unsigned long)>>; count_bits_impl<BitsType, std::enable_if_t<std::is_integral<BitsType>::value && sizeof(unsigned long) < sizeof(BitsType) && sizeof(BitsType) <= sizeof(unsigned long long)>>; #elif EIGEN_COMP_MSVC template <typename BitsType> struct count_bits_impl< BitsType, std::enable_if_t<std::is_integral<BitsType>::value && sizeof(BitsType) <= sizeof(unsigned long)>> { static constexpr int kNumBits = static_cast<int>(sizeof(BitsType) * CHAR_BIT); static EIGEN_DEVICE_FUNC inline int clz(BitsType bits) { unsigned long out; _BitScanReverse(&out, static_cast<unsigned long>(bits)); return bits == 0 ? kNumBits : (kNumBits - 1) - static_cast<int>(out); } static EIGEN_DEVICE_FUNC inline int ctz(BitsType bits) { unsigned long out; _BitScanForward(&out, static_cast<unsigned long>(bits)); return bits == 0 ? kNumBits : static_cast<int>(out); } }; #ifdef _WIN64 template <typename BitsType> struct count_bits_impl<BitsType, std::enable_if_t<std::is_integral<BitsType>::value && sizeof(unsigned long) < sizeof(BitsType) && sizeof(BitsType) <= sizeof(__int64)>> { static constexpr int kNumBits = static_cast<int>(sizeof(BitsType) * CHAR_BIT); static EIGEN_DEVICE_FUNC inline int clz(BitsType bits) { unsigned long out; _BitScanReverse64(&out, static_cast<unsigned __int64>(bits)); return bits == 0 ? kNumBits : (kNumBits - 1) - static_cast<int>(out); } static EIGEN_DEVICE_FUNC inline int ctz(BitsType bits) { unsigned long out; _BitScanForward64(&out, static_cast<unsigned __int64>(bits)); return bits == 0 ? kNumBits : static_cast<int>(out); } }; #endif // _WIN64 #endif // EIGEN_COMP_GNUC || EIGEN_COMP_CLANG template <typename BitsType> struct log_2_impl { … }; template <typename BitsType> int log2_ceil(const BitsType& x) { … } template <typename BitsType> int log2_floor(const BitsType& x) { … } // Implementation of is* functions template <typename T> EIGEN_DEVICE_FUNC std::enable_if_t<!(std::numeric_limits<T>::has_infinity || std::numeric_limits<T>::has_quiet_NaN || std::numeric_limits<T>::has_signaling_NaN), bool> isfinite_impl(const T&) { … } template <typename T> EIGEN_DEVICE_FUNC std::enable_if_t<(std::numeric_limits<T>::has_infinity || std::numeric_limits<T>::has_quiet_NaN || std::numeric_limits<T>::has_signaling_NaN) && (!NumTraits<T>::IsComplex), bool> isfinite_impl(const T& x) { … } template <typename T> EIGEN_DEVICE_FUNC std::enable_if_t<!std::numeric_limits<T>::has_infinity, bool> isinf_impl(const T&) { … } template <typename T> EIGEN_DEVICE_FUNC std::enable_if_t<(std::numeric_limits<T>::has_infinity && !NumTraits<T>::IsComplex), bool> isinf_impl( const T& x) { … } template <typename T> EIGEN_DEVICE_FUNC std::enable_if_t<!(std::numeric_limits<T>::has_quiet_NaN || std::numeric_limits<T>::has_signaling_NaN), bool> isnan_impl(const T&) { … } template <typename T> EIGEN_DEVICE_FUNC std::enable_if_t< (std::numeric_limits<T>::has_quiet_NaN || std::numeric_limits<T>::has_signaling_NaN) && (!NumTraits<T>::IsComplex), bool> isnan_impl(const T& x) { … } // The following overload are defined at the end of this file template <typename T> EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x); template <typename T> EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x); template <typename T> EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x); template <typename T> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS T ptanh_float(const T& a_x); /**************************************************************************** * Implementation of sign * ****************************************************************************/ template <typename Scalar, bool IsComplex = (NumTraits<Scalar>::IsComplex != 0), bool IsInteger = (NumTraits<Scalar>::IsInteger != 0)> struct sign_impl { … }; sign_impl<Scalar, false, false>; sign_impl<Scalar, true, IsInteger>; // The sign function for bool is the identity. template <> struct sign_impl<bool, false, true> { … }; template <typename Scalar> struct sign_retval { … }; // suppress "unary minus operator applied to unsigned type, result still unsigned" warnings on MSVC // note: `0 - a` is distinct from `-a` when Scalar is a floating point type and `a` is zero template <typename Scalar, bool IsInteger = NumTraits<Scalar>::IsInteger> struct negate_impl { … }; negate_impl<Scalar, true>; template <typename Scalar> struct negate_retval { … }; template <typename Scalar, bool IsInteger = NumTraits<typename unpacket_traits<Scalar>::type>::IsInteger> struct nearest_integer_impl { … }; nearest_integer_impl<Scalar, true>; } // end namespace internal /**************************************************************************** * Generic math functions * ****************************************************************************/ namespace numext { #if (!defined(EIGEN_GPUCC) || defined(EIGEN_CONSTEXPR_ARE_DEVICE_FUNC)) template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y) { … } template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y) { … } #else template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T mini(const T& x, const T& y) { return y < x ? y : x; } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float mini(const float& x, const float& y) { return fminf(x, y); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double mini(const double& x, const double& y) { return fmin(x, y); } #ifndef EIGEN_GPU_COMPILE_PHASE template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE long double mini(const long double& x, const long double& y) { #if defined(EIGEN_HIPCC) // no "fminl" on HIP yet return (x < y) ? x : y; #else return fminl(x, y); #endif } #endif template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T maxi(const T& x, const T& y) { return x < y ? y : x; } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float maxi(const float& x, const float& y) { return fmaxf(x, y); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double maxi(const double& x, const double& y) { return fmax(x, y); } #ifndef EIGEN_GPU_COMPILE_PHASE template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE long double maxi(const long double& x, const long double& y) { #if defined(EIGEN_HIPCC) // no "fmaxl" on HIP yet return (x > y) ? x : y; #else return fmaxl(x, y); #endif } #endif #endif #if defined(SYCL_DEVICE_ONLY) #define SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_BINARY … #define SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_UNARY … #define SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_BINARY … #define SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY … #define SYCL_SPECIALIZE_INTEGER_TYPES_BINARY … #define SYCL_SPECIALIZE_INTEGER_TYPES_UNARY … #define SYCL_SPECIALIZE_FLOATING_TYPES_BINARY … #define SYCL_SPECIALIZE_FLOATING_TYPES_UNARY … #define SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE … #define SYCL_SPECIALIZE_GEN_UNARY_FUNC … #define SYCL_SPECIALIZE_UNARY_FUNC … #define SYCL_SPECIALIZE_GEN1_BINARY_FUNC … #define SYCL_SPECIALIZE_GEN2_BINARY_FUNC … #define SYCL_SPECIALIZE_BINARY_FUNC … SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(mini, min) SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(mini, fmin) SYCL_SPECIALIZE_INTEGER_TYPES_BINARY(maxi, max) SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(maxi, fmax) #endif template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(real, Scalar) real(const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline internal::add_const_on_value_type_t<EIGEN_MATHFUNC_RETVAL(real_ref, Scalar)> real_ref( const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(imag, Scalar) imag(const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(arg, Scalar) arg(const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline internal::add_const_on_value_type_t<EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar)> imag_ref( const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) conj(const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(sign, Scalar) sign(const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(negate, Scalar) negate(const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(abs2, Scalar) abs2(const Scalar& x) { … } EIGEN_DEVICE_FUNC inline bool abs2(bool x) { … } template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T absdiff(const T& x, const T& y) { … } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float absdiff(const float& x, const float& y) { … } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double absdiff(const double& x, const double& y) { … } // HIP and CUDA do not support long double. #ifndef EIGEN_GPU_COMPILE_PHASE template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE long double absdiff(const long double& x, const long double& y) { … } #endif template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(const Scalar& x, const Scalar& y) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(hypot, hypot) #endif template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(log1p, Scalar) log1p(const Scalar& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(log1p, log1p) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float log1p(const float& x) { return ::log1pf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double log1p(const double& x) { return ::log1p(x); } #endif template <typename ScalarX, typename ScalarY> EIGEN_DEVICE_FUNC inline typename internal::pow_impl<ScalarX, ScalarY>::result_type pow(const ScalarX& x, const ScalarY& y) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(pow, pow) #endif template <typename T> EIGEN_DEVICE_FUNC bool(isnan)(const T& x) { … } template <typename T> EIGEN_DEVICE_FUNC bool(isinf)(const T& x) { … } template <typename T> EIGEN_DEVICE_FUNC bool(isfinite)(const T& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(isnan, isnan, bool) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(isinf, isinf, bool) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE(isfinite, isfinite, bool) #endif template <typename Scalar> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar rint(const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar round(const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar(floor)(const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar(ceil)(const Scalar& x) { … } template <typename Scalar> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar(trunc)(const Scalar& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(round, round) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(floor, floor) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(ceil, ceil) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(trunc, trunc) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float floor(const float& x) { return ::floorf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double floor(const double& x) { return ::floor(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float ceil(const float& x) { return ::ceilf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double ceil(const double& x) { return ::ceil(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float trunc(const float& x) { return ::truncf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double trunc(const double& x) { return ::trunc(x); } #endif // Integer division with rounding up. // T is assumed to be an integer type with a>=0, and b>0 template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE EIGEN_CONSTEXPR T div_ceil(T a, T b) { … } // Integer round down to nearest power of b // T is assumed to be an integer type with a>=0, and b>0 template <typename T, typename U> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE EIGEN_CONSTEXPR T round_down(T a, U b) { … } /** Log base 2 for 32 bits positive integers. * Conveniently returns 0 for x==0. */ EIGEN_CONSTEXPR inline int log2(int x) { … } /** \returns the square root of \a x. * * It is essentially equivalent to * \code using std::sqrt; return sqrt(x); \endcode * but slightly faster for float/double and some compilers (e.g., gcc), thanks to * specializations when SSE is enabled. * * It's usage is justified in performance critical functions, like norm/normalize. */ template <typename Scalar> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE EIGEN_MATHFUNC_RETVAL(sqrt, Scalar) sqrt(const Scalar& x) { … } // Boolean specialization, avoids implicit float to bool conversion (-Wimplicit-conversion-floating-point-to-bool). template <> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_DEVICE_FUNC bool sqrt<bool>(const bool& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(sqrt, sqrt) #endif /** \returns the cube root of \a x. **/ template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T cbrt(const T& x) { … } /** \returns the reciprocal square root of \a x. **/ template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T rsqrt(const T& x) { … } template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T log(const T& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(log, log) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float log(const float& x) { return ::logf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double log(const double& x) { return ::log(x); } #endif template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t<NumTraits<T>::IsSigned || NumTraits<T>::IsComplex, typename NumTraits<T>::Real> abs(const T& x) { … } template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::enable_if_t<!(NumTraits<T>::IsSigned || NumTraits<T>::IsComplex), typename NumTraits<T>::Real> abs(const T& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_INTEGER_TYPES_UNARY(abs, abs) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(abs, fabs) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float abs(const float& x) { return ::fabsf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double abs(const double& x) { return ::fabs(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float abs(const std::complex<float>& x) { return ::hypotf(x.real(), x.imag()); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double abs(const std::complex<double>& x) { return ::hypot(x.real(), x.imag()); } #endif template <typename Scalar, bool IsInteger = NumTraits<Scalar>::IsInteger, bool IsSigned = NumTraits<Scalar>::IsSigned> struct signbit_impl; signbit_impl<Scalar, false, true>; signbit_impl<Scalar, true, true>; signbit_impl<Scalar, true, false>; template <typename Scalar> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE static constexpr Scalar signbit(const Scalar& x) { … } template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T exp(const T& x) { … } // MSVC screws up some edge-cases for std::exp(complex). #ifdef EIGEN_COMP_MSVC template <typename RealScalar> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::complex<RealScalar> exp(const std::complex<RealScalar>& x) { … } #endif #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(exp, exp) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float exp(const float& x) { return ::expf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double exp(const double& x) { return ::exp(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::complex<float> exp(const std::complex<float>& x) { float com = ::expf(x.real()); float res_real = com * ::cosf(x.imag()); float res_imag = com * ::sinf(x.imag()); return std::complex<float>(res_real, res_imag); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE std::complex<double> exp(const std::complex<double>& x) { double com = ::exp(x.real()); double res_real = com * ::cos(x.imag()); double res_imag = com * ::sin(x.imag()); return std::complex<double>(res_real, res_imag); } #endif template <typename Scalar> EIGEN_DEVICE_FUNC inline EIGEN_MATHFUNC_RETVAL(expm1, Scalar) expm1(const Scalar& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(expm1, expm1) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float expm1(const float& x) { return ::expm1f(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double expm1(const double& x) { return ::expm1(x); } #endif template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T cos(const T& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(cos, cos) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float cos(const float& x) { return ::cosf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double cos(const double& x) { return ::cos(x); } #endif template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T sin(const T& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(sin, sin) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float sin(const float& x) { return ::sinf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double sin(const double& x) { return ::sin(x); } #endif template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T tan(const T& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(tan, tan) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float tan(const float& x) { return ::tanf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double tan(const double& x) { return ::tan(x); } #endif template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T acos(const T& x) { … } template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T acosh(const T& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(acos, acos) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(acosh, acosh) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float acos(const float& x) { return ::acosf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double acos(const double& x) { return ::acos(x); } #endif template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T asin(const T& x) { … } template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T asinh(const T& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(asin, asin) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(asinh, asinh) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float asin(const float& x) { return ::asinf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double asin(const double& x) { return ::asin(x); } #endif template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T atan(const T& x) { … } template <typename T, std::enable_if_t<!NumTraits<T>::IsComplex, int> = 0> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T atan2(const T& y, const T& x) { … } template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T atanh(const T& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(atan, atan) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(atanh, atanh) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float atan(const float& x) { return ::atanf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double atan(const double& x) { return ::atan(x); } #endif template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T cosh(const T& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(cosh, cosh) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float cosh(const float& x) { return ::coshf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double cosh(const double& x) { return ::cosh(x); } #endif template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T sinh(const T& x) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(sinh, sinh) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float sinh(const float& x) { return ::sinhf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double sinh(const double& x) { return ::sinh(x); } #endif template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T tanh(const T& x) { … } #if (!defined(EIGEN_GPUCC)) && EIGEN_FAST_MATH && !defined(SYCL_DEVICE_ONLY) EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float tanh(float x) { … } #endif #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_UNARY(tanh, tanh) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float tanh(const float& x) { return ::tanhf(x); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double tanh(const double& x) { return ::tanh(x); } #endif template <typename T> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE T fmod(const T& a, const T& b) { … } #if defined(SYCL_DEVICE_ONLY) SYCL_SPECIALIZE_FLOATING_TYPES_BINARY(fmod, fmod) #endif #if defined(EIGEN_GPUCC) template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE float fmod(const float& a, const float& b) { return ::fmodf(a, b); } template <> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE double fmod(const double& a, const double& b) { return ::fmod(a, b); } #endif #if defined(SYCL_DEVICE_ONLY) #undef SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_BINARY #undef SYCL_SPECIALIZE_SIGNED_INTEGER_TYPES_UNARY #undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_BINARY #undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY #undef SYCL_SPECIALIZE_INTEGER_TYPES_BINARY #undef SYCL_SPECIALIZE_UNSIGNED_INTEGER_TYPES_UNARY #undef SYCL_SPECIALIZE_FLOATING_TYPES_BINARY #undef SYCL_SPECIALIZE_FLOATING_TYPES_UNARY #undef SYCL_SPECIALIZE_FLOATING_TYPES_UNARY_FUNC_RET_TYPE #undef SYCL_SPECIALIZE_GEN_UNARY_FUNC #undef SYCL_SPECIALIZE_UNARY_FUNC #undef SYCL_SPECIALIZE_GEN1_BINARY_FUNC #undef SYCL_SPECIALIZE_GEN2_BINARY_FUNC #undef SYCL_SPECIALIZE_BINARY_FUNC #endif template <typename Scalar, typename Enable = std::enable_if_t<std::is_integral<Scalar>::value>> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar logical_shift_left(const Scalar& a, int n) { … } template <typename Scalar, typename Enable = std::enable_if_t<std::is_integral<Scalar>::value>> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar logical_shift_right(const Scalar& a, int n) { … } template <typename Scalar, typename Enable = std::enable_if_t<std::is_integral<Scalar>::value>> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar arithmetic_shift_right(const Scalar& a, int n) { … } } // end namespace numext namespace internal { template <typename T> EIGEN_DEVICE_FUNC bool isfinite_impl(const std::complex<T>& x) { … } template <typename T> EIGEN_DEVICE_FUNC bool isnan_impl(const std::complex<T>& x) { … } template <typename T> EIGEN_DEVICE_FUNC bool isinf_impl(const std::complex<T>& x) { … } /**************************************************************************** * Implementation of fuzzy comparisons * ****************************************************************************/ template <typename Scalar, bool IsComplex, bool IsInteger> struct scalar_fuzzy_default_impl { … }; scalar_fuzzy_default_impl<Scalar, false, false>; scalar_fuzzy_default_impl<Scalar, false, true>; scalar_fuzzy_default_impl<Scalar, true, false>; template <typename Scalar> struct scalar_fuzzy_impl : scalar_fuzzy_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> { … }; template <typename Scalar, typename OtherScalar> EIGEN_DEVICE_FUNC inline bool isMuchSmallerThan( const Scalar& x, const OtherScalar& y, const typename NumTraits<Scalar>::Real& precision = NumTraits<Scalar>::dummy_precision()) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline bool isApprox( const Scalar& x, const Scalar& y, const typename NumTraits<Scalar>::Real& precision = NumTraits<Scalar>::dummy_precision()) { … } template <typename Scalar> EIGEN_DEVICE_FUNC inline bool isApproxOrLessThan( const Scalar& x, const Scalar& y, const typename NumTraits<Scalar>::Real& precision = NumTraits<Scalar>::dummy_precision()) { … } /****************************************** *** The special case of the bool type *** ******************************************/ template <> struct scalar_fuzzy_impl<bool> { … }; } // end namespace internal // Default implementations that rely on other numext implementations namespace internal { // Specialization for complex types that are not supported by std::expm1. expm1_impl<std::complex<RealScalar>>; template <typename T> struct rsqrt_impl { … }; #if defined(EIGEN_GPU_COMPILE_PHASE) template <typename T> struct conj_impl<std::complex<T>, true> { EIGEN_DEVICE_FUNC static inline std::complex<T> run(const std::complex<T>& x) { return std::complex<T>(numext::real(x), -numext::imag(x)); } }; #endif } // end namespace internal } // end namespace Eigen #endif // EIGEN_MATHFUNCTIONS_H
Codebase Browser
chromium