Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / extern / Eigen2 / Eigen / src / Core / Coeffs.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra. Eigen itself is part of the KDE project.
3 //
4 // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
5 //
6 // Eigen is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 3 of the License, or (at your option) any later version.
10 //
11 // Alternatively, you can redistribute it and/or
12 // modify it under the terms of the GNU General Public License as
13 // published by the Free Software Foundation; either version 2 of
14 // the License, or (at your option) any later version.
15 //
16 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
17 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
19 // GNU General Public License for more details.
20 //
21 // You should have received a copy of the GNU Lesser General Public
22 // License and a copy of the GNU General Public License along with
23 // Eigen. If not, see <http://www.gnu.org/licenses/>.
24
25 #ifndef EIGEN_COEFFS_H
26 #define EIGEN_COEFFS_H
27
28 /** Short version: don't use this function, use
29   * \link operator()(int,int) const \endlink instead.
30   *
31   * Long version: this function is similar to
32   * \link operator()(int,int) const \endlink, but without the assertion.
33   * Use this for limiting the performance cost of debugging code when doing
34   * repeated coefficient access. Only use this when it is guaranteed that the
35   * parameters \a row and \a col are in range.
36   *
37   * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
38   * function equivalent to \link operator()(int,int) const \endlink.
39   *
40   * \sa operator()(int,int) const, coeffRef(int,int), coeff(int) const
41   */
42 template<typename Derived>
43 EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
44   ::coeff(int row, int col) const
45 {
46   ei_internal_assert(row >= 0 && row < rows()
47                      && col >= 0 && col < cols());
48   return derived().coeff(row, col);
49 }
50
51 /** \returns the coefficient at given the given row and column.
52   *
53   * \sa operator()(int,int), operator[](int) const
54   */
55 template<typename Derived>
56 EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
57   ::operator()(int row, int col) const
58 {
59   ei_assert(row >= 0 && row < rows()
60       && col >= 0 && col < cols());
61   return derived().coeff(row, col);
62 }
63
64 /** Short version: don't use this function, use
65   * \link operator()(int,int) \endlink instead.
66   *
67   * Long version: this function is similar to
68   * \link operator()(int,int) \endlink, but without the assertion.
69   * Use this for limiting the performance cost of debugging code when doing
70   * repeated coefficient access. Only use this when it is guaranteed that the
71   * parameters \a row and \a col are in range.
72   *
73   * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
74   * function equivalent to \link operator()(int,int) \endlink.
75   *
76   * \sa operator()(int,int), coeff(int, int) const, coeffRef(int)
77   */
78 template<typename Derived>
79 EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
80   ::coeffRef(int row, int col)
81 {
82   ei_internal_assert(row >= 0 && row < rows()
83                      && col >= 0 && col < cols());
84   return derived().coeffRef(row, col);
85 }
86
87 /** \returns a reference to the coefficient at given the given row and column.
88   *
89   * \sa operator()(int,int) const, operator[](int)
90   */
91 template<typename Derived>
92 EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
93   ::operator()(int row, int col)
94 {
95   ei_assert(row >= 0 && row < rows()
96       && col >= 0 && col < cols());
97   return derived().coeffRef(row, col);
98 }
99
100 /** Short version: don't use this function, use
101   * \link operator[](int) const \endlink instead.
102   *
103   * Long version: this function is similar to
104   * \link operator[](int) const \endlink, but without the assertion.
105   * Use this for limiting the performance cost of debugging code when doing
106   * repeated coefficient access. Only use this when it is guaranteed that the
107   * parameter \a index is in range.
108   *
109   * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
110   * function equivalent to \link operator[](int) const \endlink.
111   *
112   * \sa operator[](int) const, coeffRef(int), coeff(int,int) const
113   */
114 template<typename Derived>
115 EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
116   ::coeff(int index) const
117 {
118   ei_internal_assert(index >= 0 && index < size());
119   return derived().coeff(index);
120 }
121
122 /** \returns the coefficient at given index.
123   *
124   * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
125   *
126   * \sa operator[](int), operator()(int,int) const, x() const, y() const,
127   * z() const, w() const
128   */
129 template<typename Derived>
130 EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
131   ::operator[](int index) const
132 {
133   ei_assert(index >= 0 && index < size());
134   return derived().coeff(index);
135 }
136
137 /** \returns the coefficient at given index.
138   *
139   * This is synonymous to operator[](int) const.
140   *
141   * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
142   *
143   * \sa operator[](int), operator()(int,int) const, x() const, y() const,
144   * z() const, w() const
145   */
146 template<typename Derived>
147 EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
148   ::operator()(int index) const
149 {
150   ei_assert(index >= 0 && index < size());
151   return derived().coeff(index);
152 }
153
154 /** Short version: don't use this function, use
155   * \link operator[](int) \endlink instead.
156   *
157   * Long version: this function is similar to
158   * \link operator[](int) \endlink, but without the assertion.
159   * Use this for limiting the performance cost of debugging code when doing
160   * repeated coefficient access. Only use this when it is guaranteed that the
161   * parameters \a row and \a col are in range.
162   *
163   * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
164   * function equivalent to \link operator[](int) \endlink.
165   *
166   * \sa operator[](int), coeff(int) const, coeffRef(int,int)
167   */
168 template<typename Derived>
169 EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
170   ::coeffRef(int index)
171 {
172   ei_internal_assert(index >= 0 && index < size());
173   return derived().coeffRef(index);
174 }
175
176 /** \returns a reference to the coefficient at given index.
177   *
178   * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
179   *
180   * \sa operator[](int) const, operator()(int,int), x(), y(), z(), w()
181   */
182 template<typename Derived>
183 EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
184   ::operator[](int index)
185 {
186   ei_assert(index >= 0 && index < size());
187   return derived().coeffRef(index);
188 }
189
190 /** \returns a reference to the coefficient at given index.
191   *
192   * This is synonymous to operator[](int).
193   *
194   * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
195   *
196   * \sa operator[](int) const, operator()(int,int), x(), y(), z(), w()
197   */
198 template<typename Derived>
199 EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
200   ::operator()(int index)
201 {
202   ei_assert(index >= 0 && index < size());
203   return derived().coeffRef(index);
204 }
205
206 /** equivalent to operator[](0).  */
207 template<typename Derived>
208 EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
209   ::x() const { return (*this)[0]; }
210
211 /** equivalent to operator[](1).  */
212 template<typename Derived>
213 EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
214   ::y() const { return (*this)[1]; }
215
216 /** equivalent to operator[](2).  */
217 template<typename Derived>
218 EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
219   ::z() const { return (*this)[2]; }
220
221 /** equivalent to operator[](3).  */
222 template<typename Derived>
223 EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
224   ::w() const { return (*this)[3]; }
225
226 /** equivalent to operator[](0).  */
227 template<typename Derived>
228 EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
229   ::x() { return (*this)[0]; }
230
231 /** equivalent to operator[](1).  */
232 template<typename Derived>
233 EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
234   ::y() { return (*this)[1]; }
235
236 /** equivalent to operator[](2).  */
237 template<typename Derived>
238 EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
239   ::z() { return (*this)[2]; }
240
241 /** equivalent to operator[](3).  */
242 template<typename Derived>
243 EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
244   ::w() { return (*this)[3]; }
245
246 /** \returns the packet of coefficients starting at the given row and column. It is your responsibility
247   * to ensure that a packet really starts there. This method is only available on expressions having the
248   * PacketAccessBit.
249   *
250   * The \a LoadMode parameter may have the value \a Aligned or \a Unaligned. Its effect is to select
251   * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
252   * starting at an address which is a multiple of the packet size.
253   */
254 template<typename Derived>
255 template<int LoadMode>
256 EIGEN_STRONG_INLINE typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type
257 MatrixBase<Derived>::packet(int row, int col) const
258 {
259   ei_internal_assert(row >= 0 && row < rows()
260                      && col >= 0 && col < cols());
261   return derived().template packet<LoadMode>(row,col);
262 }
263
264 /** Stores the given packet of coefficients, at the given row and column of this expression. It is your responsibility
265   * to ensure that a packet really starts there. This method is only available on expressions having the
266   * PacketAccessBit.
267   *
268   * The \a LoadMode parameter may have the value \a Aligned or \a Unaligned. Its effect is to select
269   * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
270   * starting at an address which is a multiple of the packet size.
271   */
272 template<typename Derived>
273 template<int StoreMode>
274 EIGEN_STRONG_INLINE void MatrixBase<Derived>::writePacket
275 (int row, int col, const typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type& x)
276 {
277   ei_internal_assert(row >= 0 && row < rows()
278                      && col >= 0 && col < cols());
279   derived().template writePacket<StoreMode>(row,col,x);
280 }
281
282 /** \returns the packet of coefficients starting at the given index. It is your responsibility
283   * to ensure that a packet really starts there. This method is only available on expressions having the
284   * PacketAccessBit and the LinearAccessBit.
285   *
286   * The \a LoadMode parameter may have the value \a Aligned or \a Unaligned. Its effect is to select
287   * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
288   * starting at an address which is a multiple of the packet size.
289   */
290 template<typename Derived>
291 template<int LoadMode>
292 EIGEN_STRONG_INLINE typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type
293 MatrixBase<Derived>::packet(int index) const
294 {
295   ei_internal_assert(index >= 0 && index < size());
296   return derived().template packet<LoadMode>(index);
297 }
298
299 /** Stores the given packet of coefficients, at the given index in this expression. It is your responsibility
300   * to ensure that a packet really starts there. This method is only available on expressions having the
301   * PacketAccessBit and the LinearAccessBit.
302   *
303   * The \a LoadMode parameter may have the value \a Aligned or \a Unaligned. Its effect is to select
304   * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
305   * starting at an address which is a multiple of the packet size.
306   */
307 template<typename Derived>
308 template<int StoreMode>
309 EIGEN_STRONG_INLINE void MatrixBase<Derived>::writePacket
310 (int index, const typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type& x)
311 {
312   ei_internal_assert(index >= 0 && index < size());
313   derived().template writePacket<StoreMode>(index,x);
314 }
315
316 #ifndef EIGEN_PARSED_BY_DOXYGEN
317
318 /** \internal Copies the coefficient at position (row,col) of other into *this.
319   *
320   * This method is overridden in SwapWrapper, allowing swap() assignments to share 99% of their code
321   * with usual assignments.
322   *
323   * Outside of this internal usage, this method has probably no usefulness. It is hidden in the public API dox.
324   */
325 template<typename Derived>
326 template<typename OtherDerived>
327 EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyCoeff(int row, int col, const MatrixBase<OtherDerived>& other)
328 {
329   ei_internal_assert(row >= 0 && row < rows()
330                      && col >= 0 && col < cols());
331   derived().coeffRef(row, col) = other.derived().coeff(row, col);
332 }
333
334 /** \internal Copies the coefficient at the given index of other into *this.
335   *
336   * This method is overridden in SwapWrapper, allowing swap() assignments to share 99% of their code
337   * with usual assignments.
338   *
339   * Outside of this internal usage, this method has probably no usefulness. It is hidden in the public API dox.
340   */
341 template<typename Derived>
342 template<typename OtherDerived>
343 EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyCoeff(int index, const MatrixBase<OtherDerived>& other)
344 {
345   ei_internal_assert(index >= 0 && index < size());
346   derived().coeffRef(index) = other.derived().coeff(index);
347 }
348
349 /** \internal Copies the packet at position (row,col) of other into *this.
350   *
351   * This method is overridden in SwapWrapper, allowing swap() assignments to share 99% of their code
352   * with usual assignments.
353   *
354   * Outside of this internal usage, this method has probably no usefulness. It is hidden in the public API dox.
355   */
356 template<typename Derived>
357 template<typename OtherDerived, int StoreMode, int LoadMode>
358 EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyPacket(int row, int col, const MatrixBase<OtherDerived>& other)
359 {
360   ei_internal_assert(row >= 0 && row < rows()
361                      && col >= 0 && col < cols());
362   derived().template writePacket<StoreMode>(row, col,
363     other.derived().template packet<LoadMode>(row, col));
364 }
365
366 /** \internal Copies the packet at the given index of other into *this.
367   *
368   * This method is overridden in SwapWrapper, allowing swap() assignments to share 99% of their code
369   * with usual assignments.
370   *
371   * Outside of this internal usage, this method has probably no usefulness. It is hidden in the public API dox.
372   */
373 template<typename Derived>
374 template<typename OtherDerived, int StoreMode, int LoadMode>
375 EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyPacket(int index, const MatrixBase<OtherDerived>& other)
376 {
377   ei_internal_assert(index >= 0 && index < size());
378   derived().template writePacket<StoreMode>(index,
379     other.derived().template packet<LoadMode>(index));
380 }
381
382 #endif
383
384 #endif // EIGEN_COEFFS_H