// This file is part of Eigen, a lightweight C++ template library // for linear algebra. // // Copyright (C) 2008 Gael Guennebaud <[email protected]> // Copyright (C) 2006-2008 Benoit Jacob <[email protected]> // // 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_GENERIC_PACKET_MATH_H #define EIGEN_GENERIC_PACKET_MATH_H // IWYU pragma: private #include "./InternalHeaderCheck.h" namespace Eigen { namespace internal { /** \internal * \file GenericPacketMath.h * * Default implementation for types not supported by the vectorization. * In practice these functions are provided to make easier the writing * of generic vectorized code. */ #ifndef EIGEN_DEBUG_ALIGNED_LOAD #define EIGEN_DEBUG_ALIGNED_LOAD #endif #ifndef EIGEN_DEBUG_UNALIGNED_LOAD #define EIGEN_DEBUG_UNALIGNED_LOAD #endif #ifndef EIGEN_DEBUG_ALIGNED_STORE #define EIGEN_DEBUG_ALIGNED_STORE #endif #ifndef EIGEN_DEBUG_UNALIGNED_STORE #define EIGEN_DEBUG_UNALIGNED_STORE #endif struct default_packet_traits { … }; template <typename T> struct packet_traits : default_packet_traits { … }; packet_traits<const T>; template <typename T> struct unpacket_traits { … }; unpacket_traits<const T>; /** \internal A convenience utility for determining if the type is a scalar. * This is used to enable some generic packet implementations. */ template <typename Packet> struct is_scalar { … }; // automatically and succinctly define combinations of pcast<SrcPacket,TgtPacket> when // 1) the packets are the same type, or // 2) the packets differ only in sign. // In both of these cases, preinterpret (bit_cast) is equivalent to pcast (static_cast) template <typename SrcPacket, typename TgtPacket, bool Scalar = is_scalar<SrcPacket>::value && is_scalar<TgtPacket>::value> struct is_degenerate_helper : is_same<SrcPacket, TgtPacket> { … }; template <> struct is_degenerate_helper<int8_t, uint8_t, true> : std::true_type { … }; template <> struct is_degenerate_helper<int16_t, uint16_t, true> : std::true_type { … }; template <> struct is_degenerate_helper<int32_t, uint32_t, true> : std::true_type { … }; template <> struct is_degenerate_helper<int64_t, uint64_t, true> : std::true_type { … }; is_degenerate_helper<SrcPacket, TgtPacket, false>; // is_degenerate<T1,T2>::value == is_degenerate<T2,T1>::value template <typename SrcPacket, typename TgtPacket> struct is_degenerate { … }; template <typename Packet> struct is_half { … }; template <typename Src, typename Tgt> struct type_casting_traits { … }; // provides a succint template to define vectorized casting traits with respect to the largest accessible packet types template <typename Src, typename Tgt> struct vectorized_type_casting_traits { … }; /** \internal Wrapper to ensure that multiple packet types can map to the same same underlying vector type. */ template <typename T, int unique_id = 0> struct eigen_packet_wrapper { … }; template <typename Target, typename Packet, bool IsSame = is_same<Target, Packet>::value> struct preinterpret_generic; preinterpret_generic<Target, Packet, false>; preinterpret_generic<Packet, Packet, true>; /** \internal \returns reinterpret_cast<Target>(a) */ template <typename Target, typename Packet> EIGEN_DEVICE_FUNC inline Target preinterpret(const Packet& a) { … } template <typename SrcPacket, typename TgtPacket, bool Degenerate = is_degenerate<SrcPacket, TgtPacket>::value, bool TgtIsHalf = is_half<TgtPacket>::value> struct pcast_generic; pcast_generic<SrcPacket, TgtPacket, false, false>; pcast_generic<Packet, Packet, true, false>; pcast_generic<SrcPacket, TgtPacket, true, TgtIsHalf>; /** \internal \returns static_cast<TgtType>(a) (coeff-wise) */ template <typename SrcPacket, typename TgtPacket> EIGEN_DEVICE_FUNC inline TgtPacket pcast(const SrcPacket& a) { … } template <typename SrcPacket, typename TgtPacket> EIGEN_DEVICE_FUNC inline TgtPacket pcast(const SrcPacket& a, const SrcPacket& b) { … } template <typename SrcPacket, typename TgtPacket> EIGEN_DEVICE_FUNC inline TgtPacket pcast(const SrcPacket& a, const SrcPacket& b, const SrcPacket& c, const SrcPacket& d) { … } template <typename SrcPacket, typename TgtPacket> EIGEN_DEVICE_FUNC inline TgtPacket pcast(const SrcPacket& a, const SrcPacket& b, const SrcPacket& c, const SrcPacket& d, const SrcPacket& e, const SrcPacket& f, const SrcPacket& g, const SrcPacket& h) { … } pcast_generic<SrcPacket, TgtPacket, false, true>; /** \internal \returns a + b (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet padd(const Packet& a, const Packet& b) { … } // Avoid compiler warning for boolean algebra. template <> EIGEN_DEVICE_FUNC inline bool padd(const bool& a, const bool& b) { … } /** \internal \returns a packet version of \a *from, (un-aligned masked add) * There is no generic implementation. We only have implementations for specialized * cases. Generic case should not be called. */ template <typename Packet> EIGEN_DEVICE_FUNC inline std::enable_if_t<unpacket_traits<Packet>::masked_fpops_available, Packet> padd( const Packet& a, const Packet& b, typename unpacket_traits<Packet>::mask_t umask); /** \internal \returns a - b (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet psub(const Packet& a, const Packet& b) { … } /** \internal \returns -a (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pnegate(const Packet& a) { … } /** \internal \returns conj(a) (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pconj(const Packet& a) { … } /** \internal \returns a * b (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pmul(const Packet& a, const Packet& b) { … } // Avoid compiler warning for boolean algebra. template <> EIGEN_DEVICE_FUNC inline bool pmul(const bool& a, const bool& b) { … } /** \internal \returns a / b (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pdiv(const Packet& a, const Packet& b) { … } // In the generic case, memset to all one bits. template <typename Packet, typename EnableIf = void> struct ptrue_impl { … }; // For booleans, we can only directly set a valid `bool` value to avoid UB. template <> struct ptrue_impl<bool, void> { … }; // For non-trivial scalars, set to Scalar(1) (i.e. a non-zero value). // Although this is technically not a valid bitmask, the scalar path for pselect // uses a comparison to zero, so this should still work in most cases. We don't // have another option, since the scalar type requires initialization. ptrue_impl<T, std::enable_if_t<is_scalar<T>::value && NumTraits<T>::RequireInitialization>>; /** \internal \returns one bits. */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet ptrue(const Packet& a) { … } // In the general case, memset to zero. template <typename Packet, typename EnableIf = void> struct pzero_impl { … }; // For scalars, explicitly set to Scalar(0), since the underlying representation // for zero may not consist of all-zero bits. pzero_impl<T, std::enable_if_t<is_scalar<T>::value>>; /** \internal \returns packet of zeros */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pzero(const Packet& a) { … } /** \internal \returns a <= b as a bit mask */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pcmp_le(const Packet& a, const Packet& b) { … } /** \internal \returns a < b as a bit mask */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pcmp_lt(const Packet& a, const Packet& b) { … } /** \internal \returns a == b as a bit mask */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pcmp_eq(const Packet& a, const Packet& b) { … } /** \internal \returns a < b or a==NaN or b==NaN as a bit mask */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pcmp_lt_or_nan(const Packet& a, const Packet& b) { … } template <typename T> struct bit_and { … }; template <typename T> struct bit_or { … }; template <typename T> struct bit_xor { … }; template <typename T> struct bit_not { … }; template <> struct bit_and<bool> { … }; template <> struct bit_or<bool> { … }; template <> struct bit_xor<bool> { … }; template <> struct bit_not<bool> { … }; // Use operators &, |, ^, ~. template <typename T> struct operator_bitwise_helper { … }; // Apply binary operations byte-by-byte template <typename T> struct bytewise_bitwise_helper { … }; // In the general case, use byte-by-byte manipulation. template <typename T, typename EnableIf = void> struct bitwise_helper : public bytewise_bitwise_helper<T> { … }; // For integers or non-trivial scalars, use binary operators. bitwise_helper<T, typename std::enable_if_t<is_scalar<T>::value && (NumTraits<T>::IsInteger || NumTraits<T>::RequireInitialization)>>; /** \internal \returns the bitwise and of \a a and \a b */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pand(const Packet& a, const Packet& b) { … } /** \internal \returns the bitwise or of \a a and \a b */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet por(const Packet& a, const Packet& b) { … } /** \internal \returns the bitwise xor of \a a and \a b */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pxor(const Packet& a, const Packet& b) { … } /** \internal \returns the bitwise not of \a a */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pnot(const Packet& a) { … } /** \internal \returns the bitwise and of \a a and not \a b */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pandnot(const Packet& a, const Packet& b) { … } // In the general case, use bitwise select. template <typename Packet, typename EnableIf = void> struct pselect_impl { … }; // For scalars, use ternary select. pselect_impl<Packet, std::enable_if_t<is_scalar<Packet>::value>>; /** \internal \returns \a or \b for each field in packet according to \mask */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pselect(const Packet& mask, const Packet& a, const Packet& b) { … } template <> EIGEN_DEVICE_FUNC inline bool pselect<bool>(const bool& cond, const bool& a, const bool& b) { … } /** \internal \returns the min or of \a a and \a b (coeff-wise) If either \a a or \a b are NaN, the result is implementation defined. */ template <int NaNPropagation> struct pminmax_impl { … }; /** \internal \returns the min or max of \a a and \a b (coeff-wise) If either \a a or \a b are NaN, NaN is returned. */ template <> struct pminmax_impl<PropagateNaN> { … }; /** \internal \returns the min or max of \a a and \a b (coeff-wise) If both \a a and \a b are NaN, NaN is returned. Equivalent to std::fmin(a, b). */ template <> struct pminmax_impl<PropagateNumbers> { … }; #define EIGEN_BINARY_OP_NAN_PROPAGATION … /** \internal \returns the min of \a a and \a b (coeff-wise). If \a a or \b b is NaN, the return value is implementation defined. */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pmin(const Packet& a, const Packet& b) { … } /** \internal \returns the min of \a a and \a b (coeff-wise). NaNPropagation determines the NaN propagation semantics. */ template <int NaNPropagation, typename Packet> EIGEN_DEVICE_FUNC inline Packet pmin(const Packet& a, const Packet& b) { … } /** \internal \returns the max of \a a and \a b (coeff-wise) If \a a or \b b is NaN, the return value is implementation defined. */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pmax(const Packet& a, const Packet& b) { … } /** \internal \returns the max of \a a and \a b (coeff-wise). NaNPropagation determines the NaN propagation semantics. */ template <int NaNPropagation, typename Packet> EIGEN_DEVICE_FUNC inline Packet pmax(const Packet& a, const Packet& b) { … } /** \internal \returns the absolute value of \a a */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pabs(const Packet& a) { … } template <> EIGEN_DEVICE_FUNC inline unsigned int pabs(const unsigned int& a) { … } template <> EIGEN_DEVICE_FUNC inline unsigned long pabs(const unsigned long& a) { … } template <> EIGEN_DEVICE_FUNC inline unsigned long long pabs(const unsigned long long& a) { … } /** \internal \returns the addsub value of \a a,b */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet paddsub(const Packet& a, const Packet& b) { … } /** \internal \returns the phase angle of \a a */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet parg(const Packet& a) { … } /** \internal \returns \a a arithmetically shifted by N bits to the right */ template <int N, typename T> EIGEN_DEVICE_FUNC inline T parithmetic_shift_right(const T& a) { … } /** \internal \returns \a a logically shifted by N bits to the right */ template <int N, typename T> EIGEN_DEVICE_FUNC inline T plogical_shift_right(const T& a) { … } /** \internal \returns \a a shifted by N bits to the left */ template <int N, typename T> EIGEN_DEVICE_FUNC inline T plogical_shift_left(const T& a) { … } /** \internal \returns the significant and exponent of the underlying floating point numbers * See https://en.cppreference.com/w/cpp/numeric/math/frexp */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pfrexp(const Packet& a, Packet& exponent) { … } /** \internal \returns a * 2^((int)exponent) * See https://en.cppreference.com/w/cpp/numeric/math/ldexp */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pldexp(const Packet& a, const Packet& exponent) { … } /** \internal \returns the min of \a a and \a b (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pabsdiff(const Packet& a, const Packet& b) { … } /** \internal \returns a packet version of \a *from, from must be properly aligned */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pload(const typename unpacket_traits<Packet>::type* from) { … } /** \internal \returns n elements of a packet version of \a *from, from must be properly aligned * offset indicates the starting element in which to load and * offset + n <= unpacket_traits::size * All elements before offset and after the last element loaded will initialized with zero */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pload_partial(const typename unpacket_traits<Packet>::type* from, const Index n, const Index offset = 0) { … } /** \internal \returns a packet version of \a *from, (un-aligned load) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet ploadu(const typename unpacket_traits<Packet>::type* from) { … } /** \internal \returns n elements of a packet version of \a *from, (un-aligned load) * All elements after the last element loaded will initialized with zero */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet ploadu_partial(const typename unpacket_traits<Packet>::type* from, const Index n, const Index offset = 0) { … } /** \internal \returns a packet version of \a *from, (un-aligned masked load) * There is no generic implementation. We only have implementations for specialized * cases. Generic case should not be called. */ template <typename Packet> EIGEN_DEVICE_FUNC inline std::enable_if_t<unpacket_traits<Packet>::masked_load_available, Packet> ploadu( const typename unpacket_traits<Packet>::type* from, typename unpacket_traits<Packet>::mask_t umask); /** \internal \returns a packet with constant coefficients \a a, e.g.: (a,a,a,a) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pset1(const typename unpacket_traits<Packet>::type& a) { … } /** \internal \returns a packet with constant coefficients set from bits */ template <typename Packet, typename BitsType> EIGEN_DEVICE_FUNC inline Packet pset1frombits(BitsType a); /** \internal \returns a packet with constant coefficients \a a[0], e.g.: (a[0],a[0],a[0],a[0]) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pload1(const typename unpacket_traits<Packet>::type* a) { … } /** \internal \returns a packet with elements of \a *from duplicated. * For instance, for a packet of 8 elements, 4 scalars will be read from \a *from and * duplicated to form: {from[0],from[0],from[1],from[1],from[2],from[2],from[3],from[3]} * Currently, this function is only used for scalar * complex products. */ template <typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet ploaddup(const typename unpacket_traits<Packet>::type* from) { … } /** \internal \returns a packet with elements of \a *from quadrupled. * For instance, for a packet of 8 elements, 2 scalars will be read from \a *from and * replicated to form: {from[0],from[0],from[0],from[0],from[1],from[1],from[1],from[1]} * Currently, this function is only used in matrix products. * For packet-size smaller or equal to 4, this function is equivalent to pload1 */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet ploadquad(const typename unpacket_traits<Packet>::type* from) { … } /** \internal equivalent to * \code * a0 = pload1(a+0); * a1 = pload1(a+1); * a2 = pload1(a+2); * a3 = pload1(a+3); * \endcode * \sa pset1, pload1, ploaddup, pbroadcast2 */ template <typename Packet> EIGEN_DEVICE_FUNC inline void pbroadcast4(const typename unpacket_traits<Packet>::type* a, Packet& a0, Packet& a1, Packet& a2, Packet& a3) { … } /** \internal equivalent to * \code * a0 = pload1(a+0); * a1 = pload1(a+1); * \endcode * \sa pset1, pload1, ploaddup, pbroadcast4 */ template <typename Packet> EIGEN_DEVICE_FUNC inline void pbroadcast2(const typename unpacket_traits<Packet>::type* a, Packet& a0, Packet& a1) { … } /** \internal \brief Returns a packet with coefficients (a,a+1,...,a+packet_size-1). */ template <typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet plset(const typename unpacket_traits<Packet>::type& a) { … } /** \internal \returns a packet with constant coefficients \a a, e.g.: (x, 0, x, 0), where x is the value of all 1-bits. */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet peven_mask(const Packet& /*a*/) { … } /** \internal copy the packet \a from to \a *to, \a to must be properly aligned */ template <typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pstore(Scalar* to, const Packet& from) { … } /** \internal copy n elements of the packet \a from to \a *to, \a to must be properly aligned * offset indicates the starting element in which to store and * offset + n <= unpacket_traits::size */ template <typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pstore_partial(Scalar* to, const Packet& from, const Index n, const Index offset = 0) { … } /** \internal copy the packet \a from to \a *to, (un-aligned store) */ template <typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pstoreu(Scalar* to, const Packet& from) { … } /** \internal copy n elements of the packet \a from to \a *to, (un-aligned store) */ template <typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pstoreu_partial(Scalar* to, const Packet& from, const Index n, const Index offset = 0) { … } /** \internal copy the packet \a from to \a *to, (un-aligned store with a mask) * There is no generic implementation. We only have implementations for specialized * cases. Generic case should not be called. */ template <typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline std::enable_if_t<unpacket_traits<Packet>::masked_store_available, void> pstoreu( Scalar* to, const Packet& from, typename unpacket_traits<Packet>::mask_t umask); template <typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline Packet pgather(const Scalar* from, Index /*stride*/) { … } template <typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline Packet pgather_partial(const Scalar* from, Index stride, const Index n) { … } template <typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pscatter(Scalar* to, const Packet& from, Index /*stride*/) { … } template <typename Scalar, typename Packet> EIGEN_DEVICE_FUNC inline void pscatter_partial(Scalar* to, const Packet& from, Index stride, const Index n) { … } /** \internal tries to do cache prefetching of \a addr */ template <typename Scalar> EIGEN_DEVICE_FUNC inline void prefetch(const Scalar* addr) { … } /** \internal \returns the reversed elements of \a a*/ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet preverse(const Packet& a) { … } /** \internal \returns \a a with real and imaginary part flipped (for complex type only) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pcplxflip(const Packet& a) { … } /************************** * Special math functions ***************************/ /** \internal \returns isnan(a) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pisnan(const Packet& a) { … } /** \internal \returns isinf(a) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pisinf(const Packet& a) { … } /** \internal \returns the sine of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psin(const Packet& a) { … } /** \internal \returns the cosine of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pcos(const Packet& a) { … } /** \internal \returns the tan of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet ptan(const Packet& a) { … } /** \internal \returns the arc sine of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pasin(const Packet& a) { … } /** \internal \returns the arc cosine of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pacos(const Packet& a) { … } /** \internal \returns the hyperbolic sine of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psinh(const Packet& a) { … } /** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pcosh(const Packet& a) { … } /** \internal \returns the arc tangent of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet patan(const Packet& a) { … } /** \internal \returns the hyperbolic tan of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet ptanh(const Packet& a) { … } /** \internal \returns the arc tangent of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet patanh(const Packet& a) { … } /** \internal \returns the exp of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pexp(const Packet& a) { … } /** \internal \returns the expm1 of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pexpm1(const Packet& a) { … } /** \internal \returns the log of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog(const Packet& a) { … } /** \internal \returns the log1p of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog1p(const Packet& a) { … } /** \internal \returns the log10 of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog10(const Packet& a) { … } /** \internal \returns the log10 of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog2(const Packet& a) { … } /** \internal \returns the square-root of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psqrt(const Packet& a) { … } /** \internal \returns the cube-root of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pcbrt(const Packet& a) { … } template <typename Packet, bool IsScalar = is_scalar<Packet>::value, bool IsInteger = NumTraits<typename unpacket_traits<Packet>::type>::IsInteger> struct nearest_integer_packetop_impl { … }; /** \internal \returns the rounded value of \a a (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pround(const Packet& a) { … } /** \internal \returns the floor of \a a (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pfloor(const Packet& a) { … } /** \internal \returns the rounded value of \a a (coeff-wise) with current * rounding mode */ template <typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet print(const Packet& a) { … } /** \internal \returns the ceil of \a a (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pceil(const Packet& a) { … } /** \internal \returns the truncation of \a a (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet ptrunc(const Packet& a) { … } template <typename Packet, typename EnableIf = void> struct psign_impl { … }; /** \internal \returns the sign of \a a (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet psign(const Packet& a) { … } template <> EIGEN_DEVICE_FUNC inline bool psign(const bool& a) { … } /** \internal \returns the first element of a packet */ template <typename Packet> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type pfirst(const Packet& a) { … } /** \internal \returns the sum of the elements of upper and lower half of \a a if \a a is larger than 4. * For a packet {a0, a1, a2, a3, a4, a5, a6, a7}, it returns a half packet {a0+a4, a1+a5, a2+a6, a3+a7} * For packet-size smaller or equal to 4, this boils down to a noop. */ template <typename Packet> EIGEN_DEVICE_FUNC inline std::conditional_t<(unpacket_traits<Packet>::size % 8) == 0, typename unpacket_traits<Packet>::half, Packet> predux_half_dowto4(const Packet& a) { … } // Slow generic implementation of Packet reduction. template <typename Packet, typename Op> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_helper(const Packet& a, Op op) { … } /** \internal \returns the sum of the elements of \a a*/ template <typename Packet> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux(const Packet& a) { … } /** \internal \returns the product of the elements of \a a */ template <typename Packet> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_mul(const Packet& a) { … } /** \internal \returns the min of the elements of \a a */ template <typename Packet> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_min(const Packet& a) { … } template <int NaNPropagation, typename Packet> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_min(const Packet& a) { … } /** \internal \returns the min of the elements of \a a */ template <typename Packet> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_max(const Packet& a) { … } template <int NaNPropagation, typename Packet> EIGEN_DEVICE_FUNC inline typename unpacket_traits<Packet>::type predux_max(const Packet& a) { … } #undef EIGEN_BINARY_OP_NAN_PROPAGATION /** \internal \returns true if all coeffs of \a a means "true" * It is supposed to be called on values returned by pcmp_*. */ // not needed yet // template<typename Packet> EIGEN_DEVICE_FUNC inline bool predux_all(const Packet& a) // { return bool(a); } /** \internal \returns true if any coeffs of \a a means "true" * It is supposed to be called on values returned by pcmp_*. */ template <typename Packet> EIGEN_DEVICE_FUNC inline bool predux_any(const Packet& a) { … } /*************************************************************************** * The following functions might not have to be overwritten for vectorized types ***************************************************************************/ // FMA instructions. /** \internal \returns a * b + c (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pmadd(const Packet& a, const Packet& b, const Packet& c) { … } /** \internal \returns a * b - c (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pmsub(const Packet& a, const Packet& b, const Packet& c) { … } /** \internal \returns -(a * b) + c (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pnmadd(const Packet& a, const Packet& b, const Packet& c) { … } /** \internal \returns -((a * b + c) (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pnmsub(const Packet& a, const Packet& b, const Packet& c) { … } /** \internal copy a packet with constant coefficient \a a (e.g., [a,a,a,a]) to \a *to. \a to must be 16 bytes aligned */ // NOTE: this function must really be templated on the packet type (think about different packet types for the same // scalar type) template <typename Packet> inline void pstore1(typename unpacket_traits<Packet>::type* to, const typename unpacket_traits<Packet>::type& a) { … } /** \internal \returns a packet version of \a *from. * The pointer \a from must be aligned on a \a Alignment bytes boundary. */ template <typename Packet, int Alignment> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt(const typename unpacket_traits<Packet>::type* from) { … } /** \internal \returns n elements of a packet version of \a *from. * The pointer \a from must be aligned on a \a Alignment bytes boundary. */ template <typename Packet, int Alignment> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt_partial(const typename unpacket_traits<Packet>::type* from, const Index n, const Index offset = 0) { … } /** \internal copy the packet \a from to \a *to. * The pointer \a from must be aligned on a \a Alignment bytes boundary. */ template <typename Scalar, typename Packet, int Alignment> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret(Scalar* to, const Packet& from) { … } /** \internal copy n elements of the packet \a from to \a *to. * The pointer \a from must be aligned on a \a Alignment bytes boundary. */ template <typename Scalar, typename Packet, int Alignment> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE void pstoret_partial(Scalar* to, const Packet& from, const Index n, const Index offset = 0) { … } /** \internal \returns a packet version of \a *from. * Unlike ploadt, ploadt_ro takes advantage of the read-only memory path on the * hardware if available to speedup the loading of data that won't be modified * by the current computation. */ template <typename Packet, int LoadMode> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet ploadt_ro(const typename unpacket_traits<Packet>::type* from) { … } /*************************************************************************** * Fast complex products (GCC generates a function call which is very slow) ***************************************************************************/ // Eigen+CUDA does not support complexes. #if !defined(EIGEN_GPUCC) template <> inline std::complex<float> pmul(const std::complex<float>& a, const std::complex<float>& b) { … } template <> inline std::complex<double> pmul(const std::complex<double>& a, const std::complex<double>& b) { … } #endif /*************************************************************************** * PacketBlock, that is a collection of N packets where the number of words * in the packet is a multiple of N. ***************************************************************************/ template <typename Packet, int N = unpacket_traits<Packet>::size> struct PacketBlock { … }; template <typename Packet> EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet, 1>& /*kernel*/) { … } /*************************************************************************** * Selector, i.e. vector of N boolean values used to select (i.e. blend) * words from 2 packets. ***************************************************************************/ template <size_t N> struct Selector { … }; template <typename Packet> EIGEN_DEVICE_FUNC inline Packet pblend(const Selector<unpacket_traits<Packet>::size>& ifPacket, const Packet& thenPacket, const Packet& elsePacket) { … } /** \internal \returns 1 / a (coeff-wise) */ template <typename Packet> EIGEN_DEVICE_FUNC inline Packet preciprocal(const Packet& a) { … } /** \internal \returns the reciprocal square-root of \a a (coeff-wise) */ template <typename Packet> EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet prsqrt(const Packet& a) { … } template <typename Packet, bool IsScalar = is_scalar<Packet>::value, bool IsInteger = NumTraits<typename unpacket_traits<Packet>::type>::IsInteger> struct psignbit_impl; psignbit_impl<Packet, true, IsInteger>; psignbit_impl<Packet, false, false>; psignbit_impl<Packet, false, true>; /** \internal \returns the sign bit of \a a as a bitmask*/ template <typename Packet> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE constexpr Packet psignbit(const Packet& a) { … } /** \internal \returns the 2-argument arc tangent of \a y and \a x (coeff-wise) */ template <typename Packet, std::enable_if_t<is_scalar<Packet>::value, int> = 0> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet patan2(const Packet& y, const Packet& x) { … } /** \internal \returns the 2-argument arc tangent of \a y and \a x (coeff-wise) */ template <typename Packet, std::enable_if_t<!is_scalar<Packet>::value, int> = 0> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet patan2(const Packet& y, const Packet& x) { … } /** \internal \returns the argument of \a a as a complex number */ template <typename Packet, std::enable_if_t<is_scalar<Packet>::value, int> = 0> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet pcarg(const Packet& a) { … } /** \internal \returns the argument of \a a as a complex number */ template <typename Packet, std::enable_if_t<!is_scalar<Packet>::value, int> = 0> EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE Packet pcarg(const Packet& a) { … } } // end namespace internal } // end namespace Eigen #endif // EIGEN_GENERIC_PACKET_MATH_H
Codebase Browser
chromium