Teh first one
[mldemos:kalians-mldemos.git] / _AlgorithmsPlugins / KPCA / Eigen / src / Core / MapBase.h
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 // Eigen is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU Lesser General Public
9 // License as published by the Free Software Foundation; either
10 // version 3 of the License, or (at your option) any later version.
11 //
12 // Alternatively, you can redistribute it and/or
13 // modify it under the terms of the GNU General Public License as
14 // published by the Free Software Foundation; either version 2 of
15 // the License, or (at your option) any later version.
16 //
17 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
19 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
20 // GNU General Public License for more details.
21 //
22 // You should have received a copy of the GNU Lesser General Public
23 // License and a copy of the GNU General Public License along with
24 // Eigen. If not, see <http://www.gnu.org/licenses/>.
25
26 #ifndef EIGEN_MAPBASE_H
27 #define EIGEN_MAPBASE_H
28
29 #define EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) \
30       EIGEN_STATIC_ASSERT((int(internal::traits<Derived>::Flags) & LinearAccessBit) || Derived::IsVectorAtCompileTime, \
31                           YOU_ARE_TRYING_TO_USE_AN_INDEX_BASED_ACCESSOR_ON_AN_EXPRESSION_THAT_DOES_NOT_SUPPORT_THAT)
32
33
34 /** \class MapBase
35   * \ingroup Core_Module
36   *
37   * \brief Base class for Map and Block expression with direct access
38   *
39   * \sa class Map, class Block
40   */
41 template<typename Derived> class MapBase<Derived, ReadOnlyAccessors>
42   : public internal::dense_xpr_base<Derived>::type
43 {
44   public:
45
46     typedef typename internal::dense_xpr_base<Derived>::type Base;
47     enum {
48       RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
49       ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
50       SizeAtCompileTime = Base::SizeAtCompileTime
51     };
52
53     typedef typename internal::traits<Derived>::StorageKind StorageKind;
54     typedef typename internal::traits<Derived>::Index Index;
55     typedef typename internal::traits<Derived>::Scalar Scalar;
56     typedef typename internal::packet_traits<Scalar>::type PacketScalar;
57     typedef typename NumTraits<Scalar>::Real RealScalar;
58     typedef typename internal::conditional<
59                          bool(internal::is_lvalue<Derived>::value),
60                          Scalar *,
61                          const Scalar *>::type
62                      PointerType;
63
64     using Base::derived;
65 //    using Base::RowsAtCompileTime;
66 //    using Base::ColsAtCompileTime;
67 //    using Base::SizeAtCompileTime;
68     using Base::MaxRowsAtCompileTime;
69     using Base::MaxColsAtCompileTime;
70     using Base::MaxSizeAtCompileTime;
71     using Base::IsVectorAtCompileTime;
72     using Base::Flags;
73     using Base::IsRowMajor;
74
75     using Base::rows;
76     using Base::cols;
77     using Base::size;
78     using Base::coeff;
79     using Base::coeffRef;
80     using Base::lazyAssign;
81     using Base::eval;
82
83     using Base::innerStride;
84     using Base::outerStride;
85     using Base::rowStride;
86     using Base::colStride;
87
88     // bug 217 - compile error on ICC 11.1
89     using Base::operator=;
90
91     typedef typename Base::CoeffReturnType CoeffReturnType;
92
93     inline Index rows() const { return m_rows.value(); }
94     inline Index cols() const { return m_cols.value(); }
95
96     /** Returns a pointer to the first coefficient of the matrix or vector.
97       *
98       * \note When addressing this data, make sure to honor the strides returned by innerStride() and outerStride().
99       *
100       * \sa innerStride(), outerStride()
101       */
102     inline const Scalar* data() const { return m_data; }
103
104     inline const Scalar& coeff(Index row, Index col) const
105     {
106       return m_data[col * colStride() + row * rowStride()];
107     }
108
109     inline const Scalar& coeff(Index index) const
110     {
111       EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
112       return m_data[index * innerStride()];
113     }
114
115     inline const Scalar& coeffRef(Index row, Index col) const
116     {
117       return this->m_data[col * colStride() + row * rowStride()];
118     }
119
120     inline const Scalar& coeffRef(Index index) const
121     {
122       EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
123       return this->m_data[index * innerStride()];
124     }
125
126     template<int LoadMode>
127     inline PacketScalar packet(Index row, Index col) const
128     {
129       return internal::ploadt<PacketScalar, LoadMode>
130                (m_data + (col * colStride() + row * rowStride()));
131     }
132
133     template<int LoadMode>
134     inline PacketScalar packet(Index index) const
135     {
136       EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
137       return internal::ploadt<PacketScalar, LoadMode>(m_data + index * innerStride());
138     }
139
140     inline MapBase(PointerType data) : m_data(data), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime)
141     {
142       EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
143       checkSanity();
144     }
145
146     inline MapBase(PointerType data, Index size)
147             : m_data(data),
148               m_rows(RowsAtCompileTime == Dynamic ? size : Index(RowsAtCompileTime)),
149               m_cols(ColsAtCompileTime == Dynamic ? size : Index(ColsAtCompileTime))
150     {
151       EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
152       eigen_assert(size >= 0);
153       eigen_assert(data == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == size);
154       checkSanity();
155     }
156
157     inline MapBase(PointerType data, Index rows, Index cols)
158             : m_data(data), m_rows(rows), m_cols(cols)
159     {
160       eigen_assert( (data == 0)
161               || (   rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
162                   && cols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)));
163       checkSanity();
164     }
165
166   protected:
167
168     void checkSanity() const
169     {
170       EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(internal::traits<Derived>::Flags&PacketAccessBit,
171                                         internal::inner_stride_at_compile_time<Derived>::ret==1),
172                           PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1);
173       eigen_assert(EIGEN_IMPLIES(internal::traits<Derived>::Flags&AlignedBit, (size_t(m_data) % (sizeof(Scalar)*internal::packet_traits<Scalar>::size)) == 0)
174         && "data is not aligned");
175     }
176
177     PointerType m_data;
178     const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows;
179     const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols;
180 };
181
182 template<typename Derived> class MapBase<Derived, WriteAccessors>
183   : public MapBase<Derived, ReadOnlyAccessors>
184 {
185   public:
186
187     typedef MapBase<Derived, ReadOnlyAccessors> Base;
188
189     typedef typename Base::Scalar Scalar;
190     typedef typename Base::PacketScalar PacketScalar;
191     typedef typename Base::Index Index;
192     typedef typename Base::PointerType PointerType;
193
194     using Base::derived;
195     using Base::rows;
196     using Base::cols;
197     using Base::size;
198     using Base::coeff;
199     using Base::coeffRef;
200
201     using Base::innerStride;
202     using Base::outerStride;
203     using Base::rowStride;
204     using Base::colStride;
205
206     typedef typename internal::conditional<
207                     internal::is_lvalue<Derived>::value,
208                     Scalar,
209                     const Scalar
210                   >::type ScalarWithConstIfNotLvalue;
211
212     inline const Scalar* data() const { return this->m_data; }
213     inline ScalarWithConstIfNotLvalue* data() { return this->m_data; } // no const-cast here so non-const-correct code will give a compile error
214
215     inline ScalarWithConstIfNotLvalue& coeffRef(Index row, Index col)
216     {
217       return this->m_data[col * colStride() + row * rowStride()];
218     }
219
220     inline ScalarWithConstIfNotLvalue& coeffRef(Index index)
221     {
222       EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
223       return this->m_data[index * innerStride()];
224     }
225
226     template<int StoreMode>
227     inline void writePacket(Index row, Index col, const PacketScalar& x)
228     {
229       internal::pstoret<Scalar, PacketScalar, StoreMode>
230                (this->m_data + (col * colStride() + row * rowStride()), x);
231     }
232
233     template<int StoreMode>
234     inline void writePacket(Index index, const PacketScalar& x)
235     {
236       EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
237       internal::pstoret<Scalar, PacketScalar, StoreMode>
238                 (this->m_data + index * innerStride(), x);
239     }
240
241     inline MapBase(PointerType data) : Base(data) {}
242     inline MapBase(PointerType data, Index size) : Base(data, size) {}
243     inline MapBase(PointerType data, Index rows, Index cols) : Base(data, rows, cols) {}
244
245     Derived& operator=(const MapBase& other)
246     {
247       Base::Base::operator=(other);
248       return derived();
249     }
250
251     using Base::Base::operator=;
252 };
253
254
255 #endif // EIGEN_MAPBASE_H