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  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
56  PacketConverter(const TensorEvaluator& impl)
57  : m_impl(impl) {}
58 
59  template<int LoadMode, typename Index>
60  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
61  return internal::pcast<SrcPacket, TgtPacket>(m_impl.template packet<LoadMode>(index));
62  }
63 
64  private:
65  const TensorEvaluator& m_impl;
66 };
67 
68 
69 template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
70 struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 2, 1> {
71  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
72  PacketConverter(const TensorEvaluator& impl)
73  : m_impl(impl) {}
74 
75  template<int LoadMode, typename Index>
76  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
77  const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
78 
79  SrcPacket src1 = m_impl.template packet<LoadMode>(index);
80  SrcPacket src2 = m_impl.template packet<LoadMode>(index + SrcPacketSize);
81  TgtPacket result = internal::pcast<SrcPacket, TgtPacket>(src1, src2);
82  return result;
83  }
84 
85  private:
86  const TensorEvaluator& m_impl;
87 };
88 
89 
90 template <typename TensorEvaluator, typename SrcPacket, typename TgtPacket>
91 struct PacketConverter<TensorEvaluator, SrcPacket, TgtPacket, 1, 2> {
92  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
93  PacketConverter(const TensorEvaluator& impl)
94  : m_impl(impl), m_maxIndex(impl.dimensions().TotalSize()) {}
95 
96  template<int LoadMode, typename Index>
97  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TgtPacket packet(Index index) const {
98  const int SrcPacketSize = internal::unpacket_traits<SrcPacket>::size;
99  // Only call m_impl.packet() when we have direct access to the underlying data. This
100  // ensures that we don't compute the subexpression twice. We may however load some
101  // coefficients twice, but in practice this doesn't negatively impact performance.
102  if (m_impl.data() && (index + SrcPacketSize < m_maxIndex)) {
103  // Force unaligned memory loads since we can't ensure alignment anymore
104  return internal::pcast<SrcPacket, TgtPacket>(m_impl.template packet<Unaligned>(index));
105  } else {
106  const int TgtPacketSize = internal::unpacket_traits<TgtPacket>::size;
107  EIGEN_ALIGN_MAX typename internal::unpacket_traits<TgtPacket>::type values[TgtPacketSize];
108  for (int i = 0; i < TgtPacketSize; ++i) {
109  values[i] = m_impl.coeff(index+i);
110  }
111  TgtPacket rslt = internal::pload<TgtPacket>(values);
112  return rslt;
113  }
114  }
115 
116  private:
117  const TensorEvaluator& m_impl;
118  const typename TensorEvaluator::Index m_maxIndex;
119 };
120 
121 template<typename TargetType, typename XprType>
122 class TensorConversionOp : public TensorBase<TensorConversionOp<TargetType, XprType>, ReadOnlyAccessors>
123 {
124  public:
125  typedef typename internal::traits<TensorConversionOp>::Scalar Scalar;
126  typedef typename internal::traits<TensorConversionOp>::Packet Packet;
127  typedef typename internal::traits<TensorConversionOp>::StorageKind StorageKind;
128  typedef typename internal::traits<TensorConversionOp>::Index Index;
129  typedef typename internal::nested<TensorConversionOp>::type Nested;
130  typedef Scalar CoeffReturnType;
131  typedef Packet PacketReturnType;
132  typedef typename NumTraits<Scalar>::Real RealScalar;
133 
134  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorConversionOp(const XprType& xpr)
135  : m_xpr(xpr) {}
136 
137  EIGEN_DEVICE_FUNC
138  const typename internal::remove_all<typename XprType::Nested>::type&
139  expression() const { return m_xpr; }
140 
141  protected:
142  typename XprType::Nested m_xpr;
143 };
144 
145 
146 
147 
148 // Eval as rvalue
149 template<typename TargetType, typename ArgType, typename Device>
150 struct TensorEvaluator<const TensorConversionOp<TargetType, ArgType>, Device>
151 {
153  typedef typename XprType::Index Index;
154  typedef typename TensorEvaluator<ArgType, Device>::Dimensions Dimensions;
155  typedef TargetType Scalar;
156  typedef TargetType CoeffReturnType;
157  typedef typename internal::remove_all<typename internal::traits<ArgType>::Scalar>::type SrcType;
158  typedef typename internal::traits<XprType>::Packet PacketReturnType;
159  typedef typename internal::packet_traits<SrcType>::type PacketSourceType;
160 
161  enum {
162  IsAligned = false,
163  PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess && internal::type_casting_traits<SrcType, TargetType>::VectorizedCast,
165  };
166 
167  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
168  : m_impl(op.expression(), device)
169  {
170  }
171 
172  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_impl.dimensions(); }
173 
174  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(Scalar* /*data*/)
175  {
176  m_impl.evalSubExprsIfNeeded(NULL);
177  return true;
178  }
179 
180  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void cleanup()
181  {
182  m_impl.cleanup();
183  }
184 
185  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
186  {
187  internal::scalar_cast_op<SrcType, TargetType> converter;
188  return converter(m_impl.coeff(index));
189  }
190 
191  template<int LoadMode>
192  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
193  {
194  const int SrcCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::SrcCoeffRatio;
195  const int TgtCoeffRatio = internal::type_casting_traits<SrcType, TargetType>::TgtCoeffRatio;
196  PacketConverter<TensorEvaluator<ArgType, Device>, PacketSourceType, PacketReturnType,
197  SrcCoeffRatio, TgtCoeffRatio> converter(m_impl);
198  return converter.template packet<LoadMode>(index);
199  }
200 
201  EIGEN_DEVICE_FUNC Scalar* data() const { return NULL; }
202 
203  protected:
205 };
206 
207 } // end namespace Eigen
208 
209 #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:122
The tensor base class.
Definition: TensorForwardDeclarations.h:19