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::traits<Derived>::Flags) & LinearAccessBit) || Derived::IsVectorAtCompileTime, \ 16 YOU_ARE_TRYING_TO_USE_AN_INDEX_BASED_ACCESSOR_ON_AN_EXPRESSION_THAT_DOES_NOT_SUPPORT_THAT) 17 18 namespace Eigen { 19 20 /** \class MapBase 21 * \ingroup Core_Module 22 * 23 * \brief Base class for Map and Block expression with direct access 24 * 25 * \sa class Map, class Block 26 */ 27 template<typename Derived> class MapBase<Derived, ReadOnlyAccessors> 28 : public internal::dense_xpr_base<Derived>::type 29 { 30 public: 31 32 typedef typename internal::dense_xpr_base<Derived>::type Base; 33 enum { 34 RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime, 35 ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime, 36 SizeAtCompileTime = Base::SizeAtCompileTime 37 }; 38 39 typedef typename internal::traits<Derived>::StorageKind StorageKind; 40 typedef typename internal::traits<Derived>::Index Index; 41 typedef typename internal::traits<Derived>::Scalar Scalar; 42 typedef typename internal::packet_traits<Scalar>::type PacketScalar; 43 typedef typename NumTraits<Scalar>::Real RealScalar; 44 typedef typename internal::conditional< 45 bool(internal::is_lvalue<Derived>::value), 46 Scalar *, 47 const Scalar *>::type 48 PointerType; 49 50 using Base::derived; 51 // using Base::RowsAtCompileTime; 52 // using Base::ColsAtCompileTime; 53 // using Base::SizeAtCompileTime; 54 using Base::MaxRowsAtCompileTime; 55 using Base::MaxColsAtCompileTime; 56 using Base::MaxSizeAtCompileTime; 57 using Base::IsVectorAtCompileTime; 58 using Base::Flags; 59 using Base::IsRowMajor; 60 61 using Base::rows; 62 using Base::cols; 63 using Base::size; 64 using Base::coeff; 65 using Base::coeffRef; 66 using Base::lazyAssign; 67 using Base::eval; 68 69 using Base::innerStride; 70 using Base::outerStride; 71 using Base::rowStride; 72 using Base::colStride; 73 74 // bug 217 - compile error on ICC 11.1 75 using Base::operator=; 76 77 typedef typename Base::CoeffReturnType CoeffReturnType; 78 rows()79 inline Index rows() const { return m_rows.value(); } cols()80 inline Index cols() const { return m_cols.value(); } 81 82 /** Returns a pointer to the first coefficient of the matrix or vector. 83 * 84 * \note When addressing this data, make sure to honor the strides returned by innerStride() and outerStride(). 85 * 86 * \sa innerStride(), outerStride() 87 */ data()88 inline const Scalar* data() const { return m_data; } 89 coeff(Index row,Index col)90 inline const Scalar& coeff(Index row, Index col) const 91 { 92 return m_data[col * colStride() + row * rowStride()]; 93 } 94 coeff(Index index)95 inline const Scalar& coeff(Index index) const 96 { 97 EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) 98 return m_data[index * innerStride()]; 99 } 100 coeffRef(Index row,Index col)101 inline const Scalar& coeffRef(Index row, Index col) const 102 { 103 return this->m_data[col * colStride() + row * rowStride()]; 104 } 105 coeffRef(Index index)106 inline const Scalar& coeffRef(Index index) const 107 { 108 EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) 109 return this->m_data[index * innerStride()]; 110 } 111 112 template<int LoadMode> packet(Index row,Index col)113 inline PacketScalar packet(Index row, Index col) const 114 { 115 return internal::ploadt<PacketScalar, LoadMode> 116 (m_data + (col * colStride() + row * rowStride())); 117 } 118 119 template<int LoadMode> packet(Index index)120 inline PacketScalar packet(Index index) const 121 { 122 EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) 123 return internal::ploadt<PacketScalar, LoadMode>(m_data + index * innerStride()); 124 } 125 MapBase(PointerType data)126 inline MapBase(PointerType data) : m_data(data), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime) 127 { 128 EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) 129 checkSanity(); 130 } 131 MapBase(PointerType data,Index size)132 inline MapBase(PointerType data, Index size) 133 : m_data(data), 134 m_rows(RowsAtCompileTime == Dynamic ? size : Index(RowsAtCompileTime)), 135 m_cols(ColsAtCompileTime == Dynamic ? size : Index(ColsAtCompileTime)) 136 { 137 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 138 eigen_assert(size >= 0); 139 eigen_assert(data == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == size); 140 checkSanity(); 141 } 142 MapBase(PointerType data,Index rows,Index cols)143 inline MapBase(PointerType data, Index rows, Index cols) 144 : m_data(data), m_rows(rows), m_cols(cols) 145 { 146 eigen_assert( (data == 0) 147 || ( rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) 148 && cols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols))); 149 checkSanity(); 150 } 151 152 protected: 153 checkSanity()154 void checkSanity() const 155 { 156 EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(internal::traits<Derived>::Flags&PacketAccessBit, 157 internal::inner_stride_at_compile_time<Derived>::ret==1), 158 PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1); 159 eigen_assert(EIGEN_IMPLIES(internal::traits<Derived>::Flags&AlignedBit, (size_t(m_data) % 16) == 0) 160 && "data is not aligned"); 161 } 162 163 PointerType m_data; 164 const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows; 165 const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols; 166 }; 167 168 template<typename Derived> class MapBase<Derived, WriteAccessors> 169 : public MapBase<Derived, ReadOnlyAccessors> 170 { 171 public: 172 173 typedef MapBase<Derived, ReadOnlyAccessors> Base; 174 175 typedef typename Base::Scalar Scalar; 176 typedef typename Base::PacketScalar PacketScalar; 177 typedef typename Base::Index Index; 178 typedef typename Base::PointerType PointerType; 179 180 using Base::derived; 181 using Base::rows; 182 using Base::cols; 183 using Base::size; 184 using Base::coeff; 185 using Base::coeffRef; 186 187 using Base::innerStride; 188 using Base::outerStride; 189 using Base::rowStride; 190 using Base::colStride; 191 192 typedef typename internal::conditional< 193 internal::is_lvalue<Derived>::value, 194 Scalar, 195 const Scalar 196 >::type ScalarWithConstIfNotLvalue; 197 data()198 inline const Scalar* data() const { return this->m_data; } data()199 inline ScalarWithConstIfNotLvalue* data() { return this->m_data; } // no const-cast here so non-const-correct code will give a compile error 200 coeffRef(Index row,Index col)201 inline ScalarWithConstIfNotLvalue& coeffRef(Index row, Index col) 202 { 203 return this->m_data[col * colStride() + row * rowStride()]; 204 } 205 coeffRef(Index index)206 inline ScalarWithConstIfNotLvalue& coeffRef(Index index) 207 { 208 EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) 209 return this->m_data[index * innerStride()]; 210 } 211 212 template<int StoreMode> writePacket(Index row,Index col,const PacketScalar & x)213 inline void writePacket(Index row, Index col, const PacketScalar& x) 214 { 215 internal::pstoret<Scalar, PacketScalar, StoreMode> 216 (this->m_data + (col * colStride() + row * rowStride()), x); 217 } 218 219 template<int StoreMode> writePacket(Index index,const PacketScalar & x)220 inline void writePacket(Index index, const PacketScalar& x) 221 { 222 EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) 223 internal::pstoret<Scalar, PacketScalar, StoreMode> 224 (this->m_data + index * innerStride(), x); 225 } 226 MapBase(PointerType data)227 explicit inline MapBase(PointerType data) : Base(data) {} MapBase(PointerType data,Index size)228 inline MapBase(PointerType data, Index size) : Base(data, size) {} MapBase(PointerType data,Index rows,Index cols)229 inline MapBase(PointerType data, Index rows, Index cols) : Base(data, rows, cols) {} 230 231 Derived& operator=(const MapBase& other) 232 { 233 Base::Base::operator=(other); 234 return derived(); 235 } 236 237 using Base::Base::operator=; 238 }; 239 240 } // end namespace Eigen 241 242 #endif // EIGEN_MAPBASE_H 243