• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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