diff options
| -rw-r--r-- | Eigen/src/Core/Block.h | 649 | ||||
| -rw-r--r-- | Eigen/src/Core/DenseBase.h | 81 | ||||
| -rw-r--r-- | Eigen/src/Core/MatrixBase.h | 2 | ||||
| -rw-r--r-- | Eigen/src/Core/Product.h | 8 | ||||
| -rw-r--r-- | Eigen/src/Core/util/ForwardDeclarations.h | 3 | ||||
| -rw-r--r-- | Eigen/src/plugins/BlockMethods.h | 589 |
6 files changed, 606 insertions, 726 deletions
diff --git a/Eigen/src/Core/Block.h b/Eigen/src/Core/Block.h index 2a28ea7cd..a770b9721 100644 --- a/Eigen/src/Core/Block.h +++ b/Eigen/src/Core/Block.h @@ -323,654 +323,5 @@ class Block<XprType,BlockRows,BlockCols, InnerPanel,true> int m_outerStride; }; -/** \returns a dynamic-size expression of a block in *this. - * - * \param startRow the first row in the block - * \param startCol the first column in the block - * \param blockRows the number of rows in the block - * \param blockCols the number of columns in the block - * - * Example: \include MatrixBase_block_int_int_int_int.cpp - * Output: \verbinclude MatrixBase_block_int_int_int_int.out - * - * \note Even though the returned expression has dynamic size, in the case - * when it is applied to a fixed-size matrix, it inherits a fixed maximal size, - * which means that evaluating it does not cause a dynamic memory allocation. - * - * \sa class Block, block(Index,Index) - */ -template<typename Derived> -inline Block<Derived> DenseBase<Derived> - ::block(Index startRow, Index startCol, Index blockRows, Index blockCols) -{ - return Block<Derived>(derived(), startRow, startCol, blockRows, blockCols); -} - -/** This is the const version of block(Index,Index,Index,Index). */ -template<typename Derived> -inline const Block<Derived> DenseBase<Derived> - ::block(Index startRow, Index startCol, Index blockRows, Index blockCols) const -{ - return Block<Derived>(derived(), startRow, startCol, blockRows, blockCols); -} - - - - -/** \returns a dynamic-size expression of a top-right corner of *this. - * - * \param cRows the number of rows in the corner - * \param cCols the number of columns in the corner - * - * Example: \include MatrixBase_topRightCorner_int_int.cpp - * Output: \verbinclude MatrixBase_topRightCorner_int_int.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -inline Block<Derived> DenseBase<Derived> - ::topRightCorner(Index cRows, Index cCols) -{ - return Block<Derived>(derived(), 0, cols() - cCols, cRows, cCols); -} - -/** This is the const version of topRightCorner(Index, Index).*/ -template<typename Derived> -inline const Block<Derived> -DenseBase<Derived>::topRightCorner(Index cRows, Index cCols) const -{ - return Block<Derived>(derived(), 0, cols() - cCols, cRows, cCols); -} - -/** \returns an expression of a fixed-size top-right corner of *this. - * - * The template parameters CRows and CCols are the number of rows and columns in the corner. - * - * Example: \include MatrixBase_template_int_int_topRightCorner.cpp - * Output: \verbinclude MatrixBase_template_int_int_topRightCorner.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -template<int CRows, int CCols> -inline Block<Derived, CRows, CCols> -DenseBase<Derived>::topRightCorner() -{ - return Block<Derived, CRows, CCols>(derived(), 0, cols() - CCols); -} - -/** This is the const version of topRightCorner<int, int>().*/ -template<typename Derived> -template<int CRows, int CCols> -inline const Block<Derived, CRows, CCols> -DenseBase<Derived>::topRightCorner() const -{ - return Block<Derived, CRows, CCols>(derived(), 0, cols() - CCols); -} - - - - -/** \returns a dynamic-size expression of a top-left corner of *this. - * - * \param cRows the number of rows in the corner - * \param cCols the number of columns in the corner - * - * Example: \include MatrixBase_topLeftCorner_int_int.cpp - * Output: \verbinclude MatrixBase_topLeftCorner_int_int.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -inline Block<Derived> DenseBase<Derived> - ::topLeftCorner(Index cRows, Index cCols) -{ - return Block<Derived>(derived(), 0, 0, cRows, cCols); -} - -/** This is the const version of topLeftCorner(Index, Index).*/ -template<typename Derived> -inline const Block<Derived> -DenseBase<Derived>::topLeftCorner(Index cRows, Index cCols) const -{ - return Block<Derived>(derived(), 0, 0, cRows, cCols); -} - -/** \returns an expression of a fixed-size top-left corner of *this. - * - * The template parameters CRows and CCols are the number of rows and columns in the corner. - * - * Example: \include MatrixBase_template_int_int_topLeftCorner.cpp - * Output: \verbinclude MatrixBase_template_int_int_topLeftCorner.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -template<int CRows, int CCols> -inline Block<Derived, CRows, CCols> -DenseBase<Derived>::topLeftCorner() -{ - return Block<Derived, CRows, CCols>(derived(), 0, 0); -} - -/** This is the const version of topLeftCorner<int, int>().*/ -template<typename Derived> -template<int CRows, int CCols> -inline const Block<Derived, CRows, CCols> -DenseBase<Derived>::topLeftCorner() const -{ - return Block<Derived, CRows, CCols>(derived(), 0, 0); -} - - - - - - -/** \returns a dynamic-size expression of a bottom-right corner of *this. - * - * \param cRows the number of rows in the corner - * \param cCols the number of columns in the corner - * - * Example: \include MatrixBase_bottomRightCorner_int_int.cpp - * Output: \verbinclude MatrixBase_bottomRightCorner_int_int.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -inline Block<Derived> DenseBase<Derived> - ::bottomRightCorner(Index cRows, Index cCols) -{ - return Block<Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols); -} - -/** This is the const version of bottomRightCorner(Index, Index).*/ -template<typename Derived> -inline const Block<Derived> -DenseBase<Derived>::bottomRightCorner(Index cRows, Index cCols) const -{ - return Block<Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols); -} - -/** \returns an expression of a fixed-size bottom-right corner of *this. - * - * The template parameters CRows and CCols are the number of rows and columns in the corner. - * - * Example: \include MatrixBase_template_int_int_bottomRightCorner.cpp - * Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -template<int CRows, int CCols> -inline Block<Derived, CRows, CCols> -DenseBase<Derived>::bottomRightCorner() -{ - return Block<Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols); -} - -/** This is the const version of bottomRightCorner<int, int>().*/ -template<typename Derived> -template<int CRows, int CCols> -inline const Block<Derived, CRows, CCols> -DenseBase<Derived>::bottomRightCorner() const -{ - return Block<Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols); -} - - - - -/** \returns a dynamic-size expression of a bottom-left corner of *this. - * - * \param cRows the number of rows in the corner - * \param cCols the number of columns in the corner - * - * Example: \include MatrixBase_bottomLeftCorner_int_int.cpp - * Output: \verbinclude MatrixBase_bottomLeftCorner_int_int.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -inline Block<Derived> DenseBase<Derived> - ::bottomLeftCorner(Index cRows, Index cCols) -{ - return Block<Derived>(derived(), rows() - cRows, 0, cRows, cCols); -} - -/** This is the const version of bottomLeftCorner(Index, Index).*/ -template<typename Derived> -inline const Block<Derived> -DenseBase<Derived>::bottomLeftCorner(Index cRows, Index cCols) const -{ - return Block<Derived>(derived(), rows() - cRows, 0, cRows, cCols); -} - -/** \returns an expression of a fixed-size bottom-left corner of *this. - * - * The template parameters CRows and CCols are the number of rows and columns in the corner. - * - * Example: \include MatrixBase_template_int_int_bottomLeftCorner.cpp - * Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -template<int CRows, int CCols> -inline Block<Derived, CRows, CCols> -DenseBase<Derived>::bottomLeftCorner() -{ - return Block<Derived, CRows, CCols>(derived(), rows() - CRows, 0); -} - -/** This is the const version of bottomLeftCorner<int, int>().*/ -template<typename Derived> -template<int CRows, int CCols> -inline const Block<Derived, CRows, CCols> -DenseBase<Derived>::bottomLeftCorner() const -{ - return Block<Derived, CRows, CCols>(derived(), rows() - CRows, 0); -} - - - -/** \returns a block consisting of the top rows of *this. - * - * \param n the number of rows in the block - * - * Example: \include MatrixBase_topRows_int.cpp - * Output: \verbinclude MatrixBase_topRows_int.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -inline typename DenseBase<Derived>::RowsBlockXpr DenseBase<Derived> - ::topRows(Index n) -{ - return RowsBlockXpr(derived(), 0, 0, n, cols()); -} - -/** This is the const version of topRows(Index).*/ -template<typename Derived> -inline const typename DenseBase<Derived>::RowsBlockXpr -DenseBase<Derived>::topRows(Index n) const -{ - return RowsBlockXpr(derived(), 0, 0, n, cols()); -} - -/** \returns a block consisting of the top rows of *this. - * - * \tparam N the number of rows in the block - * - * Example: \include MatrixBase_template_int_topRows.cpp - * Output: \verbinclude MatrixBase_template_int_topRows.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -template<int N> -inline typename DenseBase<Derived>::template NRowsBlockXpr<N>::Type -DenseBase<Derived>::topRows() -{ - return typename DenseBase<Derived>::template NRowsBlockXpr<N>::Type(derived(), 0, 0, N, cols()); -} - -/** This is the const version of topRows<int>().*/ -template<typename Derived> -template<int N> -inline const typename DenseBase<Derived>::template NRowsBlockXpr<N>::Type -DenseBase<Derived>::topRows() const -{ - return typename DenseBase<Derived>::template NRowsBlockXpr<N>::Type(derived(), 0, 0, N, cols()); -} - - - - - -/** \returns a block consisting of the bottom rows of *this. - * - * \param n the number of rows in the block - * - * Example: \include MatrixBase_bottomRows_int.cpp - * Output: \verbinclude MatrixBase_bottomRows_int.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -inline typename DenseBase<Derived>::RowsBlockXpr DenseBase<Derived> - ::bottomRows(Index n) -{ - return RowsBlockXpr(derived(), rows() - n, 0, n, cols()); -} - -/** This is the const version of bottomRows(Index).*/ -template<typename Derived> -inline const typename DenseBase<Derived>::RowsBlockXpr -DenseBase<Derived>::bottomRows(Index n) const -{ - return RowsBlockXpr(derived(), rows() - n, 0, n, cols()); -} - -/** \returns a block consisting of the bottom rows of *this. - * - * \tparam N the number of rows in the block - * - * Example: \include MatrixBase_template_int_bottomRows.cpp - * Output: \verbinclude MatrixBase_template_int_bottomRows.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -template<int N> -inline typename DenseBase<Derived>::template NRowsBlockXpr<N>::Type -DenseBase<Derived>::bottomRows() -{ - return typename NRowsBlockXpr<N>::Type(derived(), rows() - N, 0, N, cols()); -} - -/** This is the const version of bottomRows<int>().*/ -template<typename Derived> -template<int N> -inline const typename DenseBase<Derived>::template NRowsBlockXpr<N>::Type -DenseBase<Derived>::bottomRows() const -{ - return typename NRowsBlockXpr<N>::Type(derived(), rows() - N, 0, N, cols()); -} - - - -/** \returns a block consisting of a range of rows of *this. - * - * \param startRow the index of the first row in the block - * \param numRows the number of rows in the block - * - * Example: \include DenseBase_middleRows_int.cpp - * Output: \verbinclude DenseBase_middleRows_int.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -inline typename DenseBase<Derived>::RowsBlockXpr DenseBase<Derived> - ::middleRows(Index startRow, Index numRows) -{ - return RowsBlockXpr(derived(), startRow, 0, numRows, cols()); -} - -/** This is the const version of middleRows(Index,Index).*/ -template<typename Derived> -inline const typename DenseBase<Derived>::RowsBlockXpr -DenseBase<Derived>::middleRows(Index startRow, Index numRows) const -{ - return RowsBlockXpr(derived(), startRow, 0, numRows, cols()); -} - -/** \returns a block consisting of a range of rows of *this. - * - * \tparam N the number of rows in the block - * \param startRow the index of the first row in the block - * - * Example: \include DenseBase_template_int_middleRows.cpp - * Output: \verbinclude DenseBase_template_int_middleRows.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -template<int N> -inline typename DenseBase<Derived>::template NRowsBlockXpr<N>::Type -DenseBase<Derived>::middleRows(Index startRow) -{ - return typename DenseBase<Derived>::template NRowsBlockXpr<N>::Type(derived(), startRow, 0, N, cols()); -} - -/** This is the const version of middleRows<int>().*/ -template<typename Derived> -template<int N> -inline const typename DenseBase<Derived>::template NRowsBlockXpr<N>::Type -DenseBase<Derived>::middleRows(Index startRow) const -{ - return typename DenseBase<Derived>::template NRowsBlockXpr<N>::Type(derived(), startRow, 0, N, cols()); -} - - - - -/** \returns a block consisting of the left columns of *this. - * - * \param n the number of columns in the block - * - * Example: \include MatrixBase_leftCols_int.cpp - * Output: \verbinclude MatrixBase_leftCols_int.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -inline typename DenseBase<Derived>::ColsBlockXpr DenseBase<Derived> - ::leftCols(Index n) -{ - return ColsBlockXpr(derived(), 0, 0, rows(), n); -} - -/** This is the const version of leftCols(Index).*/ -template<typename Derived> -inline const typename DenseBase<Derived>::ColsBlockXpr -DenseBase<Derived>::leftCols(Index n) const -{ - return ColsBlockXpr(derived(), 0, 0, rows(), n); -} - -/** \returns a block consisting of the left columns of *this. - * - * \tparam N the number of columns in the block - * - * Example: \include MatrixBase_template_int_leftCols.cpp - * Output: \verbinclude MatrixBase_template_int_leftCols.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -template<int N> -inline typename DenseBase<Derived>::template NColsBlockXpr<N>::Type -DenseBase<Derived>::leftCols() -{ - return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), N); -} - -/** This is the const version of leftCols<int>().*/ -template<typename Derived> -template<int N> -inline const typename DenseBase<Derived>::template NColsBlockXpr<N>::Type -DenseBase<Derived>::leftCols() const -{ - return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), N); -} - - - - - -/** \returns a block consisting of the right columns of *this. - * - * \param n the number of columns in the block - * - * Example: \include MatrixBase_rightCols_int.cpp - * Output: \verbinclude MatrixBase_rightCols_int.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -inline typename DenseBase<Derived>::ColsBlockXpr DenseBase<Derived> - ::rightCols(Index n) -{ - return ColsBlockXpr(derived(), 0, cols() - n, rows(), n); -} - -/** This is the const version of rightCols(Index).*/ -template<typename Derived> -inline const typename DenseBase<Derived>::ColsBlockXpr -DenseBase<Derived>::rightCols(Index n) const -{ - return ColsBlockXpr(derived(), 0, cols() - n, rows(), n); -} - -/** \returns a block consisting of the right columns of *this. - * - * \tparam N the number of columns in the block - * - * Example: \include MatrixBase_template_int_rightCols.cpp - * Output: \verbinclude MatrixBase_template_int_rightCols.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -template<int N> -inline typename DenseBase<Derived>::template NColsBlockXpr<N>::Type -DenseBase<Derived>::rightCols() -{ - return typename DenseBase<Derived>::template NColsBlockXpr<N>::Type(derived(), 0, cols() - N, rows(), N); -} - -/** This is the const version of rightCols<int>().*/ -template<typename Derived> -template<int N> -inline const typename DenseBase<Derived>::template NColsBlockXpr<N>::Type -DenseBase<Derived>::rightCols() const -{ - return typename DenseBase<Derived>::template NColsBlockXpr<N>::Type(derived(), 0, cols() - N, rows(), N); -} - - - - -/** \returns a block consisting of a range of columns of *this. - * - * \param startCol the index of the first column in the block - * \param numCols the number of columns in the block - * - * Example: \include DenseBase_middleCols_int.cpp - * Output: \verbinclude DenseBase_middleCols_int.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -inline typename DenseBase<Derived>::ColsBlockXpr DenseBase<Derived> - ::middleCols(Index startCol, Index numCols) -{ - return ColsBlockXpr(derived(), 0, startCol, rows(), numCols); -} - -/** This is the const version of middleCols(Index,Index).*/ -template<typename Derived> -inline const typename DenseBase<Derived>::ColsBlockXpr -DenseBase<Derived>::middleCols(Index startCol, Index numCols) const -{ - return ColsBlockXpr(derived(), 0, startCol, rows(), numCols); -} - -/** \returns a block consisting of a range of columns of *this. - * - * \tparam N the number of columns in the block - * \param startCol the index of the first column in the block - * - * Example: \include DenseBase_template_int_middleCols.cpp - * Output: \verbinclude DenseBase_template_int_middleCols.out - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -template<int N> -inline typename DenseBase<Derived>::template NColsBlockXpr<N>::Type -DenseBase<Derived>::middleCols(Index startCol) -{ - return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), N); -} - -/** This is the const version of middleCols<int>().*/ -template<typename Derived> -template<int N> -inline const typename DenseBase<Derived>::template NColsBlockXpr<N>::Type -DenseBase<Derived>::middleCols(Index startCol) const -{ - return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), N); -} - - - - - -/** \returns a fixed-size expression of a block in *this. - * - * The template parameters \a BlockRows and \a BlockCols are the number of - * rows and columns in the block. - * - * \param startRow the first row in the block - * \param startCol the first column in the block - * - * Example: \include MatrixBase_block_int_int.cpp - * Output: \verbinclude MatrixBase_block_int_int.out - * - * \note since block is a templated member, the keyword template has to be used - * if the matrix type is also a template parameter: \code m.template block<3,3>(1,1); \endcode - * - * \sa class Block, block(Index,Index,Index,Index) - */ -template<typename Derived> -template<int BlockRows, int BlockCols> -inline Block<Derived, BlockRows, BlockCols> -DenseBase<Derived>::block(Index startRow, Index startCol) -{ - return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol); -} - -/** This is the const version of block<>(Index, Index). */ -template<typename Derived> -template<int BlockRows, int BlockCols> -inline const Block<Derived, BlockRows, BlockCols> -DenseBase<Derived>::block(Index startRow, Index startCol) const -{ - return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol); -} - -/** \returns an expression of the \a i-th column of *this. Note that the numbering starts at 0. - * - * Example: \include MatrixBase_col.cpp - * Output: \verbinclude MatrixBase_col.out - * - * \sa row(), class Block */ -template<typename Derived> -inline typename DenseBase<Derived>::ColXpr -DenseBase<Derived>::col(Index i) -{ - return ColXpr(derived(), i); -} - -/** This is the const version of col(). */ -template<typename Derived> -inline const typename DenseBase<Derived>::ColXpr -DenseBase<Derived>::col(Index i) const -{ - return ColXpr(derived(), i); -} - -/** \returns an expression of the \a i-th row of *this. Note that the numbering starts at 0. - * - * Example: \include MatrixBase_row.cpp - * Output: \verbinclude MatrixBase_row.out - * - * \sa col(), class Block */ -template<typename Derived> -inline typename DenseBase<Derived>::RowXpr -DenseBase<Derived>::row(Index i) -{ - return RowXpr(derived(), i); -} - -/** This is the const version of row(). */ -template<typename Derived> -inline const typename DenseBase<Derived>::RowXpr -DenseBase<Derived>::row(Index i) const -{ - return RowXpr(derived(), i); -} #endif // EIGEN_BLOCK_H diff --git a/Eigen/src/Core/DenseBase.h b/Eigen/src/Core/DenseBase.h index 065f2efed..5cf0a637a 100644 --- a/Eigen/src/Core/DenseBase.h +++ b/Eigen/src/Core/DenseBase.h @@ -234,19 +234,6 @@ template<typename Derived> class DenseBase typedef CwiseNullaryOp<ei_linspaced_op<Scalar,true>,Derived> RandomAccessLinSpacedReturnType; /** \internal the return type of MatrixBase::eigenvalues() */ typedef Matrix<typename NumTraits<typename ei_traits<Derived>::Scalar>::Real, ei_traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType; - /** \internal expression type of a column */ - typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr; - /** \internal expression type of a row */ - typedef Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr; - /** \internal expression type of a block of whole columns */ - typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr; - /** \internal expression type of a block of whole rows */ - typedef Block<Derived, Dynamic, ei_traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr; - /** \internal expression type of a block of whole columns */ - template<int N> struct NColsBlockXpr { typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; }; - /** \internal expression type of a block of whole rows */ - template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, ei_traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; }; - #endif // not EIGEN_PARSED_BY_DOXYGEN @@ -295,15 +282,6 @@ template<typename Derived> class DenseBase public: #endif - RowXpr row(Index i); - const RowXpr row(Index i) const; - - ColXpr col(Index i); - const ColXpr col(Index i) const; - - Block<Derived> block(Index startRow, Index startCol, Index blockRows, Index blockCols); - const Block<Derived> block(Index startRow, Index startCol, Index blockRows, Index blockCols) const; - VectorBlock<Derived> segment(Index start, Index size); const VectorBlock<Derived> segment(Index start, Index size) const; @@ -313,55 +291,6 @@ template<typename Derived> class DenseBase VectorBlock<Derived> tail(Index size); const VectorBlock<Derived> tail(Index size) const; - Block<Derived> topLeftCorner(Index cRows, Index cCols); - const Block<Derived> topLeftCorner(Index cRows, Index cCols) const; - Block<Derived> topRightCorner(Index cRows, Index cCols); - const Block<Derived> topRightCorner(Index cRows, Index cCols) const; - Block<Derived> bottomLeftCorner(Index cRows, Index cCols); - const Block<Derived> bottomLeftCorner(Index cRows, Index cCols) const; - Block<Derived> bottomRightCorner(Index cRows, Index cCols); - const Block<Derived> bottomRightCorner(Index cRows, Index cCols) const; - - RowsBlockXpr topRows(Index n); - const RowsBlockXpr topRows(Index n) const; - RowsBlockXpr bottomRows(Index n); - const RowsBlockXpr bottomRows(Index n) const; - RowsBlockXpr middleRows(Index startRow, Index numRows); - const RowsBlockXpr middleRows(Index startRow, Index numRows) const; - ColsBlockXpr leftCols(Index n); - const ColsBlockXpr leftCols(Index n) const; - ColsBlockXpr rightCols(Index n); - const ColsBlockXpr rightCols(Index n) const; - ColsBlockXpr middleCols(Index startCol, Index numCols); - const ColsBlockXpr middleCols(Index startCol, Index numCols) const; - - template<int CRows, int CCols> Block<Derived, CRows, CCols> topLeftCorner(); - template<int CRows, int CCols> const Block<Derived, CRows, CCols> topLeftCorner() const; - template<int CRows, int CCols> Block<Derived, CRows, CCols> topRightCorner(); - template<int CRows, int CCols> const Block<Derived, CRows, CCols> topRightCorner() const; - template<int CRows, int CCols> Block<Derived, CRows, CCols> bottomLeftCorner(); - template<int CRows, int CCols> const Block<Derived, CRows, CCols> bottomLeftCorner() const; - template<int CRows, int CCols> Block<Derived, CRows, CCols> bottomRightCorner(); - template<int CRows, int CCols> const Block<Derived, CRows, CCols> bottomRightCorner() const; - - template<int NRows> typename NRowsBlockXpr<NRows>::Type topRows(); - template<int NRows> const typename NRowsBlockXpr<NRows>::Type topRows() const; - template<int NRows> typename NRowsBlockXpr<NRows>::Type bottomRows(); - template<int NRows> const typename NRowsBlockXpr<NRows>::Type bottomRows() const; - template<int NRows> typename NRowsBlockXpr<NRows>::Type middleRows(Index startRow); - template<int NRows> const typename NRowsBlockXpr<NRows>::Type middleRows(Index startRow) const; - template<int NCols> typename NColsBlockXpr<NCols>::Type leftCols(); - template<int NCols> const typename NColsBlockXpr<NCols>::Type leftCols() const; - template<int NCols> typename NColsBlockXpr<NCols>::Type rightCols(); - template<int NCols> const typename NColsBlockXpr<NCols>::Type rightCols() const; - template<int NCols> typename NColsBlockXpr<NCols>::Type middleCols(Index startCol); - template<int NCols> const typename NColsBlockXpr<NCols>::Type middleCols(Index startCol) const; - - template<int BlockRows, int BlockCols> - Block<Derived, BlockRows, BlockCols> block(Index startRow, Index startCol); - template<int BlockRows, int BlockCols> - const Block<Derived, BlockRows, BlockCols> block(Index startRow, Index startCol) const; - template<int Size> VectorBlock<Derived,Size> head(void); template<int Size> const VectorBlock<Derived,Size> head() const; @@ -531,6 +460,13 @@ template<typename Derived> class DenseBase const Eigen::Reverse<Derived, BothDirections> reverse() const; void reverseInPlace(); +#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::DenseBase +# include "../plugins/BlockMethods.h" +# ifdef EIGEN_DENSEBASE_PLUGIN +# include EIGEN_DENSEBASE_PLUGIN +# endif +#undef EIGEN_CURRENT_STORAGE_BASE_CLASS + #ifdef EIGEN2_SUPPORT Block<Derived> corner(CornerType type, Index cRows, Index cCols); @@ -542,9 +478,6 @@ template<typename Derived> class DenseBase #endif // EIGEN2_SUPPORT - #ifdef EIGEN_DENSEBASE_PLUGIN - #include EIGEN_DENSEBASE_PLUGIN - #endif // disable the use of evalTo for dense objects with a nice compilation error template<typename Dest> inline void evalTo(Dest& ) const diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h index 25b2fa5e8..c186730be 100644 --- a/Eigen/src/Core/MatrixBase.h +++ b/Eigen/src/Core/MatrixBase.h @@ -183,7 +183,7 @@ template<typename Derived> class MatrixBase operator*(const MatrixBase<OtherDerived> &other) const; template<typename OtherDerived> - const typename ProductReturnType<Derived,OtherDerived,LazyCoeffBasedProductMode>::Type + const typename LazyProductReturnType<Derived,OtherDerived>::Type lazyProduct(const MatrixBase<OtherDerived> &other) const; template<typename OtherDerived> diff --git a/Eigen/src/Core/Product.h b/Eigen/src/Core/Product.h index 25b48517d..8e82338e7 100644 --- a/Eigen/src/Core/Product.h +++ b/Eigen/src/Core/Product.h @@ -163,6 +163,10 @@ struct ProductReturnType<Lhs,Rhs,LazyCoeffBasedProductMode> typedef CoeffBasedProduct<LhsNested, RhsNested, NestByRefBit> Type; }; +// this is a workaround for sun CC +template<typename Lhs, typename Rhs> +struct LazyProductReturnType : public ProductReturnType<Lhs,Rhs,LazyCoeffBasedProductMode> +{}; /*********************************************************************** * Implementation of Inner Vector Vector Product @@ -514,7 +518,7 @@ MatrixBase<Derived>::operator*(const MatrixBase<OtherDerived> &other) const */ template<typename Derived> template<typename OtherDerived> -const typename ProductReturnType<Derived,OtherDerived,LazyCoeffBasedProductMode>::Type +const typename LazyProductReturnType<Derived,OtherDerived>::Type MatrixBase<Derived>::lazyProduct(const MatrixBase<OtherDerived> &other) const { enum { @@ -533,7 +537,7 @@ MatrixBase<Derived>::lazyProduct(const MatrixBase<OtherDerived> &other) const INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION) EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT) - return typename ProductReturnType<Derived,OtherDerived,LazyCoeffBasedProductMode>::Type(derived(), other.derived()); + return typename LazyProductReturnType<Derived,OtherDerived>::Type(derived(), other.derived()); } #endif // EIGEN_PRODUCT_H diff --git a/Eigen/src/Core/util/ForwardDeclarations.h b/Eigen/src/Core/util/ForwardDeclarations.h index 84fa52ffb..3f67a8f4f 100644 --- a/Eigen/src/Core/util/ForwardDeclarations.h +++ b/Eigen/src/Core/util/ForwardDeclarations.h @@ -109,6 +109,9 @@ template<typename Lhs, typename Rhs, int ProductType = ei_product_type<Lhs,Rhs>::value> struct ProductReturnType; +// this is a workaround for sun CC +template<typename Lhs, typename Rhs> struct LazyProductReturnType; + // Provides scalar/packet-wise product and product with accumulation // with optional conjugation of the arguments. template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct ei_conj_helper; diff --git a/Eigen/src/plugins/BlockMethods.h b/Eigen/src/plugins/BlockMethods.h new file mode 100644 index 000000000..3aae95a64 --- /dev/null +++ b/Eigen/src/plugins/BlockMethods.h @@ -0,0 +1,589 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr> +// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com> +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, you can redistribute it and/or +// modify it under the terms of the GNU General Public License as +// published by the Free Software Foundation; either version 2 of +// the License, or (at your option) any later version. +// +// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see <http://www.gnu.org/licenses/>. + +#ifndef EIGEN_BLOCKMETHODS_H +#define EIGEN_BLOCKMETHODS_H + +#ifndef EIGEN_PARSED_BY_DOXYGEN + +/** \internal expression type of a column */ +typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr; +/** \internal expression type of a row */ +typedef Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr; +/** \internal expression type of a block of whole columns */ +typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr; +/** \internal expression type of a block of whole rows */ +typedef Block<Derived, Dynamic, ei_traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr; +/** \internal expression type of a block of whole columns */ +template<int N> struct NColsBlockXpr { typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; }; +/** \internal expression type of a block of whole rows */ +template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, ei_traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; }; + + +#endif // not EIGEN_PARSED_BY_DOXYGEN + +/** \returns a dynamic-size expression of a block in *this. + * + * \param startRow the first row in the block + * \param startCol the first column in the block + * \param blockRows the number of rows in the block + * \param blockCols the number of columns in the block + * + * Example: \include MatrixBase_block_int_int_int_int.cpp + * Output: \verbinclude MatrixBase_block_int_int_int_int.out + * + * \note Even though the returned expression has dynamic size, in the case + * when it is applied to a fixed-size matrix, it inherits a fixed maximal size, + * which means that evaluating it does not cause a dynamic memory allocation. + * + * \sa class Block, block(Index,Index) + */ +inline Block<Derived> block(Index startRow, Index startCol, Index blockRows, Index blockCols) +{ + return Block<Derived>(derived(), startRow, startCol, blockRows, blockCols); +} + +/** This is the const version of block(Index,Index,Index,Index). */ +inline const Block<Derived> block(Index startRow, Index startCol, Index blockRows, Index blockCols) const +{ + return Block<Derived>(derived(), startRow, startCol, blockRows, blockCols); +} + + + + +/** \returns a dynamic-size expression of a top-right corner of *this. + * + * \param cRows the number of rows in the corner + * \param cCols the number of columns in the corner + * + * Example: \include MatrixBase_topRightCorner_int_int.cpp + * Output: \verbinclude MatrixBase_topRightCorner_int_int.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +inline Block<Derived> topRightCorner(Index cRows, Index cCols) +{ + return Block<Derived>(derived(), 0, cols() - cCols, cRows, cCols); +} + +/** This is the const version of topRightCorner(Index, Index).*/ +inline const Block<Derived> topRightCorner(Index cRows, Index cCols) const +{ + return Block<Derived>(derived(), 0, cols() - cCols, cRows, cCols); +} + +/** \returns an expression of a fixed-size top-right corner of *this. + * + * The template parameters CRows and CCols are the number of rows and columns in the corner. + * + * Example: \include MatrixBase_template_int_int_topRightCorner.cpp + * Output: \verbinclude MatrixBase_template_int_int_topRightCorner.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +template<int CRows, int CCols> +inline Block<Derived, CRows, CCols> topRightCorner() +{ + return Block<Derived, CRows, CCols>(derived(), 0, cols() - CCols); +} + +/** This is the const version of topRightCorner<int, int>().*/ +template<int CRows, int CCols> +inline const Block<Derived, CRows, CCols> topRightCorner() const +{ + return Block<Derived, CRows, CCols>(derived(), 0, cols() - CCols); +} + + + + +/** \returns a dynamic-size expression of a top-left corner of *this. + * + * \param cRows the number of rows in the corner + * \param cCols the number of columns in the corner + * + * Example: \include MatrixBase_topLeftCorner_int_int.cpp + * Output: \verbinclude MatrixBase_topLeftCorner_int_int.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +inline Block<Derived> topLeftCorner(Index cRows, Index cCols) +{ + return Block<Derived>(derived(), 0, 0, cRows, cCols); +} + +/** This is the const version of topLeftCorner(Index, Index).*/ +inline const Block<Derived> topLeftCorner(Index cRows, Index cCols) const +{ + return Block<Derived>(derived(), 0, 0, cRows, cCols); +} + +/** \returns an expression of a fixed-size top-left corner of *this. + * + * The template parameters CRows and CCols are the number of rows and columns in the corner. + * + * Example: \include MatrixBase_template_int_int_topLeftCorner.cpp + * Output: \verbinclude MatrixBase_template_int_int_topLeftCorner.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +template<int CRows, int CCols> +inline Block<Derived, CRows, CCols> topLeftCorner() +{ + return Block<Derived, CRows, CCols>(derived(), 0, 0); +} + +/** This is the const version of topLeftCorner<int, int>().*/ +template<int CRows, int CCols> +inline const Block<Derived, CRows, CCols> topLeftCorner() const +{ + return Block<Derived, CRows, CCols>(derived(), 0, 0); +} + + + +/** \returns a dynamic-size expression of a bottom-right corner of *this. + * + * \param cRows the number of rows in the corner + * \param cCols the number of columns in the corner + * + * Example: \include MatrixBase_bottomRightCorner_int_int.cpp + * Output: \verbinclude MatrixBase_bottomRightCorner_int_int.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +inline Block<Derived> bottomRightCorner(Index cRows, Index cCols) +{ + return Block<Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols); +} + +/** This is the const version of bottomRightCorner(Index, Index).*/ +inline const Block<Derived> bottomRightCorner(Index cRows, Index cCols) const +{ + return Block<Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols); +} + +/** \returns an expression of a fixed-size bottom-right corner of *this. + * + * The template parameters CRows and CCols are the number of rows and columns in the corner. + * + * Example: \include MatrixBase_template_int_int_bottomRightCorner.cpp + * Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +template<int CRows, int CCols> +inline Block<Derived, CRows, CCols> bottomRightCorner() +{ + return Block<Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols); +} + +/** This is the const version of bottomRightCorner<int, int>().*/ +template<int CRows, int CCols> +inline const Block<Derived, CRows, CCols> bottomRightCorner() const +{ + return Block<Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols); +} + + + +/** \returns a dynamic-size expression of a bottom-left corner of *this. + * + * \param cRows the number of rows in the corner + * \param cCols the number of columns in the corner + * + * Example: \include MatrixBase_bottomLeftCorner_int_int.cpp + * Output: \verbinclude MatrixBase_bottomLeftCorner_int_int.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +inline Block<Derived> bottomLeftCorner(Index cRows, Index cCols) +{ + return Block<Derived>(derived(), rows() - cRows, 0, cRows, cCols); +} + +/** This is the const version of bottomLeftCorner(Index, Index).*/ +inline const Block<Derived> bottomLeftCorner(Index cRows, Index cCols) const +{ + return Block<Derived>(derived(), rows() - cRows, 0, cRows, cCols); +} + +/** \returns an expression of a fixed-size bottom-left corner of *this. + * + * The template parameters CRows and CCols are the number of rows and columns in the corner. + * + * Example: \include MatrixBase_template_int_int_bottomLeftCorner.cpp + * Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +template<int CRows, int CCols> +inline Block<Derived, CRows, CCols> bottomLeftCorner() +{ + return Block<Derived, CRows, CCols>(derived(), rows() - CRows, 0); +} + +/** This is the const version of bottomLeftCorner<int, int>().*/ +template<int CRows, int CCols> +inline const Block<Derived, CRows, CCols> bottomLeftCorner() const +{ + return Block<Derived, CRows, CCols>(derived(), rows() - CRows, 0); +} + + + +/** \returns a block consisting of the top rows of *this. + * + * \param n the number of rows in the block + * + * Example: \include MatrixBase_topRows_int.cpp + * Output: \verbinclude MatrixBase_topRows_int.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +inline RowsBlockXpr topRows(Index n) +{ + return RowsBlockXpr(derived(), 0, 0, n, cols()); +} + +/** This is the const version of topRows(Index).*/ +inline const RowsBlockXpr topRows(Index n) const +{ + return RowsBlockXpr(derived(), 0, 0, n, cols()); +} + +/** \returns a block consisting of the top rows of *this. + * + * \tparam N the number of rows in the block + * + * Example: \include MatrixBase_template_int_topRows.cpp + * Output: \verbinclude MatrixBase_template_int_topRows.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +template<int N> +inline typename NRowsBlockXpr<N>::Type topRows() +{ + return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, N, cols()); +} + +/** This is the const version of topRows<int>().*/ +template<int N> +inline const typename NRowsBlockXpr<N>::Type topRows() const +{ + return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, N, cols()); +} + + + +/** \returns a block consisting of the bottom rows of *this. + * + * \param n the number of rows in the block + * + * Example: \include MatrixBase_bottomRows_int.cpp + * Output: \verbinclude MatrixBase_bottomRows_int.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +inline RowsBlockXpr bottomRows(Index n) +{ + return RowsBlockXpr(derived(), rows() - n, 0, n, cols()); +} + +/** This is the const version of bottomRows(Index).*/ +inline const RowsBlockXpr bottomRows(Index n) const +{ + return RowsBlockXpr(derived(), rows() - n, 0, n, cols()); +} + +/** \returns a block consisting of the bottom rows of *this. + * + * \tparam N the number of rows in the block + * + * Example: \include MatrixBase_template_int_bottomRows.cpp + * Output: \verbinclude MatrixBase_template_int_bottomRows.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +template<int N> +inline typename NRowsBlockXpr<N>::Type bottomRows() +{ + return typename NRowsBlockXpr<N>::Type(derived(), rows() - N, 0, N, cols()); +} + +/** This is the const version of bottomRows<int>().*/ +template<int N> +inline const typename NRowsBlockXpr<N>::Type bottomRows() const +{ + return typename NRowsBlockXpr<N>::Type(derived(), rows() - N, 0, N, cols()); +} + + + +/** \returns a block consisting of a range of rows of *this. + * + * \param startRow the index of the first row in the block + * \param numRows the number of rows in the block + * + * Example: \include DenseBase_middleRows_int.cpp + * Output: \verbinclude DenseBase_middleRows_int.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +inline RowsBlockXpr middleRows(Index startRow, Index numRows) +{ + return RowsBlockXpr(derived(), startRow, 0, numRows, cols()); +} + +/** This is the const version of middleRows(Index,Index).*/ +inline const RowsBlockXpr middleRows(Index startRow, Index numRows) const +{ + return RowsBlockXpr(derived(), startRow, 0, numRows, cols()); +} + +/** \returns a block consisting of a range of rows of *this. + * + * \tparam N the number of rows in the block + * \param startRow the index of the first row in the block + * + * Example: \include DenseBase_template_int_middleRows.cpp + * Output: \verbinclude DenseBase_template_int_middleRows.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +template<int N> +inline typename NRowsBlockXpr<N>::Type middleRows(Index startRow) +{ + return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, N, cols()); +} + +/** This is the const version of middleRows<int>().*/ +template<int N> +inline const typename NRowsBlockXpr<N>::Type middleRows(Index startRow) const +{ + return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, N, cols()); +} + + + +/** \returns a block consisting of the left columns of *this. + * + * \param n the number of columns in the block + * + * Example: \include MatrixBase_leftCols_int.cpp + * Output: \verbinclude MatrixBase_leftCols_int.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +inline ColsBlockXpr leftCols(Index n) +{ + return ColsBlockXpr(derived(), 0, 0, rows(), n); +} + +/** This is the const version of leftCols(Index).*/ +inline const ColsBlockXpr leftCols(Index n) const +{ + return ColsBlockXpr(derived(), 0, 0, rows(), n); +} + +/** \returns a block consisting of the left columns of *this. + * + * \tparam N the number of columns in the block + * + * Example: \include MatrixBase_template_int_leftCols.cpp + * Output: \verbinclude MatrixBase_template_int_leftCols.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +template<int N> +inline typename NColsBlockXpr<N>::Type leftCols() +{ + return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), N); +} + +/** This is the const version of leftCols<int>().*/ +template<int N> +inline const typename NColsBlockXpr<N>::Type leftCols() const +{ + return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), N); +} + + + +/** \returns a block consisting of the right columns of *this. + * + * \param n the number of columns in the block + * + * Example: \include MatrixBase_rightCols_int.cpp + * Output: \verbinclude MatrixBase_rightCols_int.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +inline ColsBlockXpr rightCols(Index n) +{ + return ColsBlockXpr(derived(), 0, cols() - n, rows(), n); +} + +/** This is the const version of rightCols(Index).*/ +inline const ColsBlockXpr rightCols(Index n) const +{ + return ColsBlockXpr(derived(), 0, cols() - n, rows(), n); +} + +/** \returns a block consisting of the right columns of *this. + * + * \tparam N the number of columns in the block + * + * Example: \include MatrixBase_template_int_rightCols.cpp + * Output: \verbinclude MatrixBase_template_int_rightCols.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +template<int N> +inline typename NColsBlockXpr<N>::Type rightCols() +{ + return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - N, rows(), N); +} + +/** This is the const version of rightCols<int>().*/ +template<int N> +inline const typename NColsBlockXpr<N>::Type rightCols() const +{ + return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - N, rows(), N); +} + + + +/** \returns a block consisting of a range of columns of *this. + * + * \param startCol the index of the first column in the block + * \param numCols the number of columns in the block + * + * Example: \include DenseBase_middleCols_int.cpp + * Output: \verbinclude DenseBase_middleCols_int.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +inline ColsBlockXpr middleCols(Index startCol, Index numCols) +{ + return ColsBlockXpr(derived(), 0, startCol, rows(), numCols); +} + +/** This is the const version of middleCols(Index,Index).*/ +inline const ColsBlockXpr middleCols(Index startCol, Index numCols) const +{ + return ColsBlockXpr(derived(), 0, startCol, rows(), numCols); +} + +/** \returns a block consisting of a range of columns of *this. + * + * \tparam N the number of columns in the block + * \param startCol the index of the first column in the block + * + * Example: \include DenseBase_template_int_middleCols.cpp + * Output: \verbinclude DenseBase_template_int_middleCols.out + * + * \sa class Block, block(Index,Index,Index,Index) + */ +template<int N> +inline typename NColsBlockXpr<N>::Type middleCols(Index startCol) +{ + return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), N); +} + +/** This is the const version of middleCols<int>().*/ +template<int N> +inline const typename NColsBlockXpr<N>::Type middleCols(Index startCol) const +{ + return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), N); +} + + + +/** \returns a fixed-size expression of a block in *this. + * + * The template parameters \a BlockRows and \a BlockCols are the number of + * rows and columns in the block. + * + * \param startRow the first row in the block + * \param startCol the first column in the block + * + * Example: \include MatrixBase_block_int_int.cpp + * Output: \verbinclude MatrixBase_block_int_int.out + * + * \note since block is a templated member, the keyword template has to be used + * if the matrix type is also a template parameter: \code m.template block<3,3>(1,1); \endcode + * + * \sa class Block, block(Index,Index,Index,Index) + */ +template<int BlockRows, int BlockCols> +inline Block<Derived, BlockRows, BlockCols> block(Index startRow, Index startCol) +{ + return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol); +} + +/** This is the const version of block<>(Index, Index). */ +template<int BlockRows, int BlockCols> +inline const Block<Derived, BlockRows, BlockCols> block(Index startRow, Index startCol) const +{ + return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol); +} + +/** \returns an expression of the \a i-th column of *this. Note that the numbering starts at 0. + * + * Example: \include MatrixBase_col.cpp + * Output: \verbinclude MatrixBase_col.out + * + * \sa row(), class Block */ +inline ColXpr col(Index i) +{ + return ColXpr(derived(), i); +} + +/** This is the const version of col(). */ +inline const ColXpr col(Index i) const +{ + return ColXpr(derived(), i); +} + +/** \returns an expression of the \a i-th row of *this. Note that the numbering starts at 0. + * + * Example: \include MatrixBase_row.cpp + * Output: \verbinclude MatrixBase_row.out + * + * \sa col(), class Block */ +inline RowXpr row(Index i) +{ + return RowXpr(derived(), i); +} + +/** This is the const version of row(). */ +inline const RowXpr row(Index i) const +{ + return RowXpr(derived(), i); +} + +#endif // EIGEN_BLOCKMETHODS_H |