GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-07-30 16:52:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

Update all block expressions to accept compile-time sizes passed by fix<N> or fix<N>(n)

Browse Source
This commit is contained in:
Gael Guennebaud 2017-01-18 09:43:58 +01:00
parent 5484ddd353
commit 198507141b
2 changed files with 411 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -78,6 +78,7 @@ EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
/// ///
/// \sa class Block, fix, fix<N>(int) /// \sa class Block, fix, fix<N>(int)
/// ///
EIGEN_DEVICE_FUNC
template<typename NRowsType, typename NColsType> template<typename NRowsType, typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type inline typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
@ -91,11 +92,12 @@ block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols)
} }
/// This is the const version of block(Index,Index,NRowsType,NColsType) /// This is the const version of block(Index,Index,NRowsType,NColsType)
EIGEN_DEVICE_FUNC
template<typename NRowsType, typename NColsType> template<typename NRowsType, typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type inline const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
#else #else
inline typename ConstFixedBlockXpr<...,...>::Type inline const typename ConstFixedBlockXpr<...,...>::Type
#endif #endif
block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols) const block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols) const
{ {
@ -105,32 +107,51 @@ block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols)
/// \returns a dynamic-size expression of a top-right corner of *this. /// \returns a expression of a top-right corner of \c *this with either dynamic or fixed sizes.
/// ///
/// \param cRows the number of rows in the corner /// \param cRows the number of rows in the corner
/// \param cCols the number of columns in the corner /// \param cCols the number of columns in the corner
/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
/// ///
/// Example: \include MatrixBase_topRightCorner_int_int.cpp /// Example with dynamic sizes: \include MatrixBase_topRightCorner_int_int.cpp
/// Output: \verbinclude MatrixBase_topRightCorner_int_int.out /// Output: \verbinclude MatrixBase_topRightCorner_int_int.out
/// ///
/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline BlockXpr topRightCorner(Index cRows, Index cCols) template<typename NRowsType, typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
#else
inline typename FixedBlockXpr<...,...>::Type
#endif
topRightCorner(NRowsType cRows, NColsType cCols)
{ {
return BlockXpr(derived(), 0, cols() - cCols, cRows, cCols); return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
(derived(), 0, cols() - internal::get_runtime_value(cCols), internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
} }
/// This is the const version of topRightCorner(Index, Index). /// This is the const version of topRightCorner(NRowsType, NColsType).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline const ConstBlockXpr topRightCorner(Index cRows, Index cCols) const template<typename NRowsType, typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
#else
inline const typename ConstFixedBlockXpr<...,...>::Type
#endif
topRightCorner(NRowsType cRows, NColsType cCols) const
{ {
return ConstBlockXpr(derived(), 0, cols() - cCols, cRows, cCols); return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
(derived(), 0, cols() - internal::get_runtime_value(cCols), internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
} }
/// \returns an expression of a fixed-size top-right corner of *this. /// \returns an expression of a fixed-size top-right corner of \c *this.
/// ///
/// \tparam CRows the number of rows in the corner /// \tparam CRows the number of rows in the corner
/// \tparam CCols the number of columns in the corner /// \tparam CCols the number of columns in the corner
@ -157,7 +178,7 @@ inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner() con
return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols); return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);
} }
/// \returns an expression of a top-right corner of *this. /// \returns an expression of a top-right corner of \c *this.
/// ///
/// \tparam CRows number of rows in corner as specified at compile-time /// \tparam CRows number of rows in corner as specified at compile-time
/// \tparam CCols number of columns in corner as specified at compile-time /// \tparam CCols number of columns in corner as specified at compile-time
@ -191,32 +212,51 @@ inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner(Index
/// \returns a dynamic-size expression of a top-left corner of *this. /// \returns an expression of a top-left corner of \c *this with either dynamic or fixed sizes.
/// ///
/// \param cRows the number of rows in the corner /// \param cRows the number of rows in the corner
/// \param cCols the number of columns in the corner /// \param cCols the number of columns in the corner
/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
/// ///
/// Example: \include MatrixBase_topLeftCorner_int_int.cpp /// Example: \include MatrixBase_topLeftCorner_int_int.cpp
/// Output: \verbinclude MatrixBase_topLeftCorner_int_int.out /// Output: \verbinclude MatrixBase_topLeftCorner_int_int.out
/// ///
/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline BlockXpr topLeftCorner(Index cRows, Index cCols) template<typename NRowsType, typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
#else
inline typename FixedBlockXpr<...,...>::Type
#endif
topLeftCorner(NRowsType cRows, NColsType cCols)
{ {
return BlockXpr(derived(), 0, 0, cRows, cCols); return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
(derived(), 0, 0, internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
} }
/// This is the const version of topLeftCorner(Index, Index). /// This is the const version of topLeftCorner(Index, Index).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline const ConstBlockXpr topLeftCorner(Index cRows, Index cCols) const template<typename NRowsType, typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
#else
inline const typename ConstFixedBlockXpr<...,...>::Type
#endif
topLeftCorner(NRowsType cRows, NColsType cCols) const
{ {
return ConstBlockXpr(derived(), 0, 0, cRows, cCols); return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
(derived(), 0, 0, internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
} }
/// \returns an expression of a fixed-size top-left corner of *this. /// \returns an expression of a fixed-size top-left corner of \c *this.
/// ///
/// The template parameters CRows and CCols are the number of rows and columns in the corner. /// The template parameters CRows and CCols are the number of rows and columns in the corner.
/// ///
@ -225,7 +265,7 @@ inline const ConstBlockXpr topLeftCorner(Index cRows, Index cCols) const
/// ///
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
template<int CRows, int CCols> template<int CRows, int CCols>
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
@ -242,7 +282,7 @@ inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner() cons
return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0); return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);
} }
/// \returns an expression of a top-left corner of *this. /// \returns an expression of a top-left corner of \c *this.
/// ///
/// \tparam CRows number of rows in corner as specified at compile-time /// \tparam CRows number of rows in corner as specified at compile-time
/// \tparam CCols number of columns in corner as specified at compile-time /// \tparam CCols number of columns in corner as specified at compile-time
@ -276,32 +316,53 @@ inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index
/// \returns a dynamic-size expression of a bottom-right corner of *this. /// \returns an expression of a bottom-right corner of \c *this with either dynamic or fixed sizes.
/// ///
/// \param cRows the number of rows in the corner /// \param cRows the number of rows in the corner
/// \param cCols the number of columns in the corner /// \param cCols the number of columns in the corner
/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
/// ///
/// Example: \include MatrixBase_bottomRightCorner_int_int.cpp /// Example: \include MatrixBase_bottomRightCorner_int_int.cpp
/// Output: \verbinclude MatrixBase_bottomRightCorner_int_int.out /// Output: \verbinclude MatrixBase_bottomRightCorner_int_int.out
/// ///
/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline BlockXpr bottomRightCorner(Index cRows, Index cCols) template<typename NRowsType, typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
#else
inline typename FixedBlockXpr<...,...>::Type
#endif
bottomRightCorner(NRowsType cRows, NColsType cCols)
{ {
return BlockXpr(derived(), rows() - cRows, cols() - cCols, cRows, cCols); return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
(derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),
internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
} }
/// This is the const version of bottomRightCorner(Index, Index). /// This is the const version of bottomRightCorner(NRowsType, NColsType).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline const ConstBlockXpr bottomRightCorner(Index cRows, Index cCols) const template<typename NRowsType, typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
#else
inline const typename ConstFixedBlockXpr<...,...>::Type
#endif
bottomRightCorner(NRowsType cRows, NColsType cCols) const
{ {
return ConstBlockXpr(derived(), rows() - cRows, cols() - cCols, cRows, cCols); return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
(derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),
internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
} }
/// \returns an expression of a fixed-size bottom-right corner of *this. /// \returns an expression of a fixed-size bottom-right corner of \c *this.
/// ///
/// The template parameters CRows and CCols are the number of rows and columns in the corner. /// The template parameters CRows and CCols are the number of rows and columns in the corner.
/// ///
@ -310,7 +371,7 @@ inline const ConstBlockXpr bottomRightCorner(Index cRows, Index cCols) const
/// ///
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
template<int CRows, int CCols> template<int CRows, int CCols>
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
@ -327,7 +388,7 @@ inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner()
return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols); return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);
} }
/// \returns an expression of a bottom-right corner of *this. /// \returns an expression of a bottom-right corner of \c *this.
/// ///
/// \tparam CRows number of rows in corner as specified at compile-time /// \tparam CRows number of rows in corner as specified at compile-time
/// \tparam CCols number of columns in corner as specified at compile-time /// \tparam CCols number of columns in corner as specified at compile-time
@ -361,32 +422,53 @@ inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner(In
/// \returns a dynamic-size expression of a bottom-left corner of *this. /// \returns an expression of a bottom-left corner of \c *this with either dynamic or fixed sizes.
/// ///
/// \param cRows the number of rows in the corner /// \param cRows the number of rows in the corner
/// \param cCols the number of columns in the corner /// \param cCols the number of columns in the corner
/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
/// ///
/// Example: \include MatrixBase_bottomLeftCorner_int_int.cpp /// Example: \include MatrixBase_bottomLeftCorner_int_int.cpp
/// Output: \verbinclude MatrixBase_bottomLeftCorner_int_int.out /// Output: \verbinclude MatrixBase_bottomLeftCorner_int_int.out
/// ///
/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline BlockXpr bottomLeftCorner(Index cRows, Index cCols) template<typename NRowsType, typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
#else
inline typename FixedBlockXpr<...,...>::Type
#endif
bottomLeftCorner(NRowsType cRows, NColsType cCols)
{ {
return BlockXpr(derived(), rows() - cRows, 0, cRows, cCols); return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
(derived(), rows() - internal::get_runtime_value(cRows), 0,
internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
} }
/// This is the const version of bottomLeftCorner(Index, Index). /// This is the const version of bottomLeftCorner(NRowsType, NColsType).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline const ConstBlockXpr bottomLeftCorner(Index cRows, Index cCols) const template<typename NRowsType, typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
#else
inline typename ConstFixedBlockXpr<...,...>::Type
#endif
bottomLeftCorner(NRowsType cRows, NColsType cCols) const
{ {
return ConstBlockXpr(derived(), rows() - cRows, 0, cRows, cCols); return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
(derived(), rows() - internal::get_runtime_value(cRows), 0,
internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
} }
/// \returns an expression of a fixed-size bottom-left corner of *this. /// \returns an expression of a fixed-size bottom-left corner of \c *this.
/// ///
/// The template parameters CRows and CCols are the number of rows and columns in the corner. /// The template parameters CRows and CCols are the number of rows and columns in the corner.
/// ///
@ -395,7 +477,7 @@ inline const ConstBlockXpr bottomLeftCorner(Index cRows, Index cCols) const
/// ///
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
template<int CRows, int CCols> template<int CRows, int CCols>
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
@ -412,7 +494,7 @@ inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner() c
return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0); return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);
} }
/// \returns an expression of a bottom-left corner of *this. /// \returns an expression of a bottom-left corner of \c *this.
/// ///
/// \tparam CRows number of rows in corner as specified at compile-time /// \tparam CRows number of rows in corner as specified at compile-time
/// \tparam CCols number of columns in corner as specified at compile-time /// \tparam CCols number of columns in corner as specified at compile-time
@ -446,31 +528,50 @@ inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Ind
/// \returns a block consisting of the top rows of *this. /// \returns a block consisting of the top rows of \c *this.
/// ///
/// \param n the number of rows in the block /// \param n the number of rows in the block
/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
/// ///
/// Example: \include MatrixBase_topRows_int.cpp /// Example: \include MatrixBase_topRows_int.cpp
/// Output: \verbinclude MatrixBase_topRows_int.out /// Output: \verbinclude MatrixBase_topRows_int.out
/// ///
/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments.
/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline RowsBlockXpr topRows(Index n) template<typename NRowsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
#else
inline typename NRowsBlockXpr<...>::Type
#endif
topRows(NRowsType n)
{ {
return RowsBlockXpr(derived(), 0, 0, n, cols()); return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
(derived(), 0, 0, internal::get_runtime_value(n), cols());
} }
/// This is the const version of topRows(Index). /// This is the const version of topRows(NRowsType).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline ConstRowsBlockXpr topRows(Index n) const template<typename NRowsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
#else
inline const typename ConstNRowsBlockXpr<...>::Type
#endif
topRows(NRowsType n) const
{ {
return ConstRowsBlockXpr(derived(), 0, 0, n, cols()); return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
(derived(), 0, 0, internal::get_runtime_value(n), cols());
} }
/// \returns a block consisting of the top rows of *this. /// \returns a block consisting of the top rows of \c *this.
/// ///
/// \tparam N the number of rows in the block as specified at compile-time /// \tparam N the number of rows in the block as specified at compile-time
/// \param n the number of rows in the block as specified at run-time /// \param n the number of rows in the block as specified at run-time
@ -483,7 +584,7 @@ inline ConstRowsBlockXpr topRows(Index n) const
/// ///
EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
template<int N> template<int N>
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
@ -502,31 +603,50 @@ inline typename ConstNRowsBlockXpr<N>::Type topRows(Index n = N) const
/// \returns a block consisting of the bottom rows of *this. /// \returns a block consisting of the bottom rows of \c *this.
/// ///
/// \param n the number of rows in the block /// \param n the number of rows in the block
/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
/// ///
/// Example: \include MatrixBase_bottomRows_int.cpp /// Example: \include MatrixBase_bottomRows_int.cpp
/// Output: \verbinclude MatrixBase_bottomRows_int.out /// Output: \verbinclude MatrixBase_bottomRows_int.out
/// ///
/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments.
/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline RowsBlockXpr bottomRows(Index n) template<typename NRowsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
#else
inline typename NRowsBlockXpr<...>::Type
#endif
bottomRows(NRowsType n)
{ {
return RowsBlockXpr(derived(), rows() - n, 0, n, cols()); return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
(derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());
} }
/// This is the const version of bottomRows(Index). /// This is the const version of bottomRows(NRowsType).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline ConstRowsBlockXpr bottomRows(Index n) const template<typename NRowsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
#else
inline const typename ConstNRowsBlockXpr<...>::Type
#endif
bottomRows(NRowsType n) const
{ {
return ConstRowsBlockXpr(derived(), rows() - n, 0, n, cols()); return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
(derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());
} }
/// \returns a block consisting of the bottom rows of *this. /// \returns a block consisting of the bottom rows of \c *this.
/// ///
/// \tparam N the number of rows in the block as specified at compile-time /// \tparam N the number of rows in the block as specified at compile-time
/// \param n the number of rows in the block as specified at run-time /// \param n the number of rows in the block as specified at run-time
@ -539,7 +659,7 @@ inline ConstRowsBlockXpr bottomRows(Index n) const
/// ///
EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
template<int N> template<int N>
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
@ -558,32 +678,51 @@ inline typename ConstNRowsBlockXpr<N>::Type bottomRows(Index n = N) const
/// \returns a block consisting of a range of rows of *this. /// \returns a block consisting of a range of rows of \c *this.
/// ///
/// \param startRow the index of the first row in the block /// \param startRow the index of the first row in the block
/// \param n the number of rows in the block /// \param n the number of rows in the block
/// \tparam NRowsType the type of the value handling the number of rows in the block, typically Index.
/// ///
/// Example: \include DenseBase_middleRows_int.cpp /// Example: \include DenseBase_middleRows_int.cpp
/// Output: \verbinclude DenseBase_middleRows_int.out /// Output: \verbinclude DenseBase_middleRows_int.out
/// ///
/// The number of rows \a n can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments.
/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline RowsBlockXpr middleRows(Index startRow, Index n) template<typename NRowsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
#else
inline typename NRowsBlockXpr<...>::Type
#endif
middleRows(Index startRow, NRowsType n)
{ {
return RowsBlockXpr(derived(), startRow, 0, n, cols()); return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
(derived(), startRow, 0, internal::get_runtime_value(n), cols());
} }
/// This is the const version of middleRows(Index,Index). /// This is the const version of middleRows(Index,NRowsType).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline ConstRowsBlockXpr middleRows(Index startRow, Index n) const template<typename NRowsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
#else
inline const typename ConstNRowsBlockXpr<...>::Type
#endif
middleRows(Index startRow, NRowsType n) const
{ {
return ConstRowsBlockXpr(derived(), startRow, 0, n, cols()); return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
(derived(), startRow, 0, internal::get_runtime_value(n), cols());
} }
/// \returns a block consisting of a range of rows of *this. /// \returns a block consisting of a range of rows of \c *this.
/// ///
/// \tparam N the number of rows in the block as specified at compile-time /// \tparam N the number of rows in the block as specified at compile-time
/// \param startRow the index of the first row in the block /// \param startRow the index of the first row in the block
@ -597,7 +736,7 @@ inline ConstRowsBlockXpr middleRows(Index startRow, Index n) const
/// ///
EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
template<int N> template<int N>
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
@ -616,31 +755,50 @@ inline typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow, Index n =
/// \returns a block consisting of the left columns of *this. /// \returns a block consisting of the left columns of \c *this.
/// ///
/// \param n the number of columns in the block /// \param n the number of columns in the block
/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
/// ///
/// Example: \include MatrixBase_leftCols_int.cpp /// Example: \include MatrixBase_leftCols_int.cpp
/// Output: \verbinclude MatrixBase_leftCols_int.out /// Output: \verbinclude MatrixBase_leftCols_int.out
/// ///
/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments.
/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline ColsBlockXpr leftCols(Index n) template<typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
#else
inline typename NColsBlockXpr<...>::Type
#endif
leftCols(NColsType n)
{ {
return ColsBlockXpr(derived(), 0, 0, rows(), n); return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
(derived(), 0, 0, rows(), internal::get_runtime_value(n));
} }
/// This is the const version of leftCols(Index). /// This is the const version of leftCols(NColsType).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline ConstColsBlockXpr leftCols(Index n) const template<typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
#else
inline const typename ConstNColsBlockXpr<...>::Type
#endif
leftCols(NColsType n) const
{ {
return ConstColsBlockXpr(derived(), 0, 0, rows(), n); return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
(derived(), 0, 0, rows(), internal::get_runtime_value(n));
} }
/// \returns a block consisting of the left columns of *this. /// \returns a block consisting of the left columns of \c *this.
/// ///
/// \tparam N the number of columns in the block as specified at compile-time /// \tparam N the number of columns in the block as specified at compile-time
/// \param n the number of columns in the block as specified at run-time /// \param n the number of columns in the block as specified at run-time
@ -653,7 +811,7 @@ inline ConstColsBlockXpr leftCols(Index n) const
/// ///
EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
template<int N> template<int N>
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
@ -672,31 +830,50 @@ inline typename ConstNColsBlockXpr<N>::Type leftCols(Index n = N) const
/// \returns a block consisting of the right columns of *this. /// \returns a block consisting of the right columns of \c *this.
/// ///
/// \param n the number of columns in the block /// \param n the number of columns in the block
/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
/// ///
/// Example: \include MatrixBase_rightCols_int.cpp /// Example: \include MatrixBase_rightCols_int.cpp
/// Output: \verbinclude MatrixBase_rightCols_int.out /// Output: \verbinclude MatrixBase_rightCols_int.out
/// ///
/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments.
/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline ColsBlockXpr rightCols(Index n) template<typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
#else
inline typename NColsBlockXpr<...>::Type
#endif
rightCols(NColsType n)
{ {
return ColsBlockXpr(derived(), 0, cols() - n, rows(), n); return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
(derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));
} }
/// This is the const version of rightCols(Index). /// This is the const version of rightCols(NColsType).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline ConstColsBlockXpr rightCols(Index n) const template<typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
#else
inline const typename ConstNColsBlockXpr<...>::Type
#endif
rightCols(NColsType n) const
{ {
return ConstColsBlockXpr(derived(), 0, cols() - n, rows(), n); return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
(derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));
} }
/// \returns a block consisting of the right columns of *this. /// \returns a block consisting of the right columns of \c *this.
/// ///
/// \tparam N the number of columns in the block as specified at compile-time /// \tparam N the number of columns in the block as specified at compile-time
/// \param n the number of columns in the block as specified at run-time /// \param n the number of columns in the block as specified at run-time
@ -709,7 +886,7 @@ inline ConstColsBlockXpr rightCols(Index n) const
/// ///
EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
template<int N> template<int N>
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
@ -728,32 +905,51 @@ inline typename ConstNColsBlockXpr<N>::Type rightCols(Index n = N) const
/// \returns a block consisting of a range of columns of *this. /// \returns a block consisting of a range of columns of \c *this.
/// ///
/// \param startCol the index of the first column in the block /// \param startCol the index of the first column in the block
/// \param numCols the number of columns in the block /// \param numCols the number of columns in the block
/// \tparam NColsType the type of the value handling the number of columns in the block, typically Index.
/// ///
/// Example: \include DenseBase_middleCols_int.cpp /// Example: \include DenseBase_middleCols_int.cpp
/// Output: \verbinclude DenseBase_middleCols_int.out /// Output: \verbinclude DenseBase_middleCols_int.out
/// ///
/// The number of columns \a n can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments.
/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline ColsBlockXpr middleCols(Index startCol, Index numCols) template<typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
#else
inline typename NColsBlockXpr<...>::Type
#endif
middleCols(Index startCol, NColsType numCols)
{ {
return ColsBlockXpr(derived(), 0, startCol, rows(), numCols); return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
(derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));
} }
/// This is the const version of middleCols(Index,Index). /// This is the const version of middleCols(Index,NColsType).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline ConstColsBlockXpr middleCols(Index startCol, Index numCols) const template<typename NColsType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
#else
inline const typename ConstNColsBlockXpr<...>::Type
#endif
middleCols(Index startCol, NColsType numCols) const
{ {
return ConstColsBlockXpr(derived(), 0, startCol, rows(), numCols); return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
(derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));
} }
/// \returns a block consisting of a range of columns of *this. /// \returns a block consisting of a range of columns of \c *this.
/// ///
/// \tparam N the number of columns in the block as specified at compile-time /// \tparam N the number of columns in the block as specified at compile-time
/// \param startCol the index of the first column in the block /// \param startCol the index of the first column in the block
@ -767,7 +963,7 @@ inline ConstColsBlockXpr middleCols(Index startCol, Index numCols) const
/// ///
EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
/// ///
/// \sa class Block, block(Index,Index,NRowsType,NColsType) /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
template<int N> template<int N>
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
@ -786,7 +982,7 @@ inline typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol, Index n =
/// \returns a fixed-size expression of a block in *this. /// \returns a fixed-size expression of a block of \c *this.
/// ///
/// The template parameters \a NRows and \a NCols are the number of /// The template parameters \a NRows and \a NCols are the number of
/// rows and columns in the block. /// rows and columns in the block.
@ -825,7 +1021,7 @@ inline const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow
return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol); return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);
} }
/// \returns an expression of a block in *this. /// \returns an expression of a block of \c *this.
/// ///
/// \tparam NRows number of rows in block as specified at compile-time /// \tparam NRows number of rows in block as specified at compile-time
/// \tparam NCols number of columns in block as specified at compile-time /// \tparam NCols number of columns in block as specified at compile-time
@ -854,7 +1050,7 @@ inline const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow
/// ///
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
/// ///
/// \sa block(Index,Index,NRowsType,NColsType), block(Index,Index,NRowsType,NColsType), class Block /// \sa block(Index,Index,NRowsType,NColsType), class Block
/// ///
template<int NRows, int NCols> template<int NRows, int NCols>
inline typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol, inline typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,
@ -871,7 +1067,7 @@ inline const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow
return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols); return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
} }
/// \returns an expression of the \a i-th column of *this. Note that the numbering starts at 0. /// \returns an expression of the \a i-th column of \c *this. Note that the numbering starts at 0.
/// ///
/// Example: \include MatrixBase_col.cpp /// Example: \include MatrixBase_col.cpp
/// Output: \verbinclude MatrixBase_col.out /// Output: \verbinclude MatrixBase_col.out
@ -892,7 +1088,7 @@ inline ConstColXpr col(Index i) const
return ConstColXpr(derived(), i); return ConstColXpr(derived(), i);
} }
/// \returns an expression of the \a i-th row of *this. Note that the numbering starts at 0. /// \returns an expression of the \a i-th row of \c *this. Note that the numbering starts at 0.
/// ///
/// Example: \include MatrixBase_row.cpp /// Example: \include MatrixBase_row.cpp
/// Output: \verbinclude MatrixBase_row.out /// Output: \verbinclude MatrixBase_row.out
@ -913,96 +1109,153 @@ inline ConstRowXpr row(Index i) const
return ConstRowXpr(derived(), i); return ConstRowXpr(derived(), i);
} }
/// \returns a dynamic-size expression of a segment (i.e. a vector block) in *this. /// \returns an expression of a segment (i.e. a vector block) in \c *this with either dynamic or fixed sizes.
/// ///
/// \only_for_vectors /// \only_for_vectors
/// ///
/// \param start the first coefficient in the segment /// \param start the first coefficient in the segment
/// \param n the number of coefficients in the segment /// \param n the number of coefficients in the segment
/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.
/// ///
/// Example: \include MatrixBase_segment_int_int.cpp /// Example: \include MatrixBase_segment_int_int.cpp
/// Output: \verbinclude MatrixBase_segment_int_int.out /// Output: \verbinclude MatrixBase_segment_int_int.out
/// ///
/// \note Even though the returned expression has dynamic size, in the case /// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments.
/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
/// \note Even in the case that the returned expression has dynamic size, in the case
/// when it is applied to a fixed-size vector, it inherits a fixed maximal size, /// when it is applied to a fixed-size vector, it inherits a fixed maximal size,
/// which means that evaluating it does not cause a dynamic memory allocation. /// which means that evaluating it does not cause a dynamic memory allocation.
/// ///
/// \sa class Block, segment(Index) /// \sa block(Index,Index,NRowsType,NColsType), fix<N>, fix<N>(int), class Block
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline SegmentReturnType segment(Index start, Index n) template<typename NType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
#else
inline typename FixedSegmentReturnType<...>::Type
#endif
segment(Index start, NType n)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return SegmentReturnType(derived(), start, n); return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
(derived(), start, internal::get_runtime_value(n));
} }
/// This is the const version of segment(Index,Index). /// This is the const version of segment(Index,NType).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline ConstSegmentReturnType segment(Index start, Index n) const template<typename NType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
#else
inline const typename ConstFixedSegmentReturnType<...>::Type
#endif
segment(Index start, NType n) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return ConstSegmentReturnType(derived(), start, n); return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
(derived(), start, internal::get_runtime_value(n));
} }
/// \returns a dynamic-size expression of the first coefficients of *this. /// \returns an expression of the first coefficients of \c *this with either dynamic or fixed sizes.
/// ///
/// \only_for_vectors /// \only_for_vectors
/// ///
/// \param n the number of coefficients in the segment /// \param n the number of coefficients in the segment
/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.
/// ///
/// Example: \include MatrixBase_start_int.cpp /// Example: \include MatrixBase_start_int.cpp
/// Output: \verbinclude MatrixBase_start_int.out /// Output: \verbinclude MatrixBase_start_int.out
/// ///
/// \note Even though the returned expression has dynamic size, in the case /// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments.
/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
/// \note Even in the case that the returned expression has dynamic size, in the case
/// when it is applied to a fixed-size vector, it inherits a fixed maximal size, /// when it is applied to a fixed-size vector, it inherits a fixed maximal size,
/// which means that evaluating it does not cause a dynamic memory allocation. /// which means that evaluating it does not cause a dynamic memory allocation.
/// ///
/// \sa class Block, block(Index,Index) /// \sa class Block, block(Index,Index)
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline SegmentReturnType head(Index n) template<typename NType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
#else
inline typename FixedSegmentReturnType<...>::Type
#endif
head(NType n)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return SegmentReturnType(derived(), 0, n); return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
(derived(), 0, internal::get_runtime_value(n));
} }
/// This is the const version of head(Index). /// This is the const version of head(NType).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline ConstSegmentReturnType head(Index n) const template<typename NType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
#else
inline const typename ConstFixedSegmentReturnType<...>::Type
#endif
head(NType n) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return ConstSegmentReturnType(derived(), 0, n); return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
(derived(), 0, internal::get_runtime_value(n));
} }
/// \returns a dynamic-size expression of the last coefficients of *this. /// \returns an expression of a last coefficients of \c *this with either dynamic or fixed sizes.
/// ///
/// \only_for_vectors /// \only_for_vectors
/// ///
/// \param n the number of coefficients in the segment /// \param n the number of coefficients in the segment
/// \tparam NType the type of the value handling the number of coefficients in the segment, typically Index.
/// ///
/// Example: \include MatrixBase_end_int.cpp /// Example: \include MatrixBase_end_int.cpp
/// Output: \verbinclude MatrixBase_end_int.out /// Output: \verbinclude MatrixBase_end_int.out
/// ///
/// \note Even though the returned expression has dynamic size, in the case /// The number of coefficients \a n can also be specified at compile-time by passing Eigen::fix<N>,
/// or Eigen::fix<N>(n) as arguments.
/// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
///
/// \note Even in the case that the returned expression has dynamic size, in the case
/// when it is applied to a fixed-size vector, it inherits a fixed maximal size, /// when it is applied to a fixed-size vector, it inherits a fixed maximal size,
/// which means that evaluating it does not cause a dynamic memory allocation. /// which means that evaluating it does not cause a dynamic memory allocation.
/// ///
/// \sa class Block, block(Index,Index) /// \sa class Block, block(Index,Index)
/// ///
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline SegmentReturnType tail(Index n) template<typename NType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
#else
inline typename FixedSegmentReturnType<...>::Type
#endif
tail(NType n)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return SegmentReturnType(derived(), this->size() - n, n); return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
(derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
} }
/// This is the const version of tail(Index). /// This is the const version of tail(Index).
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
inline ConstSegmentReturnType tail(Index n) const template<typename NType>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
#else
inline const typename ConstFixedSegmentReturnType<...>::Type
#endif
tail(NType n) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return ConstSegmentReturnType(derived(), this->size() - n, n); return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
(derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
} }
/// \returns a fixed-size expression of a segment (i.e. a vector block) in \c *this /// \returns a fixed-size expression of a segment (i.e. a vector block) in \c *this
@ -1019,7 +1272,7 @@ inline ConstSegmentReturnType tail(Index n) const
/// Example: \include MatrixBase_template_int_segment.cpp /// Example: \include MatrixBase_template_int_segment.cpp
/// Output: \verbinclude MatrixBase_template_int_segment.out /// Output: \verbinclude MatrixBase_template_int_segment.out
/// ///
/// \sa class Block /// \sa segment(Index,NType), class Block
/// ///
template<int N> template<int N>
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
@ -1038,7 +1291,7 @@ inline typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index
return typename ConstFixedSegmentReturnType<N>::Type(derived(), start, n); return typename ConstFixedSegmentReturnType<N>::Type(derived(), start, n);
} }
/// \returns a fixed-size expression of the first coefficients of *this. /// \returns a fixed-size expression of the first coefficients of \c *this.
/// ///
/// \only_for_vectors /// \only_for_vectors
/// ///
@ -1051,7 +1304,7 @@ inline typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index
/// Example: \include MatrixBase_template_int_start.cpp /// Example: \include MatrixBase_template_int_start.cpp
/// Output: \verbinclude MatrixBase_template_int_start.out /// Output: \verbinclude MatrixBase_template_int_start.out
/// ///
/// \sa class Block /// \sa head(NType), class Block
/// ///
template<int N> template<int N>
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC
@ -1070,7 +1323,7 @@ inline typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const
return typename ConstFixedSegmentReturnType<N>::Type(derived(), 0, n); return typename ConstFixedSegmentReturnType<N>::Type(derived(), 0, n);
} }
/// \returns a fixed-size expression of the last coefficients of *this. /// \returns a fixed-size expression of the last coefficients of \c *this.
/// ///
/// \only_for_vectors /// \only_for_vectors
/// ///
@ -1083,7 +1336,7 @@ inline typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const
/// Example: \include MatrixBase_template_int_end.cpp /// Example: \include MatrixBase_template_int_end.cpp
/// Output: \verbinclude MatrixBase_template_int_end.out /// Output: \verbinclude MatrixBase_template_int_end.out
/// ///
/// \sa class Block /// \sa tail(NType), class Block
/// ///
template<int N> template<int N>
EIGEN_DEVICE_FUNC EIGEN_DEVICE_FUNC

34
test/indexed_view.cpp
View File

@ -280,9 +280,9 @@ void check_indexed_view()
// check mat(i,j) with weird types for i and j // check mat(i,j) with weird types for i and j
{ {
VERIFY_IS_APPROX( A(B.RowsAtCompileTime-1, 1), A(3,1) ); VERIFY_IS_APPROX( A(B.RowsAtCompileTime-1, 1), A(3,1) );
VERIFY_IS_APPROX( A(B.RowsAtCompileTime, 1), A(3,1) ); VERIFY_IS_APPROX( A(B.RowsAtCompileTime, 1), A(4,1) );
VERIFY_IS_APPROX( A(B.RowsAtCompileTime-1, B.ColsAtCompileTime-1), A(3,3) ); VERIFY_IS_APPROX( A(B.RowsAtCompileTime-1, B.ColsAtCompileTime-1), A(3,3) );
VERIFY_IS_APPROX( A(B.RowsAtCompileTime, B.ColsAtCompileTime), A(3,3) ); VERIFY_IS_APPROX( A(B.RowsAtCompileTime, B.ColsAtCompileTime), A(4,4) );
enum { I = 3, J = 4 }; enum { I = 3, J = 4 };
VERIFY_IS_APPROX( A(I,J), A(3,4) ); VERIFY_IS_APPROX( A(I,J), A(3,4) );
} }
@ -295,8 +295,38 @@ void check_indexed_view()
VERIFY( is_same_eq( A.block<Dynamic,4>(1,1,3,4), A.block(1,1,fix<Dynamic>(3),fix<4>)) ); VERIFY( is_same_eq( A.block<Dynamic,4>(1,1,3,4), A.block(1,1,fix<Dynamic>(3),fix<4>)) );
VERIFY( is_same_eq( A.block(1,1,3,4), A.block(1,1,fix<Dynamic>(3),fix<Dynamic>(4))) ); VERIFY( is_same_eq( A.block(1,1,3,4), A.block(1,1,fix<Dynamic>(3),fix<Dynamic>(4))) );
VERIFY( is_same_eq( A.topLeftCorner<3,4>(), A.topLeftCorner(fix<3>,fix<4>)) );
VERIFY( is_same_eq( A.bottomLeftCorner<3,4>(), A.bottomLeftCorner(fix<3>,fix<4>)) );
VERIFY( is_same_eq( A.bottomRightCorner<3,4>(), A.bottomRightCorner(fix<3>,fix<4>)) );
VERIFY( is_same_eq( A.topRightCorner<3,4>(), A.topRightCorner(fix<3>,fix<4>)) );
VERIFY( is_same_eq( A.leftCols<3>(), A.leftCols(fix<3>)) );
VERIFY( is_same_eq( A.rightCols<3>(), A.rightCols(fix<3>)) );
VERIFY( is_same_eq( A.middleCols<3>(1), A.middleCols(1,fix<3>)) );
VERIFY( is_same_eq( A.topRows<3>(), A.topRows(fix<3>)) );
VERIFY( is_same_eq( A.bottomRows<3>(), A.bottomRows(fix<3>)) );
VERIFY( is_same_eq( A.middleRows<3>(1), A.middleRows(1,fix<3>)) );
VERIFY( is_same_eq( a.segment<3>(1), a.segment(1,fix<3>)) );
VERIFY( is_same_eq( a.head<3>(), a.head(fix<3>)) );
VERIFY( is_same_eq( a.tail<3>(), a.tail(fix<3>)) );
const ArrayXXi& cA(A); const ArrayXXi& cA(A);
VERIFY( is_same_eq( cA.block<Dynamic,4>(1,1,3,4), cA.block(1,1,fix<Dynamic>(3),fix<4>)) ); VERIFY( is_same_eq( cA.block<Dynamic,4>(1,1,3,4), cA.block(1,1,fix<Dynamic>(3),fix<4>)) );
VERIFY( is_same_eq( cA.topLeftCorner<3,4>(), cA.topLeftCorner(fix<3>,fix<4>)) );
VERIFY( is_same_eq( cA.bottomLeftCorner<3,4>(), cA.bottomLeftCorner(fix<3>,fix<4>)) );
VERIFY( is_same_eq( cA.bottomRightCorner<3,4>(), cA.bottomRightCorner(fix<3>,fix<4>)) );
VERIFY( is_same_eq( cA.topRightCorner<3,4>(), cA.topRightCorner(fix<3>,fix<4>)) );
VERIFY( is_same_eq( cA.leftCols<3>(), cA.leftCols(fix<3>)) );
VERIFY( is_same_eq( cA.rightCols<3>(), cA.rightCols(fix<3>)) );
VERIFY( is_same_eq( cA.middleCols<3>(1), cA.middleCols(1,fix<3>)) );
VERIFY( is_same_eq( cA.topRows<3>(), cA.topRows(fix<3>)) );
VERIFY( is_same_eq( cA.bottomRows<3>(), cA.bottomRows(fix<3>)) );
VERIFY( is_same_eq( cA.middleRows<3>(1), cA.middleRows(1,fix<3>)) );
} }
} }