Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
 
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 typedef typename XprTraits::PointerType PointerType;
50};
51
52template<typename XprType>
53struct eval<TensorLayoutSwapOp<XprType>, Eigen::Dense>
54{
55 typedef const TensorLayoutSwapOp<XprType>& type;
56};
57
58template<typename XprType>
59struct nested<TensorLayoutSwapOp<XprType>, 1, typename eval<TensorLayoutSwapOp<XprType> >::type>
60{
61 typedef TensorLayoutSwapOp<XprType> type;
62};
63
64} // end namespace internal
65
66
67
68template<typename XprType>
69class TensorLayoutSwapOp : public TensorBase<TensorLayoutSwapOp<XprType>, WriteAccessors>
70{
71 public:
72 typedef TensorBase<TensorLayoutSwapOp<XprType>, WriteAccessors> Base;
73 typedef typename Eigen::internal::traits<TensorLayoutSwapOp>::Scalar Scalar;
74 typedef typename Eigen::NumTraits<Scalar>::Real RealScalar;
75 typedef typename internal::remove_const<typename XprType::CoeffReturnType>::type CoeffReturnType;
76 typedef typename Eigen::internal::nested<TensorLayoutSwapOp>::type Nested;
77 typedef typename Eigen::internal::traits<TensorLayoutSwapOp>::StorageKind StorageKind;
78 typedef typename Eigen::internal::traits<TensorLayoutSwapOp>::Index Index;
79
80 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorLayoutSwapOp(const XprType& expr)
81 : m_xpr(expr) {}
82
83 EIGEN_DEVICE_FUNC
84 const typename internal::remove_all<typename XprType::Nested>::type&
85 expression() const { return m_xpr; }
86
87 EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorLayoutSwapOp)
88 protected:
89 typename XprType::Nested m_xpr;
90};
91
92
93// Eval as rvalue
94template<typename ArgType, typename Device>
95struct TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device>
96{
97 typedef TensorLayoutSwapOp<ArgType> XprType;
98 typedef typename XprType::Index Index;
99 static const int NumDims = internal::array_size<typename TensorEvaluator<ArgType, Device>::Dimensions>::value;
100 typedef DSizes<Index, NumDims> Dimensions;
101
102 enum {
103 IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
104 PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
105 BlockAccess = false,
106 PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
107 Layout = (static_cast<int>(TensorEvaluator<ArgType, Device>::Layout) == static_cast<int>(ColMajor)) ? RowMajor : ColMajor,
108 CoordAccess = false, // to be implemented
109 RawAccess = TensorEvaluator<ArgType, Device>::RawAccess
110 };
111
112 //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
113 typedef internal::TensorBlockNotImplemented TensorBlock;
114 //===--------------------------------------------------------------------===//
115
116 EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
117 : m_impl(op.expression(), device)
118 {
119 for(int i = 0; i < NumDims; ++i) {
120 m_dimensions[i] = m_impl.dimensions()[NumDims-1-i];
121 }
122 }
123
124#ifdef EIGEN_USE_SYCL
125 // binding placeholder accessors to a command group handler for SYCL
126 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void bind(cl::sycl::handler &cgh) const {
127 m_impl.bind(cgh);
128 }
129#endif
130
131 typedef typename XprType::Scalar Scalar;
132 typedef typename XprType::CoeffReturnType CoeffReturnType;
133 typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
134 typedef StorageMemory<CoeffReturnType, Device> Storage;
135 typedef typename Storage::Type EvaluatorPointerType;
136
137 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Dimensions& dimensions() const { return m_dimensions; }
138
139 EIGEN_STRONG_INLINE bool evalSubExprsIfNeeded(EvaluatorPointerType data) {
140 return m_impl.evalSubExprsIfNeeded(data);
141 }
142 EIGEN_STRONG_INLINE void cleanup() {
143 m_impl.cleanup();
144 }
145
146 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
147 {
148 return m_impl.coeff(index);
149 }
150
151 template<int LoadMode>
152 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const
153 {
154 return m_impl.template packet<LoadMode>(index);
155 }
156
157 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost costPerCoeff(bool vectorized) const {
158 return m_impl.costPerCoeff(vectorized);
159 }
160
161 EIGEN_DEVICE_FUNC typename Storage::Type data() const {
162 return constCast(m_impl.data());
163 }
164
165 const TensorEvaluator<ArgType, Device>& impl() const { return m_impl; }
166
167 protected:
168 TensorEvaluator<ArgType, Device> m_impl;
169 Dimensions m_dimensions;
170};
171
172
173// Eval as lvalue
174template<typename ArgType, typename Device>
175 struct TensorEvaluator<TensorLayoutSwapOp<ArgType>, Device>
176 : public TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device>
177{
178 typedef TensorEvaluator<const TensorLayoutSwapOp<ArgType>, Device> Base;
179 typedef TensorLayoutSwapOp<ArgType> XprType;
180
181 enum {
182 IsAligned = TensorEvaluator<ArgType, Device>::IsAligned,
183 PacketAccess = TensorEvaluator<ArgType, Device>::PacketAccess,
184 BlockAccess = false,
185 PreferBlockAccess = TensorEvaluator<ArgType, Device>::PreferBlockAccess,
186 Layout = (static_cast<int>(TensorEvaluator<ArgType, Device>::Layout) == static_cast<int>(ColMajor)) ? RowMajor : ColMajor,
187 CoordAccess = false // to be implemented
188 };
189
190 //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===//
191 typedef internal::TensorBlockNotImplemented TensorBlock;
192 //===--------------------------------------------------------------------===//
193
194 EIGEN_STRONG_INLINE TensorEvaluator(const XprType& op, const Device& device)
195 : Base(op, device)
196 { }
197
198 typedef typename XprType::Index Index;
199 typedef typename XprType::Scalar Scalar;
200 typedef typename XprType::CoeffReturnType CoeffReturnType;
201 typedef typename PacketType<CoeffReturnType, Device>::type PacketReturnType;
202
203 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType& coeffRef(Index index)
204 {
205 return this->m_impl.coeffRef(index);
206 }
207 template <int StoreMode> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
208 void writePacket(Index index, const PacketReturnType& x)
209 {
210 this->m_impl.template writePacket<StoreMode>(index, x);
211 }
212};
213
214} // end namespace Eigen
215
216#endif // EIGEN_CXX11_TENSOR_TENSOR_LAYOUT_SWAP_H
WriteAccessors
Namespace containing all symbols from the Eigen library.
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index