Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / extern / Eigen2 / Eigen / src / Core / Block.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) 2008 Gael Guennebaud <g.gael@free.fr>
5 // Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
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_BLOCK_H
27 #define EIGEN_BLOCK_H
28
29 /** \class Block
30   *
31   * \brief Expression of a fixed-size or dynamic-size block
32   *
33   * \param MatrixType the type of the object in which we are taking a block
34   * \param BlockRows the number of rows of the block we are taking at compile time (optional)
35   * \param BlockCols the number of columns of the block we are taking at compile time (optional)
36   * \param _PacketAccess allows to enforce aligned loads and stores if set to ForceAligned.
37   *                      The default is AsRequested. This parameter is internaly used by Eigen
38   *                      in expressions such as \code mat.block() += other; \endcode and most of
39   *                      the time this is the only way it is used.
40   * \param _DirectAccessStatus \internal used for partial specialization
41   *
42   * This class represents an expression of either a fixed-size or dynamic-size block. It is the return
43   * type of MatrixBase::block(int,int,int,int) and MatrixBase::block<int,int>(int,int) and
44   * most of the time this is the only way it is used.
45   *
46   * However, if you want to directly maniputate block expressions,
47   * for instance if you want to write a function returning such an expression, you
48   * will need to use this class.
49   *
50   * Here is an example illustrating the dynamic case:
51   * \include class_Block.cpp
52   * Output: \verbinclude class_Block.out
53   *
54   * \note Even though this expression has dynamic size, in the case where \a MatrixType
55   * has fixed size, this expression inherits a fixed maximal size which means that evaluating
56   * it does not cause a dynamic memory allocation.
57   *
58   * Here is an example illustrating the fixed-size case:
59   * \include class_FixedBlock.cpp
60   * Output: \verbinclude class_FixedBlock.out
61   *
62   * \sa MatrixBase::block(int,int,int,int), MatrixBase::block(int,int), class VectorBlock
63   */
64
65 template<typename MatrixType, int BlockRows, int BlockCols, int _PacketAccess, int _DirectAccessStatus>
66 struct ei_traits<Block<MatrixType, BlockRows, BlockCols, _PacketAccess, _DirectAccessStatus> >
67 {
68   typedef typename ei_traits<MatrixType>::Scalar Scalar;
69   typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
70   typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested;
71   enum{
72     RowsAtCompileTime = ei_traits<MatrixType>::RowsAtCompileTime == 1 ? 1 : BlockRows,
73     ColsAtCompileTime = ei_traits<MatrixType>::ColsAtCompileTime == 1 ? 1 : BlockCols,
74     MaxRowsAtCompileTime = RowsAtCompileTime == 1 ? 1
75       : (BlockRows==Dynamic ? int(ei_traits<MatrixType>::MaxRowsAtCompileTime) : BlockRows),
76     MaxColsAtCompileTime = ColsAtCompileTime == 1 ? 1
77       : (BlockCols==Dynamic ? int(ei_traits<MatrixType>::MaxColsAtCompileTime) : BlockCols),
78     RowMajor = int(ei_traits<MatrixType>::Flags)&RowMajorBit,
79     InnerSize = RowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
80     InnerMaxSize = RowMajor ? int(MaxColsAtCompileTime) : int(MaxRowsAtCompileTime),
81     MaskPacketAccessBit = (InnerMaxSize == Dynamic || (InnerSize >= ei_packet_traits<Scalar>::size))
82                         ? PacketAccessBit : 0,
83     FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0,
84     Flags = (ei_traits<MatrixType>::Flags & (HereditaryBits | MaskPacketAccessBit | DirectAccessBit)) | FlagsLinearAccessBit,
85     CoeffReadCost = ei_traits<MatrixType>::CoeffReadCost,
86     PacketAccess = _PacketAccess
87   };
88   typedef typename ei_meta_if<int(PacketAccess)==ForceAligned,
89                  Block<MatrixType, BlockRows, BlockCols, _PacketAccess, _DirectAccessStatus>&,
90                  Block<MatrixType, BlockRows, BlockCols, ForceAligned, _DirectAccessStatus> >::ret AlignedDerivedType;
91 };
92
93 template<typename MatrixType, int BlockRows, int BlockCols, int PacketAccess, int _DirectAccessStatus> class Block
94   : public MatrixBase<Block<MatrixType, BlockRows, BlockCols, PacketAccess, _DirectAccessStatus> >
95 {
96   public:
97
98     EIGEN_GENERIC_PUBLIC_INTERFACE(Block)
99
100     class InnerIterator;
101
102     /** Column or Row constructor
103       */
104     inline Block(const MatrixType& matrix, int i)
105       : m_matrix(matrix),
106         // It is a row if and only if BlockRows==1 and BlockCols==MatrixType::ColsAtCompileTime,
107         // and it is a column if and only if BlockRows==MatrixType::RowsAtCompileTime and BlockCols==1,
108         // all other cases are invalid.
109         // The case a 1x1 matrix seems ambiguous, but the result is the same anyway.
110         m_startRow( (BlockRows==1) && (BlockCols==MatrixType::ColsAtCompileTime) ? i : 0),
111         m_startCol( (BlockRows==MatrixType::RowsAtCompileTime) && (BlockCols==1) ? i : 0),
112         m_blockRows(matrix.rows()), // if it is a row, then m_blockRows has a fixed-size of 1, so no pb to try to overwrite it
113         m_blockCols(matrix.cols())  // same for m_blockCols
114     {
115       ei_assert( (i>=0) && (
116           ((BlockRows==1) && (BlockCols==MatrixType::ColsAtCompileTime) && i<matrix.rows())
117         ||((BlockRows==MatrixType::RowsAtCompileTime) && (BlockCols==1) && i<matrix.cols())));
118     }
119
120     /** Fixed-size constructor
121       */
122     inline Block(const MatrixType& matrix, int startRow, int startCol)
123       : m_matrix(matrix), m_startRow(startRow), m_startCol(startCol),
124         m_blockRows(matrix.rows()), m_blockCols(matrix.cols())
125     {
126       EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
127       ei_assert(startRow >= 0 && BlockRows >= 1 && startRow + BlockRows <= matrix.rows()
128           && startCol >= 0 && BlockCols >= 1 && startCol + BlockCols <= matrix.cols());
129     }
130
131     /** Dynamic-size constructor
132       */
133     inline Block(const MatrixType& matrix,
134           int startRow, int startCol,
135           int blockRows, int blockCols)
136       : m_matrix(matrix), m_startRow(startRow), m_startCol(startCol),
137                           m_blockRows(blockRows), m_blockCols(blockCols)
138     {
139       ei_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
140           && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
141       ei_assert(startRow >= 0 && blockRows >= 1 && startRow + blockRows <= matrix.rows()
142           && startCol >= 0 && blockCols >= 1 && startCol + blockCols <= matrix.cols());
143     }
144
145     EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
146
147     inline int rows() const { return m_blockRows.value(); }
148     inline int cols() const { return m_blockCols.value(); }
149
150     inline Scalar& coeffRef(int row, int col)
151     {
152       return m_matrix.const_cast_derived()
153                .coeffRef(row + m_startRow.value(), col + m_startCol.value());
154     }
155
156     inline const Scalar coeff(int row, int col) const
157     {
158       return m_matrix.coeff(row + m_startRow.value(), col + m_startCol.value());
159     }
160
161     inline Scalar& coeffRef(int index)
162     {
163       return m_matrix.const_cast_derived()
164              .coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
165                        m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
166     }
167
168     inline const Scalar coeff(int index) const
169     {
170       return m_matrix
171              .coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
172                     m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
173     }
174
175     template<int LoadMode>
176     inline PacketScalar packet(int row, int col) const
177     {
178       return m_matrix.template packet<Unaligned>
179               (row + m_startRow.value(), col + m_startCol.value());
180     }
181
182     template<int LoadMode>
183     inline void writePacket(int row, int col, const PacketScalar& x)
184     {
185       m_matrix.const_cast_derived().template writePacket<Unaligned>
186               (row + m_startRow.value(), col + m_startCol.value(), x);
187     }
188
189     template<int LoadMode>
190     inline PacketScalar packet(int index) const
191     {
192       return m_matrix.template packet<Unaligned>
193               (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
194                m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
195     }
196
197     template<int LoadMode>
198     inline void writePacket(int index, const PacketScalar& x)
199     {
200       m_matrix.const_cast_derived().template writePacket<Unaligned>
201          (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
202           m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0), x);
203     }
204
205   protected:
206
207     const typename MatrixType::Nested m_matrix;
208     const ei_int_if_dynamic<MatrixType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow;
209     const ei_int_if_dynamic<MatrixType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol;
210     const ei_int_if_dynamic<RowsAtCompileTime> m_blockRows;
211     const ei_int_if_dynamic<ColsAtCompileTime> m_blockCols;
212 };
213
214 /** \internal */
215 template<typename MatrixType, int BlockRows, int BlockCols, int PacketAccess>
216 class Block<MatrixType,BlockRows,BlockCols,PacketAccess,HasDirectAccess>
217   : public MapBase<Block<MatrixType, BlockRows, BlockCols,PacketAccess,HasDirectAccess> >
218 {
219   public:
220
221     _EIGEN_GENERIC_PUBLIC_INTERFACE(Block, MapBase<Block>)
222
223     class InnerIterator;
224     typedef typename ei_traits<Block>::AlignedDerivedType AlignedDerivedType;
225     friend class Block<MatrixType,BlockRows,BlockCols,PacketAccess==AsRequested?ForceAligned:AsRequested,HasDirectAccess>;
226
227     EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
228
229     AlignedDerivedType _convertToForceAligned()
230     {
231       return Block<MatrixType,BlockRows,BlockCols,ForceAligned,HasDirectAccess>
232                     (m_matrix, Base::m_data, Base::m_rows.value(), Base::m_cols.value());
233     }
234
235     /** Column or Row constructor
236       */
237     inline Block(const MatrixType& matrix, int i)
238       : Base(&matrix.const_cast_derived().coeffRef(
239               (BlockRows==1) && (BlockCols==MatrixType::ColsAtCompileTime) ? i : 0,
240               (BlockRows==MatrixType::RowsAtCompileTime) && (BlockCols==1) ? i : 0),
241              BlockRows==1 ? 1 : matrix.rows(),
242              BlockCols==1 ? 1 : matrix.cols()),
243         m_matrix(matrix)
244     {
245       ei_assert( (i>=0) && (
246           ((BlockRows==1) && (BlockCols==MatrixType::ColsAtCompileTime) && i<matrix.rows())
247         ||((BlockRows==MatrixType::RowsAtCompileTime) && (BlockCols==1) && i<matrix.cols())));
248     }
249
250     /** Fixed-size constructor
251       */
252     inline Block(const MatrixType& matrix, int startRow, int startCol)
253       : Base(&matrix.const_cast_derived().coeffRef(startRow,startCol)), m_matrix(matrix)
254     {
255       ei_assert(startRow >= 0 && BlockRows >= 1 && startRow + BlockRows <= matrix.rows()
256              && startCol >= 0 && BlockCols >= 1 && startCol + BlockCols <= matrix.cols());
257     }
258
259     /** Dynamic-size constructor
260       */
261     inline Block(const MatrixType& matrix,
262           int startRow, int startCol,
263           int blockRows, int blockCols)
264       : Base(&matrix.const_cast_derived().coeffRef(startRow,startCol), blockRows, blockCols),
265         m_matrix(matrix)
266     {
267       ei_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
268              && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
269       ei_assert(startRow >= 0 && blockRows >= 1 && startRow + blockRows <= matrix.rows()
270              && startCol >= 0 && blockCols >= 1 && startCol + blockCols <= matrix.cols());
271     }
272
273     inline int stride(void) const { return m_matrix.stride(); }
274
275   protected:
276
277     /** \internal used by allowAligned() */
278     inline Block(const MatrixType& matrix, const Scalar* data, int blockRows, int blockCols)
279       : Base(data, blockRows, blockCols), m_matrix(matrix)
280     {}
281
282     const typename MatrixType::Nested m_matrix;
283 };
284
285 /** \returns a dynamic-size expression of a block in *this.
286   *
287   * \param startRow the first row in the block
288   * \param startCol the first column in the block
289   * \param blockRows the number of rows in the block
290   * \param blockCols the number of columns in the block
291   *
292   * \addexample BlockIntIntIntInt \label How to reference a sub-matrix (dynamic-size)
293   *
294   * Example: \include MatrixBase_block_int_int_int_int.cpp
295   * Output: \verbinclude MatrixBase_block_int_int_int_int.out
296   *
297   * \note Even though the returned expression has dynamic size, in the case
298   * when it is applied to a fixed-size matrix, it inherits a fixed maximal size,
299   * which means that evaluating it does not cause a dynamic memory allocation.
300   *
301   * \sa class Block, block(int,int)
302   */
303 template<typename Derived>
304 inline typename BlockReturnType<Derived>::Type MatrixBase<Derived>
305   ::block(int startRow, int startCol, int blockRows, int blockCols)
306 {
307   return typename BlockReturnType<Derived>::Type(derived(), startRow, startCol, blockRows, blockCols);
308 }
309
310 /** This is the const version of block(int,int,int,int). */
311 template<typename Derived>
312 inline const typename BlockReturnType<Derived>::Type MatrixBase<Derived>
313   ::block(int startRow, int startCol, int blockRows, int blockCols) const
314 {
315   return typename BlockReturnType<Derived>::Type(derived(), startRow, startCol, blockRows, blockCols);
316 }
317
318 /** \returns a dynamic-size expression of a segment (i.e. a vector block) in *this.
319   *
320   * \only_for_vectors
321   *
322   * \addexample SegmentIntInt \label How to reference a sub-vector (dynamic size)
323   *
324   * \param start the first coefficient in the segment
325   * \param size the number of coefficients in the segment
326   *
327   * Example: \include MatrixBase_segment_int_int.cpp
328   * Output: \verbinclude MatrixBase_segment_int_int.out
329   *
330   * \note Even though the returned expression has dynamic size, in the case
331   * when it is applied to a fixed-size vector, it inherits a fixed maximal size,
332   * which means that evaluating it does not cause a dynamic memory allocation.
333   *
334   * \sa class Block, segment(int)
335   */
336 template<typename Derived>
337 inline typename BlockReturnType<Derived>::SubVectorType MatrixBase<Derived>
338   ::segment(int start, int size)
339 {
340   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
341   return typename BlockReturnType<Derived>::SubVectorType(derived(), RowsAtCompileTime == 1 ? 0 : start,
342                                    ColsAtCompileTime == 1 ? 0 : start,
343                                    RowsAtCompileTime == 1 ? 1 : size,
344                                    ColsAtCompileTime == 1 ? 1 : size);
345 }
346
347 /** This is the const version of segment(int,int).*/
348 template<typename Derived>
349 inline const typename BlockReturnType<Derived>::SubVectorType
350 MatrixBase<Derived>::segment(int start, int size) const
351 {
352   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
353   return typename BlockReturnType<Derived>::SubVectorType(derived(), RowsAtCompileTime == 1 ? 0 : start,
354                                    ColsAtCompileTime == 1 ? 0 : start,
355                                    RowsAtCompileTime == 1 ? 1 : size,
356                                    ColsAtCompileTime == 1 ? 1 : size);
357 }
358
359 /** \returns a dynamic-size expression of the first coefficients of *this.
360   *
361   * \only_for_vectors
362   *
363   * \param size the number of coefficients in the block
364   *
365   * \addexample BlockInt \label How to reference a sub-vector (fixed-size)
366   *
367   * Example: \include MatrixBase_start_int.cpp
368   * Output: \verbinclude MatrixBase_start_int.out
369   *
370   * \note Even though the returned expression has dynamic size, in the case
371   * when it is applied to a fixed-size vector, it inherits a fixed maximal size,
372   * which means that evaluating it does not cause a dynamic memory allocation.
373   *
374   * \sa class Block, block(int,int)
375   */
376 template<typename Derived>
377 inline typename BlockReturnType<Derived,Dynamic>::SubVectorType
378 MatrixBase<Derived>::start(int size)
379 {
380   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
381   return Block<Derived,
382                RowsAtCompileTime == 1 ? 1 : Dynamic,
383                ColsAtCompileTime == 1 ? 1 : Dynamic>
384               (derived(), 0, 0,
385                RowsAtCompileTime == 1 ? 1 : size,
386                ColsAtCompileTime == 1 ? 1 : size);
387 }
388
389 /** This is the const version of start(int).*/
390 template<typename Derived>
391 inline const typename BlockReturnType<Derived,Dynamic>::SubVectorType
392 MatrixBase<Derived>::start(int size) const
393 {
394   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
395   return Block<Derived,
396                RowsAtCompileTime == 1 ? 1 : Dynamic,
397                ColsAtCompileTime == 1 ? 1 : Dynamic>
398               (derived(), 0, 0,
399                RowsAtCompileTime == 1 ? 1 : size,
400                ColsAtCompileTime == 1 ? 1 : size);
401 }
402
403 /** \returns a dynamic-size expression of the last coefficients of *this.
404   *
405   * \only_for_vectors
406   *
407   * \param size the number of coefficients in the block
408   *
409   * \addexample BlockEnd \label How to reference the end of a vector (fixed-size)
410   *
411   * Example: \include MatrixBase_end_int.cpp
412   * Output: \verbinclude MatrixBase_end_int.out
413   *
414   * \note Even though the returned expression has dynamic size, in the case
415   * when it is applied to a fixed-size vector, it inherits a fixed maximal size,
416   * which means that evaluating it does not cause a dynamic memory allocation.
417   *
418   * \sa class Block, block(int,int)
419   */
420 template<typename Derived>
421 inline typename BlockReturnType<Derived,Dynamic>::SubVectorType
422 MatrixBase<Derived>::end(int size)
423 {
424   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
425   return Block<Derived,
426                RowsAtCompileTime == 1 ? 1 : Dynamic,
427                ColsAtCompileTime == 1 ? 1 : Dynamic>
428               (derived(),
429                RowsAtCompileTime == 1 ? 0 : rows() - size,
430                ColsAtCompileTime == 1 ? 0 : cols() - size,
431                RowsAtCompileTime == 1 ? 1 : size,
432                ColsAtCompileTime == 1 ? 1 : size);
433 }
434
435 /** This is the const version of end(int).*/
436 template<typename Derived>
437 inline const typename BlockReturnType<Derived,Dynamic>::SubVectorType
438 MatrixBase<Derived>::end(int size) const
439 {
440   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
441   return Block<Derived,
442                RowsAtCompileTime == 1 ? 1 : Dynamic,
443                ColsAtCompileTime == 1 ? 1 : Dynamic>
444               (derived(),
445                RowsAtCompileTime == 1 ? 0 : rows() - size,
446                ColsAtCompileTime == 1 ? 0 : cols() - size,
447                RowsAtCompileTime == 1 ? 1 : size,
448                ColsAtCompileTime == 1 ? 1 : size);
449 }
450
451 /** \returns a fixed-size expression of a segment (i.e. a vector block) in \c *this
452   *
453   * \only_for_vectors
454   *
455   * The template parameter \a Size is the number of coefficients in the block
456   *
457   * \param start the index of the first element of the sub-vector
458   *
459   * Example: \include MatrixBase_template_int_segment.cpp
460   * Output: \verbinclude MatrixBase_template_int_segment.out
461   *
462   * \sa class Block
463   */
464 template<typename Derived>
465 template<int Size>
466 inline typename BlockReturnType<Derived,Size>::SubVectorType
467 MatrixBase<Derived>::segment(int start)
468 {
469   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
470   return Block<Derived,  (RowsAtCompileTime == 1 ? 1 : Size),
471                          (ColsAtCompileTime == 1 ? 1 : Size)>
472               (derived(), RowsAtCompileTime == 1 ? 0 : start,
473                           ColsAtCompileTime == 1 ? 0 : start);
474 }
475
476 /** This is the const version of segment<int>(int).*/
477 template<typename Derived>
478 template<int Size>
479 inline const typename BlockReturnType<Derived,Size>::SubVectorType
480 MatrixBase<Derived>::segment(int start) const
481 {
482   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
483   return Block<Derived,  (RowsAtCompileTime == 1 ? 1 : Size),
484                          (ColsAtCompileTime == 1 ? 1 : Size)>
485               (derived(), RowsAtCompileTime == 1 ? 0 : start,
486                           ColsAtCompileTime == 1 ? 0 : start);
487 }
488
489 /** \returns a fixed-size expression of the first coefficients of *this.
490   *
491   * \only_for_vectors
492   *
493   * The template parameter \a Size is the number of coefficients in the block
494   *
495   * \addexample BlockStart \label How to reference the start of a vector (fixed-size)
496   *
497   * Example: \include MatrixBase_template_int_start.cpp
498   * Output: \verbinclude MatrixBase_template_int_start.out
499   *
500   * \sa class Block
501   */
502 template<typename Derived>
503 template<int Size>
504 inline typename BlockReturnType<Derived,Size>::SubVectorType
505 MatrixBase<Derived>::start()
506 {
507   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
508   return Block<Derived, (RowsAtCompileTime == 1 ? 1 : Size),
509                         (ColsAtCompileTime == 1 ? 1 : Size)>(derived(), 0, 0);
510 }
511
512 /** This is the const version of start<int>().*/
513 template<typename Derived>
514 template<int Size>
515 inline const typename BlockReturnType<Derived,Size>::SubVectorType
516 MatrixBase<Derived>::start() const
517 {
518   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
519   return Block<Derived, (RowsAtCompileTime == 1 ? 1 : Size),
520                         (ColsAtCompileTime == 1 ? 1 : Size)>(derived(), 0, 0);
521 }
522
523 /** \returns a fixed-size expression of the last coefficients of *this.
524   *
525   * \only_for_vectors
526   *
527   * The template parameter \a Size is the number of coefficients in the block
528   *
529   * Example: \include MatrixBase_template_int_end.cpp
530   * Output: \verbinclude MatrixBase_template_int_end.out
531   *
532   * \sa class Block
533   */
534 template<typename Derived>
535 template<int Size>
536 inline typename BlockReturnType<Derived,Size>::SubVectorType
537 MatrixBase<Derived>::end()
538 {
539   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
540   return Block<Derived, RowsAtCompileTime == 1 ? 1 : Size,
541                         ColsAtCompileTime == 1 ? 1 : Size>
542            (derived(),
543             RowsAtCompileTime == 1 ? 0 : rows() - Size,
544             ColsAtCompileTime == 1 ? 0 : cols() - Size);
545 }
546
547 /** This is the const version of end<int>.*/
548 template<typename Derived>
549 template<int Size>
550 inline const typename BlockReturnType<Derived,Size>::SubVectorType
551 MatrixBase<Derived>::end() const
552 {
553   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
554   return Block<Derived, RowsAtCompileTime == 1 ? 1 : Size,
555                         ColsAtCompileTime == 1 ? 1 : Size>
556            (derived(),
557             RowsAtCompileTime == 1 ? 0 : rows() - Size,
558             ColsAtCompileTime == 1 ? 0 : cols() - Size);
559 }
560
561 /** \returns a dynamic-size expression of a corner of *this.
562   *
563   * \param type the type of corner. Can be \a Eigen::TopLeft, \a Eigen::TopRight,
564   * \a Eigen::BottomLeft, \a Eigen::BottomRight.
565   * \param cRows the number of rows in the corner
566   * \param cCols the number of columns in the corner
567   *
568   * \addexample BlockCornerDynamicSize \label How to reference a sub-corner of a matrix
569   *
570   * Example: \include MatrixBase_corner_enum_int_int.cpp
571   * Output: \verbinclude MatrixBase_corner_enum_int_int.out
572   *
573   * \note Even though the returned expression has dynamic size, in the case
574   * when it is applied to a fixed-size matrix, it inherits a fixed maximal size,
575   * which means that evaluating it does not cause a dynamic memory allocation.
576   *
577   * \sa class Block, block(int,int,int,int)
578   */
579 template<typename Derived>
580 inline typename BlockReturnType<Derived>::Type MatrixBase<Derived>
581   ::corner(CornerType type, int cRows, int cCols)
582 {
583   switch(type)
584   {
585     default:
586       ei_assert(false && "Bad corner type.");
587     case TopLeft:
588       return typename BlockReturnType<Derived>::Type(derived(), 0, 0, cRows, cCols);
589     case TopRight:
590       return typename BlockReturnType<Derived>::Type(derived(), 0, cols() - cCols, cRows, cCols);
591     case BottomLeft:
592       return typename BlockReturnType<Derived>::Type(derived(), rows() - cRows, 0, cRows, cCols);
593     case BottomRight:
594       return typename BlockReturnType<Derived>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
595   }
596 }
597
598 /** This is the const version of corner(CornerType, int, int).*/
599 template<typename Derived>
600 inline const typename BlockReturnType<Derived>::Type
601 MatrixBase<Derived>::corner(CornerType type, int cRows, int cCols) const
602 {
603   switch(type)
604   {
605     default:
606       ei_assert(false && "Bad corner type.");
607     case TopLeft:
608       return typename BlockReturnType<Derived>::Type(derived(), 0, 0, cRows, cCols);
609     case TopRight:
610       return typename BlockReturnType<Derived>::Type(derived(), 0, cols() - cCols, cRows, cCols);
611     case BottomLeft:
612       return typename BlockReturnType<Derived>::Type(derived(), rows() - cRows, 0, cRows, cCols);
613     case BottomRight:
614       return typename BlockReturnType<Derived>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
615   }
616 }
617
618 /** \returns a fixed-size expression of a corner of *this.
619   *
620   * \param type the type of corner. Can be \a Eigen::TopLeft, \a Eigen::TopRight,
621   * \a Eigen::BottomLeft, \a Eigen::BottomRight.
622   *
623   * The template parameters CRows and CCols arethe number of rows and columns in the corner.
624   *
625   * Example: \include MatrixBase_template_int_int_corner_enum.cpp
626   * Output: \verbinclude MatrixBase_template_int_int_corner_enum.out
627   *
628   * \sa class Block, block(int,int,int,int)
629   */
630 template<typename Derived>
631 template<int CRows, int CCols>
632 inline typename BlockReturnType<Derived, CRows, CCols>::Type
633 MatrixBase<Derived>::corner(CornerType type)
634 {
635   switch(type)
636   {
637     default:
638       ei_assert(false && "Bad corner type.");
639     case TopLeft:
640       return Block<Derived, CRows, CCols>(derived(), 0, 0);
641     case TopRight:
642       return Block<Derived, CRows, CCols>(derived(), 0, cols() - CCols);
643     case BottomLeft:
644       return Block<Derived, CRows, CCols>(derived(), rows() - CRows, 0);
645     case BottomRight:
646       return Block<Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols);
647   }
648 }
649
650 /** This is the const version of corner<int, int>(CornerType).*/
651 template<typename Derived>
652 template<int CRows, int CCols>
653 inline const typename BlockReturnType<Derived, CRows, CCols>::Type
654 MatrixBase<Derived>::corner(CornerType type) const
655 {
656   switch(type)
657   {
658     default:
659       ei_assert(false && "Bad corner type.");
660     case TopLeft:
661       return Block<Derived, CRows, CCols>(derived(), 0, 0);
662     case TopRight:
663       return Block<Derived, CRows, CCols>(derived(), 0, cols() - CCols);
664     case BottomLeft:
665       return Block<Derived, CRows, CCols>(derived(), rows() - CRows, 0);
666     case BottomRight:
667       return Block<Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols);
668   }
669 }
670
671 /** \returns a fixed-size expression of a block in *this.
672   *
673   * The template parameters \a BlockRows and \a BlockCols are the number of
674   * rows and columns in the block.
675   *
676   * \param startRow the first row in the block
677   * \param startCol the first column in the block
678   *
679   * \addexample BlockSubMatrixFixedSize \label How to reference a sub-matrix (fixed-size)
680   *
681   * Example: \include MatrixBase_block_int_int.cpp
682   * Output: \verbinclude MatrixBase_block_int_int.out
683   *
684   * \note since block is a templated member, the keyword template has to be used
685   * if the matrix type is also a template parameter: \code m.template block<3,3>(1,1); \endcode
686   *
687   * \sa class Block, block(int,int,int,int)
688   */
689 template<typename Derived>
690 template<int BlockRows, int BlockCols>
691 inline typename BlockReturnType<Derived, BlockRows, BlockCols>::Type
692 MatrixBase<Derived>::block(int startRow, int startCol)
693 {
694   return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
695 }
696
697 /** This is the const version of block<>(int, int). */
698 template<typename Derived>
699 template<int BlockRows, int BlockCols>
700 inline const typename BlockReturnType<Derived, BlockRows, BlockCols>::Type
701 MatrixBase<Derived>::block(int startRow, int startCol) const
702 {
703   return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
704 }
705
706 /** \returns an expression of the \a i-th column of *this. Note that the numbering starts at 0.
707   *
708   * \addexample BlockColumn \label How to reference a single column of a matrix
709   *
710   * Example: \include MatrixBase_col.cpp
711   * Output: \verbinclude MatrixBase_col.out
712   *
713   * \sa row(), class Block */
714 template<typename Derived>
715 inline typename MatrixBase<Derived>::ColXpr
716 MatrixBase<Derived>::col(int i)
717 {
718   return ColXpr(derived(), i);
719 }
720
721 /** This is the const version of col(). */
722 template<typename Derived>
723 inline const typename MatrixBase<Derived>::ColXpr
724 MatrixBase<Derived>::col(int i) const
725 {
726   return ColXpr(derived(), i);
727 }
728
729 /** \returns an expression of the \a i-th row of *this. Note that the numbering starts at 0.
730   *
731   * \addexample BlockRow \label How to reference a single row of a matrix
732   *
733   * Example: \include MatrixBase_row.cpp
734   * Output: \verbinclude MatrixBase_row.out
735   *
736   * \sa col(), class Block */
737 template<typename Derived>
738 inline typename MatrixBase<Derived>::RowXpr
739 MatrixBase<Derived>::row(int i)
740 {
741   return RowXpr(derived(), i);
742 }
743
744 /** This is the const version of row(). */
745 template<typename Derived>
746 inline const typename MatrixBase<Derived>::RowXpr
747 MatrixBase<Derived>::row(int i) const
748 {
749   return RowXpr(derived(), i);
750 }
751
752 #endif // EIGEN_BLOCK_H