devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Implement mixed static/dynamic-size .block() (bug #579)

Browse Source
This commit is contained in:
Jitse Niesen
2013-06-18 14:29:15 +01:00
parent 05da15bf40
commit e37ff98bbb
9 changed files with 238 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
Eigen/src/plugins/BlockMethods.h
View File

@@ -90,12 +90,13 @@ inline const Block<const Derived> topRightCorner(Index cRows, Index cCols) const
/** \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.
* \tparam CRows the number of rows in the corner
* \tparam CCols the number of 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)
* \sa class Block, block<int,int>(Index,Index)
*/
template<int CRows, int CCols>
inline Block<Derived, CRows, CCols> topRightCorner()
@@ -110,6 +111,35 @@ inline const Block<const Derived, CRows, CCols> topRightCorner() const
return Block<const Derived, CRows, CCols>(derived(), 0, cols() - CCols);
}
/** \returns an expression of a top-right corner of *this.
*
* \tparam CRows number of rows in corner as specified at compile time
* \tparam CCols number of columns in corner as specified at compile time
* \param cRows number of rows in corner as specified at run time
* \param cCols number of columns in corner as specified at run time
*
* This function is mainly useful for corners where the number of rows is specified at compile time
* and the number of columns is specified at run time, or vice versa. The compile-time and run-time
* information should not contradict. In other words, \a cRows should equal \a CRows unless
* \a CRows is \a Dynamic, and the same for the number of columns.
*
* Example: \include MatrixBase_template_int_int_topRightCorner_int_int.cpp
* Output: \verbinclude MatrixBase_template_int_int_topRightCorner_int_int.out
*
* \sa class Block
*/
template<int CRows, int CCols>
inline Block<Derived, CRows, CCols> topRightCorner(Index cRows, Index cCols)
{
return Block<Derived, CRows, CCols>(derived(), 0, cols() - cCols, cRows, cCols);
}
/** This is the const version of topRightCorner<int, int>(Index, Index).*/
template<int CRows, int CCols>
inline const Block<const Derived, CRows, CCols> topRightCorner(Index cRows, Index cCols) const
{
return Block<const Derived, CRows, CCols>(derived(), 0, cols() - cCols, cRows, cCols);
}
@@ -156,6 +186,36 @@ inline const Block<const Derived, CRows, CCols> topLeftCorner() const
return Block<const Derived, CRows, CCols>(derived(), 0, 0);
}
/** \returns an expression of a top-left corner of *this.
*
* \tparam CRows number of rows in corner as specified at compile time
* \tparam CCols number of columns in corner as specified at compile time
* \param cRows number of rows in corner as specified at run time
* \param cCols number of columns in corner as specified at run time
*
* This function is mainly useful for corners where the number of rows is specified at compile time
* and the number of columns is specified at run time, or vice versa. The compile-time and run-time
* information should not contradict. In other words, \a cRows should equal \a CRows unless
* \a CRows is \a Dynamic, and the same for the number of columns.
*
* Example: \include MatrixBase_template_int_int_topLeftCorner_int_int.cpp
* Output: \verbinclude MatrixBase_template_int_int_topLeftCorner_int_int.out
*
* \sa class Block
*/
template<int CRows, int CCols>
inline Block<Derived, CRows, CCols> topLeftCorner(Index cRows, Index cCols)
{
return Block<Derived, CRows, CCols>(derived(), 0, 0, cRows, cCols);
}
/** This is the const version of topLeftCorner<int, int>(Index, Index).*/
template<int CRows, int CCols>
inline const Block<const Derived, CRows, CCols> topLeftCorner(Index cRows, Index cCols) const
{
return Block<const Derived, CRows, CCols>(derived(), 0, 0, cRows, cCols);
}
/** \returns a dynamic-size expression of a bottom-right corner of *this.
@@ -201,6 +261,36 @@ inline const Block<const Derived, CRows, CCols> bottomRightCorner() const
return Block<const Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols);
}
/** \returns an expression of a bottom-right corner of *this.
*
* \tparam CRows number of rows in corner as specified at compile time
* \tparam CCols number of columns in corner as specified at compile time
* \param cRows number of rows in corner as specified at run time
* \param cCols number of columns in corner as specified at run time
*
* This function is mainly useful for corners where the number of rows is specified at compile time
* and the number of columns is specified at run time, or vice versa. The compile-time and run-time
* information should not contradict. In other words, \a cRows should equal \a CRows unless
* \a CRows is \a Dynamic, and the same for the number of columns.
*
* Example: \include MatrixBase_template_int_int_bottomRightCorner_int_int.cpp
* Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner_int_int.out
*
* \sa class Block
*/
template<int CRows, int CCols>
inline Block<Derived, CRows, CCols> bottomRightCorner(Index cRows, Index cCols)
{
return Block<Derived, CRows, CCols>(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
}
/** This is the const version of bottomRightCorner<int, int>(Index, Index).*/
template<int CRows, int CCols>
inline const Block<const Derived, CRows, CCols> bottomRightCorner(Index cRows, Index cCols) const
{
return Block<const Derived, CRows, CCols>(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
}
/** \returns a dynamic-size expression of a bottom-left corner of *this.
@@ -246,6 +336,36 @@ inline const Block<const Derived, CRows, CCols> bottomLeftCorner() const
return Block<const Derived, CRows, CCols>(derived(), rows() - CRows, 0);
}
/** \returns an expression of a bottom-left corner of *this.
*
* \tparam CRows number of rows in corner as specified at compile time
* \tparam CCols number of columns in corner as specified at compile time
* \param cRows number of rows in corner as specified at run time
* \param cCols number of columns in corner as specified at run time
*
* This function is mainly useful for corners where the number of rows is specified at compile time
* and the number of columns is specified at run time, or vice versa. The compile-time and run-time
* information should not contradict. In other words, \a cRows should equal \a CRows unless
* \a CRows is \a Dynamic, and the same for the number of columns.
*
* Example: \include MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp
* Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner_int_int.out
*
* \sa class Block
*/
template<int CRows, int CCols>
inline Block<Derived, CRows, CCols> bottomLeftCorner(Index cRows, Index cCols)
{
return Block<Derived, CRows, CCols>(derived(), rows() - cRows, 0, cRows, cCols);
}
/** This is the const version of bottomLeftCorner<int, int>(Index, Index).*/
template<int CRows, int CCols>
inline const Block<const Derived, CRows, CCols> bottomLeftCorner(Index cRows, Index cCols) const
{
return Block<const Derived, CRows, CCols>(derived(), rows() - cRows, 0, cRows, cCols);
}
/** \returns a block consisting of the top rows of *this.
@@ -545,6 +665,40 @@ inline const Block<const Derived, BlockRows, BlockCols> block(Index startRow, In
return Block<const Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
}
/** \returns an expression of a block in *this.
*
* \tparam BlockRows number of rows in block as specified at compile time
* \tparam BlockCols number of columns in block as specified at compile time
* \param startRow the first row in the block
* \param startCol the first column in the block
* \param blockRows number of rows in block as specified at run time
* \param blockCols number of columns in block as specified at run time
*
* This function is mainly useful for blocks where the number of rows is specified at compile time
* and the number of columns is specified at run time, or vice versa. The compile-time and run-time
* information should not contradict. In other words, \a blockRows should equal \a BlockRows unless
* \a BlockRows is \a Dynamic, and the same for the number of columns.
*
* Example: \include MatrixBase_template_int_int_block_int_int_int_int.cpp
* Output: \verbinclude MatrixBase_template_int_int_block_int_int_int_int.cpp
*
* \sa class Block, block(Index,Index,Index,Index)
*/
template<int BlockRows, int BlockCols>
inline Block<Derived, BlockRows, BlockCols> block(Index startRow, Index startCol,
Index blockRows, Index blockCols)
{
return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol, blockRows, blockCols);
}
/** This is the const version of block<>(Index, Index, Index, Index). */
template<int BlockRows, int BlockCols>
inline const Block<const Derived, BlockRows, BlockCols> block(Index startRow, Index startCol,
Index blockRows, Index blockCols) const
{
return Block<const Derived, BlockRows, BlockCols>(derived(), startRow, startCol, blockRows, blockCols);
}
/** \returns an expression of the \a i-th column of *this. Note that the numbering starts at 0.
*
* Example: \include MatrixBase_col.cpp