// This file is part of Eigen, a lightweight C++ template library // for linear algebra. // // Copyright (C) 2015 Benoit Steiner // // 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_CXX11_TENSOR_TENSOR_CONVERSION_H #define EIGEN_CXX11_TENSOR_TENSOR_CONVERSION_H namespace Eigen { /** \class TensorConversionOp * \ingroup CXX11_Tensor_Module * * \brief Tensor conversion class. This class makes it possible to vectorize * type casting operations when the number of scalars per packet in the source * and the destination type differ */ namespace internal { template struct traits > { // Type promotion to handle the case where the types of the lhs and the rhs are different. typedef TargetType Scalar; typedef typename traits::StorageKind StorageKind; typedef typename traits::Index Index; typedef typename XprType::Nested Nested; typedef typename remove_reference::type _Nested; static const int NumDimensions = traits::NumDimensions; static const int Layout = traits::Layout; enum { Flags = 0 }; }; template struct eval, Eigen::Dense> { typedef const TensorConversionOp& type; }; template struct nested, 1, typename eval >::type> { typedef TensorConversionOp type; }; } // end namespace internal template struct PacketConverter { PacketConverter(const TensorEvaluator& impl) : m_impl(impl) {} template EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const { return internal::pcast(m_impl.template packet(index)); } private: const TensorEvaluator& m_impl; }; template struct PacketConverter { PacketConverter(const TensorEvaluator& impl) : m_impl(impl) {} template EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const { const int SrcPacketSize = internal::unpacket_traits::size; SrcPacket src1 = m_impl.template packet(index); SrcPacket src2 = m_impl.template packet(index + SrcPacketSize); TgtPacket result = internal::pcast(src1, src2); return result; } private: const TensorEvaluator& m_impl; }; template struct PacketConverter { PacketConverter(const TensorEvaluator& impl) : m_impl(impl) {} template EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const { const int SrcPacketSize = internal::unpacket_traits::size; SrcPacket src1 = m_impl.template packet(index); SrcPacket src2 = m_impl.template packet(index + SrcPacketSize); SrcPacket src3 = m_impl.template packet(index + 2 * SrcPacketSize); SrcPacket src4 = m_impl.template packet(index + 3 * SrcPacketSize); TgtPacket result = internal::pcast(src1, src2, src3, src4); return result; } private: const TensorEvaluator& m_impl; }; template struct PacketConverter { PacketConverter(const TensorEvaluator& impl) : m_impl(impl), m_maxIndex(impl.dimensions().TotalSize()) {} template EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const { const int SrcPacketSize = internal::unpacket_traits::size; if (index + SrcPacketSize < m_maxIndex) { return internal::pcast(m_impl.template packet(index)); } else { const int TgtPacketSize = internal::unpacket_traits::size; EIGEN_ALIGN_DEFAULT typename internal::unpacket_traits::type values[TgtPacketSize]; for (int i = 0; i < TgtPacketSize; ++i) { values[i] = m_impl.coeff(index+i); } TgtPacket rslt = internal::pload(values); return rslt; } } private: const TensorEvaluator& m_impl; const typename TensorEvaluator::Index m_maxIndex; }; template class TensorConversionOp : public TensorBase, ReadOnlyAccessors> { public: typedef typename internal::traits::Scalar Scalar; typedef typename internal::traits::StorageKind StorageKind; typedef typename internal::traits::Index Index; typedef typename internal::nested::type Nested; typedef Scalar CoeffReturnType; typedef typename NumTraits::Real RealScalar; EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConversionOp(const XprType& xpr) : m_xpr(xpr) {} EIGEN_DEVICE_FUNC const typename internal::remove_all::type& expression() const { return m_xpr; } protected: typename XprType::Nested m_xpr; }; // Eval as rvalue template struct TensorEvaluator, Device> { typedef TensorConversionOp XprType; typedef typename XprType::Index Index; typedef typename TensorEvaluator::Dimensions Dimensions; typedef TargetType Scalar; typedef TargetType CoeffReturnType; typedef typename internal::remove_all::Scalar>::type SrcType; typedef typename PacketType::type PacketReturnType; typedef typename PacketType::type PacketSourceType; enum { IsAligned = false, PacketAccess = TensorEvaluator::PacketAccess && internal::type_casting_traits::VectorizedCast, BlockAccess = false, Layout = TensorEvaluator::Layout, }; EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device) : m_impl(op.expression(), device) { } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_impl.dimensions(); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(Scalar* data) { if (internal::is_same::value) { return m_impl.evalSubExprsIfNeeded((SrcType*)data); } m_impl.evalSubExprsIfNeeded(NULL); return true; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void cleanup() { m_impl.cleanup(); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { internal::scalar_cast_op converter; return converter(m_impl.coeff(index)); } template EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const { const int SrcCoeffRatio = internal::type_casting_traits::SrcCoeffRatio; const int TgtCoeffRatio = internal::type_casting_traits::TgtCoeffRatio; PacketConverter, PacketSourceType, PacketReturnType, SrcCoeffRatio, TgtCoeffRatio> converter(m_impl); return converter.template packet(index); } EIGEN_DEVICE_FUNC Scalar* data() const { return NULL; } protected: TensorEvaluator m_impl; }; } // end namespace Eigen #endif // EIGEN_CXX11_TENSOR_TENSOR_CONVERSION_H