BlockMethods.h

00001 // This file is part of Eigen, a lightweight C++ template library
00002 // for linear algebra.
00003 //
00004 // Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
00005 // Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
00006 //
00007 // This Source Code Form is subject to the terms of the Mozilla
00008 // Public License v. 2.0. If a copy of the MPL was not distributed
00009 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
00010 
00011 
00012 #ifndef EIGEN_PARSED_BY_DOXYGEN
00013 
00014 /** \internal expression type of a column */
00015 typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr;
00016 typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ConstColXpr;
00017 /** \internal expression type of a row */
00018 typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr;
00019 typedef const Block<const Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowXpr;
00020 /** \internal expression type of a block of whole columns */
00021 typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr;
00022 typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ConstColsBlockXpr;
00023 /** \internal expression type of a block of whole rows */
00024 typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr;
00025 typedef const Block<const Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowsBlockXpr;
00026 /** \internal expression type of a block of whole columns */
00027 template<int N> struct NColsBlockXpr { typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; };
00028 template<int N> struct ConstNColsBlockXpr { typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; };
00029 /** \internal expression type of a block of whole rows */
00030 template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; };
00031 template<int N> struct ConstNRowsBlockXpr { typedef const Block<const Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; };
00032 
00033 typedef VectorBlock<Derived> SegmentReturnType;
00034 typedef const VectorBlock<const Derived> ConstSegmentReturnType;
00035 template<int Size> struct FixedSegmentReturnType { typedef VectorBlock<Derived, Size> Type; };
00036 template<int Size> struct ConstFixedSegmentReturnType { typedef const VectorBlock<const Derived, Size> Type; };
00037 
00038 #endif // not EIGEN_PARSED_BY_DOXYGEN
00039 
00040 /** \returns a dynamic-size expression of a block in *this.
00041   *
00042   * \param startRow the first row in the block
00043   * \param startCol the first column in the block
00044   * \param blockRows the number of rows in the block
00045   * \param blockCols the number of columns in the block
00046   *
00047   * Example: \include MatrixBase_block_int_int_int_int.cpp
00048   * Output: \verbinclude MatrixBase_block_int_int_int_int.out
00049   *
00050   * \note Even though the returned expression has dynamic size, in the case
00051   * when it is applied to a fixed-size matrix, it inherits a fixed maximal size,
00052   * which means that evaluating it does not cause a dynamic memory allocation.
00053   *
00054   * \sa class Block, block(Index,Index)
00055   */
00056 inline Block<Derived> block(Index startRow, Index startCol, Index blockRows, Index blockCols)
00057 {
00058   return Block<Derived>(derived(), startRow, startCol, blockRows, blockCols);
00059 }
00060 
00061 /** This is the const version of block(Index,Index,Index,Index). */
00062 inline const Block<const Derived> block(Index startRow, Index startCol, Index blockRows, Index blockCols) const
00063 {
00064   return Block<const Derived>(derived(), startRow, startCol, blockRows, blockCols);
00065 }
00066 
00067 
00068 
00069 
00070 /** \returns a dynamic-size expression of a top-right corner of *this.
00071   *
00072   * \param cRows the number of rows in the corner
00073   * \param cCols the number of columns in the corner
00074   *
00075   * Example: \include MatrixBase_topRightCorner_int_int.cpp
00076   * Output: \verbinclude MatrixBase_topRightCorner_int_int.out
00077   *
00078   * \sa class Block, block(Index,Index,Index,Index)
00079   */
00080 inline Block<Derived> topRightCorner(Index cRows, Index cCols)
00081 {
00082   return Block<Derived>(derived(), 0, cols() - cCols, cRows, cCols);
00083 }
00084 
00085 /** This is the const version of topRightCorner(Index, Index).*/
00086 inline const Block<const Derived> topRightCorner(Index cRows, Index cCols) const
00087 {
00088   return Block<const Derived>(derived(), 0, cols() - cCols, cRows, cCols);
00089 }
00090 
00091 /** \returns an expression of a fixed-size top-right corner of *this.
00092   *
00093   * \tparam CRows the number of rows in the corner
00094   * \tparam CCols the number of columns in the corner
00095   *
00096   * Example: \include MatrixBase_template_int_int_topRightCorner.cpp
00097   * Output: \verbinclude MatrixBase_template_int_int_topRightCorner.out
00098   *
00099   * \sa class Block, block<int,int>(Index,Index)
00100   */
00101 template<int CRows, int CCols>
00102 inline Block<Derived, CRows, CCols> topRightCorner()
00103 {
00104   return Block<Derived, CRows, CCols>(derived(), 0, cols() - CCols);
00105 }
00106 
00107 /** This is the const version of topRightCorner<int, int>().*/
00108 template<int CRows, int CCols>
00109 inline const Block<const Derived, CRows, CCols> topRightCorner() const
00110 {
00111   return Block<const Derived, CRows, CCols>(derived(), 0, cols() - CCols);
00112 }
00113 
00114 /** \returns an expression of a top-right corner of *this.
00115   *
00116   * \tparam CRows number of rows in corner as specified at compile-time
00117   * \tparam CCols number of columns in corner as specified at compile-time
00118   * \param  cRows number of rows in corner as specified at run-time
00119   * \param  cCols number of columns in corner as specified at run-time
00120   *
00121   * This function is mainly useful for corners where the number of rows is specified at compile-time
00122   * and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
00123   * information should not contradict. In other words, \a cRows should equal \a CRows unless
00124   * \a CRows is \a Dynamic, and the same for the number of columns.
00125   *
00126   * Example: \include MatrixBase_template_int_int_topRightCorner_int_int.cpp
00127   * Output: \verbinclude MatrixBase_template_int_int_topRightCorner_int_int.out
00128   *
00129   * \sa class Block
00130   */
00131 template<int CRows, int CCols>
00132 inline Block<Derived, CRows, CCols> topRightCorner(Index cRows, Index cCols)
00133 {
00134   return Block<Derived, CRows, CCols>(derived(), 0, cols() - cCols, cRows, cCols);
00135 }
00136 
00137 /** This is the const version of topRightCorner<int, int>(Index, Index).*/
00138 template<int CRows, int CCols>
00139 inline const Block<const Derived, CRows, CCols> topRightCorner(Index cRows, Index cCols) const
00140 {
00141   return Block<const Derived, CRows, CCols>(derived(), 0, cols() - cCols, cRows, cCols);
00142 }
00143 
00144 
00145 
00146 /** \returns a dynamic-size expression of a top-left corner of *this.
00147   *
00148   * \param cRows the number of rows in the corner
00149   * \param cCols the number of columns in the corner
00150   *
00151   * Example: \include MatrixBase_topLeftCorner_int_int.cpp
00152   * Output: \verbinclude MatrixBase_topLeftCorner_int_int.out
00153   *
00154   * \sa class Block, block(Index,Index,Index,Index)
00155   */
00156 inline Block<Derived> topLeftCorner(Index cRows, Index cCols)
00157 {
00158   return Block<Derived>(derived(), 0, 0, cRows, cCols);
00159 }
00160 
00161 /** This is the const version of topLeftCorner(Index, Index).*/
00162 inline const Block<const Derived> topLeftCorner(Index cRows, Index cCols) const
00163 {
00164   return Block<const Derived>(derived(), 0, 0, cRows, cCols);
00165 }
00166 
00167 /** \returns an expression of a fixed-size top-left corner of *this.
00168   *
00169   * The template parameters CRows and CCols are the number of rows and columns in the corner.
00170   *
00171   * Example: \include MatrixBase_template_int_int_topLeftCorner.cpp
00172   * Output: \verbinclude MatrixBase_template_int_int_topLeftCorner.out
00173   *
00174   * \sa class Block, block(Index,Index,Index,Index)
00175   */
00176 template<int CRows, int CCols>
00177 inline Block<Derived, CRows, CCols> topLeftCorner()
00178 {
00179   return Block<Derived, CRows, CCols>(derived(), 0, 0);
00180 }
00181 
00182 /** This is the const version of topLeftCorner<int, int>().*/
00183 template<int CRows, int CCols>
00184 inline const Block<const Derived, CRows, CCols> topLeftCorner() const
00185 {
00186   return Block<const Derived, CRows, CCols>(derived(), 0, 0);
00187 }
00188 
00189 /** \returns an expression of a top-left corner of *this.
00190   *
00191   * \tparam CRows number of rows in corner as specified at compile-time
00192   * \tparam CCols number of columns in corner as specified at compile-time
00193   * \param  cRows number of rows in corner as specified at run-time
00194   * \param  cCols number of columns in corner as specified at run-time
00195   *
00196   * This function is mainly useful for corners where the number of rows is specified at compile-time
00197   * and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
00198   * information should not contradict. In other words, \a cRows should equal \a CRows unless
00199   * \a CRows is \a Dynamic, and the same for the number of columns.
00200   *
00201   * Example: \include MatrixBase_template_int_int_topLeftCorner_int_int.cpp
00202   * Output: \verbinclude MatrixBase_template_int_int_topLeftCorner_int_int.out
00203   *
00204   * \sa class Block
00205   */
00206 template<int CRows, int CCols>
00207 inline Block<Derived, CRows, CCols> topLeftCorner(Index cRows, Index cCols)
00208 {
00209   return Block<Derived, CRows, CCols>(derived(), 0, 0, cRows, cCols);
00210 }
00211 
00212 /** This is the const version of topLeftCorner<int, int>(Index, Index).*/
00213 template<int CRows, int CCols>
00214 inline const Block<const Derived, CRows, CCols> topLeftCorner(Index cRows, Index cCols) const
00215 {
00216   return Block<const Derived, CRows, CCols>(derived(), 0, 0, cRows, cCols);
00217 }
00218 
00219 
00220 
00221 /** \returns a dynamic-size expression of a bottom-right corner of *this.
00222   *
00223   * \param cRows the number of rows in the corner
00224   * \param cCols the number of columns in the corner
00225   *
00226   * Example: \include MatrixBase_bottomRightCorner_int_int.cpp
00227   * Output: \verbinclude MatrixBase_bottomRightCorner_int_int.out
00228   *
00229   * \sa class Block, block(Index,Index,Index,Index)
00230   */
00231 inline Block<Derived> bottomRightCorner(Index cRows, Index cCols)
00232 {
00233   return Block<Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
00234 }
00235 
00236 /** This is the const version of bottomRightCorner(Index, Index).*/
00237 inline const Block<const Derived> bottomRightCorner(Index cRows, Index cCols) const
00238 {
00239   return Block<const Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
00240 }
00241 
00242 /** \returns an expression of a fixed-size bottom-right corner of *this.
00243   *
00244   * The template parameters CRows and CCols are the number of rows and columns in the corner.
00245   *
00246   * Example: \include MatrixBase_template_int_int_bottomRightCorner.cpp
00247   * Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner.out
00248   *
00249   * \sa class Block, block(Index,Index,Index,Index)
00250   */
00251 template<int CRows, int CCols>
00252 inline Block<Derived, CRows, CCols> bottomRightCorner()
00253 {
00254   return Block<Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols);
00255 }
00256 
00257 /** This is the const version of bottomRightCorner<int, int>().*/
00258 template<int CRows, int CCols>
00259 inline const Block<const Derived, CRows, CCols> bottomRightCorner() const
00260 {
00261   return Block<const Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols);
00262 }
00263 
00264 /** \returns an expression of a bottom-right corner of *this.
00265   *
00266   * \tparam CRows number of rows in corner as specified at compile-time
00267   * \tparam CCols number of columns in corner as specified at compile-time
00268   * \param  cRows number of rows in corner as specified at run-time
00269   * \param  cCols number of columns in corner as specified at run-time
00270   *
00271   * This function is mainly useful for corners where the number of rows is specified at compile-time
00272   * and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
00273   * information should not contradict. In other words, \a cRows should equal \a CRows unless
00274   * \a CRows is \a Dynamic, and the same for the number of columns.
00275   *
00276   * Example: \include MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
00277   * Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner_int_int.out
00278   *
00279   * \sa class Block
00280   */
00281 template<int CRows, int CCols>
00282 inline Block<Derived, CRows, CCols> bottomRightCorner(Index cRows, Index cCols)
00283 {
00284   return Block<Derived, CRows, CCols>(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
00285 }
00286 
00287 /** This is the const version of bottomRightCorner<int, int>(Index, Index).*/
00288 template<int CRows, int CCols>
00289 inline const Block<const Derived, CRows, CCols> bottomRightCorner(Index cRows, Index cCols) const
00290 {
00291   return Block<const Derived, CRows, CCols>(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
00292 }
00293 
00294 
00295 
00296 /** \returns a dynamic-size expression of a bottom-left corner of *this.
00297   *
00298   * \param cRows the number of rows in the corner
00299   * \param cCols the number of columns in the corner
00300   *
00301   * Example: \include MatrixBase_bottomLeftCorner_int_int.cpp
00302   * Output: \verbinclude MatrixBase_bottomLeftCorner_int_int.out
00303   *
00304   * \sa class Block, block(Index,Index,Index,Index)
00305   */
00306 inline Block<Derived> bottomLeftCorner(Index cRows, Index cCols)
00307 {
00308   return Block<Derived>(derived(), rows() - cRows, 0, cRows, cCols);
00309 }
00310 
00311 /** This is the const version of bottomLeftCorner(Index, Index).*/
00312 inline const Block<const Derived> bottomLeftCorner(Index cRows, Index cCols) const
00313 {
00314   return Block<const Derived>(derived(), rows() - cRows, 0, cRows, cCols);
00315 }
00316 
00317 /** \returns an expression of a fixed-size bottom-left corner of *this.
00318   *
00319   * The template parameters CRows and CCols are the number of rows and columns in the corner.
00320   *
00321   * Example: \include MatrixBase_template_int_int_bottomLeftCorner.cpp
00322   * Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner.out
00323   *
00324   * \sa class Block, block(Index,Index,Index,Index)
00325   */
00326 template<int CRows, int CCols>
00327 inline Block<Derived, CRows, CCols> bottomLeftCorner()
00328 {
00329   return Block<Derived, CRows, CCols>(derived(), rows() - CRows, 0);
00330 }
00331 
00332 /** This is the const version of bottomLeftCorner<int, int>().*/
00333 template<int CRows, int CCols>
00334 inline const Block<const Derived, CRows, CCols> bottomLeftCorner() const
00335 {
00336   return Block<const Derived, CRows, CCols>(derived(), rows() - CRows, 0);
00337 }
00338 
00339 /** \returns an expression of a bottom-left corner of *this.
00340   *
00341   * \tparam CRows number of rows in corner as specified at compile-time
00342   * \tparam CCols number of columns in corner as specified at compile-time
00343   * \param  cRows number of rows in corner as specified at run-time
00344   * \param  cCols number of columns in corner as specified at run-time
00345   *
00346   * This function is mainly useful for corners where the number of rows is specified at compile-time
00347   * and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
00348   * information should not contradict. In other words, \a cRows should equal \a CRows unless
00349   * \a CRows is \a Dynamic, and the same for the number of columns.
00350   *
00351   * Example: \include MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
00352   * Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner_int_int.out
00353   *
00354   * \sa class Block
00355   */
00356 template<int CRows, int CCols>
00357 inline Block<Derived, CRows, CCols> bottomLeftCorner(Index cRows, Index cCols)
00358 {
00359   return Block<Derived, CRows, CCols>(derived(), rows() - cRows, 0, cRows, cCols);
00360 }
00361 
00362 /** This is the const version of bottomLeftCorner<int, int>(Index, Index).*/
00363 template<int CRows, int CCols>
00364 inline const Block<const Derived, CRows, CCols> bottomLeftCorner(Index cRows, Index cCols) const
00365 {
00366   return Block<const Derived, CRows, CCols>(derived(), rows() - cRows, 0, cRows, cCols);
00367 }
00368 
00369 
00370 
00371 /** \returns a block consisting of the top rows of *this.
00372   *
00373   * \param n the number of rows in the block
00374   *
00375   * Example: \include MatrixBase_topRows_int.cpp
00376   * Output: \verbinclude MatrixBase_topRows_int.out
00377   *
00378   * \sa class Block, block(Index,Index,Index,Index)
00379   */
00380 inline RowsBlockXpr topRows(Index n)
00381 {
00382   return RowsBlockXpr(derived(), 0, 0, n, cols());
00383 }
00384 
00385 /** This is the const version of topRows(Index).*/
00386 inline ConstRowsBlockXpr topRows(Index n) const
00387 {
00388   return ConstRowsBlockXpr(derived(), 0, 0, n, cols());
00389 }
00390 
00391 /** \returns a block consisting of the top rows of *this.
00392   *
00393   * \tparam N the number of rows in the block as specified at compile-time
00394   * \param n the number of rows in the block as specified at run-time
00395   *
00396   * The compile-time and run-time information should not contradict. In other words,
00397   * \a n should equal \a N unless \a N is \a Dynamic.
00398   *
00399   * Example: \include MatrixBase_template_int_topRows.cpp
00400   * Output: \verbinclude MatrixBase_template_int_topRows.out
00401   *
00402   * \sa class Block, block(Index,Index,Index,Index)
00403   */
00404 template<int N>
00405 inline typename NRowsBlockXpr<N>::Type topRows(Index n = N)
00406 {
00407   return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
00408 }
00409 
00410 /** This is the const version of topRows<int>().*/
00411 template<int N>
00412 inline typename ConstNRowsBlockXpr<N>::Type topRows(Index n = N) const
00413 {
00414   return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
00415 }
00416 
00417 
00418 
00419 /** \returns a block consisting of the bottom rows of *this.
00420   *
00421   * \param n the number of rows in the block
00422   *
00423   * Example: \include MatrixBase_bottomRows_int.cpp
00424   * Output: \verbinclude MatrixBase_bottomRows_int.out
00425   *
00426   * \sa class Block, block(Index,Index,Index,Index)
00427   */
00428 inline RowsBlockXpr bottomRows(Index n)
00429 {
00430   return RowsBlockXpr(derived(), rows() - n, 0, n, cols());
00431 }
00432 
00433 /** This is the const version of bottomRows(Index).*/
00434 inline ConstRowsBlockXpr bottomRows(Index n) const
00435 {
00436   return ConstRowsBlockXpr(derived(), rows() - n, 0, n, cols());
00437 }
00438 
00439 /** \returns a block consisting of the bottom rows of *this.
00440   *
00441   * \tparam N the number of rows in the block as specified at compile-time
00442   * \param n the number of rows in the block as specified at run-time
00443   *
00444   * The compile-time and run-time information should not contradict. In other words,
00445   * \a n should equal \a N unless \a N is \a Dynamic.
00446   *
00447   * Example: \include MatrixBase_template_int_bottomRows.cpp
00448   * Output: \verbinclude MatrixBase_template_int_bottomRows.out
00449   *
00450   * \sa class Block, block(Index,Index,Index,Index)
00451   */
00452 template<int N>
00453 inline typename NRowsBlockXpr<N>::Type bottomRows(Index n = N)
00454 {
00455   return typename NRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
00456 }
00457 
00458 /** This is the const version of bottomRows<int>().*/
00459 template<int N>
00460 inline typename ConstNRowsBlockXpr<N>::Type bottomRows(Index n = N) const
00461 {
00462   return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
00463 }
00464 
00465 
00466 
00467 /** \returns a block consisting of a range of rows of *this.
00468   *
00469   * \param startRow the index of the first row in the block
00470   * \param n the number of rows in the block
00471   *
00472   * Example: \include DenseBase_middleRows_int.cpp
00473   * Output: \verbinclude DenseBase_middleRows_int.out
00474   *
00475   * \sa class Block, block(Index,Index,Index,Index)
00476   */
00477 inline RowsBlockXpr middleRows(Index startRow, Index n)
00478 {
00479   return RowsBlockXpr(derived(), startRow, 0, n, cols());
00480 }
00481 
00482 /** This is the const version of middleRows(Index,Index).*/
00483 inline ConstRowsBlockXpr middleRows(Index startRow, Index n) const
00484 {
00485   return ConstRowsBlockXpr(derived(), startRow, 0, n, cols());
00486 }
00487 
00488 /** \returns a block consisting of a range of rows of *this.
00489   *
00490   * \tparam N the number of rows in the block as specified at compile-time
00491   * \param startRow the index of the first row in the block
00492   * \param n the number of rows in the block as specified at run-time
00493   *
00494   * The compile-time and run-time information should not contradict. In other words,
00495   * \a n should equal \a N unless \a N is \a Dynamic.
00496   *
00497   * Example: \include DenseBase_template_int_middleRows.cpp
00498   * Output: \verbinclude DenseBase_template_int_middleRows.out
00499   *
00500   * \sa class Block, block(Index,Index,Index,Index)
00501   */
00502 template<int N>
00503 inline typename NRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N)
00504 {
00505   return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
00506 }
00507 
00508 /** This is the const version of middleRows<int>().*/
00509 template<int N>
00510 inline typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N) const
00511 {
00512   return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
00513 }
00514 
00515 
00516 
00517 /** \returns a block consisting of the left columns of *this.
00518   *
00519   * \param n the number of columns in the block
00520   *
00521   * Example: \include MatrixBase_leftCols_int.cpp
00522   * Output: \verbinclude MatrixBase_leftCols_int.out
00523   *
00524   * \sa class Block, block(Index,Index,Index,Index)
00525   */
00526 inline ColsBlockXpr leftCols(Index n)
00527 {
00528   return ColsBlockXpr(derived(), 0, 0, rows(), n);
00529 }
00530 
00531 /** This is the const version of leftCols(Index).*/
00532 inline ConstColsBlockXpr leftCols(Index n) const
00533 {
00534   return ConstColsBlockXpr(derived(), 0, 0, rows(), n);
00535 }
00536 
00537 /** \returns a block consisting of the left columns of *this.
00538   *
00539   * \tparam N the number of columns in the block as specified at compile-time
00540   * \param n the number of columns in the block as specified at run-time
00541   *
00542   * The compile-time and run-time information should not contradict. In other words,
00543   * \a n should equal \a N unless \a N is \a Dynamic.
00544   *
00545   * Example: \include MatrixBase_template_int_leftCols.cpp
00546   * Output: \verbinclude MatrixBase_template_int_leftCols.out
00547   *
00548   * \sa class Block, block(Index,Index,Index,Index)
00549   */
00550 template<int N>
00551 inline typename NColsBlockXpr<N>::Type leftCols(Index n = N)
00552 {
00553   return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
00554 }
00555 
00556 /** This is the const version of leftCols<int>().*/
00557 template<int N>
00558 inline typename ConstNColsBlockXpr<N>::Type leftCols(Index n = N) const
00559 {
00560   return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
00561 }
00562 
00563 
00564 
00565 /** \returns a block consisting of the right columns of *this.
00566   *
00567   * \param n the number of columns in the block
00568   *
00569   * Example: \include MatrixBase_rightCols_int.cpp
00570   * Output: \verbinclude MatrixBase_rightCols_int.out
00571   *
00572   * \sa class Block, block(Index,Index,Index,Index)
00573   */
00574 inline ColsBlockXpr rightCols(Index n)
00575 {
00576   return ColsBlockXpr(derived(), 0, cols() - n, rows(), n);
00577 }
00578 
00579 /** This is the const version of rightCols(Index).*/
00580 inline ConstColsBlockXpr rightCols(Index n) const
00581 {
00582   return ConstColsBlockXpr(derived(), 0, cols() - n, rows(), n);
00583 }
00584 
00585 /** \returns a block consisting of the right columns of *this.
00586   *
00587   * \tparam N the number of columns in the block as specified at compile-time
00588   * \param n the number of columns in the block as specified at run-time
00589   *
00590   * The compile-time and run-time information should not contradict. In other words,
00591   * \a n should equal \a N unless \a N is \a Dynamic.
00592   *
00593   * Example: \include MatrixBase_template_int_rightCols.cpp
00594   * Output: \verbinclude MatrixBase_template_int_rightCols.out
00595   *
00596   * \sa class Block, block(Index,Index,Index,Index)
00597   */
00598 template<int N>
00599 inline typename NColsBlockXpr<N>::Type rightCols(Index n = N)
00600 {
00601   return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
00602 }
00603 
00604 /** This is the const version of rightCols<int>().*/
00605 template<int N>
00606 inline typename ConstNColsBlockXpr<N>::Type rightCols(Index n = N) const
00607 {
00608   return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
00609 }
00610 
00611 
00612 
00613 /** \returns a block consisting of a range of columns of *this.
00614   *
00615   * \param startCol the index of the first column in the block
00616   * \param numCols the number of columns in the block
00617   *
00618   * Example: \include DenseBase_middleCols_int.cpp
00619   * Output: \verbinclude DenseBase_middleCols_int.out
00620   *
00621   * \sa class Block, block(Index,Index,Index,Index)
00622   */
00623 inline ColsBlockXpr middleCols(Index startCol, Index numCols)
00624 {
00625   return ColsBlockXpr(derived(), 0, startCol, rows(), numCols);
00626 }
00627 
00628 /** This is the const version of middleCols(Index,Index).*/
00629 inline ConstColsBlockXpr middleCols(Index startCol, Index numCols) const
00630 {
00631   return ConstColsBlockXpr(derived(), 0, startCol, rows(), numCols);
00632 }
00633 
00634 /** \returns a block consisting of a range of columns of *this.
00635   *
00636   * \tparam N the number of columns in the block as specified at compile-time
00637   * \param startCol the index of the first column in the block
00638   * \param n the number of columns in the block as specified at run-time
00639   *
00640   * The compile-time and run-time information should not contradict. In other words,
00641   * \a n should equal \a N unless \a N is \a Dynamic.
00642   *
00643   * Example: \include DenseBase_template_int_middleCols.cpp
00644   * Output: \verbinclude DenseBase_template_int_middleCols.out
00645   *
00646   * \sa class Block, block(Index,Index,Index,Index)
00647   */
00648 template<int N>
00649 inline typename NColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N)
00650 {
00651   return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
00652 }
00653 
00654 /** This is the const version of middleCols<int>().*/
00655 template<int N>
00656 inline typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N) const
00657 {
00658   return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
00659 }
00660 
00661 
00662 
00663 /** \returns a fixed-size expression of a block in *this.
00664   *
00665   * The template parameters \a BlockRows and \a BlockCols are the number of
00666   * rows and columns in the block.
00667   *
00668   * \param startRow the first row in the block
00669   * \param startCol the first column in the block
00670   *
00671   * Example: \include MatrixBase_block_int_int.cpp
00672   * Output: \verbinclude MatrixBase_block_int_int.out
00673   *
00674   * \note since block is a templated member, the keyword template has to be used
00675   * if the matrix type is also a template parameter: \code m.template block<3,3>(1,1); \endcode
00676   *
00677   * \sa class Block, block(Index,Index,Index,Index)
00678   */
00679 template<int BlockRows, int BlockCols>
00680 inline Block<Derived, BlockRows, BlockCols> block(Index startRow, Index startCol)
00681 {
00682   return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
00683 }
00684 
00685 /** This is the const version of block<>(Index, Index). */
00686 template<int BlockRows, int BlockCols>
00687 inline const Block<const Derived, BlockRows, BlockCols> block(Index startRow, Index startCol) const
00688 {
00689   return Block<const Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
00690 }
00691 
00692 /** \returns an expression of a block in *this.
00693   *
00694   * \tparam BlockRows number of rows in block as specified at compile-time
00695   * \tparam BlockCols number of columns in block as specified at compile-time
00696   * \param  startRow  the first row in the block
00697   * \param  startCol  the first column in the block
00698   * \param  blockRows number of rows in block as specified at run-time
00699   * \param  blockCols number of columns in block as specified at run-time
00700   *
00701   * This function is mainly useful for blocks where the number of rows is specified at compile-time
00702   * and the number of columns is specified at run-time, or vice versa. The compile-time and run-time
00703   * information should not contradict. In other words, \a blockRows should equal \a BlockRows unless
00704   * \a BlockRows is \a Dynamic, and the same for the number of columns.
00705   *
00706   * Example: \include MatrixBase_template_int_int_block_int_int_int_int.cpp
00707   * Output: \verbinclude MatrixBase_template_int_int_block_int_int_int_int.cpp
00708   *
00709   * \sa class Block, block(Index,Index,Index,Index)
00710   */
00711 template<int BlockRows, int BlockCols>
00712 inline Block<Derived, BlockRows, BlockCols> block(Index startRow, Index startCol, 
00713                                                   Index blockRows, Index blockCols)
00714 {
00715   return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol, blockRows, blockCols);
00716 }
00717 
00718 /** This is the const version of block<>(Index, Index, Index, Index). */
00719 template<int BlockRows, int BlockCols>
00720 inline const Block<const Derived, BlockRows, BlockCols> block(Index startRow, Index startCol,
00721                                                               Index blockRows, Index blockCols) const
00722 {
00723   return Block<const Derived, BlockRows, BlockCols>(derived(), startRow, startCol, blockRows, blockCols);
00724 }
00725 
00726 /** \returns an expression of the \a i-th column of *this. Note that the numbering starts at 0.
00727   *
00728   * Example: \include MatrixBase_col.cpp
00729   * Output: \verbinclude MatrixBase_col.out
00730   *
00731   * \sa row(), class Block */
00732 inline ColXpr col(Index i)
00733 {
00734   return ColXpr(derived(), i);
00735 }
00736 
00737 /** This is the const version of col(). */
00738 inline ConstColXpr col(Index i) const
00739 {
00740   return ConstColXpr(derived(), i);
00741 }
00742 
00743 /** \returns an expression of the \a i-th row of *this. Note that the numbering starts at 0.
00744   *
00745   * Example: \include MatrixBase_row.cpp
00746   * Output: \verbinclude MatrixBase_row.out
00747   *
00748   * \sa col(), class Block */
00749 inline RowXpr row(Index i)
00750 {
00751   return RowXpr(derived(), i);
00752 }
00753 
00754 /** This is the const version of row(). */
00755 inline ConstRowXpr row(Index i) const
00756 {
00757   return ConstRowXpr(derived(), i);
00758 }
00759 
00760 /** \returns a dynamic-size expression of a segment (i.e. a vector block) in *this.
00761   *
00762   * \only_for_vectors
00763   *
00764   * \param start the first coefficient in the segment
00765   * \param n the number of coefficients in the segment
00766   *
00767   * Example: \include MatrixBase_segment_int_int.cpp
00768   * Output: \verbinclude MatrixBase_segment_int_int.out
00769   *
00770   * \note Even though the returned expression has dynamic size, in the case
00771   * when it is applied to a fixed-size vector, it inherits a fixed maximal size,
00772   * which means that evaluating it does not cause a dynamic memory allocation.
00773   *
00774   * \sa class Block, segment(Index)
00775   */
00776 inline SegmentReturnType segment(Index start, Index n)
00777 {
00778   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
00779   return SegmentReturnType(derived(), start, n);
00780 }
00781 
00782 
00783 /** This is the const version of segment(Index,Index).*/
00784 inline ConstSegmentReturnType segment(Index start, Index n) const
00785 {
00786   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
00787   return ConstSegmentReturnType(derived(), start, n);
00788 }
00789 
00790 /** \returns a dynamic-size expression of the first coefficients of *this.
00791   *
00792   * \only_for_vectors
00793   *
00794   * \param n the number of coefficients in the segment
00795   *
00796   * Example: \include MatrixBase_start_int.cpp
00797   * Output: \verbinclude MatrixBase_start_int.out
00798   *
00799   * \note Even though the returned expression has dynamic size, in the case
00800   * when it is applied to a fixed-size vector, it inherits a fixed maximal size,
00801   * which means that evaluating it does not cause a dynamic memory allocation.
00802   *
00803   * \sa class Block, block(Index,Index)
00804   */
00805 inline SegmentReturnType head(Index n)
00806 {
00807   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
00808   return SegmentReturnType(derived(), 0, n);
00809 }
00810 
00811 /** This is the const version of head(Index).*/
00812 inline ConstSegmentReturnType head(Index n) const
00813 {
00814   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
00815   return ConstSegmentReturnType(derived(), 0, n);
00816 }
00817 
00818 /** \returns a dynamic-size expression of the last coefficients of *this.
00819   *
00820   * \only_for_vectors
00821   *
00822   * \param n the number of coefficients in the segment
00823   *
00824   * Example: \include MatrixBase_end_int.cpp
00825   * Output: \verbinclude MatrixBase_end_int.out
00826   *
00827   * \note Even though the returned expression has dynamic size, in the case
00828   * when it is applied to a fixed-size vector, it inherits a fixed maximal size,
00829   * which means that evaluating it does not cause a dynamic memory allocation.
00830   *
00831   * \sa class Block, block(Index,Index)
00832   */
00833 inline SegmentReturnType tail(Index n)
00834 {
00835   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
00836   return SegmentReturnType(derived(), this->size() - n, n);
00837 }
00838 
00839 /** This is the const version of tail(Index).*/
00840 inline ConstSegmentReturnType tail(Index n) const
00841 {
00842   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
00843   return ConstSegmentReturnType(derived(), this->size() - n, n);
00844 }
00845 
00846 /** \returns a fixed-size expression of a segment (i.e. a vector block) in \c *this
00847   *
00848   * \only_for_vectors
00849   *
00850   * \tparam N the number of coefficients in the segment as specified at compile-time
00851   * \param start the index of the first element in the segment
00852   * \param n the number of coefficients in the segment as specified at compile-time
00853   *
00854   * The compile-time and run-time information should not contradict. In other words,
00855   * \a n should equal \a N unless \a N is \a Dynamic.
00856   *
00857   * Example: \include MatrixBase_template_int_segment.cpp
00858   * Output: \verbinclude MatrixBase_template_int_segment.out
00859   *
00860   * \sa class Block
00861   */
00862 template<int N>
00863 inline typename FixedSegmentReturnType<N>::Type segment(Index start, Index n = N)
00864 {
00865   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
00866   return typename FixedSegmentReturnType<N>::Type(derived(), start, n);
00867 }
00868 
00869 /** This is the const version of segment<int>(Index).*/
00870 template<int N>
00871 inline typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index n = N) const
00872 {
00873   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
00874   return typename ConstFixedSegmentReturnType<N>::Type(derived(), start, n);
00875 }
00876 
00877 /** \returns a fixed-size expression of the first coefficients of *this.
00878   *
00879   * \only_for_vectors
00880   *
00881   * \tparam N the number of coefficients in the segment as specified at compile-time
00882   * \param  n the number of coefficients in the segment as specified at run-time
00883   *
00884   * The compile-time and run-time information should not contradict. In other words,
00885   * \a n should equal \a N unless \a N is \a Dynamic.
00886   *
00887   * Example: \include MatrixBase_template_int_start.cpp
00888   * Output: \verbinclude MatrixBase_template_int_start.out
00889   *
00890   * \sa class Block
00891   */
00892 template<int N>
00893 inline typename FixedSegmentReturnType<N>::Type head(Index n = N)
00894 {
00895   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
00896   return typename FixedSegmentReturnType<N>::Type(derived(), 0, n);
00897 }
00898 
00899 /** This is the const version of head<int>().*/
00900 template<int N>
00901 inline typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const
00902 {
00903   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
00904   return typename ConstFixedSegmentReturnType<N>::Type(derived(), 0, n);
00905 }
00906 
00907 /** \returns a fixed-size expression of the last coefficients of *this.
00908   *
00909   * \only_for_vectors
00910   *
00911   * \tparam N the number of coefficients in the segment as specified at compile-time
00912   * \param  n the number of coefficients in the segment as specified at run-time
00913   *
00914   * The compile-time and run-time information should not contradict. In other words,
00915   * \a n should equal \a N unless \a N is \a Dynamic.
00916   *
00917   * Example: \include MatrixBase_template_int_end.cpp
00918   * Output: \verbinclude MatrixBase_template_int_end.out
00919   *
00920   * \sa class Block
00921   */
00922 template<int N>
00923 inline typename FixedSegmentReturnType<N>::Type tail(Index n = N)
00924 {
00925   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
00926   return typename FixedSegmentReturnType<N>::Type(derived(), size() - n);
00927 }
00928 
00929 /** This is the const version of tail<int>.*/
00930 template<int N>
00931 inline typename ConstFixedSegmentReturnType<N>::Type tail(Index n = N) const
00932 {
00933   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
00934   return typename ConstFixedSegmentReturnType<N>::Type(derived(), size() - n);
00935 }