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
18namespace 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  */
27template<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
79    inline Index rows() const { return m_rows.value(); }
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      */
88    inline const Scalar* data() const { return m_data; }
89
90    inline const Scalar& coeff(Index rowId, Index colId) const
91    {
92      return m_data[colId * colStride() + rowId * rowStride()];
93    }
94
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
101    inline const Scalar& coeffRef(Index rowId, Index colId) const
102    {
103      return this->m_data[colId * colStride() + rowId * rowStride()];
104    }
105
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>
113    inline PacketScalar packet(Index rowId, Index colId) const
114    {
115      return internal::ploadt<PacketScalar, LoadMode>
116               (m_data + (colId * colStride() + rowId * rowStride()));
117    }
118
119    template<int LoadMode>
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
126    inline MapBase(PointerType dataPtr) : m_data(dataPtr), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime)
127    {
128      EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
129      checkSanity();
130    }
131
132    inline MapBase(PointerType dataPtr, Index vecSize)
133            : m_data(dataPtr),
134              m_rows(RowsAtCompileTime == Dynamic ? vecSize : Index(RowsAtCompileTime)),
135              m_cols(ColsAtCompileTime == Dynamic ? vecSize : Index(ColsAtCompileTime))
136    {
137      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
138      eigen_assert(vecSize >= 0);
139      eigen_assert(dataPtr == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == vecSize);
140      checkSanity();
141    }
142
143    inline MapBase(PointerType dataPtr, Index nbRows, Index nbCols)
144            : m_data(dataPtr), m_rows(nbRows), m_cols(nbCols)
145    {
146      eigen_assert( (dataPtr == 0)
147              || (   nbRows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == nbRows)
148                  && nbCols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == nbCols)));
149      checkSanity();
150    }
151
152  protected:
153
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
168template<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
198    inline const Scalar* data() const { return this->m_data; }
199    inline ScalarWithConstIfNotLvalue* data() { return this->m_data; } // no const-cast here so non-const-correct code will give a compile error
200
201    inline ScalarWithConstIfNotLvalue& coeffRef(Index row, Index col)
202    {
203      return this->m_data[col * colStride() + row * rowStride()];
204    }
205
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>
213    inline void writePacket(Index row, Index col, const PacketScalar& val)
214    {
215      internal::pstoret<Scalar, PacketScalar, StoreMode>
216               (this->m_data + (col * colStride() + row * rowStride()), val);
217    }
218
219    template<int StoreMode>
220    inline void writePacket(Index index, const PacketScalar& val)
221    {
222      EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
223      internal::pstoret<Scalar, PacketScalar, StoreMode>
224                (this->m_data + index * innerStride(), val);
225    }
226
227    explicit inline MapBase(PointerType dataPtr) : Base(dataPtr) {}
228    inline MapBase(PointerType dataPtr, Index vecSize) : Base(dataPtr, vecSize) {}
229    inline MapBase(PointerType dataPtr, Index nbRows, Index nbCols) : Base(dataPtr, nbRows, nbCols) {}
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#undef EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS
241
242} // end namespace Eigen
243
244#endif // EIGEN_MAPBASE_H
245