10 #ifndef EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H
11 #define EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H
23 template<
typename Axis,
typename LhsXprType,
typename RhsXprType>
24 struct traits<TensorConcatenationOp<Axis, LhsXprType, RhsXprType> >
27 typedef typename promote_storage_type<
typename LhsXprType::Scalar,
28 typename RhsXprType::Scalar>::ret Scalar;
29 typedef typename packet_traits<Scalar>::type Packet;
30 typedef typename promote_storage_type<typename traits<LhsXprType>::StorageKind,
31 typename traits<RhsXprType>::StorageKind>::ret StorageKind;
32 typedef typename promote_index_type<typename traits<LhsXprType>::Index,
33 typename traits<RhsXprType>::Index>::type Index;
34 typedef typename LhsXprType::Nested LhsNested;
35 typedef typename RhsXprType::Nested RhsNested;
36 typedef typename remove_reference<LhsNested>::type _LhsNested;
37 typedef typename remove_reference<RhsNested>::type _RhsNested;
38 static const int NumDimensions = traits<LhsXprType>::NumDimensions;
39 static const int Layout = traits<LhsXprType>::Layout;
43 template<
typename Axis,
typename LhsXprType,
typename RhsXprType>
44 struct eval<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>,
Eigen::Dense>
46 typedef const TensorConcatenationOp<Axis, LhsXprType, RhsXprType>& type;
49 template<
typename Axis,
typename LhsXprType,
typename RhsXprType>
50 struct nested<TensorConcatenationOp<Axis, LhsXprType, RhsXprType>, 1, typename eval<TensorConcatenationOp<Axis, LhsXprType, RhsXprType> >::type>
52 typedef TensorConcatenationOp<Axis, LhsXprType, RhsXprType> type;
58 template<
typename Axis,
typename LhsXprType,
typename RhsXprType>
62 typedef typename internal::traits<TensorConcatenationOp>::Scalar Scalar;
63 typedef typename internal::traits<TensorConcatenationOp>::Packet Packet;
64 typedef typename internal::traits<TensorConcatenationOp>::StorageKind StorageKind;
65 typedef typename internal::traits<TensorConcatenationOp>::Index Index;
66 typedef typename internal::nested<TensorConcatenationOp>::type Nested;
67 typedef typename internal::promote_storage_type<
typename LhsXprType::CoeffReturnType,
68 typename RhsXprType::CoeffReturnType>::ret CoeffReturnType;
69 typedef typename internal::promote_storage_type<
typename LhsXprType::PacketReturnType,
70 typename RhsXprType::PacketReturnType>::ret PacketReturnType;
71 typedef typename NumTraits<Scalar>::Real RealScalar;
73 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
TensorConcatenationOp(
const LhsXprType& lhs,
const RhsXprType& rhs, Axis axis)
74 : m_lhs_xpr(lhs), m_rhs_xpr(rhs), m_axis(axis) {}
77 const typename internal::remove_all<typename LhsXprType::Nested>::type&
78 lhsExpression()
const {
return m_lhs_xpr; }
81 const typename internal::remove_all<typename RhsXprType::Nested>::type&
82 rhsExpression()
const {
return m_rhs_xpr; }
84 EIGEN_DEVICE_FUNC
const Axis& axis()
const {
return m_axis; }
87 EIGEN_STRONG_INLINE TensorConcatenationOp& operator = (
const TensorConcatenationOp& other)
89 typedef TensorAssignOp<TensorConcatenationOp, const TensorConcatenationOp> Assign;
90 Assign assign(*
this, other);
91 internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
95 template<
typename OtherDerived>
97 EIGEN_STRONG_INLINE TensorConcatenationOp& operator = (
const OtherDerived& other)
99 typedef TensorAssignOp<TensorConcatenationOp, const OtherDerived> Assign;
100 Assign assign(*
this, other);
101 internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
106 typename LhsXprType::Nested m_lhs_xpr;
107 typename RhsXprType::Nested m_rhs_xpr;
113 template<
typename Axis,
typename LeftArgType,
typename RightArgType,
typename Device>
117 typedef typename XprType::Index Index;
118 static const int NumDims = internal::array_size<typename TensorEvaluator<LeftArgType, Device>::Dimensions>::value;
119 static const int RightNumDims = internal::array_size<typename TensorEvaluator<RightArgType, Device>::Dimensions>::value;
120 typedef DSizes<Index, NumDims> Dimensions;
121 typedef typename XprType::Scalar Scalar;
122 typedef typename XprType::CoeffReturnType CoeffReturnType;
123 typedef typename XprType::PacketReturnType PacketReturnType;
130 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(
const XprType& op,
const Device& device)
131 : m_leftImpl(op.lhsExpression(), device), m_rightImpl(op.rhsExpression(), device), m_axis(op.axis())
133 EIGEN_STATIC_ASSERT((static_cast<int>(TensorEvaluator<LeftArgType, Device>::Layout) == static_cast<int>(TensorEvaluator<RightArgType, Device>::Layout) || NumDims == 1), YOU_MADE_A_PROGRAMMING_MISTAKE);
134 EIGEN_STATIC_ASSERT(NumDims == RightNumDims, YOU_MADE_A_PROGRAMMING_MISTAKE);
135 EIGEN_STATIC_ASSERT(NumDims > 0, YOU_MADE_A_PROGRAMMING_MISTAKE);
137 eigen_assert(0 <= m_axis && m_axis < NumDims);
138 const Dimensions& lhs_dims = m_leftImpl.dimensions();
139 const Dimensions& rhs_dims = m_rightImpl.dimensions();
142 for (; i < m_axis; ++i) {
143 eigen_assert(lhs_dims[i] > 0);
144 eigen_assert(lhs_dims[i] == rhs_dims[i]);
145 m_dimensions[i] = lhs_dims[i];
147 eigen_assert(lhs_dims[i] > 0);
148 eigen_assert(rhs_dims[i] > 0);
149 m_dimensions[i] = lhs_dims[i] + rhs_dims[i];
150 for (++i; i < NumDims; ++i) {
151 eigen_assert(lhs_dims[i] > 0);
152 eigen_assert(lhs_dims[i] == rhs_dims[i]);
153 m_dimensions[i] = lhs_dims[i];
157 if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
158 m_leftStrides[0] = 1;
159 m_rightStrides[0] = 1;
160 m_outputStrides[0] = 1;
162 for (
int j = 1; j < NumDims; ++j) {
163 m_leftStrides[j] = m_leftStrides[j-1] * lhs_dims[j-1];
164 m_rightStrides[j] = m_rightStrides[j-1] * rhs_dims[j-1];
165 m_outputStrides[j] = m_outputStrides[j-1] * m_dimensions[j-1];
168 m_leftStrides[NumDims - 1] = 1;
169 m_rightStrides[NumDims - 1] = 1;
170 m_outputStrides[NumDims - 1] = 1;
172 for (
int j = NumDims - 2; j >= 0; --j) {
173 m_leftStrides[j] = m_leftStrides[j+1] * lhs_dims[j+1];
174 m_rightStrides[j] = m_rightStrides[j+1] * rhs_dims[j+1];
175 m_outputStrides[j] = m_outputStrides[j+1] * m_dimensions[j+1];
180 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
const Dimensions& dimensions()
const {
return m_dimensions; }
183 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
bool evalSubExprsIfNeeded(Scalar* )
185 m_leftImpl.evalSubExprsIfNeeded(NULL);
186 m_rightImpl.evalSubExprsIfNeeded(NULL);
190 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void cleanup()
192 m_leftImpl.cleanup();
193 m_rightImpl.cleanup();
198 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index)
const
201 array<Index, NumDims> subs;
202 if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
203 for (
int i = NumDims - 1; i > 0; --i) {
204 subs[i] = index / m_outputStrides[i];
205 index -= subs[i] * m_outputStrides[i];
209 for (
int i = 0; i < NumDims - 1; ++i) {
210 subs[i] = index / m_outputStrides[i];
211 index -= subs[i] * m_outputStrides[i];
213 subs[NumDims - 1] = index;
216 const Dimensions& left_dims = m_leftImpl.dimensions();
217 if (subs[m_axis] < left_dims[m_axis]) {
219 if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
220 left_index = subs[0];
221 for (
int i = 1; i < NumDims; ++i) {
222 left_index += (subs[i] % left_dims[i]) * m_leftStrides[i];
225 left_index = subs[NumDims - 1];
226 for (
int i = NumDims - 2; i >= 0; --i) {
227 left_index += (subs[i] % left_dims[i]) * m_leftStrides[i];
230 return m_leftImpl.coeff(left_index);
232 subs[m_axis] -= left_dims[m_axis];
233 const Dimensions& right_dims = m_rightImpl.dimensions();
235 if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
236 right_index = subs[0];
237 for (
int i = 1; i < NumDims; ++i) {
238 right_index += (subs[i] % right_dims[i]) * m_rightStrides[i];
241 right_index = subs[NumDims - 1];
242 for (
int i = NumDims - 2; i >= 0; --i) {
243 right_index += (subs[i] % right_dims[i]) * m_rightStrides[i];
246 return m_rightImpl.coeff(right_index);
251 template<
int LoadMode>
252 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index)
const
254 static const int packetSize = internal::unpacket_traits<PacketReturnType>::size;
255 EIGEN_STATIC_ASSERT(packetSize > 1, YOU_MADE_A_PROGRAMMING_MISTAKE)
256 eigen_assert(index + packetSize - 1 < dimensions().TotalSize());
258 EIGEN_ALIGN_MAX CoeffReturnType values[packetSize];
259 for (
int i = 0; i < packetSize; ++i) {
260 values[i] = coeff(index+i);
262 PacketReturnType rslt = internal::pload<PacketReturnType>(values);
266 EIGEN_DEVICE_FUNC Scalar* data()
const {
return NULL; }
269 Dimensions m_dimensions;
270 array<Index, NumDims> m_outputStrides;
271 array<Index, NumDims> m_leftStrides;
272 array<Index, NumDims> m_rightStrides;
273 TensorEvaluator<LeftArgType, Device> m_leftImpl;
274 TensorEvaluator<RightArgType, Device> m_rightImpl;
279 template<
typename Axis,
typename LeftArgType,
typename RightArgType,
typename Device>
280 struct TensorEvaluator<TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
281 :
public TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device>
283 typedef TensorEvaluator<const TensorConcatenationOp<Axis, LeftArgType, RightArgType>, Device> Base;
284 typedef TensorConcatenationOp<Axis, LeftArgType, RightArgType> XprType;
285 typedef typename Base::Dimensions Dimensions;
288 PacketAccess = TensorEvaluator<LeftArgType, Device>::PacketAccess & TensorEvaluator<RightArgType, Device>::PacketAccess,
289 Layout = TensorEvaluator<LeftArgType, Device>::Layout,
292 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(XprType& op,
const Device& device)
295 EIGEN_STATIC_ASSERT((static_cast<int>(Layout) == static_cast<int>(ColMajor)), YOU_MADE_A_PROGRAMMING_MISTAKE);
298 typedef typename XprType::Index Index;
299 typedef typename XprType::Scalar Scalar;
300 typedef typename XprType::CoeffReturnType CoeffReturnType;
301 typedef typename XprType::PacketReturnType PacketReturnType;
303 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index)
306 array<Index, Base::NumDims> subs;
307 for (
int i = Base::NumDims - 1; i > 0; --i) {
308 subs[i] = index / this->m_outputStrides[i];
309 index -= subs[i] * this->m_outputStrides[i];
313 const Dimensions& left_dims = this->m_leftImpl.dimensions();
314 if (subs[this->m_axis] < left_dims[this->m_axis]) {
315 Index left_index = subs[0];
316 for (
int i = 1; i < Base::NumDims; ++i) {
317 left_index += (subs[i] % left_dims[i]) * this->m_leftStrides[i];
319 return this->m_leftImpl.coeffRef(left_index);
321 subs[this->m_axis] -= left_dims[this->m_axis];
322 const Dimensions& right_dims = this->m_rightImpl.dimensions();
323 Index right_index = subs[0];
324 for (
int i = 1; i < Base::NumDims; ++i) {
325 right_index += (subs[i] % right_dims[i]) * this->m_rightStrides[i];
327 return this->m_rightImpl.coeffRef(right_index);
331 template <
int StoreMode> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
332 void writePacket(Index index,
const PacketReturnType& x)
334 static const int packetSize = internal::unpacket_traits<PacketReturnType>::size;
335 EIGEN_STATIC_ASSERT(packetSize > 1, YOU_MADE_A_PROGRAMMING_MISTAKE)
336 eigen_assert(index + packetSize - 1 < this->dimensions().TotalSize());
338 EIGEN_ALIGN_MAX CoeffReturnType values[packetSize];
339 internal::pstore<CoeffReturnType, PacketReturnType>(values, x);
340 for (
int i = 0; i < packetSize; ++i) {
341 coeffRef(index+i) = values[i];
348 #endif // EIGEN_CXX11_TENSOR_TENSOR_CONCATENATION_H
Namespace containing all symbols from the Eigen library.
Definition: CXX11Meta.h:13
The tensor evaluator classes.
Definition: TensorEvaluator.h:28
The tensor base class.
Definition: TensorForwardDeclarations.h:19
Tensor concatenation class.
Definition: TensorConcatenation.h:59