BlockMethods.h
Go to the documentation of this file.
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 
14 typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr;
15 typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ConstColXpr;
17 typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr;
18 typedef const Block<const Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowXpr;
20 typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr;
21 typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ConstColsBlockXpr;
23 typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr;
24 typedef const Block<const Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowsBlockXpr;
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; };
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; };
32 typedef Block<Derived> BlockXpr;
33 typedef const Block<const Derived> ConstBlockXpr;
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 
63 EIGEN_DEVICE_FUNC
64 inline BlockXpr block(Index startRow, Index startCol, Index blockRows, Index blockCols)
65 {
66  return BlockXpr(derived(), startRow, startCol, blockRows, blockCols);
67 }
68 
70 EIGEN_DEVICE_FUNC
71 inline const ConstBlockXpr block(Index startRow, Index startCol, Index blockRows, Index blockCols) const
72 {
73  return ConstBlockXpr(derived(), startRow, startCol, blockRows, blockCols);
74 }
75 
76 
77 
78 
91 EIGEN_DEVICE_FUNC
92 inline BlockXpr topRightCorner(Index cRows, Index cCols)
93 {
94  return BlockXpr(derived(), 0, cols() - cCols, cRows, cCols);
95 }
96 
98 EIGEN_DEVICE_FUNC
99 inline const ConstBlockXpr topRightCorner(Index cRows, Index cCols) const
100 {
101  return ConstBlockXpr(derived(), 0, cols() - cCols, cRows, cCols);
102 }
103 
116 template<int CRows, int CCols>
117 EIGEN_DEVICE_FUNC
119 {
120  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);
121 }
122 
124 template<int CRows, int CCols>
125 EIGEN_DEVICE_FUNC
127 {
128  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);
129 }
130 
150 template<int CRows, int CCols>
151 inline typename FixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols)
152 {
153  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);
154 }
155 
157 template<int CRows, int CCols>
158 inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols) const
159 {
160  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);
161 }
162 
163 
164 
177 EIGEN_DEVICE_FUNC
178 inline BlockXpr topLeftCorner(Index cRows, Index cCols)
179 {
180  return BlockXpr(derived(), 0, 0, cRows, cCols);
181 }
182 
184 EIGEN_DEVICE_FUNC
185 inline const ConstBlockXpr topLeftCorner(Index cRows, Index cCols) const
186 {
187  return ConstBlockXpr(derived(), 0, 0, cRows, cCols);
188 }
189 
201 template<int CRows, int CCols>
202 EIGEN_DEVICE_FUNC
204 {
205  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);
206 }
207 
209 template<int CRows, int CCols>
210 EIGEN_DEVICE_FUNC
212 {
213  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);
214 }
215 
235 template<int CRows, int CCols>
236 inline typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols)
237 {
238  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols);
239 }
240 
242 template<int CRows, int CCols>
243 inline const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols) const
244 {
245  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols);
246 }
247 
248 
249 
262 EIGEN_DEVICE_FUNC
263 inline BlockXpr bottomRightCorner(Index cRows, Index cCols)
264 {
265  return BlockXpr(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
266 }
267 
269 EIGEN_DEVICE_FUNC
270 inline const ConstBlockXpr bottomRightCorner(Index cRows, Index cCols) const
271 {
272  return ConstBlockXpr(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
273 }
274 
286 template<int CRows, int CCols>
287 EIGEN_DEVICE_FUNC
289 {
290  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);
291 }
292 
294 template<int CRows, int CCols>
295 EIGEN_DEVICE_FUNC
297 {
298  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);
299 }
300 
320 template<int CRows, int CCols>
322 {
323  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
324 }
325 
327 template<int CRows, int CCols>
328 inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols) const
329 {
330  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
331 }
332 
333 
334 
347 EIGEN_DEVICE_FUNC
348 inline BlockXpr bottomLeftCorner(Index cRows, Index cCols)
349 {
350  return BlockXpr(derived(), rows() - cRows, 0, cRows, cCols);
351 }
352 
354 EIGEN_DEVICE_FUNC
355 inline const ConstBlockXpr bottomLeftCorner(Index cRows, Index cCols) const
356 {
357  return ConstBlockXpr(derived(), rows() - cRows, 0, cRows, cCols);
358 }
359 
371 template<int CRows, int CCols>
372 EIGEN_DEVICE_FUNC
374 {
375  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);
376 }
377 
379 template<int CRows, int CCols>
380 EIGEN_DEVICE_FUNC
382 {
383  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);
384 }
385 
405 template<int CRows, int CCols>
406 inline typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols)
407 {
408  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);
409 }
410 
412 template<int CRows, int CCols>
413 inline const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols) const
414 {
415  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);
416 }
417 
418 
419 
431 EIGEN_DEVICE_FUNC
433 {
434  return RowsBlockXpr(derived(), 0, 0, n, cols());
435 }
436 
438 EIGEN_DEVICE_FUNC
439 inline ConstRowsBlockXpr topRows(Index n) const
440 {
441  return ConstRowsBlockXpr(derived(), 0, 0, n, cols());
442 }
443 
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 
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 
487 EIGEN_DEVICE_FUNC
489 {
490  return RowsBlockXpr(derived(), rows() - n, 0, n, cols());
491 }
492 
494 EIGEN_DEVICE_FUNC
495 inline ConstRowsBlockXpr bottomRows(Index n) const
496 {
497  return ConstRowsBlockXpr(derived(), rows() - n, 0, n, cols());
498 }
499 
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 
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 
544 EIGEN_DEVICE_FUNC
546 {
547  return RowsBlockXpr(derived(), startRow, 0, n, cols());
548 }
549 
551 EIGEN_DEVICE_FUNC
552 inline ConstRowsBlockXpr middleRows(Index startRow, Index n) const
553 {
554  return ConstRowsBlockXpr(derived(), startRow, 0, n, cols());
555 }
556 
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 
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 
601 EIGEN_DEVICE_FUNC
603 {
604  return ColsBlockXpr(derived(), 0, 0, rows(), n);
605 }
606 
608 EIGEN_DEVICE_FUNC
609 inline ConstColsBlockXpr leftCols(Index n) const
610 {
611  return ConstColsBlockXpr(derived(), 0, 0, rows(), n);
612 }
613 
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 
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 
657 EIGEN_DEVICE_FUNC
659 {
660  return ColsBlockXpr(derived(), 0, cols() - n, rows(), n);
661 }
662 
664 EIGEN_DEVICE_FUNC
665 inline ConstColsBlockXpr rightCols(Index n) const
666 {
667  return ConstColsBlockXpr(derived(), 0, cols() - n, rows(), n);
668 }
669 
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 
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 
714 EIGEN_DEVICE_FUNC
715 inline ColsBlockXpr middleCols(Index startCol, Index numCols)
716 {
717  return ColsBlockXpr(derived(), 0, startCol, rows(), numCols);
718 }
719 
721 EIGEN_DEVICE_FUNC
722 inline ConstColsBlockXpr middleCols(Index startCol, Index numCols) const
723 {
724  return ConstColsBlockXpr(derived(), 0, startCol, rows(), numCols);
725 }
726 
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 
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 
778 template<int NRows, int NCols>
779 EIGEN_DEVICE_FUNC
780 inline typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol)
781 {
782  return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);
783 }
784 
786 template<int NRows, int NCols>
787 EIGEN_DEVICE_FUNC
788 inline const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol) const
789 {
790  return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);
791 }
792 
814 template<int NRows, int NCols>
815 inline typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,
816  Index blockRows, Index blockCols)
817 {
818  return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
819 }
820 
822 template<int NRows, int NCols>
823 inline const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,
824  Index blockRows, Index blockCols) const
825 {
826  return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
827 }
828 
837 EIGEN_DEVICE_FUNC
838 inline ColXpr col(Index i)
839 {
840  return ColXpr(derived(), i);
841 }
842 
844 EIGEN_DEVICE_FUNC
845 inline ConstColXpr col(Index i) const
846 {
847  return ConstColXpr(derived(), i);
848 }
849 
858 EIGEN_DEVICE_FUNC
859 inline RowXpr row(Index i)
860 {
861  return RowXpr(derived(), i);
862 }
863 
865 EIGEN_DEVICE_FUNC
866 inline ConstRowXpr row(Index i) const
867 {
868  return ConstRowXpr(derived(), i);
869 }
870 
887 EIGEN_DEVICE_FUNC
889 {
891  return SegmentReturnType(derived(), start, n);
892 }
893 
894 
896 EIGEN_DEVICE_FUNC
897 inline ConstSegmentReturnType segment(Index start, Index n) const
898 {
900  return ConstSegmentReturnType(derived(), start, n);
901 }
902 
918 EIGEN_DEVICE_FUNC
920 {
922  return SegmentReturnType(derived(), 0, n);
923 }
924 
926 EIGEN_DEVICE_FUNC
927 inline ConstSegmentReturnType head(Index n) const
928 {
930  return ConstSegmentReturnType(derived(), 0, n);
931 }
932 
948 EIGEN_DEVICE_FUNC
950 {
952  return SegmentReturnType(derived(), this->size() - n, n);
953 }
954 
956 EIGEN_DEVICE_FUNC
957 inline ConstSegmentReturnType tail(Index n) const
958 {
960  return ConstSegmentReturnType(derived(), this->size() - n, n);
961 }
962 
979 template<int N>
980 EIGEN_DEVICE_FUNC
981 inline typename FixedSegmentReturnType<N>::Type segment(Index start, Index n = N)
982 {
984  return typename FixedSegmentReturnType<N>::Type(derived(), start, n);
985 }
986 
988 template<int N>
989 EIGEN_DEVICE_FUNC
990 inline typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index n = N) const
991 {
993  return typename ConstFixedSegmentReturnType<N>::Type(derived(), start, n);
994 }
995 
1011 template<int N>
1012 EIGEN_DEVICE_FUNC
1013 inline typename FixedSegmentReturnType<N>::Type head(Index n = N)
1014 {
1016  return typename FixedSegmentReturnType<N>::Type(derived(), 0, n);
1017 }
1018 
1020 template<int N>
1021 EIGEN_DEVICE_FUNC
1022 inline typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const
1023 {
1025  return typename ConstFixedSegmentReturnType<N>::Type(derived(), 0, n);
1026 }
1027 
1043 template<int N>
1044 EIGEN_DEVICE_FUNC
1045 inline typename FixedSegmentReturnType<N>::Type tail(Index n = N)
1046 {
1048  return typename FixedSegmentReturnType<N>::Type(derived(), size() - n);
1049 }
1050 
1052 template<int N>
1053 EIGEN_DEVICE_FUNC
1054 inline typename ConstFixedSegmentReturnType<N>::Type tail(Index n = N) const
1055 {
1057  return typename ConstFixedSegmentReturnType<N>::Type(derived(), size() - n);
1058 }
Block< Derived, 1, internal::traits< Derived >::ColsAtCompileTime, IsRowMajor > RowXpr
Definition: BlockMethods.h:17
EIGEN_DEVICE_FUNC ColsBlockXpr middleCols(Index startCol, Index numCols)
This is the const version of middleCols(Index,Index).
Definition: BlockMethods.h:715
VectorBlock< Derived > SegmentReturnType
Definition: BlockMethods.h:38
EIGEN_DEVICE_FUNC ColsBlockXpr rightCols(Index n)
This is the const version of rightCols(Index).
Definition: BlockMethods.h:658
Block< Derived, internal::traits< Derived >::RowsAtCompileTime, Dynamic,!IsRowMajor > ColsBlockXpr
Definition: BlockMethods.h:20
const Block< const Derived, internal::traits< Derived >::RowsAtCompileTime, 1,!IsRowMajor > ConstColXpr
Definition: BlockMethods.h:15
EIGEN_DEVICE_FUNC SegmentReturnType tail(Index n)
This is the const version of tail(Index).
Definition: BlockMethods.h:949
int n
const Block< const Derived, internal::traits< Derived >::RowsAtCompileTime, N,!IsRowMajor > Type
Definition: BlockMethods.h:27
EIGEN_DEVICE_FUNC SegmentReturnType segment(Index start, Index n)
This is the const version of segment(Index,Index).
Definition: BlockMethods.h:888
Block< Derived, internal::traits< Derived >::RowsAtCompileTime, 1,!IsRowMajor > ColXpr
Definition: BlockMethods.h:14
Block< Derived > BlockXpr
Definition: BlockMethods.h:32
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DEVICE_FUNC BlockXpr bottomRightCorner(Index cRows, Index cCols)
This is the const version of bottomRightCorner(Index, Index).
Definition: BlockMethods.h:263
EIGEN_DEVICE_FUNC RowsBlockXpr topRows(Index n)
This is the const version of topRows(Index).
Definition: BlockMethods.h:432
const Block< const Derived, Dynamic, internal::traits< Derived >::ColsAtCompileTime, IsRowMajor > ConstRowsBlockXpr
Definition: BlockMethods.h:24
#define N
Definition: gksort.c:12
Block< Derived, Dynamic, internal::traits< Derived >::ColsAtCompileTime, IsRowMajor > RowsBlockXpr
Definition: BlockMethods.h:23
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DEVICE_FUNC BlockXpr bottomLeftCorner(Index cRows, Index cCols)
This is the const version of bottomLeftCorner(Index, Index).
Definition: BlockMethods.h:348
Scalar Scalar int size
Definition: benchVecAdd.cpp:17
EIGEN_DEVICE_FUNC ColsBlockXpr leftCols(Index n)
This is the const version of leftCols(Index).
Definition: BlockMethods.h:602
EIGEN_DEVICE_FUNC ColXpr col(Index i)
This is the const version of col().
Definition: BlockMethods.h:838
Block< const Derived, Rows, Cols > Type
Definition: BlockMethods.h:36
Block< Derived, internal::traits< Derived >::RowsAtCompileTime, N,!IsRowMajor > Type
Definition: BlockMethods.h:26
const Block< const Derived > ConstBlockXpr
Definition: BlockMethods.h:33
Block< Derived, N, internal::traits< Derived >::ColsAtCompileTime, IsRowMajor > Type
Definition: BlockMethods.h:29
EIGEN_DEVICE_FUNC RowsBlockXpr middleRows(Index startRow, Index n)
This is the const version of middleRows(Index,Index).
Definition: BlockMethods.h:545
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DEVICE_FUNC BlockXpr block(Index startRow, Index startCol, Index blockRows, Index blockCols)
This is the const version of block(Index,Index,Index,Index). */.
Definition: BlockMethods.h:64
EIGEN_DEVICE_FUNC RowXpr row(Index i)
This is the const version of row(). */.
Definition: BlockMethods.h:859
EIGEN_DEVICE_FUNC RowsBlockXpr bottomRows(Index n)
This is the const version of bottomRows(Index).
Definition: BlockMethods.h:488
const Block< const Derived, 1, internal::traits< Derived >::ColsAtCompileTime, IsRowMajor > ConstRowXpr
Definition: BlockMethods.h:18
const VectorBlock< const Derived > ConstSegmentReturnType
Definition: BlockMethods.h:39
const VectorBlock< const Derived, Size > Type
Definition: BlockMethods.h:41
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DEVICE_FUNC BlockXpr topLeftCorner(Index cRows, Index cCols)
This is the const version of topLeftCorner(Index, Index).
Definition: BlockMethods.h:178
Expression of a fixed-size or dynamic-size block.
Definition: Block.h:103
EIGEN_DEVICE_FUNC SegmentReturnType head(Index n)
This is the const version of head(Index).
Definition: BlockMethods.h:919
VectorBlock< Derived, Size > Type
Definition: BlockMethods.h:40
const Block< const Derived, internal::traits< Derived >::RowsAtCompileTime, Dynamic,!IsRowMajor > ConstColsBlockXpr
Definition: BlockMethods.h:21
#define EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(COND)
Definition: DenseBase.h:572
Block< Derived, Rows, Cols > Type
Definition: BlockMethods.h:35
const int Dynamic
Definition: Constants.h:21
#define EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
Definition: DenseBase.h:571
EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL EIGEN_DEVICE_FUNC BlockXpr topRightCorner(Index cRows, Index cCols)
This is the const version of topRightCorner(Index, Index).
Definition: BlockMethods.h:92
#define EIGEN_STATIC_ASSERT_VECTOR_ONLY(TYPE)
Definition: StaticAssert.h:139
const MATRIX::ConstColXpr column(const MATRIX &A, size_t j)
Definition: base/Matrix.h:214
const Block< const Derived, N, internal::traits< Derived >::ColsAtCompileTime, IsRowMajor > Type
Definition: BlockMethods.h:30


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:41:43