Update Eigen to commit:59b3ef5409452095e27e8d39a2ca81139bb8c971 CHANGELOG ========= 59b3ef540 - Partially Vectorize Cast PiperOrigin-RevId: 540082410 Change-Id: Ib8f4234c6a8c0df9b35fd4887272c187de9155b9
diff --git a/Eigen/Core b/Eigen/Core index 1a9b470..1e7e38c 100644 --- a/Eigen/Core +++ b/Eigen/Core
@@ -186,7 +186,6 @@ // Generic half float support #include "src/Core/arch/Default/Half.h" #include "src/Core/arch/Default/BFloat16.h" -#include "src/Core/arch/Default/TypeCasting.h" #include "src/Core/arch/Default/GenericPacketMathFunctionsFwd.h" #if defined EIGEN_VECTORIZE_AVX512
diff --git a/Eigen/src/Core/CoreEvaluators.h b/Eigen/src/Core/CoreEvaluators.h index e233efb..32371c5 100644 --- a/Eigen/src/Core/CoreEvaluators.h +++ b/Eigen/src/Core/CoreEvaluators.h
@@ -621,6 +621,207 @@ Data m_d; }; +// ----------------------- Casting --------------------- + +template <typename SrcType, typename DstType, typename ArgType> +struct unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, IndexBased> { + using CastOp = core_cast_op<SrcType, DstType>; + using XprType = CwiseUnaryOp<CastOp, ArgType>; + + // Use the largest packet type by default + using SrcPacketType = typename packet_traits<SrcType>::type; + static constexpr int SrcPacketSize = unpacket_traits<SrcPacketType>::size; + static constexpr int SrcPacketBytes = SrcPacketSize * sizeof(SrcType); + + enum { + CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<CastOp>::Cost), + PacketAccess = functor_traits<CastOp>::PacketAccess, + ActualPacketAccessBit = PacketAccess ? PacketAccessBit : 0, + Flags = evaluator<ArgType>::Flags & (HereditaryBits | LinearAccessBit | ActualPacketAccessBit), + IsRowMajor = (evaluator<ArgType>::Flags & RowMajorBit), + Alignment = evaluator<ArgType>::Alignment + }; + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& xpr) + : m_argImpl(xpr.nestedExpression()), m_rows(xpr.rows()), m_cols(xpr.cols()) { + EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<CastOp>::Cost); + EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); + } + + template <typename DstPacketType> + using AltSrcScalarOp = std::enable_if_t<(unpacket_traits<DstPacketType>::size < SrcPacketSize && !find_packet_by_size<SrcType, unpacket_traits<DstPacketType>::size>::value), bool>; + template <typename DstPacketType> + using SrcPacketArgs1 = std::enable_if_t<(find_packet_by_size<SrcType, unpacket_traits<DstPacketType>::size>::value), bool>; + template <typename DstPacketType> + using SrcPacketArgs2 = std::enable_if_t<(unpacket_traits<DstPacketType>::size) == (2 * SrcPacketSize), bool>; + template <typename DstPacketType> + using SrcPacketArgs4 = std::enable_if_t<(unpacket_traits<DstPacketType>::size) == (4 * SrcPacketSize), bool>; + template <typename DstPacketType> + using SrcPacketArgs8 = std::enable_if_t<(unpacket_traits<DstPacketType>::size) == (8 * SrcPacketSize), bool>; + + template <bool UseRowMajor = IsRowMajor, std::enable_if_t<UseRowMajor, bool> = true> + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool check_array_bounds(Index, Index col, Index packetSize) const { + return col + packetSize <= cols(); + } + template <bool UseRowMajor = IsRowMajor, std::enable_if_t<!UseRowMajor, bool> = true> + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool check_array_bounds(Index row, Index, Index packetSize) const { + return row + packetSize <= rows(); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool check_array_bounds(Index index, Index packetSize) const { + return index + packetSize <= size(); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE SrcType srcCoeff(Index row, Index col, Index offset) const { + Index actualRow = IsRowMajor ? row : row + offset; + Index actualCol = IsRowMajor ? col + offset : col; + return m_argImpl.coeff(actualRow, actualCol); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE SrcType srcCoeff(Index index, Index offset) const { + Index actualIndex = index + offset; + return m_argImpl.coeff(actualIndex); + } + + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DstType coeff(Index row, Index col) const { + return cast<SrcType, DstType>(srcCoeff(row, col, 0)); + } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DstType coeff(Index index) const { return cast<SrcType, DstType>(srcCoeff(index, 0)); } + + template <int LoadMode, typename PacketType = SrcPacketType> + EIGEN_STRONG_INLINE PacketType srcPacket(Index row, Index col, Index offset) const { + constexpr int PacketSize = unpacket_traits<PacketType>::size; + Index actualRow = IsRowMajor ? row : row + (offset * PacketSize); + Index actualCol = IsRowMajor ? col + (offset * PacketSize) : col; + eigen_assert(check_array_bounds(actualRow, actualCol, PacketSize) && "Array index out of bounds"); + return m_argImpl.template packet<LoadMode, PacketType>(actualRow, actualCol); + } + template <int LoadMode, typename PacketType = SrcPacketType> + EIGEN_STRONG_INLINE PacketType srcPacket(Index index, Index offset) const { + constexpr int PacketSize = unpacket_traits<PacketType>::size; + Index actualIndex = index + (offset * PacketSize); + eigen_assert(check_array_bounds(actualIndex, PacketSize) && "Array index out of bounds"); + return m_argImpl.template packet<LoadMode, PacketType>(actualIndex); + } + + // There is no source packet type with equal or fewer elements than DstPacketType. + // This is problematic as the evaluation loop may attempt to access data outside the bounds of the array. + // For example, consider the cast utilizing pcast<Packet4f,Packet2d> with an array of size 4: {0.0f,1.0f,2.0f,3.0f}. + // The first iteration of the evaulation loop will load 16 bytes: {0.0f,1.0f,2.0f,3.0f} and cast to {0.0,1.0}, which is acceptable. + // The second iteration will load 16 bytes: {2.0f,3.0f,?,?}, which is outside the bounds of the array. + + // Instead, perform runtime check to determine if the load would access data outside the bounds of the array. + // If not, perform full load. Otherwise, revert to a scalar loop to perform a partial load. + // In either case, perform a vectorized cast of the source packet. + template <int LoadMode, typename DstPacketType, AltSrcScalarOp<DstPacketType> = true> + EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const { + constexpr int DstPacketSize = unpacket_traits<DstPacketType>::size; + constexpr int SrcBytesIncrement = DstPacketSize * sizeof(SrcType); + constexpr int SrcLoadMode = plain_enum_min(SrcBytesIncrement, LoadMode); + SrcPacketType src; + if (EIGEN_PREDICT_TRUE(check_array_bounds(row, col, SrcPacketSize))) { + src = srcPacket<SrcLoadMode>(row, col, 0); + } else { + Array<SrcType, SrcPacketSize, 1> srcArray; + for (size_t k = 0; k < DstPacketSize; k++) srcArray[k] = srcCoeff(row, col, k); + for (size_t k = DstPacketSize; k < SrcPacketSize; k++) srcArray[k] = SrcType(0); + src = pload<SrcPacketType>(srcArray.data()); + } + return pcast<SrcPacketType, DstPacketType>(src); + } + // Use the source packet type with the same size as DstPacketType, if it exists + template <int LoadMode, typename DstPacketType, SrcPacketArgs1<DstPacketType> = true> + EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const { + constexpr int DstPacketSize = unpacket_traits<DstPacketType>::size; + using SizedSrcPacketType = typename find_packet_by_size<SrcType, DstPacketSize>::type; + constexpr int SrcBytesIncrement = DstPacketSize * sizeof(SrcType); + constexpr int SrcLoadMode = plain_enum_min(SrcBytesIncrement, LoadMode); + return pcast<SizedSrcPacketType, DstPacketType>( + srcPacket<SrcLoadMode, SizedSrcPacketType>(row, col, 0)); + } + // unpacket_traits<DstPacketType>::size == 2 * SrcPacketSize + template <int LoadMode, typename DstPacketType, SrcPacketArgs2<DstPacketType> = true> + EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const { + constexpr int SrcLoadMode = plain_enum_min(SrcPacketBytes, LoadMode); + return pcast<SrcPacketType, DstPacketType>( + srcPacket<SrcLoadMode>(row, col, 0), srcPacket<SrcLoadMode>(row, col, 1)); + } + // unpacket_traits<DstPacketType>::size == 4 * SrcPacketSize + template <int LoadMode, typename DstPacketType, SrcPacketArgs4<DstPacketType> = true> + EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const { + constexpr int SrcLoadMode = plain_enum_min(SrcPacketBytes, LoadMode); + return pcast<SrcPacketType, DstPacketType>( + srcPacket<SrcLoadMode>(row, col, 0), srcPacket<SrcLoadMode>(row, col, 1), + srcPacket<SrcLoadMode>(row, col, 2), srcPacket<SrcLoadMode>(row, col, 3)); + } + // unpacket_traits<DstPacketType>::size == 8 * SrcPacketSize + template <int LoadMode, typename DstPacketType, SrcPacketArgs8<DstPacketType> = true> + EIGEN_STRONG_INLINE DstPacketType packet(Index row, Index col) const { + constexpr int SrcLoadMode = plain_enum_min(SrcPacketBytes, LoadMode); + return pcast<SrcPacketType, DstPacketType>( + srcPacket<SrcLoadMode>(row, col, 0), srcPacket<SrcLoadMode>(row, col, 1), + srcPacket<SrcLoadMode>(row, col, 2), srcPacket<SrcLoadMode>(row, col, 3), + srcPacket<SrcLoadMode>(row, col, 4), srcPacket<SrcLoadMode>(row, col, 5), + srcPacket<SrcLoadMode>(row, col, 6), srcPacket<SrcLoadMode>(row, col, 7)); + } + + // Analagous routines for linear access. + template <int LoadMode, typename DstPacketType, AltSrcScalarOp<DstPacketType> = true> + EIGEN_STRONG_INLINE DstPacketType packet(Index index) const { + constexpr int DstPacketSize = unpacket_traits<DstPacketType>::size; + constexpr int SrcBytesIncrement = DstPacketSize * sizeof(SrcType); + constexpr int SrcLoadMode = plain_enum_min(SrcBytesIncrement, LoadMode); + SrcPacketType src; + if (EIGEN_PREDICT_TRUE(check_array_bounds(index, SrcPacketSize))) { + src = srcPacket<SrcLoadMode>(index, 0); + } else { + Array<SrcType, SrcPacketSize, 1> srcArray; + for (size_t k = 0; k < DstPacketSize; k++) srcArray[k] = srcCoeff(index, k); + for (size_t k = DstPacketSize; k < SrcPacketSize; k++) srcArray[k] = SrcType(0); + src = pload<SrcPacketType>(srcArray.data()); + } + return pcast<SrcPacketType, DstPacketType>(src); + } + template <int LoadMode, typename DstPacketType, SrcPacketArgs1<DstPacketType> = true> + EIGEN_STRONG_INLINE DstPacketType packet(Index index) const { + constexpr int DstPacketSize = unpacket_traits<DstPacketType>::size; + using SizedSrcPacketType = typename find_packet_by_size<SrcType, DstPacketSize>::type; + constexpr int SrcBytesIncrement = DstPacketSize * sizeof(SrcType); + constexpr int SrcLoadMode = plain_enum_min(SrcBytesIncrement, LoadMode); + return pcast<SizedSrcPacketType, DstPacketType>( + srcPacket<SrcLoadMode, SizedSrcPacketType>(index, 0)); + } + template <int LoadMode, typename DstPacketType, SrcPacketArgs2<DstPacketType> = true> + EIGEN_STRONG_INLINE DstPacketType packet(Index index) const { + constexpr int SrcLoadMode = plain_enum_min(SrcPacketBytes, LoadMode); + return pcast<SrcPacketType, DstPacketType>( + srcPacket<SrcLoadMode>(index, 0), srcPacket<SrcLoadMode>(index, 1)); + } + template <int LoadMode, typename DstPacketType, SrcPacketArgs4<DstPacketType> = true> + EIGEN_STRONG_INLINE DstPacketType packet(Index index) const { + constexpr int SrcLoadMode = plain_enum_min(SrcPacketBytes, LoadMode); + return pcast<SrcPacketType, DstPacketType>( + srcPacket<SrcLoadMode>(index, 0), srcPacket<SrcLoadMode>(index, 1), + srcPacket<SrcLoadMode>(index, 2), srcPacket<SrcLoadMode>(index, 3)); + } + template <int LoadMode, typename DstPacketType, SrcPacketArgs8<DstPacketType> = true> + EIGEN_STRONG_INLINE DstPacketType packet(Index index) const { + constexpr int SrcLoadMode = plain_enum_min(SrcPacketBytes, LoadMode); + return pcast<SrcPacketType, DstPacketType>( + srcPacket<SrcLoadMode>(index, 0), srcPacket<SrcLoadMode>(index, 1), + srcPacket<SrcLoadMode>(index, 2), srcPacket<SrcLoadMode>(index, 3), + srcPacket<SrcLoadMode>(index, 4), srcPacket<SrcLoadMode>(index, 5), + srcPacket<SrcLoadMode>(index, 6), srcPacket<SrcLoadMode>(index, 7)); + } + + constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rows() const { return m_rows; } + constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index cols() const { return m_cols; } + constexpr EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index size() const { return m_rows * m_cols; } + + protected: + const evaluator<ArgType> m_argImpl; + const variable_if_dynamic<Index, XprType::RowsAtCompileTime> m_rows; + const variable_if_dynamic<Index, XprType::ColsAtCompileTime> m_cols; +}; + // -------------------- CwiseTernaryOp -------------------- // this is a ternary expression
diff --git a/Eigen/src/Core/GenericPacketMath.h b/Eigen/src/Core/GenericPacketMath.h index 8cb80bb..bfc7ae6 100644 --- a/Eigen/src/Core/GenericPacketMath.h +++ b/Eigen/src/Core/GenericPacketMath.h
@@ -146,14 +146,67 @@ template<typename T> struct unpacket_traits<const T> : unpacket_traits<T> { }; -template <typename Src, typename Tgt> struct type_casting_traits { +/** \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 { + using Scalar = typename unpacket_traits<Packet>::type; + enum { value = internal::is_same<Packet, Scalar>::value }; +}; + +// 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 {}; + +template <typename SrcPacket, typename TgtPacket> +struct is_degenerate_helper<SrcPacket, TgtPacket, false> { + using SrcScalar = typename unpacket_traits<SrcPacket>::type; + static constexpr int SrcSize = unpacket_traits<SrcPacket>::size; + using TgtScalar = typename unpacket_traits<TgtPacket>::type; + static constexpr int TgtSize = unpacket_traits<TgtPacket>::size; + static constexpr bool value = is_degenerate_helper<SrcScalar, TgtScalar, true>::value && (SrcSize == TgtSize); +}; + +// is_degenerate<T1,T2>::value == is_degenerate<T2,T1>::value +template <typename SrcPacket, typename TgtPacket> +struct is_degenerate { + static constexpr bool value = + is_degenerate_helper<SrcPacket, TgtPacket>::value || is_degenerate_helper<TgtPacket, SrcPacket>::value; +}; + +template <typename Packet> +struct is_half { + using Scalar = typename unpacket_traits<Packet>::type; + static constexpr int Size = unpacket_traits<Packet>::size; + using DefaultPacket = typename packet_traits<Scalar>::type; + static constexpr int DefaultSize = unpacket_traits<DefaultPacket>::size; + static constexpr bool value = Size < DefaultSize; +}; + +template <typename Src, typename Tgt> +struct type_casting_traits { enum { - VectorizedCast = 0, + VectorizedCast = + is_degenerate<Src, Tgt>::value && packet_traits<Src>::Vectorizable && packet_traits<Tgt>::Vectorizable, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; }; + /** \internal Wrapper to ensure that multiple packet types can map to the same same underlying vector type. */ template<typename T, int unique_id = 0> @@ -171,45 +224,84 @@ T m_val; }; +template <typename Target, typename Packet, bool IsSame = is_same<Target, Packet>::value> +struct preinterpret_generic; -/** \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 { - using Scalar = typename unpacket_traits<Packet>::type; - enum { - value = internal::is_same<Packet, Scalar>::value - }; +template <typename Target, typename Packet> +struct preinterpret_generic<Target, Packet, false> { + // the packets are not the same, attempt scalar bit_cast + static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Target run(const Packet& a) { + return numext::bit_cast<Target, Packet>(a); + } }; -/** \internal \returns static_cast<TgtType>(a) (coeff-wise) */ -template <typename SrcPacket, typename TgtPacket> -EIGEN_DEVICE_FUNC inline TgtPacket -pcast(const SrcPacket& a) { - return static_cast<TgtPacket>(a); -} -template <typename SrcPacket, typename TgtPacket> -EIGEN_DEVICE_FUNC inline TgtPacket -pcast(const SrcPacket& a, const SrcPacket& /*b*/) { - return static_cast<TgtPacket>(a); -} -template <typename SrcPacket, typename TgtPacket> -EIGEN_DEVICE_FUNC inline TgtPacket -pcast(const SrcPacket& a, const SrcPacket& /*b*/, const SrcPacket& /*c*/, const SrcPacket& /*d*/) { - return static_cast<TgtPacket>(a); -} -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*/) { - return static_cast<TgtPacket>(a); -} +template <typename Packet> +struct preinterpret_generic<Packet, Packet, true> { + // the packets are the same type: do nothing + static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet& a) { return a; } +}; /** \internal \returns reinterpret_cast<Target>(a) */ template <typename Target, typename Packet> -EIGEN_DEVICE_FUNC inline Target -preinterpret(const Packet& a); /* { return reinterpret_cast<const Target&>(a); } */ +EIGEN_DEVICE_FUNC inline Target preinterpret(const Packet& a) { + return preinterpret_generic<Target, Packet>::run(a); +} + +template <typename SrcPacket, typename TgtPacket, bool Degenerate = is_degenerate<SrcPacket, TgtPacket>::value, bool TgtIsHalf = is_half<TgtPacket>::value> +struct pcast_generic; + +template <typename SrcPacket, typename TgtPacket> +struct pcast_generic<SrcPacket, TgtPacket, false, false> { + // the packets are not degenerate: attempt scalar static_cast + static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket run(const SrcPacket& a) { + return cast_impl<SrcPacket, TgtPacket>::run(a); + } +}; + +template <typename Packet> +struct pcast_generic<Packet, Packet, true, false> { + // the packets are the same: do nothing + static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(const Packet& a) { return a; } +}; + +template <typename SrcPacket, typename TgtPacket, bool TgtIsHalf> +struct pcast_generic<SrcPacket, TgtPacket, true, TgtIsHalf> { + // the packets are degenerate: preinterpret is equivalent to pcast + static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket run(const SrcPacket& a) { return preinterpret<TgtPacket>(a); } +}; + + + +/** \internal \returns static_cast<TgtType>(a) (coeff-wise) */ +template <typename SrcPacket, typename TgtPacket> +EIGEN_DEVICE_FUNC inline TgtPacket pcast(const SrcPacket& a) { + return pcast_generic<SrcPacket, TgtPacket>::run(a); +} +template <typename SrcPacket, typename TgtPacket> +EIGEN_DEVICE_FUNC inline TgtPacket pcast(const SrcPacket& a, const SrcPacket& b) { + return pcast_generic<SrcPacket, TgtPacket>::run(a, b); +} +template <typename SrcPacket, typename TgtPacket> +EIGEN_DEVICE_FUNC inline TgtPacket pcast(const SrcPacket& a, const SrcPacket& b, const SrcPacket& c, + const SrcPacket& d) { + return pcast_generic<SrcPacket, TgtPacket>::run(a, b, c, 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) { + return pcast_generic<SrcPacket, TgtPacket>::run(a, b, c, d, e, f, g, h); +} + +template <typename SrcPacket, typename TgtPacket> +struct pcast_generic<SrcPacket, TgtPacket, false, true> { + // TgtPacket is a half packet of some other type + // perform cast and truncate result + using DefaultTgtPacket = typename is_half<TgtPacket>::DefaultPacket; + static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket run(const SrcPacket& a) { + return preinterpret<TgtPacket>(pcast<SrcPacket, DefaultTgtPacket>(a)); + } +}; /** \internal \returns a + b (coeff-wise) */ template<typename Packet> EIGEN_DEVICE_FUNC inline Packet
diff --git a/Eigen/src/Core/MathFunctions.h b/Eigen/src/Core/MathFunctions.h index 40ee3f5..d7851e3 100644 --- a/Eigen/src/Core/MathFunctions.h +++ b/Eigen/src/Core/MathFunctions.h
@@ -430,6 +430,13 @@ } }; +template <typename OldType> +struct cast_impl<OldType, bool> { + EIGEN_DEVICE_FUNC + static inline bool run(const OldType& x) { return x != OldType(0); } +}; + + // 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. template<typename OldType, typename NewType>
diff --git a/Eigen/src/Core/arch/AVX/TypeCasting.h b/Eigen/src/Core/arch/AVX/TypeCasting.h index 386543e..461f3a6 100644 --- a/Eigen/src/Core/arch/AVX/TypeCasting.h +++ b/Eigen/src/Core/arch/AVX/TypeCasting.h
@@ -80,6 +80,14 @@ return _mm256_set_m128i(_mm256_cvttpd_epi32(b), _mm256_cvttpd_epi32(a)); } +template <> EIGEN_STRONG_INLINE Packet4f pcast<Packet4d, Packet4f>(const Packet4d& a) { + return _mm256_cvtpd_ps(a); +} + +template <> EIGEN_STRONG_INLINE Packet4i pcast<Packet4d, Packet4i>(const Packet4d& a) { + return _mm256_cvttpd_epi32(a); +} + template <> EIGEN_STRONG_INLINE Packet16b pcast<Packet8f, Packet16b>(const Packet8f& a, const Packet8f& b) { @@ -118,6 +126,44 @@ return _mm256_castsi256_ps(a); } +template<> EIGEN_STRONG_INLINE Packet8ui preinterpret<Packet8ui, Packet8i>(const Packet8i& a) { + return Packet8ui(a); +} + +template<> EIGEN_STRONG_INLINE Packet8i preinterpret<Packet8i, Packet8ui>(const Packet8ui& a) { + return Packet8i(a); +} + +// truncation operations + +template<> EIGEN_STRONG_INLINE Packet4f preinterpret<Packet4f, Packet8f>(const Packet8f& a) { + return _mm256_castps256_ps128(a); +} + +template<> EIGEN_STRONG_INLINE Packet2d preinterpret<Packet2d, Packet4d>(const Packet4d& a) { + return _mm256_castpd256_pd128(a); +} + +template<> EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i, Packet8i>(const Packet8i& a) { + return _mm256_castsi256_si128(a); +} + +template<> EIGEN_STRONG_INLINE Packet4ui preinterpret<Packet4ui, Packet8ui>(const Packet8ui& a) { + return _mm256_castsi256_si128(a); +} + + +#ifdef EIGEN_VECTORIZE_AVX2 +template<> EIGEN_STRONG_INLINE Packet4ul preinterpret<Packet4ul, Packet4l>(const Packet4l& a) { + return Packet4ul(a); +} + +template<> EIGEN_STRONG_INLINE Packet4l preinterpret<Packet4l, Packet4ul>(const Packet4ul& a) { + return Packet4l(a); +} + +#endif + template<> EIGEN_STRONG_INLINE Packet8f pcast<Packet8h, Packet8f>(const Packet8h& a) { return half2float(a); }
diff --git a/Eigen/src/Core/arch/AVX512/TypeCasting.h b/Eigen/src/Core/arch/AVX512/TypeCasting.h index 02e6335..2f38d7f 100644 --- a/Eigen/src/Core/arch/AVX512/TypeCasting.h +++ b/Eigen/src/Core/arch/AVX512/TypeCasting.h
@@ -59,6 +59,13 @@ return cat256i(_mm512_cvttpd_epi32(a), _mm512_cvttpd_epi32(b)); } +template<> EIGEN_STRONG_INLINE Packet8i pcast<Packet8d, Packet8i>(const Packet8d& a) { + return _mm512_cvtpd_epi32(a); +} +template<> EIGEN_STRONG_INLINE Packet8f pcast<Packet8d, Packet8f>(const Packet8d& a) { + return _mm512_cvtpd_ps(a); +} + template<> EIGEN_STRONG_INLINE Packet16i preinterpret<Packet16i, Packet16f>(const Packet16f& a) { return _mm512_castps_si512(a); } @@ -107,12 +114,19 @@ return _mm512_castpd128_pd512(a); } -template<> EIGEN_STRONG_INLINE Packet16f preinterpret<Packet16f, Packet16f>(const Packet16f& a) { - return a; +template<> EIGEN_STRONG_INLINE Packet8i preinterpret<Packet8i, Packet16i>(const Packet16i& a) { + return _mm512_castsi512_si256(a); +} +template<> EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i, Packet16i>(const Packet16i& a) { + return _mm512_castsi512_si128(a); } -template<> EIGEN_STRONG_INLINE Packet8d preinterpret<Packet8d, Packet8d>(const Packet8d& a) { - return a; +template<> EIGEN_STRONG_INLINE Packet8h preinterpret<Packet8h, Packet16h>(const Packet16h& a) { + return _mm256_castsi256_si128(a); +} + +template<> EIGEN_STRONG_INLINE Packet8bf preinterpret<Packet8bf, Packet16bf>(const Packet16bf& a) { + return _mm256_castsi256_si128(a); } #ifndef EIGEN_VECTORIZE_AVX512FP16 @@ -191,6 +205,13 @@ }; }; +template<> EIGEN_STRONG_INLINE Packet16h preinterpret<Packet16h, Packet32h>(const Packet32h& a) { + return _mm256_castpd_si256(_mm512_extractf64x4_pd(_mm512_castph_pd(a), 0)); +} +template<> EIGEN_STRONG_INLINE Packet8h preinterpret<Packet8h, Packet32h>(const Packet32h& a) { + return _mm256_castsi256_si128(preinterpret<Packet16h>(a)); +} + template <> EIGEN_STRONG_INLINE Packet16f pcast<Packet32h, Packet16f>(const Packet32h& a) { // Discard second-half of input.
diff --git a/Eigen/src/Core/arch/Default/Half.h b/Eigen/src/Core/arch/Default/Half.h index c8ca33a..17ce135 100644 --- a/Eigen/src/Core/arch/Default/Half.h +++ b/Eigen/src/Core/arch/Default/Half.h
@@ -1014,4 +1014,49 @@ } // end namespace std #endif +namespace Eigen { +namespace internal { + +template <> +struct cast_impl<float, half> { + EIGEN_DEVICE_FUNC + static inline half run(const float& a) { +#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \ + (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE)) + return __float2half(a); +#else + return half(a); +#endif + } +}; + +template <> +struct cast_impl<int, half> { + EIGEN_DEVICE_FUNC + static inline half run(const int& a) { +#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \ + (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE)) + return __float2half(static_cast<float>(a)); +#else + return half(static_cast<float>(a)); +#endif + } +}; + +template <> +struct cast_impl<half, float> { + EIGEN_DEVICE_FUNC + static inline float run(const half& a) { +#if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \ + (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE)) + return __half2float(a); +#else + return static_cast<float>(a); +#endif + } +}; + +} // namespace internal +} // namespace Eigen + #endif // EIGEN_HALF_H
diff --git a/Eigen/src/Core/arch/Default/TypeCasting.h b/Eigen/src/Core/arch/Default/TypeCasting.h deleted file mode 100644 index dc779a7..0000000 --- a/Eigen/src/Core/arch/Default/TypeCasting.h +++ /dev/null
@@ -1,116 +0,0 @@ -// This file is part of Eigen, a lightweight C++ template library -// for linear algebra. -// -// Copyright (C) 2016 Benoit Steiner <benoit.steiner.goog@gmail.com> -// Copyright (C) 2019 Rasmus Munk Larsen <rmlarsen@google.com> -// -// 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_TYPE_CASTING_H -#define EIGEN_GENERIC_TYPE_CASTING_H - -#include "../../InternalHeaderCheck.h" - -namespace Eigen { - -namespace internal { - -template<> -struct scalar_cast_op<float, Eigen::half> { - typedef Eigen::half result_type; - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half operator() (const float& a) const { - #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \ - (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE)) - return __float2half(a); - #else - return Eigen::half(a); - #endif - } -}; - -template<> -struct functor_traits<scalar_cast_op<float, Eigen::half> > -{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; }; - - -template<> -struct scalar_cast_op<int, Eigen::half> { - typedef Eigen::half result_type; - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::half operator() (const int& a) const { - #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \ - (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE)) - return __float2half(static_cast<float>(a)); - #else - return Eigen::half(static_cast<float>(a)); - #endif - } -}; - -template<> -struct functor_traits<scalar_cast_op<int, Eigen::half> > -{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; }; - - -template<> -struct scalar_cast_op<Eigen::half, float> { - typedef float result_type; - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float operator() (const Eigen::half& a) const { - #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 300) || \ - (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE)) - return __half2float(a); - #else - return static_cast<float>(a); - #endif - } -}; - -template<> -struct functor_traits<scalar_cast_op<Eigen::half, float> > -{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; }; - - -template<> -struct scalar_cast_op<float, Eigen::bfloat16> { - typedef Eigen::bfloat16 result_type; - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::bfloat16 operator() (const float& a) const { - return Eigen::bfloat16(a); - } -}; - -template<> -struct functor_traits<scalar_cast_op<float, Eigen::bfloat16> > -{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; }; - - -template<> -struct scalar_cast_op<int, Eigen::bfloat16> { - typedef Eigen::bfloat16 result_type; - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::bfloat16 operator() (const int& a) const { - return Eigen::bfloat16(static_cast<float>(a)); - } -}; - -template<> -struct functor_traits<scalar_cast_op<int, Eigen::bfloat16> > -{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; }; - - -template<> -struct scalar_cast_op<Eigen::bfloat16, float> { - typedef float result_type; - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE float operator() (const Eigen::bfloat16& a) const { - return static_cast<float>(a); - } -}; - -template<> -struct functor_traits<scalar_cast_op<Eigen::bfloat16, float> > -{ enum { Cost = NumTraits<float>::AddCost, PacketAccess = false }; }; - - -} -} - -#endif // EIGEN_GENERIC_TYPE_CASTING_H
diff --git a/Eigen/src/Core/arch/NEON/TypeCasting.h b/Eigen/src/Core/arch/NEON/TypeCasting.h index add31b9..834fcf5 100644 --- a/Eigen/src/Core/arch/NEON/TypeCasting.h +++ b/Eigen/src/Core/arch/NEON/TypeCasting.h
@@ -17,6 +17,61 @@ namespace internal { + +//============================================================================== +// preinterpret (truncation operations) +//============================================================================== + +template <> +EIGEN_STRONG_INLINE Packet8c preinterpret<Packet8c, Packet16c>(const Packet16c& a) { + return Packet8c(vget_low_s8(a)); +} +template <> +EIGEN_STRONG_INLINE Packet4c preinterpret<Packet4c, Packet8c>(const Packet8c& a) { + return Packet4c(vget_lane_s32(vreinterpret_s32_s8(a), 0)); +} +template <> +EIGEN_STRONG_INLINE Packet4c preinterpret<Packet4c, Packet16c>(const Packet16c& a) { + return preinterpret<Packet4c>(preinterpret<Packet8c>(a)); +} + +template <> +EIGEN_STRONG_INLINE Packet8uc preinterpret<Packet8uc, Packet16uc>(const Packet16uc& a) { + return Packet8uc(vget_low_u8(a)); +} +template <> +EIGEN_STRONG_INLINE Packet4uc preinterpret<Packet4uc, Packet8uc>(const Packet8uc& a) { + return Packet4uc(vget_lane_u32(vreinterpret_u32_u8(a), 0)); +} +template <> +EIGEN_STRONG_INLINE Packet4uc preinterpret<Packet4uc, Packet16uc>(const Packet16uc& a) { + return preinterpret<Packet4uc>(preinterpret<Packet8uc>(a)); +} + +template <> +EIGEN_STRONG_INLINE Packet4s preinterpret<Packet4s, Packet8s>(const Packet8s& a) { + return Packet4s(vget_low_s16(a)); +} + +template <> +EIGEN_STRONG_INLINE Packet4us preinterpret<Packet4us, Packet8us>(const Packet8us& a) { + return Packet4us(vget_low_u16(a)); +} + +template <> +EIGEN_STRONG_INLINE Packet2i preinterpret<Packet2i, Packet4i>(const Packet4i& a) { + return Packet2i(vget_low_s32(a)); +} +template <> +EIGEN_STRONG_INLINE Packet2ui preinterpret<Packet2ui, Packet4ui>(const Packet4ui& a) { + return Packet2ui(vget_low_u32(a)); +} + +template <> +EIGEN_STRONG_INLINE Packet2f preinterpret<Packet2f, Packet4f>(const Packet4f& a) { + return Packet2f(vget_low_f32(a)); +} + //============================================================================== // preinterpret //============================================================================== @@ -37,6 +92,7 @@ return Packet4f(vreinterpretq_f32_u32(a)); } + template <> EIGEN_STRONG_INLINE Packet4c preinterpret<Packet4c, Packet4uc>(const Packet4uc& a) { return static_cast<Packet4c>(a); @@ -50,6 +106,7 @@ return Packet16c(vreinterpretq_s8_u8(a)); } + template <> EIGEN_STRONG_INLINE Packet4uc preinterpret<Packet4uc, Packet4c>(const Packet4c& a) { return static_cast<Packet4uc>(a); @@ -71,7 +128,6 @@ EIGEN_STRONG_INLINE Packet8s preinterpret<Packet8s, Packet8us>(const Packet8us& a) { return Packet8s(vreinterpretq_s16_u16(a)); } - template <> EIGEN_STRONG_INLINE Packet4us preinterpret<Packet4us, Packet4s>(const Packet4s& a) { return Packet4us(vreinterpret_u16_s16(a)); @@ -127,18 +183,7 @@ //============================================================================== // pcast, SrcType = float //============================================================================== -template <> -struct type_casting_traits<float, float> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet4f pcast<Packet4f, Packet4f>(const Packet4f& a) { - return a; -} -template <> -EIGEN_STRONG_INLINE Packet2f pcast<Packet2f, Packet2f>(const Packet2f& a) { - return a; -} + template <> struct type_casting_traits<float, numext::int64_t> { @@ -156,10 +201,18 @@ return vcvtq_s64_f64(vcvt_f64_f32(vget_low_f32(a))); } template <> +EIGEN_STRONG_INLINE Packet2l pcast<Packet2f, Packet2l>(const Packet2f& a) { + return vcvtq_s64_f64(vcvt_f64_f32(a)); +} +template <> EIGEN_STRONG_INLINE Packet2ul pcast<Packet4f, Packet2ul>(const Packet4f& a) { // Discard second half of input. return vcvtq_u64_f64(vcvt_f64_f32(vget_low_f32(a))); } +template <> +EIGEN_STRONG_INLINE Packet2ul pcast<Packet2f, Packet2ul>(const Packet2f& a) { + return vcvtq_u64_f64(vcvt_f64_f32(a)); +} #else template <> EIGEN_STRONG_INLINE Packet2l pcast<Packet4f, Packet2l>(const Packet4f& a) { @@ -167,10 +220,19 @@ return vmovl_s32(vget_low_s32(vcvtq_s32_f32(a))); } template <> +EIGEN_STRONG_INLINE Packet2l pcast<Packet2f, Packet2l>(const Packet2f& a) { + return vmovl_s32(vcvt_s32_f32(a)); +} +template <> EIGEN_STRONG_INLINE Packet2ul pcast<Packet4f, Packet2ul>(const Packet4f& a) { // Discard second half of input. return vmovl_u32(vget_low_u32(vcvtq_u32_f32(a))); } +template <> +EIGEN_STRONG_INLINE Packet2ul pcast<Packet2f, Packet2ul>(const Packet2f& a) { + // Discard second half of input. + return vmovl_u32(vcvt_u32_f32(a)); +} #endif // EIGEN_ARCH_ARM64 template <> @@ -208,6 +270,10 @@ return vcombine_s16(vmovn_s32(vcvtq_s32_f32(a)), vmovn_s32(vcvtq_s32_f32(b))); } template <> +EIGEN_STRONG_INLINE Packet4s pcast<Packet4f, Packet4s>(const Packet4f& a) { + return vmovn_s32(vcvtq_s32_f32(a)); +} +template <> EIGEN_STRONG_INLINE Packet4s pcast<Packet2f, Packet4s>(const Packet2f& a, const Packet2f& b) { return vmovn_s32(vcombine_s32(vcvt_s32_f32(a), vcvt_s32_f32(b))); } @@ -221,6 +287,10 @@ return vcombine_u16(vmovn_u32(vcvtq_u32_f32(a)), vmovn_u32(vcvtq_u32_f32(b))); } template <> +EIGEN_STRONG_INLINE Packet4us pcast<Packet4f, Packet4us>(const Packet4f& a) { + return vmovn_u32(vcvtq_u32_f32(a)); +} +template <> EIGEN_STRONG_INLINE Packet4us pcast<Packet2f, Packet4us>(const Packet2f& a, const Packet2f& b) { return vmovn_u32(vcombine_u32(vcvt_u32_f32(a), vcvt_u32_f32(b))); } @@ -237,12 +307,25 @@ return vcombine_s8(vmovn_s16(ab_s16), vmovn_s16(cd_s16)); } template <> +EIGEN_STRONG_INLINE Packet8c pcast<Packet4f, Packet8c>(const Packet4f& a, const Packet4f& b) { + const int16x8_t ab_s16 = pcast<Packet4f, Packet8s>(a, b); + return vmovn_s16(ab_s16); +} +template <> EIGEN_STRONG_INLINE Packet8c pcast<Packet2f, Packet8c>(const Packet2f& a, const Packet2f& b, const Packet2f& c, const Packet2f& d) { const int16x4_t ab_s16 = pcast<Packet2f, Packet4s>(a, b); const int16x4_t cd_s16 = pcast<Packet2f, Packet4s>(c, d); return vmovn_s16(vcombine_s16(ab_s16, cd_s16)); } +template <> +EIGEN_STRONG_INLINE Packet4c pcast<Packet4f, Packet4c>(const Packet4f& a) { + const int32x4_t a_s32x4 = vcvtq_s32_f32(a); + const int16x4_t a_s16x4 = vmovn_s32(a_s32x4); + const int16x8_t aa_s16x8 = vcombine_s16(a_s16x4, a_s16x4); + const int8x8_t aa_s8x8 = vmovn_s16(aa_s16x8); + return vget_lane_s32(vreinterpret_s32_s8(aa_s8x8), 0); +} template <> struct type_casting_traits<float, numext::uint8_t> { @@ -251,16 +334,20 @@ template <> EIGEN_STRONG_INLINE Packet16uc pcast<Packet4f, Packet16uc>(const Packet4f& a, const Packet4f& b, const Packet4f& c, const Packet4f& d) { - const uint16x8_t ab_u16 = pcast<Packet4f, Packet8us>(a, b); - const uint16x8_t cd_u16 = pcast<Packet4f, Packet8us>(c, d); - return vcombine_u8(vmovn_u16(ab_u16), vmovn_u16(cd_u16)); + return preinterpret<Packet16uc>(pcast<Packet4f, Packet16c>(a, b, c, d)); +} +template <> +EIGEN_STRONG_INLINE Packet8uc pcast<Packet4f, Packet8uc>(const Packet4f& a, const Packet4f& b) { + return preinterpret<Packet8uc>(pcast<Packet4f, Packet8c>(a, b)); } template <> EIGEN_STRONG_INLINE Packet8uc pcast<Packet2f, Packet8uc>(const Packet2f& a, const Packet2f& b, const Packet2f& c, const Packet2f& d) { - const uint16x4_t ab_u16 = pcast<Packet2f, Packet4us>(a, b); - const uint16x4_t cd_u16 = pcast<Packet2f, Packet4us>(c, d); - return vmovn_u16(vcombine_u16(ab_u16, cd_u16)); + return preinterpret<Packet8uc>(pcast<Packet2f, Packet8c>(a, b, c, d)); +} +template <> +EIGEN_STRONG_INLINE Packet4uc pcast<Packet4f, Packet4uc>(const Packet4f& a) { + return static_cast<Packet4uc>(pcast<Packet4f, Packet4c>(a)); } //============================================================================== @@ -276,6 +363,10 @@ return vcvtq_f32_s32(vmovl_s16(vget_low_s16(vmovl_s8(vget_low_s8(a))))); } template <> +EIGEN_STRONG_INLINE Packet4f pcast<Packet4c, Packet4f>(const Packet4c& a) { + return vcvtq_f32_s32(vmovl_s16(vget_low_s16(vmovl_s8(vreinterpret_s8_s32(vdup_n_s32(a)))))); +} +template <> EIGEN_STRONG_INLINE Packet2f pcast<Packet8c, Packet2f>(const Packet8c& a) { // Discard all but first 2 bytes. return vcvt_f32_s32(vget_low_s32(vmovl_s16(vget_low_s16(vmovl_s8(a))))); @@ -310,11 +401,20 @@ return vmovl_s16(vget_low_s16(vmovl_s8(vget_low_s8(a)))); } template <> +EIGEN_STRONG_INLINE Packet4i pcast<Packet8c, Packet4i>(const Packet8c& a) { + return vmovl_s16(vget_low_s16(vmovl_s8(a))); +} +template <> +EIGEN_STRONG_INLINE Packet4i pcast<Packet4c, Packet4i>(const Packet4c& a) { + return pcast<Packet8c, Packet4i>(vreinterpret_s8_s32(vdup_n_s32(a))); +} +template <> EIGEN_STRONG_INLINE Packet2i pcast<Packet8c, Packet2i>(const Packet8c& a) { // Discard all but first 2 bytes. return vget_low_s32(vmovl_s16(vget_low_s16(vmovl_s8(a)))); } + template <> struct type_casting_traits<numext::int8_t, numext::uint32_t> { enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 4 }; @@ -327,6 +427,10 @@ EIGEN_STRONG_INLINE Packet2ui pcast<Packet8c, Packet2ui>(const Packet8c& a) { return preinterpret<Packet2ui>(pcast<Packet8c, Packet2i>(a)); } +template <> +EIGEN_STRONG_INLINE Packet4ui pcast<Packet4c, Packet4ui>(const Packet4c& a) { + return preinterpret<Packet4ui>(pcast<Packet4c, Packet4i>(a)); +} template <> struct type_casting_traits<numext::int8_t, numext::int16_t> { @@ -338,10 +442,18 @@ return vmovl_s8(vget_low_s8(a)); } template <> +EIGEN_STRONG_INLINE Packet8s pcast<Packet8c, Packet8s>(const Packet8c& a) { + return vmovl_s8(a); +} +template <> EIGEN_STRONG_INLINE Packet4s pcast<Packet8c, Packet4s>(const Packet8c& a) { // Discard second half of input. return vget_low_s16(vmovl_s8(a)); } +template <> +EIGEN_STRONG_INLINE Packet4s pcast<Packet4c, Packet4s>(const Packet4c& a) { + return pcast<Packet8c, Packet4s>(vreinterpret_s8_s32(vdup_n_s32(a))); +} template <> struct type_casting_traits<numext::int8_t, numext::uint16_t> { @@ -352,43 +464,18 @@ return preinterpret<Packet8us>(pcast<Packet16c, Packet8s>(a)); } template <> +EIGEN_STRONG_INLINE Packet8us pcast<Packet8c, Packet8us>(const Packet8c& a) { + return preinterpret<Packet8us>(pcast<Packet8c, Packet8s>(a)); +} +template <> EIGEN_STRONG_INLINE Packet4us pcast<Packet8c, Packet4us>(const Packet8c& a) { return preinterpret<Packet4us>(pcast<Packet8c, Packet4s>(a)); } - template <> -struct type_casting_traits<numext::int8_t, numext::int8_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet16c pcast<Packet16c, Packet16c>(const Packet16c& a) { - return a; -} -template <> -EIGEN_STRONG_INLINE Packet8c pcast<Packet8c, Packet8c>(const Packet8c& a) { - return a; -} -template <> -EIGEN_STRONG_INLINE Packet4c pcast<Packet4c, Packet4c>(const Packet4c& a) { - return a; +EIGEN_STRONG_INLINE Packet4us pcast<Packet4c, Packet4us>(const Packet4c& a) { + return preinterpret<Packet4us>(pcast<Packet4c, Packet4s>(a)); } -template <> -struct type_casting_traits<numext::int8_t, numext::uint8_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet16uc pcast<Packet16c, Packet16uc>(const Packet16c& a) { - return preinterpret<Packet16uc>(a); -} -template <> -EIGEN_STRONG_INLINE Packet8uc pcast<Packet8c, Packet8uc>(const Packet8c& a) { - return preinterpret<Packet8uc>(a); -} -template <> -EIGEN_STRONG_INLINE Packet4uc pcast<Packet4c, Packet4uc>(const Packet4c& a) { - return static_cast<Packet4uc>(a); -} //============================================================================== // pcast, SrcType = uint8_t @@ -403,6 +490,10 @@ return vcvtq_f32_u32(vmovl_u16(vget_low_u16(vmovl_u8(vget_low_u8(a))))); } template <> +EIGEN_STRONG_INLINE Packet4f pcast<Packet4uc, Packet4f>(const Packet4uc& a) { + return vcvtq_f32_u32(vmovl_u16(vget_low_u16(vmovl_u8(vreinterpret_u8_u32(vdup_n_u32(a)))))); +} +template <> EIGEN_STRONG_INLINE Packet2f pcast<Packet8uc, Packet2f>(const Packet8uc& a) { // Discard all but first 2 bytes. return vcvt_f32_u32(vget_low_u32(vmovl_u16(vget_low_u16(vmovl_u8(a))))); @@ -437,10 +528,18 @@ return vmovl_u16(vget_low_u16(vmovl_u8(vget_low_u8(a)))); } template <> +EIGEN_STRONG_INLINE Packet4ui pcast<Packet8uc, Packet4ui>(const Packet8uc& a) { + return vmovl_u16(vget_low_u16(vmovl_u8(a))); +} +template <> EIGEN_STRONG_INLINE Packet2ui pcast<Packet8uc, Packet2ui>(const Packet8uc& a) { // Discard all but first 2 bytes. return vget_low_u32(vmovl_u16(vget_low_u16(vmovl_u8(a)))); } +template <> +EIGEN_STRONG_INLINE Packet4ui pcast<Packet4uc, Packet4ui>(const Packet4uc& a) { + return pcast<Packet8uc, Packet4ui>(vreinterpret_u8_u32(vdup_n_u32(a))); +} template <> struct type_casting_traits<numext::uint8_t, numext::int32_t> { @@ -454,6 +553,10 @@ EIGEN_STRONG_INLINE Packet2i pcast<Packet8uc, Packet2i>(const Packet8uc& a) { return preinterpret<Packet2i>(pcast<Packet8uc, Packet2ui>(a)); } +template <> +EIGEN_STRONG_INLINE Packet4i pcast<Packet4uc, Packet4i>(const Packet4uc& a) { + return preinterpret<Packet4i>(pcast<Packet4uc, Packet4ui>(a)); +} template <> struct type_casting_traits<numext::uint8_t, numext::uint16_t> { @@ -465,10 +568,14 @@ return vmovl_u8(vget_low_u8(a)); } template <> -EIGEN_STRONG_INLINE Packet4us pcast<Packet8uc, Packet4us>(const Packet8uc& a) { - // Discard second half of input. - return vget_low_u16(vmovl_u8(a)); +EIGEN_STRONG_INLINE Packet8us pcast<Packet8uc, Packet8us>(const Packet8uc& a) { + return vmovl_u8(a); } +template <> +EIGEN_STRONG_INLINE Packet4us pcast<Packet4uc, Packet4us>(const Packet4uc& a) { + return vget_low_u16(vmovl_u8(vreinterpret_u8_u32(vdup_n_u32(a)))); +} + template <> struct type_casting_traits<numext::uint8_t, numext::int16_t> { @@ -479,43 +586,14 @@ return preinterpret<Packet8s>(pcast<Packet16uc, Packet8us>(a)); } template <> -EIGEN_STRONG_INLINE Packet4s pcast<Packet8uc, Packet4s>(const Packet8uc& a) { - return preinterpret<Packet4s>(pcast<Packet8uc, Packet4us>(a)); +EIGEN_STRONG_INLINE Packet8s pcast<Packet8uc, Packet8s>(const Packet8uc& a) { + return preinterpret<Packet8s>(pcast<Packet8uc, Packet8us>(a)); +} +template <> +EIGEN_STRONG_INLINE Packet4s pcast<Packet4uc, Packet4s>(const Packet4uc& a) { + return preinterpret<Packet4s>(pcast<Packet4uc, Packet4us>(a)); } -template <> -struct type_casting_traits<numext::uint8_t, numext::uint8_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet16uc pcast<Packet16uc, Packet16uc>(const Packet16uc& a) { - return a; -} -template <> -EIGEN_STRONG_INLINE Packet8uc pcast<Packet8uc, Packet8uc>(const Packet8uc& a) { - return a; -} -template <> -EIGEN_STRONG_INLINE Packet4uc pcast<Packet4uc, Packet4uc>(const Packet4uc& a) { - return a; -} - -template <> -struct type_casting_traits<numext::uint8_t, numext::int8_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet16c pcast<Packet16uc, Packet16c>(const Packet16uc& a) { - return preinterpret<Packet16c>(a); -} -template <> -EIGEN_STRONG_INLINE Packet8c pcast<Packet8uc, Packet8c>(const Packet8uc& a) { - return preinterpret<Packet8c>(a); -} -template <> -EIGEN_STRONG_INLINE Packet4c pcast<Packet4uc, Packet4c>(const Packet4uc& a) { - return static_cast<Packet4c>(a); -} //============================================================================== // pcast, SrcType = int16_t @@ -530,6 +608,10 @@ return vcvtq_f32_s32(vmovl_s16(vget_low_s16(a))); } template <> +EIGEN_STRONG_INLINE Packet4f pcast<Packet4s, Packet4f>(const Packet4s& a) { + return vcvtq_f32_s32(vmovl_s16(a)); +} +template <> EIGEN_STRONG_INLINE Packet2f pcast<Packet4s, Packet2f>(const Packet4s& a) { // Discard second half of input. return vcvt_f32_s32(vget_low_s32(vmovl_s16(a))); @@ -564,6 +646,10 @@ return vmovl_s16(vget_low_s16(a)); } template <> +EIGEN_STRONG_INLINE Packet4i pcast<Packet4s, Packet4i>(const Packet4s& a) { + return vmovl_s16(a); +} +template <> EIGEN_STRONG_INLINE Packet2i pcast<Packet4s, Packet2i>(const Packet4s& a) { // Discard second half of input. return vget_low_s32(vmovl_s16(a)); @@ -578,35 +664,14 @@ return preinterpret<Packet4ui>(pcast<Packet8s, Packet4i>(a)); } template <> +EIGEN_STRONG_INLINE Packet4ui pcast<Packet4s, Packet4ui>(const Packet4s& a) { + return preinterpret<Packet4ui>(pcast<Packet4s, Packet4i>(a)); +} +template <> EIGEN_STRONG_INLINE Packet2ui pcast<Packet4s, Packet2ui>(const Packet4s& a) { return preinterpret<Packet2ui>(pcast<Packet4s, Packet2i>(a)); } -template <> -struct type_casting_traits<numext::int16_t, numext::int16_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet8s pcast<Packet8s, Packet8s>(const Packet8s& a) { - return a; -} -template <> -EIGEN_STRONG_INLINE Packet4s pcast<Packet4s, Packet4s>(const Packet4s& a) { - return a; -} - -template <> -struct type_casting_traits<numext::int16_t, numext::uint16_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet8us pcast<Packet8s, Packet8us>(const Packet8s& a) { - return preinterpret<Packet8us>(a); -} -template <> -EIGEN_STRONG_INLINE Packet4us pcast<Packet4s, Packet4us>(const Packet4s& a) { - return preinterpret<Packet4us>(a); -} template <> struct type_casting_traits<numext::int16_t, numext::int8_t> { @@ -617,9 +682,18 @@ return vcombine_s8(vmovn_s16(a), vmovn_s16(b)); } template <> +EIGEN_STRONG_INLINE Packet8c pcast<Packet8s, Packet8c>(const Packet8s& a) { + return vmovn_s16(a); +} +template <> EIGEN_STRONG_INLINE Packet8c pcast<Packet4s, Packet8c>(const Packet4s& a, const Packet4s& b) { return vmovn_s16(vcombine_s16(a, b)); } +template <> +EIGEN_STRONG_INLINE Packet4c pcast<Packet4s, Packet4c>(const Packet4s& a) { + const int8x8_t aa_s8x8 = pcast<Packet4s, Packet8c>(a, a); + return vget_lane_s32(vreinterpret_s32_s8(aa_s8x8), 0); +} template <> struct type_casting_traits<numext::int16_t, numext::uint8_t> { @@ -627,11 +701,19 @@ }; template <> EIGEN_STRONG_INLINE Packet16uc pcast<Packet8s, Packet16uc>(const Packet8s& a, const Packet8s& b) { - return vcombine_u8(vmovn_u16(vreinterpretq_u16_s16(a)), vmovn_u16(vreinterpretq_u16_s16(b))); + return preinterpret<Packet16uc>(pcast<Packet8s, Packet16c>(a, b)); +} +template <> +EIGEN_STRONG_INLINE Packet8uc pcast<Packet8s, Packet8uc>(const Packet8s& a) { + return preinterpret<Packet8uc>(pcast<Packet8s, Packet8c>(a)); } template <> EIGEN_STRONG_INLINE Packet8uc pcast<Packet4s, Packet8uc>(const Packet4s& a, const Packet4s& b) { - return vmovn_u16(vcombine_u16(vreinterpret_u16_s16(a), vreinterpret_u16_s16(b))); + return preinterpret<Packet8uc>(pcast<Packet4s, Packet8c>(a, b)); +} +template <> +EIGEN_STRONG_INLINE Packet4uc pcast<Packet4s, Packet4uc>(const Packet4s& a) { + return static_cast<Packet4uc>(pcast<Packet4s, Packet4c>(a)); } //============================================================================== @@ -647,6 +729,10 @@ return vcvtq_f32_u32(vmovl_u16(vget_low_u16(a))); } template <> +EIGEN_STRONG_INLINE Packet4f pcast<Packet4us, Packet4f>(const Packet4us& a) { + return vcvtq_f32_u32(vmovl_u16(a)); +} +template <> EIGEN_STRONG_INLINE Packet2f pcast<Packet4us, Packet2f>(const Packet4us& a) { // Discard second half of input. return vcvt_f32_u32(vget_low_u32(vmovl_u16(a))); @@ -681,6 +767,10 @@ return vmovl_u16(vget_low_u16(a)); } template <> +EIGEN_STRONG_INLINE Packet4ui pcast<Packet4us, Packet4ui>(const Packet4us& a) { + return vmovl_u16(a); +} +template <> EIGEN_STRONG_INLINE Packet2ui pcast<Packet4us, Packet2ui>(const Packet4us& a) { // Discard second half of input. return vget_low_u32(vmovl_u16(a)); @@ -695,35 +785,14 @@ return preinterpret<Packet4i>(pcast<Packet8us, Packet4ui>(a)); } template <> +EIGEN_STRONG_INLINE Packet4i pcast<Packet4us, Packet4i>(const Packet4us& a) { + return preinterpret<Packet4i>(pcast<Packet4us, Packet4ui>(a)); +} +template <> EIGEN_STRONG_INLINE Packet2i pcast<Packet4us, Packet2i>(const Packet4us& a) { return preinterpret<Packet2i>(pcast<Packet4us, Packet2ui>(a)); } -template <> -struct type_casting_traits<numext::uint16_t, numext::uint16_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet8us pcast<Packet8us, Packet8us>(const Packet8us& a) { - return a; -} -template <> -EIGEN_STRONG_INLINE Packet4us pcast<Packet4us, Packet4us>(const Packet4us& a) { - return a; -} - -template <> -struct type_casting_traits<numext::uint16_t, numext::int16_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet8s pcast<Packet8us, Packet8s>(const Packet8us& a) { - return preinterpret<Packet8s>(a); -} -template <> -EIGEN_STRONG_INLINE Packet4s pcast<Packet4us, Packet4s>(const Packet4us& a) { - return preinterpret<Packet4s>(a); -} template <> struct type_casting_traits<numext::uint16_t, numext::uint8_t> { @@ -734,9 +803,18 @@ return vcombine_u8(vmovn_u16(a), vmovn_u16(b)); } template <> +EIGEN_STRONG_INLINE Packet8uc pcast<Packet8us, Packet8uc>(const Packet8us& a) { + return vmovn_u16(a); +} +template <> EIGEN_STRONG_INLINE Packet8uc pcast<Packet4us, Packet8uc>(const Packet4us& a, const Packet4us& b) { return vmovn_u16(vcombine_u16(a, b)); } +template <> +EIGEN_STRONG_INLINE Packet4uc pcast<Packet4us, Packet4uc>(const Packet4us& a) { + uint8x8_t aa_u8x8 = pcast<Packet4us, Packet8uc>(a, a); + return vget_lane_u32(vreinterpret_u32_u8(aa_u8x8), 0); +} template <> struct type_casting_traits<numext::uint16_t, numext::int8_t> { @@ -747,9 +825,17 @@ return preinterpret<Packet16c>(pcast<Packet8us, Packet16uc>(a, b)); } template <> +EIGEN_STRONG_INLINE Packet8c pcast<Packet8us, Packet8c>(const Packet8us& a) { + return preinterpret<Packet8c>(pcast<Packet8us, Packet8uc>(a)); +} +template <> EIGEN_STRONG_INLINE Packet8c pcast<Packet4us, Packet8c>(const Packet4us& a, const Packet4us& b) { return preinterpret<Packet8c>(pcast<Packet4us, Packet8uc>(a, b)); } +template <> +EIGEN_STRONG_INLINE Packet4c pcast<Packet4us, Packet4c>(const Packet4us& a) { + return static_cast<Packet4c>(pcast<Packet4us, Packet4uc>(a)); +} //============================================================================== // pcast, SrcType = int32_t @@ -776,6 +862,10 @@ // Discard second half of input. return vmovl_s32(vget_low_s32(a)); } +template <> +EIGEN_STRONG_INLINE Packet2l pcast<Packet2i, Packet2l>(const Packet2i& a) { + return vmovl_s32(a); +} template <> struct type_casting_traits<numext::int32_t, numext::uint64_t> { @@ -785,32 +875,11 @@ EIGEN_STRONG_INLINE Packet2ul pcast<Packet4i, Packet2ul>(const Packet4i& a) { return preinterpret<Packet2ul>(pcast<Packet4i, Packet2l>(a)); } - template <> -struct type_casting_traits<numext::int32_t, numext::int32_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet4i pcast<Packet4i, Packet4i>(const Packet4i& a) { - return a; -} -template <> -EIGEN_STRONG_INLINE Packet2i pcast<Packet2i, Packet2i>(const Packet2i& a) { - return a; +EIGEN_STRONG_INLINE Packet2ul pcast<Packet2i, Packet2ul>(const Packet2i& a) { + return preinterpret<Packet2ul>(pcast<Packet2i, Packet2l>(a)); } -template <> -struct type_casting_traits<numext::int32_t, numext::uint32_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet4ui pcast<Packet4i, Packet4ui>(const Packet4i& a) { - return preinterpret<Packet4ui>(a); -} -template <> -EIGEN_STRONG_INLINE Packet2ui pcast<Packet2i, Packet2ui>(const Packet2i& a) { - return preinterpret<Packet2ui>(a); -} template <> struct type_casting_traits<numext::int32_t, numext::int16_t> { @@ -821,6 +890,10 @@ return vcombine_s16(vmovn_s32(a), vmovn_s32(b)); } template <> +EIGEN_STRONG_INLINE Packet4s pcast<Packet4i, Packet4s>(const Packet4i& a) { + return vmovn_s32(a); +} +template <> EIGEN_STRONG_INLINE Packet4s pcast<Packet2i, Packet4s>(const Packet2i& a, const Packet2i& b) { return vmovn_s32(vcombine_s32(a, b)); } @@ -834,6 +907,10 @@ return vcombine_u16(vmovn_u32(vreinterpretq_u32_s32(a)), vmovn_u32(vreinterpretq_u32_s32(b))); } template <> +EIGEN_STRONG_INLINE Packet4us pcast<Packet4i, Packet4us>(const Packet4i& a) { + return vmovn_u32(vreinterpretq_u32_s32(a)); +} +template <> EIGEN_STRONG_INLINE Packet4us pcast<Packet2i, Packet4us>(const Packet2i& a, const Packet2i& b) { return vmovn_u32(vreinterpretq_u32_s32(vcombine_s32(a, b))); } @@ -850,12 +927,24 @@ return vcombine_s8(vmovn_s16(ab_s16), vmovn_s16(cd_s16)); } template <> +EIGEN_STRONG_INLINE Packet8c pcast<Packet4i, Packet8c>(const Packet4i& a, const Packet4i& b) { + const int16x8_t ab_s16 = pcast<Packet4i, Packet8s>(a, b); + return vmovn_s16(ab_s16); +} +template <> EIGEN_STRONG_INLINE Packet8c pcast<Packet2i, Packet8c>(const Packet2i& a, const Packet2i& b, const Packet2i& c, const Packet2i& d) { const int16x4_t ab_s16 = vmovn_s32(vcombine_s32(a, b)); const int16x4_t cd_s16 = vmovn_s32(vcombine_s32(c, d)); return vmovn_s16(vcombine_s16(ab_s16, cd_s16)); } +template <> +EIGEN_STRONG_INLINE Packet4c pcast<Packet4i, Packet4c>(const Packet4i& a) { + const int16x4_t a_s16x4 = vmovn_s32(a); + const int16x8_t aa_s16x8 = vcombine_s16(a_s16x4, a_s16x4); + const int8x8_t aa_s8x8 = vmovn_s16(aa_s16x8); + return vget_lane_s32(vreinterpret_s32_s8(aa_s8x8), 0); +} template <> struct type_casting_traits<numext::int32_t, numext::uint8_t> { @@ -864,16 +953,20 @@ template <> EIGEN_STRONG_INLINE Packet16uc pcast<Packet4i, Packet16uc>(const Packet4i& a, const Packet4i& b, const Packet4i& c, const Packet4i& d) { - const uint16x8_t ab_u16 = pcast<Packet4i, Packet8us>(a, b); - const uint16x8_t cd_u16 = pcast<Packet4i, Packet8us>(c, d); - return vcombine_u8(vmovn_u16(ab_u16), vmovn_u16(cd_u16)); + return preinterpret<Packet16uc>(pcast<Packet4i, Packet16c>(a, b, c, d)); +} +template <> +EIGEN_STRONG_INLINE Packet8uc pcast<Packet4i, Packet8uc>(const Packet4i& a, const Packet4i& b) { + return preinterpret<Packet8uc>(pcast<Packet4i, Packet8c>(a, b)); } template <> EIGEN_STRONG_INLINE Packet8uc pcast<Packet2i, Packet8uc>(const Packet2i& a, const Packet2i& b, const Packet2i& c, const Packet2i& d) { - const uint16x4_t ab_u16 = pcast<Packet2i, Packet4us>(a, b); - const uint16x4_t cd_u16 = pcast<Packet2i, Packet4us>(c, d); - return vmovn_u16(vcombine_u16(ab_u16, cd_u16)); + return preinterpret<Packet8uc>(pcast<Packet2i, Packet8c>(a, b, c, d)); +} +template <> +EIGEN_STRONG_INLINE Packet4uc pcast<Packet4i, Packet4uc>(const Packet4i& a) { + return static_cast<Packet4uc>(pcast<Packet4i, Packet4c>(a)); } //============================================================================== @@ -901,6 +994,10 @@ // Discard second half of input. return vmovl_u32(vget_low_u32(a)); } +template <> +EIGEN_STRONG_INLINE Packet2ul pcast<Packet2ui, Packet2ul>(const Packet2ui& a) { + return vmovl_u32(a); +} template <> struct type_casting_traits<numext::uint32_t, numext::int64_t> { @@ -910,32 +1007,11 @@ EIGEN_STRONG_INLINE Packet2l pcast<Packet4ui, Packet2l>(const Packet4ui& a) { return preinterpret<Packet2l>(pcast<Packet4ui, Packet2ul>(a)); } - template <> -struct type_casting_traits<numext::uint32_t, numext::uint32_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet4ui pcast<Packet4ui, Packet4ui>(const Packet4ui& a) { - return a; -} -template <> -EIGEN_STRONG_INLINE Packet2ui pcast<Packet2ui, Packet2ui>(const Packet2ui& a) { - return a; +EIGEN_STRONG_INLINE Packet2l pcast<Packet2ui, Packet2l>(const Packet2ui& a) { + return preinterpret<Packet2l>(pcast<Packet2ui, Packet2ul>(a)); } -template <> -struct type_casting_traits<numext::uint32_t, numext::int32_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet4i pcast<Packet4ui, Packet4i>(const Packet4ui& a) { - return preinterpret<Packet4i>(a); -} -template <> -EIGEN_STRONG_INLINE Packet2i pcast<Packet2ui, Packet2i>(const Packet2ui& a) { - return preinterpret<Packet2i>(a); -} template <> struct type_casting_traits<numext::uint32_t, numext::uint16_t> { @@ -949,6 +1025,10 @@ EIGEN_STRONG_INLINE Packet4us pcast<Packet2ui, Packet4us>(const Packet2ui& a, const Packet2ui& b) { return vmovn_u32(vcombine_u32(a, b)); } +template <> +EIGEN_STRONG_INLINE Packet4us pcast<Packet4ui, Packet4us>(const Packet4ui& a) { + return vmovn_u32(a); +} template <> struct type_casting_traits<numext::uint32_t, numext::int16_t> { @@ -962,6 +1042,10 @@ EIGEN_STRONG_INLINE Packet4s pcast<Packet2ui, Packet4s>(const Packet2ui& a, const Packet2ui& b) { return preinterpret<Packet4s>(pcast<Packet2ui, Packet4us>(a, b)); } +template <> +EIGEN_STRONG_INLINE Packet4s pcast<Packet4ui, Packet4s>(const Packet4ui& a) { + return preinterpret<Packet4s>(pcast<Packet4ui, Packet4us>(a)); +} template <> struct type_casting_traits<numext::uint32_t, numext::uint8_t> { @@ -975,12 +1059,24 @@ return vcombine_u8(vmovn_u16(ab_u16), vmovn_u16(cd_u16)); } template <> +EIGEN_STRONG_INLINE Packet8uc pcast<Packet4ui, Packet8uc>(const Packet4ui& a, const Packet4ui& b) { + const uint16x8_t ab_u16 = vcombine_u16(vmovn_u32(a), vmovn_u32(b)); + return vmovn_u16(ab_u16); +} +template <> EIGEN_STRONG_INLINE Packet8uc pcast<Packet2ui, Packet8uc>(const Packet2ui& a, const Packet2ui& b, const Packet2ui& c, const Packet2ui& d) { const uint16x4_t ab_u16 = vmovn_u32(vcombine_u32(a, b)); const uint16x4_t cd_u16 = vmovn_u32(vcombine_u32(c, d)); return vmovn_u16(vcombine_u16(ab_u16, cd_u16)); } +template <> +EIGEN_STRONG_INLINE Packet4uc pcast<Packet4ui, Packet4uc>(const Packet4ui& a) { + const uint16x4_t a_u16x4 = vmovn_u32(a); + const uint16x8_t aa_u16x8 = vcombine_u16(a_u16x4, a_u16x4); + const uint8x8_t aa_u8x8 = vmovn_u16(aa_u16x8); + return vget_lane_u32(vreinterpret_u32_u8(aa_u8x8), 0); +} template <> struct type_casting_traits<numext::uint32_t, numext::int8_t> { @@ -992,10 +1088,18 @@ return preinterpret<Packet16c>(pcast<Packet4ui, Packet16uc>(a, b, c, d)); } template <> +EIGEN_STRONG_INLINE Packet8c pcast<Packet4ui, Packet8c>(const Packet4ui& a, const Packet4ui& b) { + return preinterpret<Packet8c>(pcast<Packet4ui, Packet8uc>(a, b)); +} +template <> EIGEN_STRONG_INLINE Packet8c pcast<Packet2ui, Packet8c>(const Packet2ui& a, const Packet2ui& b, const Packet2ui& c, const Packet2ui& d) { return preinterpret<Packet8c>(pcast<Packet2ui, Packet8uc>(a, b, c, d)); } +template <> +EIGEN_STRONG_INLINE Packet4c pcast<Packet4ui, Packet4c>(const Packet4ui& a) { + return static_cast<Packet4c>(pcast<Packet4ui, Packet4uc>(a)); +} //============================================================================== // pcast, SrcType = int64_t @@ -1008,24 +1112,11 @@ EIGEN_STRONG_INLINE Packet4f pcast<Packet2l, Packet4f>(const Packet2l& a, const Packet2l& b) { return vcvtq_f32_s32(vcombine_s32(vmovn_s64(a), vmovn_s64(b))); } - template <> -struct type_casting_traits<numext::int64_t, numext::int64_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet2l pcast<Packet2l, Packet2l>(const Packet2l& a) { - return a; +EIGEN_STRONG_INLINE Packet2f pcast<Packet2l, Packet2f>(const Packet2l& a) { + return vcvt_f32_s32(vmovn_s64(a)); } -template <> -struct type_casting_traits<numext::int64_t, numext::uint64_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet2ul pcast<Packet2l, Packet2ul>(const Packet2l& a) { - return preinterpret<Packet2ul>(a); -} template <> struct type_casting_traits<numext::int64_t, numext::int32_t> { @@ -1035,6 +1126,10 @@ EIGEN_STRONG_INLINE Packet4i pcast<Packet2l, Packet4i>(const Packet2l& a, const Packet2l& b) { return vcombine_s32(vmovn_s64(a), vmovn_s64(b)); } +template <> +EIGEN_STRONG_INLINE Packet2i pcast<Packet2l, Packet2i>(const Packet2l& a) { + return vmovn_s64(a); +} template <> struct type_casting_traits<numext::int64_t, numext::uint32_t> { @@ -1044,6 +1139,10 @@ EIGEN_STRONG_INLINE Packet4ui pcast<Packet2l, Packet4ui>(const Packet2l& a, const Packet2l& b) { return vcombine_u32(vmovn_u64(vreinterpretq_u64_s64(a)), vmovn_u64(vreinterpretq_u64_s64(b))); } +template <> +EIGEN_STRONG_INLINE Packet2ui pcast<Packet2l, Packet2ui>(const Packet2l& a) { + return vmovn_u64(vreinterpretq_u64_s64(a)); +} template <> struct type_casting_traits<numext::int64_t, numext::int16_t> { @@ -1056,6 +1155,11 @@ const int32x4_t cd_s32 = pcast<Packet2l, Packet4i>(c, d); return vcombine_s16(vmovn_s32(ab_s32), vmovn_s32(cd_s32)); } +template <> +EIGEN_STRONG_INLINE Packet4s pcast<Packet2l, Packet4s>(const Packet2l& a, const Packet2l& b) { + const int32x4_t ab_s32 = pcast<Packet2l, Packet4i>(a, b); + return vmovn_s32(ab_s32); +} template <> struct type_casting_traits<numext::int64_t, numext::uint16_t> { @@ -1064,9 +1168,11 @@ template <> EIGEN_STRONG_INLINE Packet8us pcast<Packet2l, Packet8us>(const Packet2l& a, const Packet2l& b, const Packet2l& c, const Packet2l& d) { - const uint32x4_t ab_u32 = pcast<Packet2l, Packet4ui>(a, b); - const uint32x4_t cd_u32 = pcast<Packet2l, Packet4ui>(c, d); - return vcombine_u16(vmovn_u32(ab_u32), vmovn_u32(cd_u32)); + return preinterpret<Packet8us>(pcast<Packet2l, Packet8s>(a, b, c, d)); +} +template <> +EIGEN_STRONG_INLINE Packet4us pcast<Packet2l, Packet4us>(const Packet2l& a, const Packet2l& b) { + return preinterpret<Packet4us>(pcast<Packet2l, Packet4s>(a, b)); } template <> @@ -1081,6 +1187,19 @@ const int16x8_t efgh_s16 = pcast<Packet2l, Packet8s>(e, f, g, h); return vcombine_s8(vmovn_s16(abcd_s16), vmovn_s16(efgh_s16)); } +template <> +EIGEN_STRONG_INLINE Packet8c pcast<Packet2l, Packet8c>(const Packet2l& a, const Packet2l& b, const Packet2l& c, + const Packet2l& d) { + const int16x8_t abcd_s16 = pcast<Packet2l, Packet8s>(a, b, c, d); + return vmovn_s16(abcd_s16); +} +template <> +EIGEN_STRONG_INLINE Packet4c pcast<Packet2l, Packet4c>(const Packet2l& a, const Packet2l& b) { + const int16x4_t ab_s16 = pcast<Packet2l, Packet4s>(a, b); + const int16x8_t abab_s16 = vcombine_s16(ab_s16, ab_s16); + const int8x8_t abab_s8 = vmovn_s16(abab_s16); + return vget_lane_s32(vreinterpret_s32_s8(abab_s8), 0); +} template <> struct type_casting_traits<numext::int64_t, numext::uint8_t> { @@ -1094,6 +1213,15 @@ const uint16x8_t efgh_u16 = pcast<Packet2l, Packet8us>(e, f, g, h); return vcombine_u8(vmovn_u16(abcd_u16), vmovn_u16(efgh_u16)); } +template <> +EIGEN_STRONG_INLINE Packet8uc pcast<Packet2l, Packet8uc>(const Packet2l& a, const Packet2l& b, const Packet2l& c, + const Packet2l& d) { + return preinterpret<Packet8uc>(pcast<Packet2l, Packet8c>(a, b, c, d)); +} +template <> +EIGEN_STRONG_INLINE Packet4uc pcast<Packet2l, Packet4uc>(const Packet2l& a, const Packet2l& b) { + return static_cast<Packet4uc>(pcast<Packet2l, Packet4c>(a, b)); +} //============================================================================== // pcast, SrcType = uint64_t @@ -1106,24 +1234,11 @@ EIGEN_STRONG_INLINE Packet4f pcast<Packet2ul, Packet4f>(const Packet2ul& a, const Packet2ul& b) { return vcvtq_f32_u32(vcombine_u32(vmovn_u64(a), vmovn_u64(b))); } - template <> -struct type_casting_traits<numext::uint64_t, numext::uint64_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet2ul pcast<Packet2ul, Packet2ul>(const Packet2ul& a) { - return a; +EIGEN_STRONG_INLINE Packet2f pcast<Packet2ul, Packet2f>(const Packet2ul& a) { + return vcvt_f32_u32(vmovn_u64(a)); } -template <> -struct type_casting_traits<numext::uint64_t, numext::int64_t> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet2l pcast<Packet2ul, Packet2l>(const Packet2ul& a) { - return preinterpret<Packet2l>(a); -} template <> struct type_casting_traits<numext::uint64_t, numext::uint32_t> { @@ -1133,6 +1248,10 @@ EIGEN_STRONG_INLINE Packet4ui pcast<Packet2ul, Packet4ui>(const Packet2ul& a, const Packet2ul& b) { return vcombine_u32(vmovn_u64(a), vmovn_u64(b)); } +template <> +EIGEN_STRONG_INLINE Packet2ui pcast<Packet2ul, Packet2ui>(const Packet2ul& a) { + return vmovn_u64(a); +} template <> struct type_casting_traits<numext::uint64_t, numext::int32_t> { @@ -1142,6 +1261,10 @@ EIGEN_STRONG_INLINE Packet4i pcast<Packet2ul, Packet4i>(const Packet2ul& a, const Packet2ul& b) { return preinterpret<Packet4i>(pcast<Packet2ul, Packet4ui>(a, b)); } +template <> +EIGEN_STRONG_INLINE Packet2i pcast<Packet2ul, Packet2i>(const Packet2ul& a) { + return preinterpret<Packet2i>(pcast<Packet2ul, Packet2ui>(a)); +} template <> struct type_casting_traits<numext::uint64_t, numext::uint16_t> { @@ -1154,6 +1277,10 @@ const uint16x4_t cd_u16 = vmovn_u32(vcombine_u32(vmovn_u64(c), vmovn_u64(d))); return vcombine_u16(ab_u16, cd_u16); } +template <> +EIGEN_STRONG_INLINE Packet4us pcast<Packet2ul, Packet4us>(const Packet2ul& a, const Packet2ul& b) { + return vmovn_u32(vcombine_u32(vmovn_u64(a), vmovn_u64(b))); +} template <> struct type_casting_traits<numext::uint64_t, numext::int16_t> { @@ -1164,6 +1291,10 @@ const Packet2ul& d) { return preinterpret<Packet8s>(pcast<Packet2ul, Packet8us>(a, b, c, d)); } +template <> +EIGEN_STRONG_INLINE Packet4s pcast<Packet2ul, Packet4s>(const Packet2ul& a, const Packet2ul& b) { + return preinterpret<Packet4s>(pcast<Packet2ul, Packet4us>(a, b)); +} template <> struct type_casting_traits<numext::uint64_t, numext::uint8_t> { @@ -1177,6 +1308,19 @@ const uint16x8_t efgh_u16 = pcast<Packet2ul, Packet8us>(e, f, g, h); return vcombine_u8(vmovn_u16(abcd_u16), vmovn_u16(efgh_u16)); } +template <> +EIGEN_STRONG_INLINE Packet8uc pcast<Packet2ul, Packet8uc>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c, + const Packet2ul& d) { + const uint16x8_t abcd_u16 = pcast<Packet2ul, Packet8us>(a, b, c, d); + return vmovn_u16(abcd_u16); +} +template <> +EIGEN_STRONG_INLINE Packet4uc pcast<Packet2ul, Packet4uc>(const Packet2ul& a, const Packet2ul& b) { + const uint16x4_t ab_u16 = pcast<Packet2ul, Packet4us>(a, b); + const uint16x8_t abab_u16 = vcombine_u16(ab_u16, ab_u16); + const uint8x8_t abab_u8 = vmovn_u16(abab_u16); + return vget_lane_u32(vreinterpret_u32_u8(abab_u8), 0); +} template <> struct type_casting_traits<numext::uint64_t, numext::int8_t> { @@ -1188,6 +1332,15 @@ const Packet2ul& g, const Packet2ul& h) { return preinterpret<Packet16c>(pcast<Packet2ul, Packet16uc>(a, b, c, d, e, f, g, h)); } +template <> +EIGEN_STRONG_INLINE Packet8c pcast<Packet2ul, Packet8c>(const Packet2ul& a, const Packet2ul& b, const Packet2ul& c, + const Packet2ul& d) { + return preinterpret<Packet8c>(pcast<Packet2ul, Packet8uc>(a, b, c, d)); +} +template <> +EIGEN_STRONG_INLINE Packet4c pcast<Packet2ul, Packet4c>(const Packet2ul& a, const Packet2ul& b) { + return static_cast<Packet4c>(pcast<Packet2ul, Packet4uc>(a, b)); +} #if EIGEN_ARCH_ARM64 @@ -1220,14 +1373,6 @@ return Packet4i(vreinterpretq_s32_f64(a)); } -template <> -struct type_casting_traits<double, double> { - enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 }; -}; -template <> -EIGEN_STRONG_INLINE Packet2d pcast<Packet2d, Packet2d>(const Packet2d& a) { - return a; -} template <> struct type_casting_traits<double, float> { @@ -1237,6 +1382,10 @@ EIGEN_STRONG_INLINE Packet4f pcast<Packet2d, Packet4f>(const Packet2d& a, const Packet2d& b) { return vcombine_f32(vcvt_f32_f64(a), vcvt_f32_f64(b)); } +template <> +EIGEN_STRONG_INLINE Packet2f pcast<Packet2d, Packet2f>(const Packet2d& a) { + return vcvt_f32_f64(a); +} template <> struct type_casting_traits<double, numext::int64_t> { @@ -1264,6 +1413,10 @@ EIGEN_STRONG_INLINE Packet4i pcast<Packet2d, Packet4i>(const Packet2d& a, const Packet2d& b) { return vcombine_s32(vmovn_s64(vcvtq_s64_f64(a)), vmovn_s64(vcvtq_s64_f64(b))); } +template <> +EIGEN_STRONG_INLINE Packet2i pcast<Packet2d, Packet2i>(const Packet2d& a) { + return vmovn_s64(vcvtq_s64_f64(a)); +} template <> struct type_casting_traits<double, numext::uint32_t> { @@ -1273,6 +1426,10 @@ EIGEN_STRONG_INLINE Packet4ui pcast<Packet2d, Packet4ui>(const Packet2d& a, const Packet2d& b) { return vcombine_u32(vmovn_u64(vcvtq_u64_f64(a)), vmovn_u64(vcvtq_u64_f64(b))); } +template <> +EIGEN_STRONG_INLINE Packet2ui pcast<Packet2d, Packet2ui>(const Packet2d& a) { + return vmovn_u64(vcvtq_u64_f64(a)); +} template <> struct type_casting_traits<double, numext::int16_t> { @@ -1285,6 +1442,11 @@ const int32x4_t cd_s32 = pcast<Packet2d, Packet4i>(c, d); return vcombine_s16(vmovn_s32(ab_s32), vmovn_s32(cd_s32)); } +template <> +EIGEN_STRONG_INLINE Packet4s pcast<Packet2d, Packet4s>(const Packet2d& a, const Packet2d& b) { + const int32x4_t ab_s32 = pcast<Packet2d, Packet4i>(a, b); + return vmovn_s32(ab_s32); +} template <> struct type_casting_traits<double, numext::uint16_t> { @@ -1293,9 +1455,11 @@ template <> EIGEN_STRONG_INLINE Packet8us pcast<Packet2d, Packet8us>(const Packet2d& a, const Packet2d& b, const Packet2d& c, const Packet2d& d) { - const uint32x4_t ab_u32 = pcast<Packet2d, Packet4ui>(a, b); - const uint32x4_t cd_u32 = pcast<Packet2d, Packet4ui>(c, d); - return vcombine_u16(vmovn_u32(ab_u32), vmovn_u32(cd_u32)); + return preinterpret<Packet8us>(pcast<Packet2d, Packet8s>(a, b, c, d)); +} +template <> +EIGEN_STRONG_INLINE Packet4us pcast<Packet2d, Packet4us>(const Packet2d& a, const Packet2d& b) { + return preinterpret<Packet4us>(pcast<Packet2d, Packet4s>(a, b)); } template <> @@ -1310,6 +1474,17 @@ const int16x8_t efgh_s16 = pcast<Packet2d, Packet8s>(e, f, g, h); return vcombine_s8(vmovn_s16(abcd_s16), vmovn_s16(efgh_s16)); } +template <> +EIGEN_STRONG_INLINE Packet8c pcast<Packet2d, Packet8c>(const Packet2d& a, const Packet2d& b, const Packet2d& c, + const Packet2d& d) { + const int16x8_t abcd_s16 = pcast<Packet2d, Packet8s>(a, b, c, d); + return vmovn_s16(abcd_s16); +} +template <> +EIGEN_STRONG_INLINE Packet4c pcast<Packet2d, Packet4c>(const Packet2d& a, const Packet2d& b) { + const int32x4_t ab_s32 = pcast<Packet2d, Packet4i>(a, b); + return pcast<Packet4i, Packet4c>(ab_s32); +} template <> struct type_casting_traits<double, numext::uint8_t> { @@ -1323,6 +1498,15 @@ const uint16x8_t efgh_u16 = pcast<Packet2d, Packet8us>(e, f, g, h); return vcombine_u8(vmovn_u16(abcd_u16), vmovn_u16(efgh_u16)); } +template <> +EIGEN_STRONG_INLINE Packet8uc pcast<Packet2d, Packet8uc>(const Packet2d& a, const Packet2d& b, const Packet2d& c, + const Packet2d& d) { + return preinterpret<Packet8uc>(pcast<Packet2d, Packet8c>(a, b, c, d)); +} +template <> +EIGEN_STRONG_INLINE Packet4uc pcast<Packet2d, Packet4uc>(const Packet2d& a, const Packet2d& b) { + return static_cast<Packet4uc>(pcast<Packet2d, Packet4c>(a, b)); +} template <> struct type_casting_traits<float, double> { @@ -1333,6 +1517,10 @@ // Discard second-half of input. return vcvt_f64_f32(vget_low_f32(a)); } +template <> +EIGEN_STRONG_INLINE Packet2d pcast<Packet2f, Packet2d>(const Packet2f& a) { + return vcvt_f64_f32(a); +} template <> struct type_casting_traits<numext::int8_t, double> { @@ -1388,6 +1576,10 @@ // Discard second half of input. return vcvtq_f64_s64(vmovl_s32(vget_low_s32(a))); } +template <> +EIGEN_STRONG_INLINE Packet2d pcast<Packet2i, Packet2d>(const Packet2i& a) { + return vcvtq_f64_s64(vmovl_s32(a)); +} template <> struct type_casting_traits<numext::uint32_t, double> { @@ -1398,6 +1590,10 @@ // Discard second half of input. return vcvtq_f64_u64(vmovl_u32(vget_low_u32(a))); } +template <> +EIGEN_STRONG_INLINE Packet2d pcast<Packet2ui, Packet2d>(const Packet2ui& a) { + return vcvtq_f64_u64(vmovl_u32(a)); +} template <> struct type_casting_traits<numext::int64_t, double> {
diff --git a/Eigen/src/Core/arch/SSE/TypeCasting.h b/Eigen/src/Core/arch/SSE/TypeCasting.h index df5c72c..0b5aa1c 100644 --- a/Eigen/src/Core/arch/SSE/TypeCasting.h +++ b/Eigen/src/Core/arch/SSE/TypeCasting.h
@@ -135,6 +135,13 @@ return _mm_castpd_si128(a); } +template<> EIGEN_STRONG_INLINE Packet4ui preinterpret<Packet4ui, Packet4i>(const Packet4i& a) { + return Packet4ui(a); +} + +template<> EIGEN_STRONG_INLINE Packet4i preinterpret<Packet4i, Packet4ui>(const Packet4ui& a) { + return Packet4i(a); +} // Disable the following code since it's broken on too many platforms / compilers. //#elif defined(EIGEN_VECTORIZE_SSE) && (!EIGEN_ARCH_x86_64) && (!EIGEN_COMP_MSVC) #if 0
diff --git a/Eigen/src/Core/functors/UnaryFunctors.h b/Eigen/src/Core/functors/UnaryFunctors.h index 8354c0a..4760d9b 100644 --- a/Eigen/src/Core/functors/UnaryFunctors.h +++ b/Eigen/src/Core/functors/UnaryFunctors.h
@@ -179,17 +179,29 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const NewType operator() (const Scalar& a) const { return cast<Scalar, NewType>(a); } }; -template <typename Scalar> -struct scalar_cast_op<Scalar, bool> { - typedef bool result_type; - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const Scalar& a) const { return a != Scalar(0); } -}; - template<typename Scalar, typename NewType> struct functor_traits<scalar_cast_op<Scalar,NewType> > { enum { Cost = is_same<Scalar, NewType>::value ? 0 : NumTraits<NewType>::AddCost, PacketAccess = false }; }; /** \internal + * `core_cast_op` serves to distinguish the vectorized implementation from that of the legacy `scalar_cast_op` for backwards + * compatibility. The manner in which packet ops are handled is defined by the specialized unary_evaluator: + * `unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, IndexBased>` in CoreEvaluators.h + * Otherwise, the non-vectorized behavior is identical to that of `scalar_cast_op` + */ +template <typename SrcType, typename DstType> +struct core_cast_op : scalar_cast_op<SrcType, DstType> {}; + +template <typename SrcType, typename DstType> +struct functor_traits<core_cast_op<SrcType, DstType>> { + using CastingTraits = type_casting_traits<SrcType, DstType>; + enum { + Cost = is_same<SrcType, DstType>::value ? 0 : NumTraits<DstType>::AddCost, + PacketAccess = CastingTraits::VectorizedCast && (CastingTraits::SrcCoeffRatio <= 8) + }; +}; + +/** \internal * \brief Template functor to arithmetically shift a scalar right by a number of bits * * \sa class CwiseUnaryOp, MatrixBase::shift_right()
diff --git a/Eigen/src/Core/util/XprHelper.h b/Eigen/src/Core/util/XprHelper.h index b5f91bf..49fa37c 100644 --- a/Eigen/src/Core/util/XprHelper.h +++ b/Eigen/src/Core/util/XprHelper.h
@@ -190,6 +190,30 @@ typedef typename find_best_packet_helper<Size,typename packet_traits<T>::type>::type type; }; +template <int Size, typename PacketType, + bool Stop = (Size == unpacket_traits<PacketType>::size) || + is_same<PacketType, typename unpacket_traits<PacketType>::half>::value> +struct find_packet_by_size_helper; +template <int Size, typename PacketType> +struct find_packet_by_size_helper<Size, PacketType, true> { + using type = PacketType; +}; +template <int Size, typename PacketType> +struct find_packet_by_size_helper<Size, PacketType, false> { + using type = typename find_packet_by_size_helper<Size, typename unpacket_traits<PacketType>::half>::type; +}; + +template <typename T, int Size> +struct find_packet_by_size { + using type = typename find_packet_by_size_helper<Size, typename packet_traits<T>::type>::type; + static constexpr bool value = (Size == unpacket_traits<type>::size); +}; +template <typename T> +struct find_packet_by_size<T, 1> { + using type = typename unpacket_traits<T>::type; + static constexpr bool value = (unpacket_traits<type>::size == 1); +}; + #if EIGEN_MAX_STATIC_ALIGN_BYTES>0 constexpr inline int compute_default_alignment_helper(int ArrayBytes, int AlignmentBytes) { if((ArrayBytes % AlignmentBytes) == 0) {
diff --git a/Eigen/src/plugins/CommonCwiseUnaryOps.h b/Eigen/src/plugins/CommonCwiseUnaryOps.h index 390759c..1c6b284 100644 --- a/Eigen/src/plugins/CommonCwiseUnaryOps.h +++ b/Eigen/src/plugins/CommonCwiseUnaryOps.h
@@ -45,7 +45,7 @@ operator-() const { return NegativeReturnType(derived()); } -template<class NewType> struct CastXpr { typedef typename internal::cast_return_type<Derived,const CwiseUnaryOp<internal::scalar_cast_op<Scalar, NewType>, const Derived> >::type Type; }; +template<class NewType> struct CastXpr { typedef typename internal::cast_return_type<Derived,const CwiseUnaryOp<internal::core_cast_op<Scalar, NewType>, const Derived> >::type Type; }; /// \returns an expression of \c *this with the \a Scalar type casted to /// \a NewScalar.
diff --git a/test/array_cwise.cpp b/test/array_cwise.cpp index 989359f..1648c7c 100644 --- a/test/array_cwise.cpp +++ b/test/array_cwise.cpp
@@ -9,6 +9,7 @@ #include <vector> #include "main.h" +#include "random_without_cast_overflow.h" // suppress annoying unsigned integer warnings template <typename Scalar, bool IsSigned = NumTraits<Scalar>::IsSigned> @@ -1213,6 +1214,109 @@ typed_logicals_test_impl<ArrayType>::run(m); } +template <typename SrcType, typename DstType, int RowsAtCompileTime, int ColsAtCompileTime> +struct cast_test_impl { + using SrcArray = Array<SrcType, RowsAtCompileTime, ColsAtCompileTime>; + using DstArray = Array<DstType, RowsAtCompileTime, ColsAtCompileTime>; + struct RandomOp { + inline SrcType operator()(const SrcType&) const { + return internal::random_without_cast_overflow<SrcType, DstType>::value(); + } + }; + + static constexpr int SrcPacketSize = internal::packet_traits<SrcType>::size; + static constexpr int DstPacketSize = internal::packet_traits<DstType>::size; + static constexpr int MaxPacketSize = internal::plain_enum_max(SrcPacketSize, DstPacketSize); + + // print non-mangled typenames + template <typename T> + static std::string printTypeInfo(const T&) { + if (internal::is_same<bool, T>::value) + return "bool"; + else if (internal::is_same<int8_t, T>::value) + return "int8_t"; + else if (internal::is_same<int16_t, T>::value) + return "int16_t"; + else if (internal::is_same<int32_t, T>::value) + return "int32_t"; + else if (internal::is_same<int64_t, T>::value) + return "int64_t"; + else if (internal::is_same<uint8_t, T>::value) + return "uint8_t"; + else if (internal::is_same<uint16_t, T>::value) + return "uint16_t"; + else if (internal::is_same<uint32_t, T>::value) + return "uint32_t"; + else if (internal::is_same<uint64_t, T>::value) + return "uint64_t"; + else if (internal::is_same<float, T>::value) + return "float"; + else if (internal::is_same<double, T>::value) + return "double"; + //else if (internal::is_same<long double, T>::value) + // return "long double"; + else if (internal::is_same<half, T>::value) + return "half"; + else if (internal::is_same<bfloat16, T>::value) + return "bfloat16"; + else + return typeid(T).name(); + } + + static void run() { + const Index testRows = RowsAtCompileTime == Dynamic ? ((10 * MaxPacketSize) + 1) : RowsAtCompileTime; + const Index testCols = ColsAtCompileTime == Dynamic ? ((10 * MaxPacketSize) + 1) : ColsAtCompileTime; + const Index testSize = testRows * testCols; + const Index minTestSize = 100; + const Index repeats = numext::div_ceil(minTestSize, testSize); + SrcArray src(testRows, testCols); + DstArray dst(testRows, testCols); + for (Index repeat = 0; repeat < repeats; repeat++) { + src = src.unaryExpr(RandomOp()); + dst = src.template cast<DstType>(); + for (Index i = 0; i < testRows; i++) + for (Index j = 0; j < testCols; j++) { + DstType ref = internal::cast_impl<SrcType, DstType>::run(src(i, j)); + bool all_nan = ((numext::isnan)(src(i, j)) && (numext::isnan)(ref) && (numext::isnan)(dst(i, j))); + bool is_equal = ref == dst(i, j); + bool pass = all_nan || is_equal; + if (!pass) { + std::cout << printTypeInfo(SrcType()) << ": [" << +src(i, j) << "] to " << printTypeInfo(DstType()) << ": [" + << +dst(i, j) << "] != [" << +ref << "]\n"; + } + VERIFY(pass); + } + } + } +}; + +template <int RowsAtCompileTime, int ColsAtCompileTime, typename... ScalarTypes> +struct cast_tests_impl { + using ScalarTuple = std::tuple<ScalarTypes...>; + static constexpr size_t ScalarTupleSize = std::tuple_size<ScalarTuple>::value; + + template <size_t i = 0, size_t j = i + 1, bool Done = (i >= ScalarTupleSize - 1) || (j >= ScalarTupleSize)> + static std::enable_if_t<Done> run() {} + + template <size_t i = 0, size_t j = i + 1, bool Done = (i >= ScalarTupleSize - 1) || (j >= ScalarTupleSize)> + static std::enable_if_t<!Done> run() { + using Type1 = typename std::tuple_element<i, ScalarTuple>::type; + using Type2 = typename std::tuple_element<j, ScalarTuple>::type; + cast_test_impl<Type1, Type2, RowsAtCompileTime, ColsAtCompileTime>::run(); + cast_test_impl<Type2, Type1, RowsAtCompileTime, ColsAtCompileTime>::run(); + static constexpr size_t next_i = (j == ScalarTupleSize - 1) ? (i + 1) : (i + 0); + static constexpr size_t next_j = (j == ScalarTupleSize - 1) ? (i + 2) : (j + 1); + run<next_i, next_j>(); + } +}; + +// for now, remove all references to 'long double' until test passes on all platforms +template <int RowsAtCompileTime, int ColsAtCompileTime> +void cast_test() { + cast_tests_impl<RowsAtCompileTime, ColsAtCompileTime, bool, int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, + uint32_t, uint64_t, float, double, /*long double, */half, bfloat16>::run(); +} + EIGEN_DECLARE_TEST(array_cwise) { for(int i = 0; i < g_repeat; i++) { @@ -1269,6 +1373,20 @@ CALL_SUBTEST_3( typed_logicals_test(ArrayX<std::complex<double>>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)))); } + for (int i = 0; i < g_repeat; i++) { + CALL_SUBTEST_1((cast_test<1, 1>())); + CALL_SUBTEST_2((cast_test<3, 1>())); + CALL_SUBTEST_2((cast_test<3, 3>())); + CALL_SUBTEST_3((cast_test<5, 1>())); + CALL_SUBTEST_3((cast_test<5, 5>())); + CALL_SUBTEST_4((cast_test<9, 1>())); + CALL_SUBTEST_4((cast_test<9, 9>())); + CALL_SUBTEST_5((cast_test<17, 1>())); + CALL_SUBTEST_5((cast_test<17, 17>())); + CALL_SUBTEST_6((cast_test<Dynamic, 1>())); + CALL_SUBTEST_6((cast_test<Dynamic, Dynamic>())); + } + VERIFY((internal::is_same< internal::global_math_functions_filtering_base<int>::type, int >::value)); VERIFY((internal::is_same< internal::global_math_functions_filtering_base<float>::type, float >::value)); VERIFY((internal::is_same< internal::global_math_functions_filtering_base<Array2i>::type, ArrayBase<Array2i> >::value));