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_BLOCKMETHODS_H 12#define EIGEN_BLOCKMETHODS_H 13 14#ifndef EIGEN_PARSED_BY_DOXYGEN 15 16/** \internal expression type of a column */ 17typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr; 18typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ConstColXpr; 19/** \internal expression type of a row */ 20typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr; 21typedef const Block<const Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowXpr; 22/** \internal expression type of a block of whole columns */ 23typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr; 24typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ConstColsBlockXpr; 25/** \internal expression type of a block of whole rows */ 26typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr; 27typedef const Block<const Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowsBlockXpr; 28/** \internal expression type of a block of whole columns */ 29template<int N> struct NColsBlockXpr { typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; }; 30template<int N> struct ConstNColsBlockXpr { typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; }; 31/** \internal expression type of a block of whole rows */ 32template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; }; 33template<int N> struct ConstNRowsBlockXpr { typedef const Block<const Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; }; 34 35 36#endif // not EIGEN_PARSED_BY_DOXYGEN 37 38/** \returns a dynamic-size expression of a block in *this. 39 * 40 * \param startRow the first row in the block 41 * \param startCol the first column in the block 42 * \param blockRows the number of rows in the block 43 * \param blockCols the number of columns in the block 44 * 45 * Example: \include MatrixBase_block_int_int_int_int.cpp 46 * Output: \verbinclude MatrixBase_block_int_int_int_int.out 47 * 48 * \note Even though the returned expression has dynamic size, in the case 49 * when it is applied to a fixed-size matrix, it inherits a fixed maximal size, 50 * which means that evaluating it does not cause a dynamic memory allocation. 51 * 52 * \sa class Block, block(Index,Index) 53 */ 54inline Block<Derived> block(Index startRow, Index startCol, Index blockRows, Index blockCols) 55{ 56 return Block<Derived>(derived(), startRow, startCol, blockRows, blockCols); 57} 58 59/** This is the const version of block(Index,Index,Index,Index). */ 60inline const Block<const Derived> block(Index startRow, Index startCol, Index blockRows, Index blockCols) const 61{ 62 return Block<const Derived>(derived(), startRow, startCol, blockRows, blockCols); 63} 64 65 66 67 68/** \returns a dynamic-size expression of a top-right corner of *this. 69 * 70 * \param cRows the number of rows in the corner 71 * \param cCols the number of columns in the corner 72 * 73 * Example: \include MatrixBase_topRightCorner_int_int.cpp 74 * Output: \verbinclude MatrixBase_topRightCorner_int_int.out 75 * 76 * \sa class Block, block(Index,Index,Index,Index) 77 */ 78inline Block<Derived> topRightCorner(Index cRows, Index cCols) 79{ 80 return Block<Derived>(derived(), 0, cols() - cCols, cRows, cCols); 81} 82 83/** This is the const version of topRightCorner(Index, Index).*/ 84inline const Block<const Derived> topRightCorner(Index cRows, Index cCols) const 85{ 86 return Block<const Derived>(derived(), 0, cols() - cCols, cRows, cCols); 87} 88 89/** \returns an expression of a fixed-size top-right corner of *this. 90 * 91 * The template parameters CRows and CCols are the number of rows and columns in the corner. 92 * 93 * Example: \include MatrixBase_template_int_int_topRightCorner.cpp 94 * Output: \verbinclude MatrixBase_template_int_int_topRightCorner.out 95 * 96 * \sa class Block, block(Index,Index,Index,Index) 97 */ 98template<int CRows, int CCols> 99inline Block<Derived, CRows, CCols> topRightCorner() 100{ 101 return Block<Derived, CRows, CCols>(derived(), 0, cols() - CCols); 102} 103 104/** This is the const version of topRightCorner<int, int>().*/ 105template<int CRows, int CCols> 106inline const Block<const Derived, CRows, CCols> topRightCorner() const 107{ 108 return Block<const Derived, CRows, CCols>(derived(), 0, cols() - CCols); 109} 110 111 112 113 114/** \returns a dynamic-size expression of a top-left corner of *this. 115 * 116 * \param cRows the number of rows in the corner 117 * \param cCols the number of columns in the corner 118 * 119 * Example: \include MatrixBase_topLeftCorner_int_int.cpp 120 * Output: \verbinclude MatrixBase_topLeftCorner_int_int.out 121 * 122 * \sa class Block, block(Index,Index,Index,Index) 123 */ 124inline Block<Derived> topLeftCorner(Index cRows, Index cCols) 125{ 126 return Block<Derived>(derived(), 0, 0, cRows, cCols); 127} 128 129/** This is the const version of topLeftCorner(Index, Index).*/ 130inline const Block<const Derived> topLeftCorner(Index cRows, Index cCols) const 131{ 132 return Block<const Derived>(derived(), 0, 0, cRows, cCols); 133} 134 135/** \returns an expression of a fixed-size top-left corner of *this. 136 * 137 * The template parameters CRows and CCols are the number of rows and columns in the corner. 138 * 139 * Example: \include MatrixBase_template_int_int_topLeftCorner.cpp 140 * Output: \verbinclude MatrixBase_template_int_int_topLeftCorner.out 141 * 142 * \sa class Block, block(Index,Index,Index,Index) 143 */ 144template<int CRows, int CCols> 145inline Block<Derived, CRows, CCols> topLeftCorner() 146{ 147 return Block<Derived, CRows, CCols>(derived(), 0, 0); 148} 149 150/** This is the const version of topLeftCorner<int, int>().*/ 151template<int CRows, int CCols> 152inline const Block<const Derived, CRows, CCols> topLeftCorner() const 153{ 154 return Block<const Derived, CRows, CCols>(derived(), 0, 0); 155} 156 157 158 159/** \returns a dynamic-size expression of a bottom-right corner of *this. 160 * 161 * \param cRows the number of rows in the corner 162 * \param cCols the number of columns in the corner 163 * 164 * Example: \include MatrixBase_bottomRightCorner_int_int.cpp 165 * Output: \verbinclude MatrixBase_bottomRightCorner_int_int.out 166 * 167 * \sa class Block, block(Index,Index,Index,Index) 168 */ 169inline Block<Derived> bottomRightCorner(Index cRows, Index cCols) 170{ 171 return Block<Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols); 172} 173 174/** This is the const version of bottomRightCorner(Index, Index).*/ 175inline const Block<const Derived> bottomRightCorner(Index cRows, Index cCols) const 176{ 177 return Block<const Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols); 178} 179 180/** \returns an expression of a fixed-size bottom-right corner of *this. 181 * 182 * The template parameters CRows and CCols are the number of rows and columns in the corner. 183 * 184 * Example: \include MatrixBase_template_int_int_bottomRightCorner.cpp 185 * Output: \verbinclude MatrixBase_template_int_int_bottomRightCorner.out 186 * 187 * \sa class Block, block(Index,Index,Index,Index) 188 */ 189template<int CRows, int CCols> 190inline Block<Derived, CRows, CCols> bottomRightCorner() 191{ 192 return Block<Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols); 193} 194 195/** This is the const version of bottomRightCorner<int, int>().*/ 196template<int CRows, int CCols> 197inline const Block<const Derived, CRows, CCols> bottomRightCorner() const 198{ 199 return Block<const Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols); 200} 201 202 203 204/** \returns a dynamic-size expression of a bottom-left corner of *this. 205 * 206 * \param cRows the number of rows in the corner 207 * \param cCols the number of columns in the corner 208 * 209 * Example: \include MatrixBase_bottomLeftCorner_int_int.cpp 210 * Output: \verbinclude MatrixBase_bottomLeftCorner_int_int.out 211 * 212 * \sa class Block, block(Index,Index,Index,Index) 213 */ 214inline Block<Derived> bottomLeftCorner(Index cRows, Index cCols) 215{ 216 return Block<Derived>(derived(), rows() - cRows, 0, cRows, cCols); 217} 218 219/** This is the const version of bottomLeftCorner(Index, Index).*/ 220inline const Block<const Derived> bottomLeftCorner(Index cRows, Index cCols) const 221{ 222 return Block<const Derived>(derived(), rows() - cRows, 0, cRows, cCols); 223} 224 225/** \returns an expression of a fixed-size bottom-left corner of *this. 226 * 227 * The template parameters CRows and CCols are the number of rows and columns in the corner. 228 * 229 * Example: \include MatrixBase_template_int_int_bottomLeftCorner.cpp 230 * Output: \verbinclude MatrixBase_template_int_int_bottomLeftCorner.out 231 * 232 * \sa class Block, block(Index,Index,Index,Index) 233 */ 234template<int CRows, int CCols> 235inline Block<Derived, CRows, CCols> bottomLeftCorner() 236{ 237 return Block<Derived, CRows, CCols>(derived(), rows() - CRows, 0); 238} 239 240/** This is the const version of bottomLeftCorner<int, int>().*/ 241template<int CRows, int CCols> 242inline const Block<const Derived, CRows, CCols> bottomLeftCorner() const 243{ 244 return Block<const Derived, CRows, CCols>(derived(), rows() - CRows, 0); 245} 246 247 248 249/** \returns a block consisting of the top rows of *this. 250 * 251 * \param n the number of rows in the block 252 * 253 * Example: \include MatrixBase_topRows_int.cpp 254 * Output: \verbinclude MatrixBase_topRows_int.out 255 * 256 * \sa class Block, block(Index,Index,Index,Index) 257 */ 258inline RowsBlockXpr topRows(Index n) 259{ 260 return RowsBlockXpr(derived(), 0, 0, n, cols()); 261} 262 263/** This is the const version of topRows(Index).*/ 264inline ConstRowsBlockXpr topRows(Index n) const 265{ 266 return ConstRowsBlockXpr(derived(), 0, 0, n, cols()); 267} 268 269/** \returns a block consisting of the top rows of *this. 270 * 271 * \tparam N the number of rows in the block 272 * 273 * Example: \include MatrixBase_template_int_topRows.cpp 274 * Output: \verbinclude MatrixBase_template_int_topRows.out 275 * 276 * \sa class Block, block(Index,Index,Index,Index) 277 */ 278template<int N> 279inline typename NRowsBlockXpr<N>::Type topRows() 280{ 281 return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, N, cols()); 282} 283 284/** This is the const version of topRows<int>().*/ 285template<int N> 286inline typename ConstNRowsBlockXpr<N>::Type topRows() const 287{ 288 return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, N, cols()); 289} 290 291 292 293/** \returns a block consisting of the bottom rows of *this. 294 * 295 * \param n the number of rows in the block 296 * 297 * Example: \include MatrixBase_bottomRows_int.cpp 298 * Output: \verbinclude MatrixBase_bottomRows_int.out 299 * 300 * \sa class Block, block(Index,Index,Index,Index) 301 */ 302inline RowsBlockXpr bottomRows(Index n) 303{ 304 return RowsBlockXpr(derived(), rows() - n, 0, n, cols()); 305} 306 307/** This is the const version of bottomRows(Index).*/ 308inline ConstRowsBlockXpr bottomRows(Index n) const 309{ 310 return ConstRowsBlockXpr(derived(), rows() - n, 0, n, cols()); 311} 312 313/** \returns a block consisting of the bottom rows of *this. 314 * 315 * \tparam N the number of rows in the block 316 * 317 * Example: \include MatrixBase_template_int_bottomRows.cpp 318 * Output: \verbinclude MatrixBase_template_int_bottomRows.out 319 * 320 * \sa class Block, block(Index,Index,Index,Index) 321 */ 322template<int N> 323inline typename NRowsBlockXpr<N>::Type bottomRows() 324{ 325 return typename NRowsBlockXpr<N>::Type(derived(), rows() - N, 0, N, cols()); 326} 327 328/** This is the const version of bottomRows<int>().*/ 329template<int N> 330inline typename ConstNRowsBlockXpr<N>::Type bottomRows() const 331{ 332 return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - N, 0, N, cols()); 333} 334 335 336 337/** \returns a block consisting of a range of rows of *this. 338 * 339 * \param startRow the index of the first row in the block 340 * \param numRows the number of rows in the block 341 * 342 * Example: \include DenseBase_middleRows_int.cpp 343 * Output: \verbinclude DenseBase_middleRows_int.out 344 * 345 * \sa class Block, block(Index,Index,Index,Index) 346 */ 347inline RowsBlockXpr middleRows(Index startRow, Index numRows) 348{ 349 return RowsBlockXpr(derived(), startRow, 0, numRows, cols()); 350} 351 352/** This is the const version of middleRows(Index,Index).*/ 353inline ConstRowsBlockXpr middleRows(Index startRow, Index numRows) const 354{ 355 return ConstRowsBlockXpr(derived(), startRow, 0, numRows, cols()); 356} 357 358/** \returns a block consisting of a range of rows of *this. 359 * 360 * \tparam N the number of rows in the block 361 * \param startRow the index of the first row in the block 362 * 363 * Example: \include DenseBase_template_int_middleRows.cpp 364 * Output: \verbinclude DenseBase_template_int_middleRows.out 365 * 366 * \sa class Block, block(Index,Index,Index,Index) 367 */ 368template<int N> 369inline typename NRowsBlockXpr<N>::Type middleRows(Index startRow) 370{ 371 return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, N, cols()); 372} 373 374/** This is the const version of middleRows<int>().*/ 375template<int N> 376inline typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow) const 377{ 378 return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, N, cols()); 379} 380 381 382 383/** \returns a block consisting of the left columns of *this. 384 * 385 * \param n the number of columns in the block 386 * 387 * Example: \include MatrixBase_leftCols_int.cpp 388 * Output: \verbinclude MatrixBase_leftCols_int.out 389 * 390 * \sa class Block, block(Index,Index,Index,Index) 391 */ 392inline ColsBlockXpr leftCols(Index n) 393{ 394 return ColsBlockXpr(derived(), 0, 0, rows(), n); 395} 396 397/** This is the const version of leftCols(Index).*/ 398inline ConstColsBlockXpr leftCols(Index n) const 399{ 400 return ConstColsBlockXpr(derived(), 0, 0, rows(), n); 401} 402 403/** \returns a block consisting of the left columns of *this. 404 * 405 * \tparam N the number of columns in the block 406 * 407 * Example: \include MatrixBase_template_int_leftCols.cpp 408 * Output: \verbinclude MatrixBase_template_int_leftCols.out 409 * 410 * \sa class Block, block(Index,Index,Index,Index) 411 */ 412template<int N> 413inline typename NColsBlockXpr<N>::Type leftCols() 414{ 415 return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), N); 416} 417 418/** This is the const version of leftCols<int>().*/ 419template<int N> 420inline typename ConstNColsBlockXpr<N>::Type leftCols() const 421{ 422 return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), N); 423} 424 425 426 427/** \returns a block consisting of the right columns of *this. 428 * 429 * \param n the number of columns in the block 430 * 431 * Example: \include MatrixBase_rightCols_int.cpp 432 * Output: \verbinclude MatrixBase_rightCols_int.out 433 * 434 * \sa class Block, block(Index,Index,Index,Index) 435 */ 436inline ColsBlockXpr rightCols(Index n) 437{ 438 return ColsBlockXpr(derived(), 0, cols() - n, rows(), n); 439} 440 441/** This is the const version of rightCols(Index).*/ 442inline ConstColsBlockXpr rightCols(Index n) const 443{ 444 return ConstColsBlockXpr(derived(), 0, cols() - n, rows(), n); 445} 446 447/** \returns a block consisting of the right columns of *this. 448 * 449 * \tparam N the number of columns in the block 450 * 451 * Example: \include MatrixBase_template_int_rightCols.cpp 452 * Output: \verbinclude MatrixBase_template_int_rightCols.out 453 * 454 * \sa class Block, block(Index,Index,Index,Index) 455 */ 456template<int N> 457inline typename NColsBlockXpr<N>::Type rightCols() 458{ 459 return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - N, rows(), N); 460} 461 462/** This is the const version of rightCols<int>().*/ 463template<int N> 464inline typename ConstNColsBlockXpr<N>::Type rightCols() const 465{ 466 return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - N, rows(), N); 467} 468 469 470 471/** \returns a block consisting of a range of columns of *this. 472 * 473 * \param startCol the index of the first column in the block 474 * \param numCols the number of columns in the block 475 * 476 * Example: \include DenseBase_middleCols_int.cpp 477 * Output: \verbinclude DenseBase_middleCols_int.out 478 * 479 * \sa class Block, block(Index,Index,Index,Index) 480 */ 481inline ColsBlockXpr middleCols(Index startCol, Index numCols) 482{ 483 return ColsBlockXpr(derived(), 0, startCol, rows(), numCols); 484} 485 486/** This is the const version of middleCols(Index,Index).*/ 487inline ConstColsBlockXpr middleCols(Index startCol, Index numCols) const 488{ 489 return ConstColsBlockXpr(derived(), 0, startCol, rows(), numCols); 490} 491 492/** \returns a block consisting of a range of columns of *this. 493 * 494 * \tparam N the number of columns in the block 495 * \param startCol the index of the first column in the block 496 * 497 * Example: \include DenseBase_template_int_middleCols.cpp 498 * Output: \verbinclude DenseBase_template_int_middleCols.out 499 * 500 * \sa class Block, block(Index,Index,Index,Index) 501 */ 502template<int N> 503inline typename NColsBlockXpr<N>::Type middleCols(Index startCol) 504{ 505 return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), N); 506} 507 508/** This is the const version of middleCols<int>().*/ 509template<int N> 510inline typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol) const 511{ 512 return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), N); 513} 514 515 516 517/** \returns a fixed-size expression of a block in *this. 518 * 519 * The template parameters \a BlockRows and \a BlockCols are the number of 520 * rows and columns in the block. 521 * 522 * \param startRow the first row in the block 523 * \param startCol the first column in the block 524 * 525 * Example: \include MatrixBase_block_int_int.cpp 526 * Output: \verbinclude MatrixBase_block_int_int.out 527 * 528 * \note since block is a templated member, the keyword template has to be used 529 * if the matrix type is also a template parameter: \code m.template block<3,3>(1,1); \endcode 530 * 531 * \sa class Block, block(Index,Index,Index,Index) 532 */ 533template<int BlockRows, int BlockCols> 534inline Block<Derived, BlockRows, BlockCols> block(Index startRow, Index startCol) 535{ 536 return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol); 537} 538 539/** This is the const version of block<>(Index, Index). */ 540template<int BlockRows, int BlockCols> 541inline const Block<const Derived, BlockRows, BlockCols> block(Index startRow, Index startCol) const 542{ 543 return Block<const Derived, BlockRows, BlockCols>(derived(), startRow, startCol); 544} 545 546/** \returns an expression of the \a i-th column of *this. Note that the numbering starts at 0. 547 * 548 * Example: \include MatrixBase_col.cpp 549 * Output: \verbinclude MatrixBase_col.out 550 * 551 * \sa row(), class Block */ 552inline ColXpr col(Index i) 553{ 554 return ColXpr(derived(), i); 555} 556 557/** This is the const version of col(). */ 558inline ConstColXpr col(Index i) const 559{ 560 return ConstColXpr(derived(), i); 561} 562 563/** \returns an expression of the \a i-th row of *this. Note that the numbering starts at 0. 564 * 565 * Example: \include MatrixBase_row.cpp 566 * Output: \verbinclude MatrixBase_row.out 567 * 568 * \sa col(), class Block */ 569inline RowXpr row(Index i) 570{ 571 return RowXpr(derived(), i); 572} 573 574/** This is the const version of row(). */ 575inline ConstRowXpr row(Index i) const 576{ 577 return ConstRowXpr(derived(), i); 578} 579 580#endif // EIGEN_BLOCKMETHODS_H 581