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

1 files changed, 156 insertions, 2 deletions

diff --git a/Eigen/src/plugins/BlockMethods.h b/Eigen/src/plugins/BlockMethods.h
index 19a491cf7..6911bedef 100644
--- a/Eigen/src/plugins/BlockMethods.h
+++ b/Eigen/src/plugins/BlockMethods.h
@@ -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