1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
5// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
6//
7// This Source Code Form is subject to the terms of the Mozilla
8// Public License v. 2.0. If a copy of the MPL was not distributed
9// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10
11#ifndef EIGEN_MAPBASE_H
12#define EIGEN_MAPBASE_H
13
14#define EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) \
15 EIGEN_STATIC_ASSERT((int(internal::evaluator<Derived>::Flags) & LinearAccessBit) || Derived::IsVectorAtCompileTime, \
16 YOU_ARE_TRYING_TO_USE_AN_INDEX_BASED_ACCESSOR_ON_AN_EXPRESSION_THAT_DOES_NOT_SUPPORT_THAT)
17
18namespace Eigen {
19
20/** \ingroup Core_Module
21 *
22 * \brief Base class for dense Map and Block expression with direct access
23 *
24 * This base class provides the const low-level accessors (e.g. coeff, coeffRef) of dense
25 * Map and Block objects with direct access.
26 * Typical users do not have to directly deal with this class.
27 *
28 * This class can be extended by through the macro plugin \c EIGEN_MAPBASE_PLUGIN.
29 * See \link TopicCustomizing_Plugins customizing Eigen \endlink for details.
30 *
31 * The \c Derived class has to provide the following two methods describing the memory layout:
32 * \code Index innerStride() const; \endcode
33 * \code Index outerStride() const; \endcode
34 *
35 * \sa class Map, class Block
36 */
37template<typename Derived> class MapBase<Derived, ReadOnlyAccessors>
38 : public internal::dense_xpr_base<Derived>::type
39{
40 public:
41
42 typedef typename internal::dense_xpr_base<Derived>::type Base;
43 enum {
44 RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
45 ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
46 InnerStrideAtCompileTime = internal::traits<Derived>::InnerStrideAtCompileTime,
47 SizeAtCompileTime = Base::SizeAtCompileTime
48 };
49
50 typedef typename internal::traits<Derived>::StorageKind StorageKind;
51 typedef typename internal::traits<Derived>::Scalar Scalar;
52 typedef typename internal::packet_traits<Scalar>::type PacketScalar;
53 typedef typename NumTraits<Scalar>::Real RealScalar;
54 typedef typename internal::conditional<
55 bool(internal::is_lvalue<Derived>::value),
56 Scalar *,
57 const Scalar *>::type
58 PointerType;
59
60 using Base::derived;
61// using Base::RowsAtCompileTime;
62// using Base::ColsAtCompileTime;
63// using Base::SizeAtCompileTime;
64 using Base::MaxRowsAtCompileTime;
65 using Base::MaxColsAtCompileTime;
66 using Base::MaxSizeAtCompileTime;
67 using Base::IsVectorAtCompileTime;
68 using Base::Flags;
69 using Base::IsRowMajor;
70
71 using Base::rows;
72 using Base::cols;
73 using Base::size;
74 using Base::coeff;
75 using Base::coeffRef;
76 using Base::lazyAssign;
77 using Base::eval;
78
79 using Base::innerStride;
80 using Base::outerStride;
81 using Base::rowStride;
82 using Base::colStride;
83
84 // bug 217 - compile error on ICC 11.1
85 using Base::operator=;
86
87 typedef typename Base::CoeffReturnType CoeffReturnType;
88
89 /** \copydoc DenseBase::rows() */
90 EIGEN_DEVICE_FUNC inline Index rows() const { return m_rows.value(); }
91 /** \copydoc DenseBase::cols() */
92 EIGEN_DEVICE_FUNC inline Index cols() const { return m_cols.value(); }
93
94 /** Returns a pointer to the first coefficient of the matrix or vector.
95 *
96 * \note When addressing this data, make sure to honor the strides returned by innerStride() and outerStride().
97 *
98 * \sa innerStride(), outerStride()
99 */
100 EIGEN_DEVICE_FUNC inline const Scalar* data() const { return m_data; }
101
102 /** \copydoc PlainObjectBase::coeff(Index,Index) const */
103 EIGEN_DEVICE_FUNC
104 inline const Scalar& coeff(Index rowId, Index colId) const
105 {
106 return m_data[colId * colStride() + rowId * rowStride()];
107 }
108
109 /** \copydoc PlainObjectBase::coeff(Index) const */
110 EIGEN_DEVICE_FUNC
111 inline const Scalar& coeff(Index index) const
112 {
113 EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
114 return m_data[index * innerStride()];
115 }
116
117 /** \copydoc PlainObjectBase::coeffRef(Index,Index) const */
118 EIGEN_DEVICE_FUNC
119 inline const Scalar& coeffRef(Index rowId, Index colId) const
120 {
121 return this->m_data[colId * colStride() + rowId * rowStride()];
122 }
123
124 /** \copydoc PlainObjectBase::coeffRef(Index) const */
125 EIGEN_DEVICE_FUNC
126 inline const Scalar& coeffRef(Index index) const
127 {
128 EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
129 return this->m_data[index * innerStride()];
130 }
131
132 /** \internal */
133 template<int LoadMode>
134 inline PacketScalar packet(Index rowId, Index colId) const
135 {
136 return internal::ploadt<PacketScalar, LoadMode>
137 (m_data + (colId * colStride() + rowId * rowStride()));
138 }
139
140 /** \internal */
141 template<int LoadMode>
142 inline PacketScalar packet(Index index) const
143 {
144 EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
145 return internal::ploadt<PacketScalar, LoadMode>(m_data + index * innerStride());
146 }
147
148 /** \internal Constructor for fixed size matrices or vectors */
149 EIGEN_DEVICE_FUNC
150 explicit inline MapBase(PointerType dataPtr) : m_data(dataPtr), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime)
151 {
152 EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
153 checkSanity<Derived>();
154 }
155
156 /** \internal Constructor for dynamically sized vectors */
157 EIGEN_DEVICE_FUNC
158 inline MapBase(PointerType dataPtr, Index vecSize)
159 : m_data(dataPtr),
160 m_rows(RowsAtCompileTime == Dynamic ? vecSize : Index(RowsAtCompileTime)),
161 m_cols(ColsAtCompileTime == Dynamic ? vecSize : Index(ColsAtCompileTime))
162 {
163 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
164 eigen_assert(vecSize >= 0);
165 eigen_assert(dataPtr == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == vecSize);
166 checkSanity<Derived>();
167 }
168
169 /** \internal Constructor for dynamically sized matrices */
170 EIGEN_DEVICE_FUNC
171 inline MapBase(PointerType dataPtr, Index rows, Index cols)
172 : m_data(dataPtr), m_rows(rows), m_cols(cols)
173 {
174 eigen_assert( (dataPtr == 0)
175 || ( rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
176 && cols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)));
177 checkSanity<Derived>();
178 }
179
180 #ifdef EIGEN_MAPBASE_PLUGIN
181 #include EIGEN_MAPBASE_PLUGIN
182 #endif
183
184 protected:
185
186 template<typename T>
187 EIGEN_DEVICE_FUNC
188 void checkSanity(typename internal::enable_if<(internal::traits<T>::Alignment>0),void*>::type = 0) const
189 {
190#if EIGEN_MAX_ALIGN_BYTES>0
191 // innerStride() is not set yet when this function is called, so we optimistically assume the lowest plausible value:
192 const Index minInnerStride = InnerStrideAtCompileTime == Dynamic ? 1 : Index(InnerStrideAtCompileTime);
193 EIGEN_ONLY_USED_FOR_DEBUG(minInnerStride);
194 eigen_assert(( ((internal::UIntPtr(m_data) % internal::traits<Derived>::Alignment) == 0)
195 || (cols() * rows() * minInnerStride * sizeof(Scalar)) < internal::traits<Derived>::Alignment ) && "data is not aligned");
196#endif
197 }
198
199 template<typename T>
200 EIGEN_DEVICE_FUNC
201 void checkSanity(typename internal::enable_if<internal::traits<T>::Alignment==0,void*>::type = 0) const
202 {}
203
204 PointerType m_data;
205 const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows;
206 const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols;
207};
208
209/** \ingroup Core_Module
210 *
211 * \brief Base class for non-const dense Map and Block expression with direct access
212 *
213 * This base class provides the non-const low-level accessors (e.g. coeff and coeffRef) of
214 * dense Map and Block objects with direct access.
215 * It inherits MapBase<Derived, ReadOnlyAccessors> which defines the const variant for reading specific entries.
216 *
217 * \sa class Map, class Block
218 */
219template<typename Derived> class MapBase<Derived, WriteAccessors>
220 : public MapBase<Derived, ReadOnlyAccessors>
221{
222 typedef MapBase<Derived, ReadOnlyAccessors> ReadOnlyMapBase;
223 public:
224
225 typedef MapBase<Derived, ReadOnlyAccessors> Base;
226
227 typedef typename Base::Scalar Scalar;
228 typedef typename Base::PacketScalar PacketScalar;
229 typedef typename Base::StorageIndex StorageIndex;
230 typedef typename Base::PointerType PointerType;
231
232 using Base::derived;
233 using Base::rows;
234 using Base::cols;
235 using Base::size;
236 using Base::coeff;
237 using Base::coeffRef;
238
239 using Base::innerStride;
240 using Base::outerStride;
241 using Base::rowStride;
242 using Base::colStride;
243
244 typedef typename internal::conditional<
245 internal::is_lvalue<Derived>::value,
246 Scalar,
247 const Scalar
248 >::type ScalarWithConstIfNotLvalue;
249
250 EIGEN_DEVICE_FUNC
251 inline const Scalar* data() const { return this->m_data; }
252 EIGEN_DEVICE_FUNC
253 inline ScalarWithConstIfNotLvalue* data() { return this->m_data; } // no const-cast here so non-const-correct code will give a compile error
254
255 EIGEN_DEVICE_FUNC
256 inline ScalarWithConstIfNotLvalue& coeffRef(Index row, Index col)
257 {
258 return this->m_data[col * colStride() + row * rowStride()];
259 }
260
261 EIGEN_DEVICE_FUNC
262 inline ScalarWithConstIfNotLvalue& coeffRef(Index index)
263 {
264 EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
265 return this->m_data[index * innerStride()];
266 }
267
268 template<int StoreMode>
269 inline void writePacket(Index row, Index col, const PacketScalar& val)
270 {
271 internal::pstoret<Scalar, PacketScalar, StoreMode>
272 (this->m_data + (col * colStride() + row * rowStride()), val);
273 }
274
275 template<int StoreMode>
276 inline void writePacket(Index index, const PacketScalar& val)
277 {
278 EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
279 internal::pstoret<Scalar, PacketScalar, StoreMode>
280 (this->m_data + index * innerStride(), val);
281 }
282
283 EIGEN_DEVICE_FUNC explicit inline MapBase(PointerType dataPtr) : Base(dataPtr) {}
284 EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index vecSize) : Base(dataPtr, vecSize) {}
285 EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index rows, Index cols) : Base(dataPtr, rows, cols) {}
286
287 EIGEN_DEVICE_FUNC
288 Derived& operator=(const MapBase& other)
289 {
290 ReadOnlyMapBase::Base::operator=(other);
291 return derived();
292 }
293
294 // In theory we could simply refer to Base:Base::operator=, but MSVC does not like Base::Base,
295 // see bugs 821 and 920.
296 using ReadOnlyMapBase::Base::operator=;
297};
298
299#undef EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS
300
301} // end namespace Eigen
302
303#endif // EIGEN_MAPBASE_H
304