Loading...
Searching...
No Matches
TensorLayoutSwap.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2014 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_LAYOUT_SWAP_H
11#define EIGEN_CXX11_TENSOR_TENSOR_LAYOUT_SWAP_H
12
13namespace Eigen {
14
37namespace internal {
38template<typename XprType>
39struct traits<TensorLayoutSwapOp<XprType> > : public traits<XprType>
40{
41 typedef typename XprType::Scalar Scalar;
42 typedef traits<XprType> XprTraits;
43 typedef typename XprTraits::StorageKind StorageKind;
44 typedef typename XprTraits::Index Index;
45 typedef typename XprType::Nested Nested;
46 typedef typename remove_reference<Nested>::type _Nested;
47 static const int NumDimensions = traits<XprType>::NumDimensions;
48 static const int Layout = (traits<XprType>::Layout == ColMajor) ? RowMajor : ColMajor;
49};
50
51template<typename XprType>
52struct eval<TensorLayoutSwapOp<XprType>, Eigen::Dense>
53{
54 typedef const TensorLayoutSwapOp<XprType>& type;
55};
56
57template<typename XprType>
58struct nested<TensorLayoutSwapOp<XprType>, 1, typename eval<TensorLayoutSwapOp<XprType> >::type>
59{
60 typedef TensorLayoutSwapOp<XprType> type;
61};
62
63} // end namespace internal
64
65
66
67template<typename XprType>
68class TensorLayoutSwapOp : public TensorBase<TensorLayoutSwapOp<XprType>, WriteAccessors>
69{
70 public:
71 typedef typename Eigen::internal::traits<TensorLayoutSwapOp>::Scalar Scalar;
72 typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
73 typedef typename internal::remove_const<typename XprType::CoeffReturnType>::type CoeffReturnType;
74 typedef typename Eigen::internal::nested<TensorLayoutSwapOp>::type Nested;
75 typedef typename Eigen::internal::traits<TensorLayoutSwapOp>::StorageKind StorageKind;
76 typedef typename Eigen::internal::traits<TensorLayoutSwapOp>::Index Index;
77
78 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorLayoutSwapOp(const XprType& expr)
79 : m_xpr(expr) {}
80
81 EIGEN_DEVICE_FUNC
82 const typename internal::remove_all<typename XprType::Nested>::type&
83 expression() const { return m_xpr; }
84
85 EIGEN_DEVICE_FUNC
86 EIGEN_STRONG_INLINE TensorLayoutSwapOp& operator = (const TensorLayoutSwapOp& other)
87 {
88 typedef TensorAssignOp<TensorLayoutSwapOp, const TensorLayoutSwapOp> Assign;
89 Assign assign(*this, other);
90 internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
91 return *this;
92 }
93
94 template<typename OtherDerived>
95 EIGEN_DEVICE_FUNC
96 EIGEN_STRONG_INLINE TensorLayoutSwapOp& operator = (const OtherDerived& other)
97 {
98 typedef TensorAssignOp<TensorLayoutSwapOp, const OtherDerived> Assign;
99 Assign assign(*this, other);
100 internal::TensorExecutor<const Assign, DefaultDevice>::run(assign, DefaultDevice());
101 return *this;
102 }
103
104 protected:
105 typename XprType::Nested m_xpr;
106};
107
108
109// Eval as rvalue
110template<typename ArgType, typename Device>
111struct TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device>
112{
113 typedef TensorLayoutSwapOp<ArgType> XprType;
114 typedef typename XprType::Index Index;
115 static const int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
116 typedef DSizes<Index, NumDims> Dimensions;
117
118 enum {
119 IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
120 PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
121 Layout = (static_cast<int>(TensorEvaluator<ArgType, Device>::Layout) == static_cast<int>(ColMajor)) ? RowMajor : ColMajor,
122 CoordAccess = false, // to be implemented
123 RawAccess = TensorEvaluator<ArgType, Device>::RawAccess
124 };
125
126 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
127 : m_impl(op.expression(), device)
128 {
129 for(int i = 0; i < NumDims; ++i) {
130 m_dimensions[i] = m_impl.dimensions()[NumDims-1-i];
131 }
132 }
133
134 typedef typename XprType::Scalar Scalar;
135 typedef typename XprType::CoeffReturnType CoeffReturnType;
136 typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
137
138 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
139
140 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(CoeffReturnType* data) {
141 return m_impl.evalSubExprsIfNeeded(data);
142 }
143 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void cleanup() {
144 m_impl.cleanup();
145 }
146
147 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
148 {
149 return m_impl.coeff(index);
150 }
151
152 template<int LoadMode>
153 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
154 {
155 return m_impl.template packet<LoadMode>(index);
156 }
157
158 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
159 return m_impl.costPerCoeff(vectorized);
160 }
161
162 EIGEN_DEVICE_FUNC Scalar* data() const { return m_impl.data(); }
163
164 const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
165
166 protected:
167 TensorEvaluator<ArgType, Device> m_impl;
168 Dimensions m_dimensions;
169};
170
171
172// Eval as lvalue
173template<typename ArgType, typename Device>
174 struct TensorEvaluator<TensorLayoutSwapOp<ArgType>, Device>
175 : public TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device>
176{
177 typedef TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device> Base;
178 typedef TensorLayoutSwapOp<ArgType> XprType;
179
180 enum {
181 IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
182 PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
183 Layout = (static_cast<int>(TensorEvaluator<ArgType, Device>::Layout) == static_cast<int>(ColMajor)) ? RowMajor : ColMajor,
184 CoordAccess = false // to be implemented
185 };
186
187 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
188 : Base(op, device)
189 { }
190
191 typedef typename XprType::Index Index;
192 typedef typename XprType::Scalar Scalar;
193 typedef typename XprType::CoeffReturnType CoeffReturnType;
194 typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
195
196 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index)
197 {
198 return this->m_impl.coeffRef(index);
199 }
200 template <int StoreMode> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
201 void writePacket(Index index, const PacketReturnType& x)
202 {
203 this->m_impl.template writePacket<StoreMode>(index, x);
204 }
205};
206
207} // end namespace Eigen
208
209#endif // EIGEN_CXX11_TENSOR_TENSOR_LAYOUT_SWAP_H
Namespace containing all symbols from the Eigen library.
Definition: AdolcForward:45
const Device & device() const
required by sycl in order to construct sycl buffer from raw pointer
Definition: TensorEvaluator.h:114