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