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 */
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
block(Index startRow,Index startCol,Index blockRows,Index blockCols)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
block(Index startRow,Index startCol,Index blockRows,Index blockCols)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
topRightCorner(Index cRows,Index cCols)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
topRightCorner(Index cRows,Index cCols)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
topRightCorner()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
topRightCorner()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>
topRightCorner(Index cRows,Index 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>
topRightCorner(Index cRows,Index 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
topLeftCorner(Index cRows,Index cCols)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
topLeftCorner(Index cRows,Index cCols)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
topLeftCorner()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
topLeftCorner()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>
topLeftCorner(Index cRows,Index 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>
topLeftCorner(Index cRows,Index 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
bottomRightCorner(Index cRows,Index cCols)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
bottomRightCorner(Index cRows,Index cCols)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
bottomRightCorner()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
bottomRightCorner()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>
bottomRightCorner(Index cRows,Index 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>
bottomRightCorner(Index cRows,Index 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
bottomLeftCorner(Index cRows,Index cCols)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
bottomLeftCorner(Index cRows,Index cCols)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
bottomLeftCorner()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
bottomLeftCorner()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>
bottomLeftCorner(Index cRows,Index 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>
bottomLeftCorner(Index cRows,Index 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
topRows(Index n)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
topRows(Index n)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
bottomRows(Index n)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
bottomRows(Index n)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
middleRows(Index startRow,Index n)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
middleRows(Index startRow,Index n)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
leftCols(Index n)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
leftCols(Index n)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
rightCols(Index n)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
rightCols(Index n)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
middleCols(Index startCol,Index numCols)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
middleCols(Index startCol,Index numCols)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
block(Index startRow,Index startCol)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
block(Index startRow,Index startCol)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>
block(Index startRow,Index startCol,Index blockRows,Index blockCols)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>
block(Index startRow,Index startCol,Index blockRows,Index blockCols)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
col(Index i)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
col(Index i)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
row(Index i)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
row(Index i)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
segment(Index start,Index n)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
segment(Index start,Index n)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
head(Index n)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
head(Index n)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
tail(Index n)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
tail(Index n)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