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 (at) inria.fr> 5 // Copyright (C) 2006-2010 Benoit Jacob <jacob.benoit.1 (at) 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 */ 14 typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr; 15 typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ConstColXpr; 16 /// \internal expression type of a row */ 17 typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr; 18 typedef const Block<const Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowXpr; 19 /// \internal expression type of a block of whole columns */ 20 typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr; 21 typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ConstColsBlockXpr; 22 /// \internal expression type of a block of whole rows */ 23 typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr; 24 typedef const Block<const Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowsBlockXpr; 25 /// \internal expression type of a block of whole columns */ 26 template<int N> struct NColsBlockXpr { typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; }; 27 template<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 */ 29 template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; }; 30 template<int N> struct ConstNRowsBlockXpr { typedef const Block<const Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; }; 31 /// \internal expression of a block */ 32 typedef Block<Derived> BlockXpr; 33 typedef const Block<const Derived> ConstBlockXpr; 34 /// \internal expression of a block of fixed sizes */ 35 template<int Rows, int Cols> struct FixedBlockXpr { typedef Block<Derived,Rows,Cols> Type; }; 36 template<int Rows, int Cols> struct ConstFixedBlockXpr { typedef Block<const Derived,Rows,Cols> Type; }; 37 38 typedef VectorBlock<Derived> SegmentReturnType; 39 typedef const VectorBlock<const Derived> ConstSegmentReturnType; 40 template<int Size> struct FixedSegmentReturnType { typedef VectorBlock<Derived, Size> Type; }; 41 template<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 /// 59 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 60 /// 61 /// \sa class Block, block(Index,Index) 62 /// 63 EIGEN_DEVICE_FUNC 64 inline 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). */ 70 EIGEN_DEVICE_FUNC 71 inline 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 /// 87 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 88 /// 89 /// \sa class Block, block(Index,Index,Index,Index) 90 /// 91 EIGEN_DEVICE_FUNC 92 inline 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). 98 EIGEN_DEVICE_FUNC 99 inline 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 /// 112 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 113 /// 114 /// \sa class Block, block<int,int>(Index,Index) 115 /// 116 template<int CRows, int CCols> 117 EIGEN_DEVICE_FUNC 118 inline 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>(). 124 template<int CRows, int CCols> 125 EIGEN_DEVICE_FUNC 126 inline 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 /// 146 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 147 /// 148 /// \sa class Block 149 /// 150 template<int CRows, int CCols> 151 inline 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). 157 template<int CRows, int CCols> 158 inline 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 /// 173 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 174 /// 175 /// \sa class Block, block(Index,Index,Index,Index) 176 /// 177 EIGEN_DEVICE_FUNC 178 inline 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). 184 EIGEN_DEVICE_FUNC 185 inline 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 /// 197 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 198 /// 199 /// \sa class Block, block(Index,Index,Index,Index) 200 /// 201 template<int CRows, int CCols> 202 EIGEN_DEVICE_FUNC 203 inline 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>(). 209 template<int CRows, int CCols> 210 EIGEN_DEVICE_FUNC 211 inline 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 /// 231 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 232 /// 233 /// \sa class Block 234 /// 235 template<int CRows, int CCols> 236 inline 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). 242 template<int CRows, int CCols> 243 inline 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 /// 258 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 259 /// 260 /// \sa class Block, block(Index,Index,Index,Index) 261 /// 262 EIGEN_DEVICE_FUNC 263 inline 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). 269 EIGEN_DEVICE_FUNC 270 inline 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 /// 282 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 283 /// 284 /// \sa class Block, block(Index,Index,Index,Index) 285 /// 286 template<int CRows, int CCols> 287 EIGEN_DEVICE_FUNC 288 inline 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>(). 294 template<int CRows, int CCols> 295 EIGEN_DEVICE_FUNC 296 inline 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 /// 316 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 317 /// 318 /// \sa class Block 319 /// 320 template<int CRows, int CCols> 321 inline 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). 327 template<int CRows, int CCols> 328 inline 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 /// 343 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 344 /// 345 /// \sa class Block, block(Index,Index,Index,Index) 346 /// 347 EIGEN_DEVICE_FUNC 348 inline 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). 354 EIGEN_DEVICE_FUNC 355 inline 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 /// 367 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 368 /// 369 /// \sa class Block, block(Index,Index,Index,Index) 370 /// 371 template<int CRows, int CCols> 372 EIGEN_DEVICE_FUNC 373 inline 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>(). 379 template<int CRows, int CCols> 380 EIGEN_DEVICE_FUNC 381 inline 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 /// 401 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 402 /// 403 /// \sa class Block 404 /// 405 template<int CRows, int CCols> 406 inline 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). 412 template<int CRows, int CCols> 413 inline 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 /// 427 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 428 /// 429 /// \sa class Block, block(Index,Index,Index,Index) 430 /// 431 EIGEN_DEVICE_FUNC 432 inline RowsBlockXpr topRows(Index n) 433 { 434 return RowsBlockXpr(derived(), 0, 0, n, cols()); 435 } 436 437 /// This is the const version of topRows(Index). 438 EIGEN_DEVICE_FUNC 439 inline 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 /// 455 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 456 /// 457 /// \sa class Block, block(Index,Index,Index,Index) 458 /// 459 template<int N> 460 EIGEN_DEVICE_FUNC 461 inline 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>(). 467 template<int N> 468 EIGEN_DEVICE_FUNC 469 inline 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 /// 483 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 484 /// 485 /// \sa class Block, block(Index,Index,Index,Index) 486 /// 487 EIGEN_DEVICE_FUNC 488 inline 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). 494 EIGEN_DEVICE_FUNC 495 inline 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 /// 511 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 512 /// 513 /// \sa class Block, block(Index,Index,Index,Index) 514 /// 515 template<int N> 516 EIGEN_DEVICE_FUNC 517 inline 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>(). 523 template<int N> 524 EIGEN_DEVICE_FUNC 525 inline 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 /// 540 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 541 /// 542 /// \sa class Block, block(Index,Index,Index,Index) 543 /// 544 EIGEN_DEVICE_FUNC 545 inline 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). 551 EIGEN_DEVICE_FUNC 552 inline 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 /// 569 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 570 /// 571 /// \sa class Block, block(Index,Index,Index,Index) 572 /// 573 template<int N> 574 EIGEN_DEVICE_FUNC 575 inline 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>(). 581 template<int N> 582 EIGEN_DEVICE_FUNC 583 inline 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 /// 597 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 598 /// 599 /// \sa class Block, block(Index,Index,Index,Index) 600 /// 601 EIGEN_DEVICE_FUNC 602 inline ColsBlockXpr leftCols(Index n) 603 { 604 return ColsBlockXpr(derived(), 0, 0, rows(), n); 605 } 606 607 /// This is the const version of leftCols(Index). 608 EIGEN_DEVICE_FUNC 609 inline 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 /// 625 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 626 /// 627 /// \sa class Block, block(Index,Index,Index,Index) 628 /// 629 template<int N> 630 EIGEN_DEVICE_FUNC 631 inline 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>(). 637 template<int N> 638 EIGEN_DEVICE_FUNC 639 inline 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 /// 653 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 654 /// 655 /// \sa class Block, block(Index,Index,Index,Index) 656 /// 657 EIGEN_DEVICE_FUNC 658 inline 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). 664 EIGEN_DEVICE_FUNC 665 inline 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 /// 681 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 682 /// 683 /// \sa class Block, block(Index,Index,Index,Index) 684 /// 685 template<int N> 686 EIGEN_DEVICE_FUNC 687 inline 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>(). 693 template<int N> 694 EIGEN_DEVICE_FUNC 695 inline 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 /// 710 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 711 /// 712 /// \sa class Block, block(Index,Index,Index,Index) 713 /// 714 EIGEN_DEVICE_FUNC 715 inline 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). 721 EIGEN_DEVICE_FUNC 722 inline 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 /// 739 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 740 /// 741 /// \sa class Block, block(Index,Index,Index,Index) 742 /// 743 template<int N> 744 EIGEN_DEVICE_FUNC 745 inline 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>(). 751 template<int N> 752 EIGEN_DEVICE_FUNC 753 inline 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 /// 774 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 775 /// 776 /// \sa class Block, block(Index,Index,Index,Index) 777 /// 778 template<int NRows, int NCols> 779 EIGEN_DEVICE_FUNC 780 inline 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). */ 786 template<int NRows, int NCols> 787 EIGEN_DEVICE_FUNC 788 inline 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 /// 810 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL 811 /// 812 /// \sa class Block, block(Index,Index,Index,Index) 813 /// 814 template<int NRows, int NCols> 815 inline 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). 822 template<int NRows, int NCols> 823 inline 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 /// 834 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major) 835 /** 836 * \sa row(), class Block */ 837 EIGEN_DEVICE_FUNC 838 inline ColXpr col(Index i) 839 { 840 return ColXpr(derived(), i); 841 } 842 843 /// This is the const version of col(). 844 EIGEN_DEVICE_FUNC 845 inline 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 /// 855 EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major) 856 /** 857 * \sa col(), class Block */ 858 EIGEN_DEVICE_FUNC 859 inline RowXpr row(Index i) 860 { 861 return RowXpr(derived(), i); 862 } 863 864 /// This is the const version of row(). */ 865 EIGEN_DEVICE_FUNC 866 inline 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 /// 887 EIGEN_DEVICE_FUNC 888 inline 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). 896 EIGEN_DEVICE_FUNC 897 inline 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 /// 918 EIGEN_DEVICE_FUNC 919 inline 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). 926 EIGEN_DEVICE_FUNC 927 inline 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 /// 948 EIGEN_DEVICE_FUNC 949 inline 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). 956 EIGEN_DEVICE_FUNC 957 inline 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 /// 979 template<int N> 980 EIGEN_DEVICE_FUNC 981 inline 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). 988 template<int N> 989 EIGEN_DEVICE_FUNC 990 inline 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 /// 1011 template<int N> 1012 EIGEN_DEVICE_FUNC 1013 inline 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>(). 1020 template<int N> 1021 EIGEN_DEVICE_FUNC 1022 inline 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 /// 1043 template<int N> 1044 EIGEN_DEVICE_FUNC 1045 inline 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>. 1052 template<int N> 1053 EIGEN_DEVICE_FUNC 1054 inline 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
