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