1// This file is part of Eigen, a lightweight C++ template library 2// for linear algebra. 3// 4// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr> 5// Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1@gmail.com> 6// 7// This Source Code Form is subject to the terms of the Mozilla 8// Public License v. 2.0. If a copy of the MPL was not distributed 9// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 11#ifndef EIGEN_PARSED_BY_DOXYGEN 12 13/// \internal expression type of a column */ 14typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr; 15typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ConstColXpr; 16/// \internal expression type of a row */ 17typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr; 18typedef const Block<const Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowXpr; 19/// \internal expression type of a block of whole columns */ 20typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr; 21typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ConstColsBlockXpr; 22/// \internal expression type of a block of whole rows */ 23typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr; 24typedef const Block<const Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowsBlockXpr; 25/// \internal expression type of a block of whole columns */ 26template<int N> struct NColsBlockXpr { typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; }; 27template<int N> struct ConstNColsBlockXpr { typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; }; 28/// \internal expression type of a block of whole rows */ 29template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; }; 30template<int N> struct ConstNRowsBlockXpr { typedef const Block<const Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; }; 31/// \internal expression of a block */ 32typedef Block<Derived> BlockXpr; 33typedef const Block<const Derived> ConstBlockXpr; 34/// \internal expression of a block of fixed sizes */ 35template<int Rows, int Cols> struct FixedBlockXpr { typedef Block<Derived,Rows,Cols> Type; }; 36template<int Rows, int Cols> struct ConstFixedBlockXpr { typedef Block<const Derived,Rows,Cols> Type; }; 37 38typedef VectorBlock<Derived> SegmentReturnType; 39typedef const VectorBlock<const Derived> ConstSegmentReturnType; 40template<int Size> struct FixedSegmentReturnType { typedef VectorBlock<Derived, Size> Type; }; 41template<int Size> struct ConstFixedSegmentReturnType { typedef const VectorBlock<const Derived, Size> Type; }; 42 43#endif // not EIGEN_PARSED_BY_DOXYGEN 44 45/// \returns a dynamic-size expression of a block in *this. 46/// 47/// \param startRow the first row in the block 48/// \param startCol the first column in the block 49/// \param blockRows the number of rows in the block 50/// \param blockCols the number of columns in the block 51/// 52/// Example: \include MatrixBase_block_int_int_int_int.cpp 53/// Output: \verbinclude MatrixBase_block_int_int_int_int.out 54/// 55/// \note Even though the returned expression has dynamic size, in the case 56/// when it is applied to a fixed-size matrix, it inherits a fixed maximal size, 57/// which means that evaluating it does not cause a dynamic memory allocation. 58/// 59EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 60/// 61/// \sa class Block, block(Index,Index) 62/// 63EIGEN_DEVICE_FUNC 64inline BlockXpr block(Index startRow, Index startCol, Index blockRows, Index blockCols) 65{ 66 return BlockXpr(derived(), startRow, startCol, blockRows, blockCols); 67} 68 69/// This is the const version of block(Index,Index,Index,Index). */ 70EIGEN_DEVICE_FUNC 71inline const ConstBlockXpr block(Index startRow, Index startCol, Index blockRows, Index blockCols) const 72{ 73 return ConstBlockXpr(derived(), startRow, startCol, blockRows, blockCols); 74} 75 76 77 78 79/// \returns a dynamic-size expression of a top-right corner of *this. 80/// 81/// \param cRows the number of rows in the corner 82/// \param cCols the number of columns in the corner 83/// 84/// Example: \include MatrixBase_topRightCorner_int_int.cpp 85/// Output: \verbinclude MatrixBase_topRightCorner_int_int.out 86/// 87EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 88/// 89/// \sa class Block, block(Index,Index,Index,Index) 90/// 91EIGEN_DEVICE_FUNC 92inline BlockXpr topRightCorner(Index cRows, Index cCols) 93{ 94 return BlockXpr(derived(), 0, cols() - cCols, cRows, cCols); 95} 96 97/// This is the const version of topRightCorner(Index, Index). 98EIGEN_DEVICE_FUNC 99inline const ConstBlockXpr topRightCorner(Index cRows, Index cCols) const 100{ 101 return ConstBlockXpr(derived(), 0, cols() - cCols, cRows, cCols); 102} 103 104/// \returns an expression of a fixed-size top-right corner of *this. 105/// 106/// \tparam CRows the number of rows in the corner 107/// \tparam CCols the number of columns in the corner 108/// 109/// Example: \include MatrixBase_template_int_int_topRightCorner.cpp 110/// Output: \verbinclude MatrixBase_template_int_int_topRightCorner.out 111/// 112EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 113/// 114/// \sa class Block, block<int,int>(Index,Index) 115/// 116template<int CRows, int CCols> 117EIGEN_DEVICE_FUNC 118inline typename FixedBlockXpr<CRows,CCols>::Type topRightCorner() 119{ 120 return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols); 121} 122 123/// This is the const version of topRightCorner<int, int>(). 124template<int CRows, int CCols> 125EIGEN_DEVICE_FUNC 126inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner() const 127{ 128 return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols); 129} 130 131/// \returns an expression of a top-right corner of *this. 132/// 133/// \tparam CRows number of rows in corner as specified at compile-time 134/// \tparam CCols number of columns in corner as specified at compile-time 135/// \param cRows number of rows in corner as specified at run-time 136/// \param cCols number of columns in corner as specified at run-time 137/// 138/// This function is mainly useful for corners where the number of rows is specified at compile-time 139/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time 140/// information should not contradict. In other words, \a cRows should equal \a CRows unless 141/// \a CRows is \a Dynamic, and the same for the number of columns. 142/// 143/// Example: \include MatrixBase_template_int_int_topRightCorner_int_int.cpp 144/// Output: \verbinclude MatrixBase_template_int_int_topRightCorner_int_int.out 145/// 146EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 147/// 148/// \sa class Block 149/// 150template<int CRows, int CCols> 151inline typename FixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols) 152{ 153 return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols); 154} 155 156/// This is the const version of topRightCorner<int, int>(Index, Index). 157template<int CRows, int CCols> 158inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols) const 159{ 160 return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols); 161} 162 163 164 165/// \returns a dynamic-size expression of a top-left corner of *this. 166/// 167/// \param cRows the number of rows in the corner 168/// \param cCols the number of columns in the corner 169/// 170/// Example: \include MatrixBase_topLeftCorner_int_int.cpp 171/// Output: \verbinclude MatrixBase_topLeftCorner_int_int.out 172/// 173EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 174/// 175/// \sa class Block, block(Index,Index,Index,Index) 176/// 177EIGEN_DEVICE_FUNC 178inline BlockXpr topLeftCorner(Index cRows, Index cCols) 179{ 180 return BlockXpr(derived(), 0, 0, cRows, cCols); 181} 182 183/// This is the const version of topLeftCorner(Index, Index). 184EIGEN_DEVICE_FUNC 185inline const ConstBlockXpr topLeftCorner(Index cRows, Index cCols) const 186{ 187 return ConstBlockXpr(derived(), 0, 0, cRows, cCols); 188} 189 190/// \returns an expression of a fixed-size top-left corner of *this. 191/// 192/// The template parameters CRows and CCols are the number of rows and columns in the corner. 193/// 194/// Example: \include MatrixBase_template_int_int_topLeftCorner.cpp 195/// Output: \verbinclude MatrixBase_template_int_int_topLeftCorner.out 196/// 197EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 198/// 199/// \sa class Block, block(Index,Index,Index,Index) 200/// 201template<int CRows, int CCols> 202EIGEN_DEVICE_FUNC 203inline typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner() 204{ 205 return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0); 206} 207 208/// This is the const version of topLeftCorner<int, int>(). 209template<int CRows, int CCols> 210EIGEN_DEVICE_FUNC 211inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner() const 212{ 213 return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0); 214} 215 216/// \returns an expression of a top-left corner of *this. 217/// 218/// \tparam CRows number of rows in corner as specified at compile-time 219/// \tparam CCols number of columns in corner as specified at compile-time 220/// \param cRows number of rows in corner as specified at run-time 221/// \param cCols number of columns in corner as specified at run-time 222/// 223/// This function is mainly useful for corners where the number of rows is specified at compile-time 224/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time 225/// information should not contradict. In other words, \a cRows should equal \a CRows unless 226/// \a CRows is \a Dynamic, and the same for the number of columns. 227/// 228/// Example: \include MatrixBase_template_int_int_topLeftCorner_int_int.cpp 229/// Output: \verbinclude MatrixBase_template_int_int_topLeftCorner_int_int.out 230/// 231EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 232/// 233/// \sa class Block 234/// 235template<int CRows, int CCols> 236inline typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols) 237{ 238 return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols); 239} 240 241/// This is the const version of topLeftCorner<int, int>(Index, Index). 242template<int CRows, int CCols> 243inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols) const 244{ 245 return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols); 246} 247 248 249 250/// \returns a dynamic-size expression of a bottom-right corner of *this. 251/// 252/// \param cRows the number of rows in the corner 253/// \param cCols the number of columns in the corner 254/// 255/// Example: \include MatrixBase_bottomRightCorner_int_int.cpp 256/// Output: \verbinclude MatrixBase_bottomRightCorner_int_int.out 257/// 258EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 259/// 260/// \sa class Block, block(Index,Index,Index,Index) 261/// 262EIGEN_DEVICE_FUNC 263inline BlockXpr bottomRightCorner(Index cRows, Index cCols) 264{ 265 return BlockXpr(derived(), rows() - cRows, cols() - cCols, cRows, cCols); 266} 267 268/// This is the const version of bottomRightCorner(Index, Index). 269EIGEN_DEVICE_FUNC 270inline const ConstBlockXpr bottomRightCorner(Index cRows, Index cCols) const 271{ 272 return ConstBlockXpr(derived(), rows() - cRows, cols() - cCols, cRows, cCols); 273} 274 275/// \returns an expression of a fixed-size bottom-right corner of *this. 276/// 277/// The template parameters CRows and CCols are the number of rows and columns in the corner. 278/// 279/// Example: \include MatrixBase_template_int_int_bottomRightCorner.cpp 280/// Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner.out 281/// 282EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 283/// 284/// \sa class Block, block(Index,Index,Index,Index) 285/// 286template<int CRows, int CCols> 287EIGEN_DEVICE_FUNC 288inline typename FixedBlockXpr<CRows,CCols>::Type bottomRightCorner() 289{ 290 return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols); 291} 292 293/// This is the const version of bottomRightCorner<int, int>(). 294template<int CRows, int CCols> 295EIGEN_DEVICE_FUNC 296inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner() const 297{ 298 return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols); 299} 300 301/// \returns an expression of a bottom-right corner of *this. 302/// 303/// \tparam CRows number of rows in corner as specified at compile-time 304/// \tparam CCols number of columns in corner as specified at compile-time 305/// \param cRows number of rows in corner as specified at run-time 306/// \param cCols number of columns in corner as specified at run-time 307/// 308/// This function is mainly useful for corners where the number of rows is specified at compile-time 309/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time 310/// information should not contradict. In other words, \a cRows should equal \a CRows unless 311/// \a CRows is \a Dynamic, and the same for the number of columns. 312/// 313/// Example: \include MatrixBase_template_int_int_bottomRightCorner_int_int.cpp 314/// Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner_int_int.out 315/// 316EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 317/// 318/// \sa class Block 319/// 320template<int CRows, int CCols> 321inline typename FixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols) 322{ 323 return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols); 324} 325 326/// This is the const version of bottomRightCorner<int, int>(Index, Index). 327template<int CRows, int CCols> 328inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols) const 329{ 330 return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols); 331} 332 333 334 335/// \returns a dynamic-size expression of a bottom-left corner of *this. 336/// 337/// \param cRows the number of rows in the corner 338/// \param cCols the number of columns in the corner 339/// 340/// Example: \include MatrixBase_bottomLeftCorner_int_int.cpp 341/// Output: \verbinclude MatrixBase_bottomLeftCorner_int_int.out 342/// 343EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 344/// 345/// \sa class Block, block(Index,Index,Index,Index) 346/// 347EIGEN_DEVICE_FUNC 348inline BlockXpr bottomLeftCorner(Index cRows, Index cCols) 349{ 350 return BlockXpr(derived(), rows() - cRows, 0, cRows, cCols); 351} 352 353/// This is the const version of bottomLeftCorner(Index, Index). 354EIGEN_DEVICE_FUNC 355inline const ConstBlockXpr bottomLeftCorner(Index cRows, Index cCols) const 356{ 357 return ConstBlockXpr(derived(), rows() - cRows, 0, cRows, cCols); 358} 359 360/// \returns an expression of a fixed-size bottom-left corner of *this. 361/// 362/// The template parameters CRows and CCols are the number of rows and columns in the corner. 363/// 364/// Example: \include MatrixBase_template_int_int_bottomLeftCorner.cpp 365/// Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner.out 366/// 367EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 368/// 369/// \sa class Block, block(Index,Index,Index,Index) 370/// 371template<int CRows, int CCols> 372EIGEN_DEVICE_FUNC 373inline typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner() 374{ 375 return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0); 376} 377 378/// This is the const version of bottomLeftCorner<int, int>(). 379template<int CRows, int CCols> 380EIGEN_DEVICE_FUNC 381inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner() const 382{ 383 return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0); 384} 385 386/// \returns an expression of a bottom-left corner of *this. 387/// 388/// \tparam CRows number of rows in corner as specified at compile-time 389/// \tparam CCols number of columns in corner as specified at compile-time 390/// \param cRows number of rows in corner as specified at run-time 391/// \param cCols number of columns in corner as specified at run-time 392/// 393/// This function is mainly useful for corners where the number of rows is specified at compile-time 394/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time 395/// information should not contradict. In other words, \a cRows should equal \a CRows unless 396/// \a CRows is \a Dynamic, and the same for the number of columns. 397/// 398/// Example: \include MatrixBase_template_int_int_bottomLeftCorner_int_int.cpp 399/// Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner_int_int.out 400/// 401EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 402/// 403/// \sa class Block 404/// 405template<int CRows, int CCols> 406inline typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols) 407{ 408 return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols); 409} 410 411/// This is the const version of bottomLeftCorner<int, int>(Index, Index). 412template<int CRows, int CCols> 413inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols) const 414{ 415 return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols); 416} 417 418 419 420/// \returns a block consisting of the top rows of *this. 421/// 422/// \param n the number of rows in the block 423/// 424/// Example: \include MatrixBase_topRows_int.cpp 425/// Output: \verbinclude MatrixBase_topRows_int.out 426/// 427EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 428/// 429/// \sa class Block, block(Index,Index,Index,Index) 430/// 431EIGEN_DEVICE_FUNC 432inline RowsBlockXpr topRows(Index n) 433{ 434 return RowsBlockXpr(derived(), 0, 0, n, cols()); 435} 436 437/// This is the const version of topRows(Index). 438EIGEN_DEVICE_FUNC 439inline ConstRowsBlockXpr topRows(Index n) const 440{ 441 return ConstRowsBlockXpr(derived(), 0, 0, n, cols()); 442} 443 444/// \returns a block consisting of the top rows of *this. 445/// 446/// \tparam N the number of rows in the block as specified at compile-time 447/// \param n the number of rows in the block as specified at run-time 448/// 449/// The compile-time and run-time information should not contradict. In other words, 450/// \a n should equal \a N unless \a N is \a Dynamic. 451/// 452/// Example: \include MatrixBase_template_int_topRows.cpp 453/// Output: \verbinclude MatrixBase_template_int_topRows.out 454/// 455EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 456/// 457/// \sa class Block, block(Index,Index,Index,Index) 458/// 459template<int N> 460EIGEN_DEVICE_FUNC 461inline typename NRowsBlockXpr<N>::Type topRows(Index n = N) 462{ 463 return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols()); 464} 465 466/// This is the const version of topRows<int>(). 467template<int N> 468EIGEN_DEVICE_FUNC 469inline typename ConstNRowsBlockXpr<N>::Type topRows(Index n = N) const 470{ 471 return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols()); 472} 473 474 475 476/// \returns a block consisting of the bottom rows of *this. 477/// 478/// \param n the number of rows in the block 479/// 480/// Example: \include MatrixBase_bottomRows_int.cpp 481/// Output: \verbinclude MatrixBase_bottomRows_int.out 482/// 483EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 484/// 485/// \sa class Block, block(Index,Index,Index,Index) 486/// 487EIGEN_DEVICE_FUNC 488inline RowsBlockXpr bottomRows(Index n) 489{ 490 return RowsBlockXpr(derived(), rows() - n, 0, n, cols()); 491} 492 493/// This is the const version of bottomRows(Index). 494EIGEN_DEVICE_FUNC 495inline ConstRowsBlockXpr bottomRows(Index n) const 496{ 497 return ConstRowsBlockXpr(derived(), rows() - n, 0, n, cols()); 498} 499 500/// \returns a block consisting of the bottom rows of *this. 501/// 502/// \tparam N the number of rows in the block as specified at compile-time 503/// \param n the number of rows in the block as specified at run-time 504/// 505/// The compile-time and run-time information should not contradict. In other words, 506/// \a n should equal \a N unless \a N is \a Dynamic. 507/// 508/// Example: \include MatrixBase_template_int_bottomRows.cpp 509/// Output: \verbinclude MatrixBase_template_int_bottomRows.out 510/// 511EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 512/// 513/// \sa class Block, block(Index,Index,Index,Index) 514/// 515template<int N> 516EIGEN_DEVICE_FUNC 517inline typename NRowsBlockXpr<N>::Type bottomRows(Index n = N) 518{ 519 return typename NRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols()); 520} 521 522/// This is the const version of bottomRows<int>(). 523template<int N> 524EIGEN_DEVICE_FUNC 525inline typename ConstNRowsBlockXpr<N>::Type bottomRows(Index n = N) const 526{ 527 return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols()); 528} 529 530 531 532/// \returns a block consisting of a range of rows of *this. 533/// 534/// \param startRow the index of the first row in the block 535/// \param n the number of rows in the block 536/// 537/// Example: \include DenseBase_middleRows_int.cpp 538/// Output: \verbinclude DenseBase_middleRows_int.out 539/// 540EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 541/// 542/// \sa class Block, block(Index,Index,Index,Index) 543/// 544EIGEN_DEVICE_FUNC 545inline RowsBlockXpr middleRows(Index startRow, Index n) 546{ 547 return RowsBlockXpr(derived(), startRow, 0, n, cols()); 548} 549 550/// This is the const version of middleRows(Index,Index). 551EIGEN_DEVICE_FUNC 552inline ConstRowsBlockXpr middleRows(Index startRow, Index n) const 553{ 554 return ConstRowsBlockXpr(derived(), startRow, 0, n, cols()); 555} 556 557/// \returns a block consisting of a range of rows of *this. 558/// 559/// \tparam N the number of rows in the block as specified at compile-time 560/// \param startRow the index of the first row in the block 561/// \param n the number of rows in the block as specified at run-time 562/// 563/// The compile-time and run-time information should not contradict. In other words, 564/// \a n should equal \a N unless \a N is \a Dynamic. 565/// 566/// Example: \include DenseBase_template_int_middleRows.cpp 567/// Output: \verbinclude DenseBase_template_int_middleRows.out 568/// 569EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 570/// 571/// \sa class Block, block(Index,Index,Index,Index) 572/// 573template<int N> 574EIGEN_DEVICE_FUNC 575inline typename NRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N) 576{ 577 return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols()); 578} 579 580/// This is the const version of middleRows<int>(). 581template<int N> 582EIGEN_DEVICE_FUNC 583inline typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N) const 584{ 585 return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols()); 586} 587 588 589 590/// \returns a block consisting of the left columns of *this. 591/// 592/// \param n the number of columns in the block 593/// 594/// Example: \include MatrixBase_leftCols_int.cpp 595/// Output: \verbinclude MatrixBase_leftCols_int.out 596/// 597EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 598/// 599/// \sa class Block, block(Index,Index,Index,Index) 600/// 601EIGEN_DEVICE_FUNC 602inline ColsBlockXpr leftCols(Index n) 603{ 604 return ColsBlockXpr(derived(), 0, 0, rows(), n); 605} 606 607/// This is the const version of leftCols(Index). 608EIGEN_DEVICE_FUNC 609inline ConstColsBlockXpr leftCols(Index n) const 610{ 611 return ConstColsBlockXpr(derived(), 0, 0, rows(), n); 612} 613 614/// \returns a block consisting of the left columns of *this. 615/// 616/// \tparam N the number of columns in the block as specified at compile-time 617/// \param n the number of columns in the block as specified at run-time 618/// 619/// The compile-time and run-time information should not contradict. In other words, 620/// \a n should equal \a N unless \a N is \a Dynamic. 621/// 622/// Example: \include MatrixBase_template_int_leftCols.cpp 623/// Output: \verbinclude MatrixBase_template_int_leftCols.out 624/// 625EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 626/// 627/// \sa class Block, block(Index,Index,Index,Index) 628/// 629template<int N> 630EIGEN_DEVICE_FUNC 631inline typename NColsBlockXpr<N>::Type leftCols(Index n = N) 632{ 633 return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n); 634} 635 636/// This is the const version of leftCols<int>(). 637template<int N> 638EIGEN_DEVICE_FUNC 639inline typename ConstNColsBlockXpr<N>::Type leftCols(Index n = N) const 640{ 641 return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n); 642} 643 644 645 646/// \returns a block consisting of the right columns of *this. 647/// 648/// \param n the number of columns in the block 649/// 650/// Example: \include MatrixBase_rightCols_int.cpp 651/// Output: \verbinclude MatrixBase_rightCols_int.out 652/// 653EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 654/// 655/// \sa class Block, block(Index,Index,Index,Index) 656/// 657EIGEN_DEVICE_FUNC 658inline ColsBlockXpr rightCols(Index n) 659{ 660 return ColsBlockXpr(derived(), 0, cols() - n, rows(), n); 661} 662 663/// This is the const version of rightCols(Index). 664EIGEN_DEVICE_FUNC 665inline ConstColsBlockXpr rightCols(Index n) const 666{ 667 return ConstColsBlockXpr(derived(), 0, cols() - n, rows(), n); 668} 669 670/// \returns a block consisting of the right columns of *this. 671/// 672/// \tparam N the number of columns in the block as specified at compile-time 673/// \param n the number of columns in the block as specified at run-time 674/// 675/// The compile-time and run-time information should not contradict. In other words, 676/// \a n should equal \a N unless \a N is \a Dynamic. 677/// 678/// Example: \include MatrixBase_template_int_rightCols.cpp 679/// Output: \verbinclude MatrixBase_template_int_rightCols.out 680/// 681EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 682/// 683/// \sa class Block, block(Index,Index,Index,Index) 684/// 685template<int N> 686EIGEN_DEVICE_FUNC 687inline typename NColsBlockXpr<N>::Type rightCols(Index n = N) 688{ 689 return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n); 690} 691 692/// This is the const version of rightCols<int>(). 693template<int N> 694EIGEN_DEVICE_FUNC 695inline typename ConstNColsBlockXpr<N>::Type rightCols(Index n = N) const 696{ 697 return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n); 698} 699 700 701 702/// \returns a block consisting of a range of columns of *this. 703/// 704/// \param startCol the index of the first column in the block 705/// \param numCols the number of columns in the block 706/// 707/// Example: \include DenseBase_middleCols_int.cpp 708/// Output: \verbinclude DenseBase_middleCols_int.out 709/// 710EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 711/// 712/// \sa class Block, block(Index,Index,Index,Index) 713/// 714EIGEN_DEVICE_FUNC 715inline ColsBlockXpr middleCols(Index startCol, Index numCols) 716{ 717 return ColsBlockXpr(derived(), 0, startCol, rows(), numCols); 718} 719 720/// This is the const version of middleCols(Index,Index). 721EIGEN_DEVICE_FUNC 722inline ConstColsBlockXpr middleCols(Index startCol, Index numCols) const 723{ 724 return ConstColsBlockXpr(derived(), 0, startCol, rows(), numCols); 725} 726 727/// \returns a block consisting of a range of columns of *this. 728/// 729/// \tparam N the number of columns in the block as specified at compile-time 730/// \param startCol the index of the first column in the block 731/// \param n the number of columns in the block as specified at run-time 732/// 733/// The compile-time and run-time information should not contradict. In other words, 734/// \a n should equal \a N unless \a N is \a Dynamic. 735/// 736/// Example: \include DenseBase_template_int_middleCols.cpp 737/// Output: \verbinclude DenseBase_template_int_middleCols.out 738/// 739EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 740/// 741/// \sa class Block, block(Index,Index,Index,Index) 742/// 743template<int N> 744EIGEN_DEVICE_FUNC 745inline typename NColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N) 746{ 747 return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n); 748} 749 750/// This is the const version of middleCols<int>(). 751template<int N> 752EIGEN_DEVICE_FUNC 753inline typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N) const 754{ 755 return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n); 756} 757 758 759 760/// \returns a fixed-size expression of a block in *this. 761/// 762/// The template parameters \a NRows and \a NCols are the number of 763/// rows and columns in the block. 764/// 765/// \param startRow the first row in the block 766/// \param startCol the first column in the block 767/// 768/// Example: \include MatrixBase_block_int_int.cpp 769/// Output: \verbinclude MatrixBase_block_int_int.out 770/// 771/// \note since block is a templated member, the keyword template has to be used 772/// if the matrix type is also a template parameter: \code m.template block<3,3>(1,1); \endcode 773/// 774EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 775/// 776/// \sa class Block, block(Index,Index,Index,Index) 777/// 778template<int NRows, int NCols> 779EIGEN_DEVICE_FUNC 780inline typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol) 781{ 782 return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol); 783} 784 785/// This is the const version of block<>(Index, Index). */ 786template<int NRows, int NCols> 787EIGEN_DEVICE_FUNC 788inline const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol) const 789{ 790 return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol); 791} 792 793/// \returns an expression of a block in *this. 794/// 795/// \tparam NRows number of rows in block as specified at compile-time 796/// \tparam NCols number of columns in block as specified at compile-time 797/// \param startRow the first row in the block 798/// \param startCol the first column in the block 799/// \param blockRows number of rows in block as specified at run-time 800/// \param blockCols number of columns in block as specified at run-time 801/// 802/// This function is mainly useful for blocks where the number of rows is specified at compile-time 803/// and the number of columns is specified at run-time, or vice versa. The compile-time and run-time 804/// information should not contradict. In other words, \a blockRows should equal \a NRows unless 805/// \a NRows is \a Dynamic, and the same for the number of columns. 806/// 807/// Example: \include MatrixBase_template_int_int_block_int_int_int_int.cpp 808/// Output: \verbinclude MatrixBase_template_int_int_block_int_int_int_int.cpp 809/// 810EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 811/// 812/// \sa class Block, block(Index,Index,Index,Index) 813/// 814template<int NRows, int NCols> 815inline typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol, 816 Index blockRows, Index blockCols) 817{ 818 return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols); 819} 820 821/// This is the const version of block<>(Index, Index, Index, Index). 822template<int NRows, int NCols> 823inline const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol, 824 Index blockRows, Index blockCols) const 825{ 826 return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols); 827} 828 829/// \returns an expression of the \a i-th column of *this. Note that the numbering starts at 0. 830/// 831/// Example: \include MatrixBase_col.cpp 832/// Output: \verbinclude MatrixBase_col.out 833/// 834EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 835/** 836 * \sa row(), class Block */ 837EIGEN_DEVICE_FUNC 838inline ColXpr col(Index i) 839{ 840 return ColXpr(derived(), i); 841} 842 843/// This is the const version of col(). 844EIGEN_DEVICE_FUNC 845inline ConstColXpr col(Index i) const 846{ 847 return ConstColXpr(derived(), i); 848} 849 850/// \returns an expression of the \a i-th row of *this. Note that the numbering starts at 0. 851/// 852/// Example: \include MatrixBase_row.cpp 853/// Output: \verbinclude MatrixBase_row.out 854/// 855EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 856/** 857 * \sa col(), class Block */ 858EIGEN_DEVICE_FUNC 859inline RowXpr row(Index i) 860{ 861 return RowXpr(derived(), i); 862} 863 864/// This is the const version of row(). */ 865EIGEN_DEVICE_FUNC 866inline ConstRowXpr row(Index i) const 867{ 868 return ConstRowXpr(derived(), i); 869} 870 871/// \returns a dynamic-size expression of a segment (i.e. a vector block) in *this. 872/// 873/// \only_for_vectors 874/// 875/// \param start the first coefficient in the segment 876/// \param n the number of coefficients in the segment 877/// 878/// Example: \include MatrixBase_segment_int_int.cpp 879/// Output: \verbinclude MatrixBase_segment_int_int.out 880/// 881/// \note Even though the returned expression has dynamic size, in the case 882/// when it is applied to a fixed-size vector, it inherits a fixed maximal size, 883/// which means that evaluating it does not cause a dynamic memory allocation. 884/// 885/// \sa class Block, segment(Index) 886/// 887EIGEN_DEVICE_FUNC 888inline SegmentReturnType segment(Index start, Index n) 889{ 890 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 891 return SegmentReturnType(derived(), start, n); 892} 893 894 895/// This is the const version of segment(Index,Index). 896EIGEN_DEVICE_FUNC 897inline ConstSegmentReturnType segment(Index start, Index n) const 898{ 899 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 900 return ConstSegmentReturnType(derived(), start, n); 901} 902 903/// \returns a dynamic-size expression of the first coefficients of *this. 904/// 905/// \only_for_vectors 906/// 907/// \param n the number of coefficients in the segment 908/// 909/// Example: \include MatrixBase_start_int.cpp 910/// Output: \verbinclude MatrixBase_start_int.out 911/// 912/// \note Even though the returned expression has dynamic size, in the case 913/// when it is applied to a fixed-size vector, it inherits a fixed maximal size, 914/// which means that evaluating it does not cause a dynamic memory allocation. 915/// 916/// \sa class Block, block(Index,Index) 917/// 918EIGEN_DEVICE_FUNC 919inline SegmentReturnType head(Index n) 920{ 921 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 922 return SegmentReturnType(derived(), 0, n); 923} 924 925/// This is the const version of head(Index). 926EIGEN_DEVICE_FUNC 927inline ConstSegmentReturnType head(Index n) const 928{ 929 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 930 return ConstSegmentReturnType(derived(), 0, n); 931} 932 933/// \returns a dynamic-size expression of the last coefficients of *this. 934/// 935/// \only_for_vectors 936/// 937/// \param n the number of coefficients in the segment 938/// 939/// Example: \include MatrixBase_end_int.cpp 940/// Output: \verbinclude MatrixBase_end_int.out 941/// 942/// \note Even though the returned expression has dynamic size, in the case 943/// when it is applied to a fixed-size vector, it inherits a fixed maximal size, 944/// which means that evaluating it does not cause a dynamic memory allocation. 945/// 946/// \sa class Block, block(Index,Index) 947/// 948EIGEN_DEVICE_FUNC 949inline SegmentReturnType tail(Index n) 950{ 951 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 952 return SegmentReturnType(derived(), this->size() - n, n); 953} 954 955/// This is the const version of tail(Index). 956EIGEN_DEVICE_FUNC 957inline ConstSegmentReturnType tail(Index n) const 958{ 959 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 960 return ConstSegmentReturnType(derived(), this->size() - n, n); 961} 962 963/// \returns a fixed-size expression of a segment (i.e. a vector block) in \c *this 964/// 965/// \only_for_vectors 966/// 967/// \tparam N the number of coefficients in the segment as specified at compile-time 968/// \param start the index of the first element in the segment 969/// \param n the number of coefficients in the segment as specified at compile-time 970/// 971/// The compile-time and run-time information should not contradict. In other words, 972/// \a n should equal \a N unless \a N is \a Dynamic. 973/// 974/// Example: \include MatrixBase_template_int_segment.cpp 975/// Output: \verbinclude MatrixBase_template_int_segment.out 976/// 977/// \sa class Block 978/// 979template<int N> 980EIGEN_DEVICE_FUNC 981inline typename FixedSegmentReturnType<N>::Type segment(Index start, Index n = N) 982{ 983 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 984 return typename FixedSegmentReturnType<N>::Type(derived(), start, n); 985} 986 987/// This is the const version of segment<int>(Index). 988template<int N> 989EIGEN_DEVICE_FUNC 990inline typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index n = N) const 991{ 992 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 993 return typename ConstFixedSegmentReturnType<N>::Type(derived(), start, n); 994} 995 996/// \returns a fixed-size expression of the first coefficients of *this. 997/// 998/// \only_for_vectors 999/// 1000/// \tparam N the number of coefficients in the segment as specified at compile-time 1001/// \param n the number of coefficients in the segment as specified at run-time 1002/// 1003/// The compile-time and run-time information should not contradict. In other words, 1004/// \a n should equal \a N unless \a N is \a Dynamic. 1005/// 1006/// Example: \include MatrixBase_template_int_start.cpp 1007/// Output: \verbinclude MatrixBase_template_int_start.out 1008/// 1009/// \sa class Block 1010/// 1011template<int N> 1012EIGEN_DEVICE_FUNC 1013inline typename FixedSegmentReturnType<N>::Type head(Index n = N) 1014{ 1015 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 1016 return typename FixedSegmentReturnType<N>::Type(derived(), 0, n); 1017} 1018 1019/// This is the const version of head<int>(). 1020template<int N> 1021EIGEN_DEVICE_FUNC 1022inline typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const 1023{ 1024 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 1025 return typename ConstFixedSegmentReturnType<N>::Type(derived(), 0, n); 1026} 1027 1028/// \returns a fixed-size expression of the last coefficients of *this. 1029/// 1030/// \only_for_vectors 1031/// 1032/// \tparam N the number of coefficients in the segment as specified at compile-time 1033/// \param n the number of coefficients in the segment as specified at run-time 1034/// 1035/// The compile-time and run-time information should not contradict. In other words, 1036/// \a n should equal \a N unless \a N is \a Dynamic. 1037/// 1038/// Example: \include MatrixBase_template_int_end.cpp 1039/// Output: \verbinclude MatrixBase_template_int_end.out 1040/// 1041/// \sa class Block 1042/// 1043template<int N> 1044EIGEN_DEVICE_FUNC 1045inline typename FixedSegmentReturnType<N>::Type tail(Index n = N) 1046{ 1047 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 1048 return typename FixedSegmentReturnType<N>::Type(derived(), size() - n); 1049} 1050 1051/// This is the const version of tail<int>. 1052template<int N> 1053EIGEN_DEVICE_FUNC 1054inline typename ConstFixedSegmentReturnType<N>::Type tail(Index n = N) const 1055{ 1056 EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) 1057 return typename ConstFixedSegmentReturnType<N>::Type(derived(), size() - n); 1058} 1059