Attachment #407 for bug #579

This bugzilla service is closed. All entries have been migrated to https://gitlab.com/libeigen/eigen





/** \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.
  *


/** \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.
  *


/** \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.
  *


/** \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.
  *


/** \returns a block consisting of the top rows of *this.
  *
  * \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
  * Output: \verbinclude MatrixBase_template_int_topRows.out

  * \sa class Block, block(Index,Index,Index,Index)
  */
template<int N>
inline typename NRowsBlockXpr<N>::Type topRows(Index n = N)
{
  return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
}

/** This is the const version of topRows<int>().*/
template<int N>
inline typename ConstNRowsBlockXpr<N>::Type topRows(Index n = N) const
{
  return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
}




/** \returns a block consisting of the bottom rows of *this.
  *
  * \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
  * Output: \verbinclude MatrixBase_template_int_bottomRows.out

  * \sa class Block, block(Index,Index,Index,Index)
  */
template<int N>
inline typename NRowsBlockXpr<N>::Type bottomRows(Index n = N)
{
  return typename NRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
}

/** This is the const version of bottomRows<int>().*/
template<int N>
inline typename ConstNRowsBlockXpr<N>::Type bottomRows(Index n = N) const
{
  return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
}



/** \returns a block consisting of a range of rows of *this.
  *
  * \param startRow the index of the first row in the block
  * \param n the number of rows in the block
  *
  * Example: \include DenseBase_middleRows_int.cpp
  * Output: \verbinclude DenseBase_middleRows_int.out
  *
  * \sa class Block, block(Index,Index,Index,Index)
  */
inline RowsBlockXpr middleRows(Index startRow, Index n)
{
  return RowsBlockXpr(derived(), startRow, 0, n, cols());
}

/** This is the const version of middleRows(Index,Index).*/
inline ConstRowsBlockXpr middleRows(Index startRow, Index n) const
{
  return ConstRowsBlockXpr(derived(), startRow, 0, n, cols());
}

/** \returns a block consisting of a range of rows of *this.
  *
  * \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 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
  * Output: \verbinclude DenseBase_template_int_middleRows.out

  * \sa class Block, block(Index,Index,Index,Index)
  */
template<int N>
inline typename NRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N)
{
  return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
}

/** This is the const version of middleRows<int>().*/
template<int N>
inline typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N) const
{
  return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
}




/** \returns a block consisting of the left columns of *this.
  *
  * \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
  * Output: \verbinclude MatrixBase_template_int_leftCols.out

  * \sa class Block, block(Index,Index,Index,Index)
  */
template<int N>
inline typename NColsBlockXpr<N>::Type leftCols(Index n = N)
{
  return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
}

/** This is the const version of leftCols<int>().*/
template<int N>
inline typename ConstNColsBlockXpr<N>::Type leftCols(Index n = N) const
{
  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
}




/** \returns a block consisting of the right columns of *this.
  *
  * \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
  * Output: \verbinclude MatrixBase_template_int_rightCols.out

  * \sa class Block, block(Index,Index,Index,Index)
  */
template<int N>
inline typename NColsBlockXpr<N>::Type rightCols(Index n = N)
{
  return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
}

/** This is the const version of rightCols<int>().*/
template<int N>
inline typename ConstNColsBlockXpr<N>::Type rightCols(Index n = N) const
{
  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
}




/** \returns a block consisting of a range of columns of *this.
  *
  * \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 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
  * Output: \verbinclude DenseBase_template_int_middleCols.out

  * \sa class Block, block(Index,Index,Index,Index)
  */
template<int N>
inline typename NColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N)
{
  return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
}

/** This is the const version of middleCols<int>().*/
template<int N>
inline typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N) const
{
  return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
}




/** \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.
  *

  * \only_for_vectors
  *
  * \param start the first coefficient in the segment
  * \param n the number of coefficients in the segment
  *
  * Example: \include MatrixBase_segment_int_int.cpp
  * Output: \verbinclude MatrixBase_segment_int_int.out

  *
  * \sa class Block, segment(Index)
  */
inline SegmentReturnType segment(Index start, Index n)
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  return SegmentReturnType(derived(), start, n);
}


/** This is the const version of segment(Index,Index).*/
inline ConstSegmentReturnType segment(Index start, Index n) const
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  return ConstSegmentReturnType(derived(), start, n);
}

/** \returns a dynamic-size expression of the first coefficients of *this.
  *
  * \only_for_vectors
  *
  * \param n the number of coefficients in the segment
  *
  * Example: \include MatrixBase_start_int.cpp
  * Output: \verbinclude MatrixBase_start_int.out

  *
  * \sa class Block, block(Index,Index)
  */
inline SegmentReturnType head(Index n)
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  return SegmentReturnType(derived(), 0, n);
}

/** This is the const version of head(Index).*/
inline ConstSegmentReturnType head(Index n) const
  head(Index vecSize) const
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  return ConstSegmentReturnType(derived(), 0, n);
}

/** \returns a dynamic-size expression of the last coefficients of *this.
  *
  * \only_for_vectors
  *
  * \param n the number of coefficients in the segment
  *
  * Example: \include MatrixBase_end_int.cpp
  * Output: \verbinclude MatrixBase_end_int.out

  *
  * \sa class Block, block(Index,Index)
  */
inline SegmentReturnType tail(Index n)
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  return SegmentReturnType(derived(), this->size() - n, n);
}

/** This is the const version of tail(Index).*/
inline ConstSegmentReturnType tail(Index n) const
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  return ConstSegmentReturnType(derived(), this->size() - n, n);
}

/** \returns a fixed-size expression of a segment (i.e. a vector block) in \c *this
  *
  * \only_for_vectors
  *
  * \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
  *
  * 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
  * Output: \verbinclude MatrixBase_template_int_segment.out
  *
  * \sa class Block
  */
template<int N>
inline typename FixedSegmentReturnType<N>::Type segment(Index start, Index n = N)
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  return typename FixedSegmentReturnType<N>::Type(derived(), start, n);
}

/** This is the const version of segment<int>(Index).*/
template<int N>
inline typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index n = N) const
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  return typename ConstFixedSegmentReturnType<N>::Type(derived(), start, n);
}

/** \returns a fixed-size expression of the first coefficients of *this.
  *
  * \only_for_vectors
  *
  * \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
  * Output: \verbinclude MatrixBase_template_int_start.out
  *
  * \sa class Block
  */
template<int N>
inline typename FixedSegmentReturnType<N>::Type head(Index n = N)
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  return typename FixedSegmentReturnType<N>::Type(derived(), 0, n);
}

/** This is the const version of head<int>().*/
template<int N>
inline typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  return typename ConstFixedSegmentReturnType<N>::Type(derived(), 0, n);
}

/** \returns a fixed-size expression of the last coefficients of *this.
  *
  * \only_for_vectors
  *
  * \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
  * Output: \verbinclude MatrixBase_template_int_end.out
  *
  * \sa class Block
  */
template<int N>
inline typename FixedSegmentReturnType<N>::Type tail(Index n = N)
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  return typename FixedSegmentReturnType<N>::Type(derived(), size() - n);
}

/** This is the const version of tail<int>.*/
template<int N>
inline typename ConstFixedSegmentReturnType<N>::Type tail(Index n = N) const
{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  return typename ConstFixedSegmentReturnType<N>::Type(derived(), size() - n);
}

Return to bug 579