TensorConversion.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2015 Benoit Steiner <benoit.steiner.goog@gmail.com>
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 
10 #ifndef EIGEN_CXX11_TENSOR_TENSOR_CONVERSION_H
11 #define EIGEN_CXX11_TENSOR_TENSOR_CONVERSION_H
12 
13 namespace Eigen {
14 
22 namespace internal {
23 template<typename TargetType, typename XprType>
24 struct traits<TensorConversionOp<TargetType, XprType> >
25 {
26  // Type promotion to handle the case where the types of the lhs and the rhs are different.
27  typedef TargetType Scalar;
28  typedef typename packet_traits<Scalar>::type Packet;
29  typedef typename traits<XprType>::StorageKind StorageKind;
30  typedef typename traits<XprType>::Index Index;
31  typedef typename XprType::Nested Nested;
32  typedef typename remove_reference<Nested>::type _Nested;
33  static const int NumDimensions = traits<XprType>::NumDimensions;
34  static const int Layout = traits<XprType>::Layout;
35  enum { Flags = 0 };
36 };
37 
38 template<typename TargetType, typename XprType>
39 struct eval<TensorConversionOp<TargetType, XprType>, Eigen::Dense>
40 {
41  typedef const TensorConversionOp<TargetType, XprType>& type;
42 };
43 
44 template<typename TargetType, typename XprType>
45 struct nested<TensorConversionOp<TargetType, XprType>, 1, typename eval<TensorConversionOp<TargetType, XprType> >::type>
46 {
47  typedef TensorConversionOp<TargetType, XprType> type;
48 };
49 
50 } // end namespace internal
51 
52 
53 template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket, int SrcCoeffRatio, int TgtCoeffRatio>
54 struct PacketConverter {
55  PacketConverter(const TensorEvaluator& impl)
56  : m_impl(impl) {}
57 
58  template<int LoadMode, typename Index>
59  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
60  return internal::pcast<SrcPacket, TgtPacket>(m_impl.template packet<LoadMode>(index));
61  }
62 
63  private:
64  const TensorEvaluator& m_impl;
65 };
66 
67 
68 template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
69 struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 2, 1> {
70  PacketConverter(const TensorEvaluator& impl)
71  : m_impl(impl) {}
72 
73  template<int LoadMode, typename Index>
74  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
75  const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
76 
77  SrcPacket src1 = m_impl.template packet<LoadMode>(index);
78  SrcPacket src2 = m_impl.template packet<LoadMode>(index + SrcPacketSize);
79  TgtPacket result = internal::pcast<SrcPacket, TgtPacket>(src1, src2);
80  return result;
81  }
82 
83  private:
84  const TensorEvaluator& m_impl;
85 };
86 
87 
88 template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
89 struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 1, 2> {
90  PacketConverter(const TensorEvaluator& impl)
91  : m_impl(impl), m_maxIndex(impl.dimensions().TotalSize()) {}
92 
93  template<int LoadMode, typename Index>
94  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
95  const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
96  // Only call m_impl.packet() when we have direct access to the underlying data. This
97  // ensures that we don't compute the subexpression twice. We may however load some
98  // coefficients twice, but in practice this doesn't negatively impact performance.
99  if (m_impl.data() && (index + SrcPacketSize < m_maxIndex)) {
100  // Force unaligned memory loads since we can't ensure alignment anymore
101  return internal::pcast<SrcPacket, TgtPacket>(m_impl.template packet<Unaligned>(index));
102  } else {
103  const int TgtPacketSize = internal::unpacket_traits<TgtPacket>::size;
104  EIGEN_ALIGN_MAX typename internal::unpacket_traits<TgtPacket>::type values[TgtPacketSize];
105  for (int i = 0; i < TgtPacketSize; ++i) {
106  values[i] = m_impl.coeff(index+i);
107  }
108  TgtPacket rslt = internal::pload<TgtPacket>(values);
109  return rslt;
110  }
111  }
112 
113  private:
114  const TensorEvaluator& m_impl;
115  const typename TensorEvaluator::Index m_maxIndex;
116 };
117 
118 template<typename TargetType, typename XprType>
119 class TensorConversionOp : public TensorBase<TensorConversionOp<TargetType, XprType>, ReadOnlyAccessors>
120 {
121  public:
122  typedef typename internal::traits<TensorConversionOp>::Scalar Scalar;
123  typedef typename internal::traits<TensorConversionOp>::Packet Packet;
124  typedef typename internal::traits<TensorConversionOp>::StorageKind StorageKind;
125  typedef typename internal::traits<TensorConversionOp>::Index Index;
126  typedef typename internal::nested<TensorConversionOp>::type Nested;
127  typedef typename XprType::CoeffReturnType CoeffReturnType;
128  typedef typename XprType::PacketReturnType PacketReturnType;
129  typedef typename NumTraits<Scalar>::Real RealScalar;
130 
131  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConversionOp(const XprType& xpr)
132  : m_xpr(xpr) {}
133 
134  EIGEN_DEVICE_FUNC
135  const typename internal::remove_all<typename XprType::Nested>::type&
136  expression() const { return m_xpr; }
137 
138  protected:
139  typename XprType::Nested m_xpr;
140 };
141 
142 
143 
144 
145 // Eval as rvalue
146 template<typename TargetType, typename ArgType, typename Device>
147 struct TensorEvaluator<const TensorConversionOp<TargetType, ArgType>, Device>
148 {
150  typedef typename XprType::Index Index;
151  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
152  typedef TargetType Scalar;
153  typedef TargetType CoeffReturnType;
154  typedef typename internal::remove_all<typename internal::traits<ArgType>::Scalar>::type SrcType;
155  typedef typename internal::traits<XprType>::Packet PacketReturnType;
156  typedef typename internal::packet_traits<SrcType>::type PacketSourceType;
157 
158  enum {
159  IsAligned = false,
160  PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess && internal::type_casting_traits<SrcType, TargetType>::VectorizedCast,
162  };
163 
164  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
165  : m_impl(op.expression(), device)
166  {
167  }
168 
169  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_impl.dimensions(); }
170 
171  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(Scalar* /*data*/)
172  {
173  m_impl.evalSubExprsIfNeeded(NULL);
174  return true;
175  }
176 
177  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void cleanup()
178  {
179  m_impl.cleanup();
180  }
181 
182  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
183  {
184  internal::scalar_cast_op<SrcType, TargetType> converter;
185  return converter(m_impl.coeff(index));
186  }
187 
188  template<int LoadMode>
189  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
190  {
191  const int SrcCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::SrcCoeffRatio;
192  const int TgtCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::TgtCoeffRatio;
193  PacketConverter<TensorEvaluator<ArgType, Device>, PacketSourceType, PacketReturnType,
194  SrcCoeffRatio, TgtCoeffRatio> converter(m_impl);
195  return converter.template packet<LoadMode>(index);
196  }
197 
198  EIGEN_DEVICE_FUNC Scalar* data() const { return NULL; }
199 
200  protected:
201  TensorEvaluator<ArgType, Device> m_impl;
202 };
203 
204 } // end namespace Eigen
205 
206 #endif // EIGEN_CXX11_TENSOR_TENSOR_CONVERSION_H
Namespace containing all symbols from the Eigen library.
Definition: CXX11Meta.h:13
The tensor evaluator classes.
Definition: TensorEvaluator.h:28
Tensor conversion class. This class makes it possible to vectorize type casting operations when the n...
Definition: TensorConversion.h:119
The tensor base class.
Definition: TensorForwardDeclarations.h:19