GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-07-09 14:41:49 +08:00
Code Issues Packages Projects Releases Wiki Activity

Added optional run-time size parameters to fixed-size block methods

Browse Source
This commit is contained in:
Márton Danóczy 2013-12-17 01:05:05 +01:00
parent 7c1fc0ee7c
commit cdedc9e90d
1 changed files with 137 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -113,13 +113,13 @@ inline const Block<const Derived, CRows, CCols> topRightCorner() const
/** \returns an expression of a top-right corner of *this. /** \returns an expression of a top-right corner of *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
* \param cRows number of rows in corner as specified at run 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 * \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 * 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 * 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 * 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. * \a CRows is \a Dynamic, and the same for the number of columns.
* *
@ -188,13 +188,13 @@ inline const Block<const Derived, CRows, CCols> topLeftCorner() const
/** \returns an expression of a top-left corner of *this. /** \returns an expression of a top-left corner of *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
* \param cRows number of rows in corner as specified at run 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 * \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 * 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 * 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 * 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. * \a CRows is \a Dynamic, and the same for the number of columns.
* *
@ -263,13 +263,13 @@ inline const Block<const Derived, CRows, CCols> bottomRightCorner() const
/** \returns an expression of a bottom-right corner of *this. /** \returns an expression of a bottom-right corner of *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
* \param cRows number of rows in corner as specified at run 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 * \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 * 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 * 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 * 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. * \a CRows is \a Dynamic, and the same for the number of columns.
* *
@ -338,13 +338,13 @@ inline const Block<const Derived, CRows, CCols> bottomLeftCorner() const
/** \returns an expression of a bottom-left corner of *this. /** \returns an expression of a bottom-left corner of *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
* \param cRows number of rows in corner as specified at run 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 * \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 * 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 * 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 * 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. * \a CRows is \a Dynamic, and the same for the number of columns.
* *
@ -390,7 +390,11 @@ inline ConstRowsBlockXpr topRows(Index n) const
/** \returns a block consisting of the top rows of *this. /** \returns a block consisting of the top rows of *this.
* *
* \tparam N the number of rows in the block * \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
*
* The compile-time and run-time information should not contradict. In other words,
* \a n should equal \a N unless \a N is \a Dynamic.
* *
* Example: \include MatrixBase_template_int_topRows.cpp * Example: \include MatrixBase_template_int_topRows.cpp
* Output: \verbinclude MatrixBase_template_int_topRows.out * Output: \verbinclude MatrixBase_template_int_topRows.out
@ -398,16 +402,16 @@ inline ConstRowsBlockXpr topRows(Index n) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int N> template<int N>
inline typename NRowsBlockXpr<N>::Type topRows() inline typename NRowsBlockXpr<N>::Type topRows(Index n = N)
{ {
return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, N, cols()); return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
} }
/** This is the const version of topRows<int>().*/ /** This is the const version of topRows<int>().*/
template<int N> template<int N>
inline typename ConstNRowsBlockXpr<N>::Type topRows() const inline typename ConstNRowsBlockXpr<N>::Type topRows(Index n = N) const
{ {
return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, N, cols()); return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
} }
@ -434,7 +438,11 @@ inline ConstRowsBlockXpr bottomRows(Index n) const
/** \returns a block consisting of the bottom rows of *this. /** \returns a block consisting of the bottom rows of *this.
* *
* \tparam N the number of rows in the block * \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
*
* The compile-time and run-time information should not contradict. In other words,
* \a n should equal \a N unless \a N is \a Dynamic.
* *
* Example: \include MatrixBase_template_int_bottomRows.cpp * Example: \include MatrixBase_template_int_bottomRows.cpp
* Output: \verbinclude MatrixBase_template_int_bottomRows.out * Output: \verbinclude MatrixBase_template_int_bottomRows.out
@ -442,16 +450,16 @@ inline ConstRowsBlockXpr bottomRows(Index n) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int N> template<int N>
inline typename NRowsBlockXpr<N>::Type bottomRows() inline typename NRowsBlockXpr<N>::Type bottomRows(Index n = N)
{ {
return typename NRowsBlockXpr<N>::Type(derived(), rows() - N, 0, N, cols()); return typename NRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
} }
/** This is the const version of bottomRows<int>().*/ /** This is the const version of bottomRows<int>().*/
template<int N> template<int N>
inline typename ConstNRowsBlockXpr<N>::Type bottomRows() const inline typename ConstNRowsBlockXpr<N>::Type bottomRows(Index n = N) const
{ {
return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - N, 0, N, cols()); return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
} }
@ -459,28 +467,32 @@ inline typename ConstNRowsBlockXpr<N>::Type bottomRows() const
/** \returns a block consisting of a range of rows of *this. /** \returns a block consisting of a range of rows of *this.
* *
* \param startRow the index of the first row in the block * \param startRow the index of the first row in the block
* \param numRows the number of rows in the block * \param n the number of rows in the block
* *
* Example: \include DenseBase_middleRows_int.cpp * Example: \include DenseBase_middleRows_int.cpp
* Output: \verbinclude DenseBase_middleRows_int.out * Output: \verbinclude DenseBase_middleRows_int.out
* *
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
inline RowsBlockXpr middleRows(Index startRow, Index numRows) inline RowsBlockXpr middleRows(Index startRow, Index n)
{ {
return RowsBlockXpr(derived(), startRow, 0, numRows, cols()); return RowsBlockXpr(derived(), startRow, 0, n, cols());
} }
/** This is the const version of middleRows(Index,Index).*/ /** This is the const version of middleRows(Index,Index).*/
inline ConstRowsBlockXpr middleRows(Index startRow, Index numRows) const inline ConstRowsBlockXpr middleRows(Index startRow, Index n) const
{ {
return ConstRowsBlockXpr(derived(), startRow, 0, numRows, cols()); return ConstRowsBlockXpr(derived(), startRow, 0, n, cols());
} }
/** \returns a block consisting of a range of rows of *this. /** \returns a block consisting of a range of rows of *this.
* *
* \tparam N the number of rows in the block * \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
* \param n the number of rows in the block as specified at run-time
*
* The compile-time and run-time information should not contradict. In other words,
* \a n should equal \a N unless \a N is \a Dynamic.
* *
* Example: \include DenseBase_template_int_middleRows.cpp * Example: \include DenseBase_template_int_middleRows.cpp
* Output: \verbinclude DenseBase_template_int_middleRows.out * Output: \verbinclude DenseBase_template_int_middleRows.out
@ -488,16 +500,16 @@ inline ConstRowsBlockXpr middleRows(Index startRow, Index numRows) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int N> template<int N>
inline typename NRowsBlockXpr<N>::Type middleRows(Index startRow) inline typename NRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N)
{ {
return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, N, cols()); return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
} }
/** This is the const version of middleRows<int>().*/ /** This is the const version of middleRows<int>().*/
template<int N> template<int N>
inline typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow) const inline typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N) const
{ {
return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, N, cols()); return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
} }
@ -524,7 +536,11 @@ inline ConstColsBlockXpr leftCols(Index n) const
/** \returns a block consisting of the left columns of *this. /** \returns a block consisting of the left columns of *this.
* *
* \tparam N the number of columns in the block * \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
*
* The compile-time and run-time information should not contradict. In other words,
* \a n should equal \a N unless \a N is \a Dynamic.
* *
* Example: \include MatrixBase_template_int_leftCols.cpp * Example: \include MatrixBase_template_int_leftCols.cpp
* Output: \verbinclude MatrixBase_template_int_leftCols.out * Output: \verbinclude MatrixBase_template_int_leftCols.out
@ -532,16 +548,16 @@ inline ConstColsBlockXpr leftCols(Index n) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int N> template<int N>
inline typename NColsBlockXpr<N>::Type leftCols() inline typename NColsBlockXpr<N>::Type leftCols(Index n = N)
{ {
return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), N); return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
} }
/** This is the const version of leftCols<int>().*/ /** This is the const version of leftCols<int>().*/
template<int N> template<int N>
inline typename ConstNColsBlockXpr<N>::Type leftCols() const inline typename ConstNColsBlockXpr<N>::Type leftCols(Index n = N) const
{ {
return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), N); return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
} }
@ -568,7 +584,11 @@ inline ConstColsBlockXpr rightCols(Index n) const
/** \returns a block consisting of the right columns of *this. /** \returns a block consisting of the right columns of *this.
* *
* \tparam N the number of columns in the block * \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
*
* The compile-time and run-time information should not contradict. In other words,
* \a n should equal \a N unless \a N is \a Dynamic.
* *
* Example: \include MatrixBase_template_int_rightCols.cpp * Example: \include MatrixBase_template_int_rightCols.cpp
* Output: \verbinclude MatrixBase_template_int_rightCols.out * Output: \verbinclude MatrixBase_template_int_rightCols.out
@ -576,16 +596,16 @@ inline ConstColsBlockXpr rightCols(Index n) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int N> template<int N>
inline typename NColsBlockXpr<N>::Type rightCols() inline typename NColsBlockXpr<N>::Type rightCols(Index n = N)
{ {
return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - N, rows(), N); return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
} }
/** This is the const version of rightCols<int>().*/ /** This is the const version of rightCols<int>().*/
template<int N> template<int N>
inline typename ConstNColsBlockXpr<N>::Type rightCols() const inline typename ConstNColsBlockXpr<N>::Type rightCols(Index n = N) const
{ {
return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - N, rows(), N); return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
} }
@ -613,8 +633,12 @@ inline ConstColsBlockXpr middleCols(Index startCol, Index numCols) const
/** \returns a block consisting of a range of columns of *this. /** \returns a block consisting of a range of columns of *this.
* *
* \tparam N the number of columns in the block * \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
* \param n the number of columns in the block as specified at run-time
*
* The compile-time and run-time information should not contradict. In other words,
* \a n should equal \a N unless \a N is \a Dynamic.
* *
* Example: \include DenseBase_template_int_middleCols.cpp * Example: \include DenseBase_template_int_middleCols.cpp
* Output: \verbinclude DenseBase_template_int_middleCols.out * Output: \verbinclude DenseBase_template_int_middleCols.out
@ -622,16 +646,16 @@ inline ConstColsBlockXpr middleCols(Index startCol, Index numCols) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int N> template<int N>
inline typename NColsBlockXpr<N>::Type middleCols(Index startCol) inline typename NColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N)
{ {
return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), N); return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
} }
/** This is the const version of middleCols<int>().*/ /** This is the const version of middleCols<int>().*/
template<int N> template<int N>
inline typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol) const inline typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N) const
{ {
return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), N); return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
} }
@ -667,15 +691,15 @@ inline const Block<const Derived, BlockRows, BlockCols> block(Index startRow, In
/** \returns an expression of a block in *this. /** \returns an expression of a block in *this.
* *
* \tparam BlockRows number of rows in block as specified at compile time * \tparam BlockRows number of rows in block as specified at compile-time
* \tparam BlockCols number of columns 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 startRow the first row in the block
* \param startCol the first column in the block * \param startCol the first column in the block
* \param blockRows number of rows in block as specified at run time * \param blockRows number of rows in block as specified at run-time
* \param blockCols number of columns 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 * 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 * 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 * 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. * \a BlockRows is \a Dynamic, and the same for the number of columns.
* *
@ -738,7 +762,7 @@ inline ConstRowXpr row(Index i) const
* \only_for_vectors * \only_for_vectors
* *
* \param start the first coefficient in the segment * \param start the first coefficient in the segment
* \param vecSize the number of coefficients in the segment * \param n the number of coefficients in the segment
* *
* 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
@ -749,25 +773,25 @@ inline ConstRowXpr row(Index i) const
* *
* \sa class Block, segment(Index) * \sa class Block, segment(Index)
*/ */
inline SegmentReturnType segment(Index start, Index vecSize) inline SegmentReturnType segment(Index start, Index n)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return SegmentReturnType(derived(), start, vecSize); return SegmentReturnType(derived(), start, n);
} }
/** This is the const version of segment(Index,Index).*/ /** This is the const version of segment(Index,Index).*/
inline ConstSegmentReturnType segment(Index start, Index vecSize) const inline ConstSegmentReturnType segment(Index start, Index n) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return ConstSegmentReturnType(derived(), start, vecSize); return ConstSegmentReturnType(derived(), start, n);
} }
/** \returns a dynamic-size expression of the first coefficients of *this. /** \returns a dynamic-size expression of the first coefficients of *this.
* *
* \only_for_vectors * \only_for_vectors
* *
* \param vecSize the number of coefficients in the block * \param n the number of coefficients in the segment
* *
* Example: \include MatrixBase_start_int.cpp * Example: \include MatrixBase_start_int.cpp
* Output: \verbinclude MatrixBase_start_int.out * Output: \verbinclude MatrixBase_start_int.out
@ -778,25 +802,24 @@ inline ConstSegmentReturnType segment(Index start, Index vecSize) const
* *
* \sa class Block, block(Index,Index) * \sa class Block, block(Index,Index)
*/ */
inline SegmentReturnType head(Index vecSize) inline SegmentReturnType head(Index n)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return SegmentReturnType(derived(), 0, vecSize); return SegmentReturnType(derived(), 0, n);
} }
/** This is the const version of head(Index).*/ /** This is the const version of head(Index).*/
inline ConstSegmentReturnType inline ConstSegmentReturnType head(Index n) const
head(Index vecSize) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return ConstSegmentReturnType(derived(), 0, vecSize); return ConstSegmentReturnType(derived(), 0, n);
} }
/** \returns a dynamic-size expression of the last coefficients of *this. /** \returns a dynamic-size expression of the last coefficients of *this.
* *
* \only_for_vectors * \only_for_vectors
* *
* \param vecSize the number of coefficients in the block * \param n the number of coefficients in the segment
* *
* Example: \include MatrixBase_end_int.cpp * Example: \include MatrixBase_end_int.cpp
* Output: \verbinclude MatrixBase_end_int.out * Output: \verbinclude MatrixBase_end_int.out
@ -807,95 +830,106 @@ inline ConstSegmentReturnType
* *
* \sa class Block, block(Index,Index) * \sa class Block, block(Index,Index)
*/ */
inline SegmentReturnType tail(Index vecSize) inline SegmentReturnType tail(Index n)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return SegmentReturnType(derived(), this->size() - vecSize, vecSize); return SegmentReturnType(derived(), this->size() - n, n);
} }
/** This is the const version of tail(Index).*/ /** This is the const version of tail(Index).*/
inline ConstSegmentReturnType tail(Index vecSize) const inline ConstSegmentReturnType tail(Index n) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return ConstSegmentReturnType(derived(), this->size() - vecSize, vecSize); return ConstSegmentReturnType(derived(), this->size() - n, 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
* *
* \only_for_vectors * \only_for_vectors
* *
* The template parameter \a Size is the number of coefficients in the block * \tparam N the number of coefficients in the segment as specified at compile-time
* \param start the index of the first element in the segment
* \param n the number of coefficients in the segment as specified at compile-time
* *
* \param start the index of the first element of the sub-vector * The compile-time and run-time information should not contradict. In other words,
* \a n should equal \a N unless \a N is \a Dynamic.
* *
* 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 class Block
*/ */
template<int Size> template<int N>
inline typename FixedSegmentReturnType<Size>::Type segment(Index start) inline typename FixedSegmentReturnType<N>::Type segment(Index start, Index n = N)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return typename FixedSegmentReturnType<Size>::Type(derived(), start); return typename FixedSegmentReturnType<N>::Type(derived(), start, n);
} }
/** This is the const version of segment<int>(Index).*/ /** This is the const version of segment<int>(Index).*/
template<int Size> template<int N>
inline typename ConstFixedSegmentReturnType<Size>::Type segment(Index start) const inline typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index n = N) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return typename ConstFixedSegmentReturnType<Size>::Type(derived(), start); 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 *this.
* *
* \only_for_vectors * \only_for_vectors
* *
* The template parameter \a Size is the number of coefficients in the block * \tparam N the number of coefficients in the segment as specified at compile-time
* \param n the number of coefficients in the segment as specified at run-time
*
* The compile-time and run-time information should not contradict. In other words,
* \a n should equal \a N unless \a N is \a Dynamic.
* *
* 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 class Block
*/ */
template<int Size> template<int N>
inline typename FixedSegmentReturnType<Size>::Type head() inline typename FixedSegmentReturnType<N>::Type head(Index n = N)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return typename FixedSegmentReturnType<Size>::Type(derived(), 0); return typename FixedSegmentReturnType<N>::Type(derived(), 0, n);
} }
/** This is the const version of head<int>().*/ /** This is the const version of head<int>().*/
template<int Size> template<int N>
inline typename ConstFixedSegmentReturnType<Size>::Type head() const inline typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return typename ConstFixedSegmentReturnType<Size>::Type(derived(), 0); 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 *this.
* *
* \only_for_vectors * \only_for_vectors
* *
* The template parameter \a Size is the number of coefficients in the block * \tparam N the number of coefficients in the segment as specified at compile-time
* \param n the number of coefficients in the segment as specified at run-time
*
* The compile-time and run-time information should not contradict. In other words,
* \a n should equal \a N unless \a N is \a Dynamic.
* *
* 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 class Block
*/ */
template<int Size> template<int N>
inline typename FixedSegmentReturnType<Size>::Type tail() inline typename FixedSegmentReturnType<N>::Type tail(Index n = N)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return typename FixedSegmentReturnType<Size>::Type(derived(), size() - Size); return typename FixedSegmentReturnType<N>::Type(derived(), size() - n);
} }
/** This is the const version of tail<int>.*/ /** This is the const version of tail<int>.*/
template<int Size> template<int N>
inline typename ConstFixedSegmentReturnType<Size>::Type tail() const inline typename ConstFixedSegmentReturnType<N>::Type tail(Index n = N) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return typename ConstFixedSegmentReturnType<Size>::Type(derived(), size() - Size); return typename ConstFixedSegmentReturnType<N>::Type(derived(), size() - n);
} }