MRPT  2.0.4
matrix_adaptors.h
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | https://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2020, Individual contributors, see AUTHORS file |
6  | See: https://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See: https://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 #pragma once
10 
11 #include <mrpt/math/math_frwds.h> // forward declarations
12 
13 namespace mrpt
14 {
15 namespace math
16 {
17 /** Internal classes not to be directly used by the user. */
18 // Forward declarations:
19 template <typename T, typename U, bool UIsObject>
20 class CBinaryRelation;
21 namespace detail
22 {
23 /**
24  * This template is a trick to switch the type of a variable using a boolean
25  * variable in the template. It's easy to extend its functionality to several
26  * types, using a unsigned char instead of a bool.
27  */
28 template <typename U, bool B>
30 
31 // partial specializations:
32 template <typename U>
33 class MatrixWrapper<U, true>
34 {
35  public:
36  using MatrixType = CMatrixTemplateObjects<U>;
37 };
38 template <typename U>
39 class MatrixWrapper<U, false>
40 {
41  public:
43 };
44 
45 template <typename T, typename U, bool UIsObject, typename FunctionType>
46 inline void applyFunction(
47  CBinaryRelation<T, U, UIsObject>& o, FunctionType fun, size_t e1, size_t e2,
48  const T& T1, const T& T2);
49 } // namespace detail
50 
51 namespace detail
52 {
53 /** Template class for matrix accessor's iterators.
54  * \sa CMatrixRowAccessor,CMatrixColumnAccessor
55  */
56 template <typename A, typename T>
58 {
59  protected:
60  A* base;
61  int pos;
62 
63  public:
64  // typedefs for iterator_traits:
65  using iterator_category = std::random_access_iterator_tag;
66  using value_type = T;
67  using difference_type = int;
68  using pointer = T*;
69  using reference = T&;
70 
71  inline AccessorIterator(A& obj, size_t N) : base(&obj), pos(N) {}
72  inline T& operator*() const { return (*base)[pos]; }
74  {
75  ++pos;
76  return *this;
77  }
79  {
80  AccessorIterator<A, T> it = *this;
81  ++*this;
82  return it;
83  }
85  {
86  --pos;
87  return *this;
88  }
90  {
91  AccessorIterator<A, T> it = *this;
92  --*this;
93  return it;
94  }
96  {
97  pos += off;
98  return *this;
99  }
100  inline AccessorIterator<A, T> operator+(int off) const
101  {
102  AccessorIterator<A, T> it = *this;
103  it += off;
104  return it;
105  }
107  {
108  pos -= off;
109  return *this;
110  }
111  inline AccessorIterator<A, T> operator-(int off) const
112  {
113  AccessorIterator<A, T> it = *this;
114  it -= off;
115  return it;
116  }
117  inline int operator-(const AccessorIterator<A, T>& it) const
118  {
119  return pos - it.pos;
120  }
121  inline T& operator[](int off) const { return (*base)[pos + off]; }
122  inline bool operator==(const AccessorIterator<A, T>& it) const
123  {
124  return (pos == it.pos) && (base == it.base);
125  }
126  inline bool operator!=(const AccessorIterator<A, T>& it) const
127  {
128  return !(operator==(it));
129  }
130 };
131 
132 /** Template class for matrix accessor's iterators.
133  * \sa CMatrixRowAccessor,CMatrixColumnAccessor
134  */
135 template <typename A, typename T>
137 {
138  protected:
139  A* base;
140  int pos;
141 
142  public:
143  // typedefs for iterator_traits:
144  using iterator_category = std::random_access_iterator_tag;
145  using value_type = T;
146  using difference_type = int;
147  using pointer = T*;
148  using reference = T&;
149 
150  inline ReverseAccessorIterator(A& obj, size_t N) : base(&obj), pos(N) {}
151  inline T& operator*() const { return (*base)[pos]; }
153  {
154  --pos;
155  return *this;
156  }
158  {
160  ++*this; // Yes, that's right.
161  return it;
162  }
164  {
165  ++pos;
166  return *this;
167  }
169  {
171  --*this; // Yes, that's right.
172  return it;
173  }
175  {
176  pos -= off;
177  return *this;
178  }
180  {
182  it += off; // Yes, that's right.
183  return it;
184  }
186  {
187  pos += off;
188  return *this;
189  }
190  inline AccessorIterator<A, T> operator-(int off) const
191  {
193  it -= off; // Yes, that's right
194  return it;
195  }
196  inline int operator-(const ReverseAccessorIterator<A, T>& it) const
197  {
198  return it.pos - pos;
199  }
200  inline T& operator[](int off) const { return (*base)[pos - off]; }
201  inline bool operator==(const ReverseAccessorIterator<A, T>& it) const
202  {
203  return (pos == it.pos) && (&base == &it.base);
204  }
205  inline bool operator!=(const ReverseAccessorIterator<A, T>& it) const
206  {
207  return !(operator==(it));
208  }
209 };
210 } // namespace detail
211 
212 /** A vector-like wrapper for a Matrix for accessing the elements of a given row
213  * with a [] operator.
214  * For usage with MRPT's CMatrixDynamic only (for MRPT numeric matrices, use
215  * Eigen methods)
216  * \sa
217  * CMatrixColumnAccessor,CMatrixRowAccessorExtended,CConstMatrixRowAccessor,CConstMatrixRowAccessorExtended
218  */
219 template <typename MAT>
221 {
222  protected:
223  MAT* m_mat;
224  size_t m_rowInd;
225 
226  public:
227  using value_type = typename MAT::Scalar;
229  inline CMatrixRowAccessor(MAT& mat, size_t rowIdx)
230  : m_mat(&mat), m_rowInd(rowIdx)
231  {
232  ASSERT_(rowIdx < mat.rows();
233  }
234  inline CMatrixRowAccessor() {}
235  inline value_type& operator[](const size_t i)
236  {
237  return (*m_mat)(m_rowInd, i);
238  }
239  inline value_type operator[](const size_t i) const
240  {
241  return (*m_mat)(m_rowInd, i);
242  }
243  using iterator =
247  using reverse_iterator =
251  inline iterator begin() { return iterator(*this, 0); }
252  inline const_iterator begin() const { return const_iterator(*this, 0); }
253  inline iterator end() { return iterator(*this, m_mat->cols()); }
254  inline const_iterator end() const
255  {
256  return const_iterator(*this, m_mat->cols());
257  }
259  {
260  return reverse_iterator(*this, m_mat->cols() - 1);
261  }
263  {
264  return const_reverse_iterator(*this, m_mat->cols() - 1);
265  }
266  inline reverse_iterator rend() { return reverse_iterator(*this, -1); }
268  {
269  return const_reverse_iterator(*this, -1);
270  }
271  inline size_t size() const { return m_mat->cols(); }
272  inline void resize(size_t N)
273  {
274  if (N != size())
275  throw std::logic_error("Tried to resize a fixed-size vector");
276  }
277 };
278 template <typename MAT>
279 inline CMatrixRowAccessor<MAT> getRowAccessor(MAT& m, size_t rowIdx)
280 {
281  return CMatrixRowAccessor<MAT>(m, rowIdx);
282 }
283 
284 /** A vector-like wrapper for a Matrix for accessing the elements of a given row
285  * with a [] operator, with offset and custom spacing.
286  * For usage with MRPT's CMatrixDynamic only (for MRPT numeric matrices, use
287  * Eigen methods)
288  * \sa
289  * CMatrixColumnAccessorExtended,CMatrixRowAccessor,CConstMatrixRowAccessor,CConstMatrixRowAccessorExtended
290  */
291 template <class MAT>
293 {
294  protected:
295  MAT* m_mat;
296  size_t m_rowInd;
297  size_t m_colOffset;
299  size_t howMany;
300 
301  public:
302  using value_type = typename MAT::Scalar;
305  MAT& mat, size_t row, size_t offset, size_t space)
306  : m_mat(&mat),
307  m_rowInd(row),
308  m_colOffset(offset),
309  m_elementsSpace(space)
310  {
311  ASSERT_(row < mat.rows());
312  howMany = (mat.cols() - m_colOffset) / m_elementsSpace;
313  }
315  inline value_type& operator[](size_t i)
316  {
317  return (*m_mat)(m_rowInd, m_colOffset + (i * m_elementsSpace));
318  }
319  inline value_type operator[](size_t i) const
320  {
321  return (*m_mat)(m_rowInd, m_colOffset + (i * m_elementsSpace));
322  }
323  using iterator =
331  inline iterator begin() { return iterator(*this, 0); }
332  inline const_iterator begin() const { return const_iterator(*this, 0); }
333  inline iterator end() { return iterator(*this, howMany); }
334  inline const_iterator end() const { return const_iterator(*this, howMany); }
336  {
337  return reverse_iterator(*this, howMany - 1);
338  }
340  {
341  return const_reverse_iterator(*this, howMany - 1);
342  }
343  inline reverse_iterator rend() { return reverse_iterator(*this, -1); }
345  {
346  return const_reverse_iterator(*this, -1);
347  }
348  inline size_t size() const { return howMany; }
349  inline void resize(size_t N)
350  {
351  if (N != size())
352  throw std::logic_error("Tried to resize a fixed-size vector");
353  }
354 };
355 template <typename MAT>
357  MAT& m, size_t rowIdx, size_t offset, size_t space = 1)
358 {
359  return CMatrixRowAccessor<MAT>(m, rowIdx, offset, space);
360 }
361 
362 /** A vector-like wrapper for a const Matrix for accessing the elements of a
363  * given row with a [] operator.
364  * For usage with MRPT's CMatrixDynamic only (for MRPT numeric matrices, use
365  * Eigen methods)
366  * \sa
367  * CConstMatrixColumnAccessor,CMatrixRowAccessorExtended,CMatrixRowAccessor,CConstMatrixRowAccessorExtended
368  */
369 template <class MAT>
371 {
372  protected:
373  const MAT* m_mat;
374  size_t m_rowInd;
375 
376  public:
377  using value_type = typename MAT::Scalar;
379  inline CConstMatrixRowAccessor(const MAT& mat, size_t row)
380  : m_mat(&mat), m_rowInd(row)
381  {
382  ASSERT_(row < mat.rows());
383  }
385  inline value_type operator[](size_t i) const
386  {
387  return (*m_mat)(m_rowInd, i);
388  }
393  inline const_iterator begin() const { return const_iterator(*this, 0); }
394  inline const_iterator end() const
395  {
396  return const_iterator(*this, m_mat->cols());
397  }
399  {
400  return const_reverse_iterator(*this, m_mat->cols() - 1);
401  }
403  {
404  return const_reverse_iterator(*this, -1);
405  }
406  inline size_t size() const { return m_mat->cols(); }
407  inline void resize(size_t N)
408  {
409  if (N != size())
410  throw std::logic_error("Tried to resize a fixed-size vector");
411  }
412 };
413 template <typename MAT>
414 inline CConstMatrixRowAccessor<MAT> getRowAccessor(const MAT& m, size_t rowIdx)
415 {
416  return CMatrixRowAccessor<MAT>(m, rowIdx);
417 }
418 
419 /** A vector-like wrapper for a const Matrix for accessing the elements of a
420  * given row with a [] operator, with offset and custom spacing.
421  * For usage with MRPT's CMatrixDynamic only (for MRPT numeric matrices, use
422  * Eigen methods)
423  * \sa
424  * CConstMatrixColumnAccessorExtended,CMatrixRowAccessor,CConstMatrixRowAccessor,CMatrixRowAccessorExtended
425  */
426 template <class MAT>
428 {
429  protected:
430  const MAT* m_mat;
431  size_t m_rowInd;
432  size_t m_colOffset;
434  size_t howMany;
435 
436  public:
437  using value_type = typename MAT::Scalar;
440  const MAT& mat, size_t row, size_t offset, size_t space)
441  : m_mat(&mat),
442  m_rowInd(row),
443  m_colOffset(offset),
444  m_elementsSpace(space)
445  {
446  ASSERT_(row < mat.rows());
447  howMany = (mat.cols() - m_colOffset) / m_elementsSpace;
448  }
450  inline value_type operator[](size_t i) const
451  {
452  return (*m_mat)(m_rowInd, m_colOffset + (i * m_elementsSpace));
453  }
458  inline const_iterator begin() const { return const_iterator(*this, 0); }
459  inline const_iterator end() const { return const_iterator(*this, howMany); }
461  {
462  return const_reverse_iterator(*this, howMany - 1);
463  }
465  {
466  return const_reverse_iterator(*this, -1);
467  }
468  inline size_t size() const { return howMany; }
469  inline void resize(size_t N)
470  {
471  if (N != size())
472  throw std::logic_error("Tried to resize a fixed-size vector");
473  }
474 };
475 template <typename MAT>
477  const MAT& m, size_t rowIdx, size_t offset, size_t space = 1)
478 {
479  return CConstMatrixRowAccessorExtended<MAT>(m, rowIdx, offset, space);
480 }
481 
482 /** A vector-like wrapper for a Matrix for accessing the elements of a given
483  * column with a [] operator.
484  * \sa
485  * CMatrixRowAccessor,CMatrixColumnAccessorExtended,CConstMatrixColumnAccessor,CConstMatrixColumnAccessorExtended
486  */
487 template <typename MAT>
489 {
490  protected:
491  MAT* m_mat;
492  size_t m_colInd;
493 
494  public:
495  using value_type = typename MAT::Scalar;
497  inline CMatrixColumnAccessor(MAT& mat, size_t colIdx)
498  : m_mat(&mat), m_colInd(colIdx)
499  {
500  ASSERT_(colIdx < mat.cols();
501  }
503  inline value_type& operator[](const size_t i)
504  {
505  return (*m_mat)(i, m_colInd);
506  }
507  inline value_type operator[](const size_t i) const
508  {
509  return (*m_mat)(i, m_colInd);
510  }
511  using iterator =
515  using reverse_iterator =
519  inline iterator begin() { return iterator(*this, 0); }
520  inline const_iterator begin() const { return const_iterator(*this, 0); }
521  inline iterator end() { return iterator(*this, m_mat->rows()); }
522  inline const_iterator end() const
523  {
524  return const_iterator(*this, m_mat->rows());
525  }
527  {
528  return reverse_iterator(*this, m_mat->rows() - 1);
529  }
531  {
532  return const_reverse_iterator(*this, m_mat->rows() - 1);
533  }
534  inline reverse_iterator rend() { return reverse_iterator(*this, -1); }
536  {
537  return const_reverse_iterator(*this, -1);
538  }
539  inline size_t size() const { return m_mat->rows(); }
540  inline void resize(size_t N)
541  {
542  if (N != size())
543  throw std::logic_error("Tried to resize a fixed-size vector");
544  }
545 };
546 template <typename MAT>
547 inline CMatrixColumnAccessor<MAT> getColumnAccessor(MAT& m, size_t colIdx)
548 {
549  return CMatrixColumnAccessor<MAT>(m, colIdx);
550 }
551 
552 /** A vector-like wrapper for a Matrix for accessing the elements of a given
553  * column with a [] operator, with offset and custom spacing.
554  * \sa
555  * CMatrixRowAccessorExtended,CMatrixColumnAccessor,CConstMatrixColumnAccessor,CConstMatrixColumnAccessorExtended
556  */
557 template <typename MAT>
559 {
560  protected:
561  MAT* m_mat;
562  size_t m_colInd;
563  size_t m_rowOffset;
565  size_t howMany;
566 
567  public:
568  using value_type = typename MAT::Scalar;
571  MAT& mat, size_t col, size_t offset, size_t space)
572  : m_mat(&mat),
573  m_colInd(col),
574  m_rowOffset(offset),
575  m_elementsSpace(space)
576  {
577  ASSERT_(col < mat.cols());
578  howMany = (mat.rows() - m_rowOffset) / m_elementsSpace;
579  }
581  inline value_type& operator[](size_t i)
582  {
583  return (*m_mat)(m_rowOffset + (i * m_elementsSpace), m_colInd);
584  }
585  inline value_type operator[](size_t i) const
586  {
587  return (*m_mat)(m_rowOffset + (i * m_elementsSpace), m_colInd);
588  }
597  inline iterator begin() { return iterator(*this, 0); }
598  inline const_iterator begin() const { return const_iterator(*this, 0); }
599  inline iterator end() { return iterator(*this, howMany); }
600  inline const_iterator end() const { return const_iterator(*this, howMany); }
602  {
603  return reverse_iterator(*this, howMany - 1);
604  }
606  {
607  return const_reverse_iterator(*this, howMany - 1);
608  }
609  inline reverse_iterator rend() { return reverse_iterator(*this, -1); }
611  {
612  return const_reverse_iterator(*this, -1);
613  }
614  inline size_t size() const { return howMany; }
615  inline void resize(size_t N)
616  {
617  if (N != size())
618  throw std::logic_error("Tried to resize a fixed-size vector");
619  }
620 };
621 template <typename MAT>
623  MAT& m, size_t colIdx, size_t offset, size_t space = 1)
624 {
625  return CMatrixColumnAccessorExtended<MAT>(m, colIdx, offset, space);
626 }
627 
628 /** A vector-like wrapper for a const Matrix for accessing the elements of a
629  * given column with a [] operator.
630  * \sa
631  * CConstMatrixRowAccessor,CMatrixColumnAccessorExtended,CMatrixColumnAccessor,CConstMatrixColumnAccessorExtended
632  */
633 template <class MAT>
635 {
636  protected:
637  const MAT* m_mat;
638  size_t m_colInd;
639 
640  public:
641  using value_type = typename MAT::Scalar;
643  inline CConstMatrixColumnAccessor(const MAT& mat, size_t colIdx)
644  : m_mat(&mat), m_colInd(colIdx)
645  {
646  ASSERT_(colIdx < mat.cols());
647  }
649  inline value_type operator[](size_t i) const
650  {
651  return (*m_mat)(i, m_colInd);
652  }
657  inline const_iterator begin() const { return const_iterator(*this, 0); }
658  inline const_iterator end() const
659  {
660  return const_iterator(*this, m_mat->rows());
661  }
663  {
664  return const_reverse_iterator(*this, m_mat->rows() - 1);
665  }
667  {
668  return const_reverse_iterator(*this, -1);
669  }
670  inline size_t size() const { return m_mat->rows(); }
671  inline void resize(size_t N)
672  {
673  if (N != size())
674  throw std::logic_error("Tried to resize a fixed-size vector");
675  }
676 };
677 template <typename MAT>
679  const MAT& m, size_t colIdx)
680 {
681  return CConstMatrixColumnAccessor<MAT>(m, colIdx);
682 }
683 
684 /** A vector-like wrapper for a const Matrix for accessing the elements of a
685  * given column with a [] operator, with offset and custom spacing.
686  * \sa
687  * CConstMatrixRowAccessorExtended,CMatrixColumnAccessor,CConstMatrixColumnAccessor,CMatrixColumnAccessorExtended
688  */
689 template <typename MAT>
691 {
692  protected:
693  const MAT* m_mat;
694  size_t m_colInd;
695  size_t m_rowOffset;
697  size_t howMany;
698 
699  public:
700  using value_type = typename MAT::Scalar;
703  const MAT& mat, size_t col, size_t offset, size_t space)
704  : m_mat(&mat),
705  m_colInd(col),
706  m_rowOffset(offset),
707  m_elementsSpace(space)
708  {
709  ASSERT_(col < mat.cols());
710  howMany = (mat.rows() - m_rowOffset) / m_elementsSpace;
711  }
713  inline value_type operator[](size_t i) const
714  {
715  return (*m_mat)(m_rowOffset + (i * m_elementsSpace), m_colInd);
716  }
721  inline const_iterator begin() const { return const_iterator(*this, 0); }
722  inline const_iterator end() const { return const_iterator(*this, howMany); }
724  {
725  return const_reverse_iterator(*this, howMany - 1);
726  }
728  {
729  return const_reverse_iterator(*this, -1);
730  }
731  inline size_t size() const { return howMany; }
732  inline void resize(size_t N)
733  {
734  if (N != size())
735  throw std::logic_error("Tried to resize a fixed-size vector");
736  }
737 };
738 template <typename MAT>
740  const MAT& m, size_t colIdx, size_t offset, size_t space = 1)
741 {
742  return CConstMatrixColumnAccessorExtended<MAT>(m, colIdx, offset, space);
743 }
744 
745 } // namespace math
746 } // namespace mrpt
mrpt::math::CConstMatrixRowAccessorExtended::operator[]
value_type operator[](size_t i) const
Definition: matrix_adaptors.h:450
mrpt::math::detail::ReverseAccessorIterator::iterator_category
std::random_access_iterator_tag iterator_category
Definition: matrix_adaptors.h:144
mrpt::math::CConstMatrixColumnAccessor::const_iterator
detail::AccessorIterator< const CConstMatrixColumnAccessor< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:654
mrpt::math::CConstMatrixRowAccessor::const_reverse_iterator
detail::ReverseAccessorIterator< const CConstMatrixRowAccessor< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:392
mrpt::math::CMatrixRowAccessorExtended::m_mat
MAT * m_mat
Definition: matrix_adaptors.h:295
mrpt::math::CMatrixColumnAccessor::rbegin
reverse_iterator rbegin()
Definition: matrix_adaptors.h:526
mrpt::math::CConstMatrixColumnAccessorExtended::m_colInd
size_t m_colInd
Definition: matrix_adaptors.h:694
mrpt::math::CMatrixRowAccessorExtended::rbegin
reverse_iterator rbegin()
Definition: matrix_adaptors.h:335
mrpt::math::CMatrixColumnAccessorExtended::iterator
detail::AccessorIterator< CMatrixColumnAccessorExtended< MAT >, value_type > iterator
Definition: matrix_adaptors.h:590
mrpt::math::CConstMatrixRowAccessor::end
const_iterator end() const
Definition: matrix_adaptors.h:394
mrpt::math::CMatrixRowAccessorExtended::end
const_iterator end() const
Definition: matrix_adaptors.h:334
mrpt::math::CConstMatrixColumnAccessorExtended::resize
void resize(size_t N)
Definition: matrix_adaptors.h:732
mrpt::math::CConstMatrixRowAccessorExtended::CConstMatrixRowAccessorExtended
CConstMatrixRowAccessorExtended()
Definition: matrix_adaptors.h:449
mrpt::math::CConstMatrixColumnAccessorExtended::m_mat
const MAT * m_mat
Definition: matrix_adaptors.h:693
mrpt::math::detail::ReverseAccessorIterator::pos
int pos
Definition: matrix_adaptors.h:140
mrpt::math::CMatrixRowAccessor::operator[]
value_type & operator[](const size_t i)
Definition: matrix_adaptors.h:235
mrpt::math::CMatrixColumnAccessor::operator[]
value_type operator[](const size_t i) const
Definition: matrix_adaptors.h:507
mrpt::math::detail::AccessorIterator::operator+=
AccessorIterator< A, T > & operator+=(int off)
Definition: matrix_adaptors.h:95
mrpt::math::detail::AccessorIterator::operator-=
AccessorIterator< A, T > & operator-=(int off)
Definition: matrix_adaptors.h:106
mrpt::math::detail::AccessorIterator::operator*
T & operator*() const
Definition: matrix_adaptors.h:72
mrpt::math::CMatrixRowAccessor::value_type
typename MAT::Scalar value_type
Definition: matrix_adaptors.h:227
mrpt::math::CMatrixColumnAccessorExtended::howMany
size_t howMany
Definition: matrix_adaptors.h:565
mrpt::math::detail::AccessorIterator::base
A * base
Definition: matrix_adaptors.h:60
mrpt::math::CMatrixColumnAccessor::begin
iterator begin()
Definition: matrix_adaptors.h:519
mrpt::math::CConstMatrixColumnAccessor::begin
const_iterator begin() const
Definition: matrix_adaptors.h:657
mrpt::math::CMatrixRowAccessorExtended::value_type
typename MAT::Scalar value_type
Definition: matrix_adaptors.h:302
mrpt::math::CConstMatrixRowAccessorExtended::value_type
typename MAT::Scalar value_type
Definition: matrix_adaptors.h:437
mrpt::math::CMatrixRowAccessorExtended::reverse_iterator
detail::ReverseAccessorIterator< CMatrixRowAccessorExtended< MAT >, value_type > reverse_iterator
Definition: matrix_adaptors.h:328
mrpt::math::detail::AccessorIterator::difference_type
int difference_type
Definition: matrix_adaptors.h:67
mrpt::math::CMatrixRowAccessorExtended::iterator
detail::AccessorIterator< CMatrixRowAccessorExtended< MAT >, value_type > iterator
Definition: matrix_adaptors.h:324
mrpt::math::detail::AccessorIterator
Template class for matrix accessor's iterators.
Definition: matrix_adaptors.h:57
mrpt::math::CConstMatrixRowAccessorExtended::const_iterator
detail::AccessorIterator< const CConstMatrixRowAccessorExtended< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:455
mrpt::math::CConstMatrixColumnAccessorExtended::howMany
size_t howMany
Definition: matrix_adaptors.h:697
mrpt::math::CConstMatrixRowAccessor::resize
void resize(size_t N)
Definition: matrix_adaptors.h:407
mrpt::math::CMatrixColumnAccessor::CMatrixColumnAccessor
CMatrixColumnAccessor()
Definition: matrix_adaptors.h:502
mrpt::math::CBinaryRelation
This class models a binary relation through the elements of any given set.
Definition: CBinaryRelation.h:41
mrpt::math::CConstMatrixColumnAccessor::m_mat
const MAT * m_mat
Definition: matrix_adaptors.h:637
mrpt::math::CMatrixColumnAccessorExtended::CMatrixColumnAccessorExtended
CMatrixColumnAccessorExtended(MAT &mat, size_t col, size_t offset, size_t space)
Definition: matrix_adaptors.h:570
mrpt::math::CConstMatrixColumnAccessorExtended::size
size_t size() const
Definition: matrix_adaptors.h:731
mrpt::math::CConstMatrixRowAccessorExtended::m_colOffset
size_t m_colOffset
Definition: matrix_adaptors.h:432
mrpt::math::CMatrixRowAccessorExtended::size
size_t size() const
Definition: matrix_adaptors.h:348
mrpt::math::detail::ReverseAccessorIterator::operator==
bool operator==(const ReverseAccessorIterator< A, T > &it) const
Definition: matrix_adaptors.h:201
mrpt::math::CMatrixColumnAccessorExtended::CMatrixColumnAccessorExtended
CMatrixColumnAccessorExtended()
Definition: matrix_adaptors.h:580
mrpt::math::CMatrixRowAccessorExtended::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:339
mrpt::math::detail::ReverseAccessorIterator::operator*
T & operator*() const
Definition: matrix_adaptors.h:151
mrpt::math::detail::AccessorIterator::operator--
AccessorIterator< A, T > & operator--()
Definition: matrix_adaptors.h:84
mrpt::math::detail::ReverseAccessorIterator
Template class for matrix accessor's iterators.
Definition: matrix_adaptors.h:136
mrpt::math::detail::AccessorIterator::operator==
bool operator==(const AccessorIterator< A, T > &it) const
Definition: matrix_adaptors.h:122
mrpt::math::detail::AccessorIterator::operator!=
bool operator!=(const AccessorIterator< A, T > &it) const
Definition: matrix_adaptors.h:126
mrpt::math::CMatrixColumnAccessorExtended::size
size_t size() const
Definition: matrix_adaptors.h:614
mrpt::math::CMatrixColumnAccessorExtended::rend
reverse_iterator rend()
Definition: matrix_adaptors.h:609
mrpt::math::CConstMatrixRowAccessorExtended::begin
const_iterator begin() const
Definition: matrix_adaptors.h:458
mrpt::math::detail::applyFunction
void applyFunction(CBinaryRelation< T, U, UIsObject > &o, FunctionType fun, size_t e1, size_t e2, const T &T1, const T &T2)
Definition: CBinaryRelation.h:562
mrpt::math::CMatrixRowAccessorExtended::resize
void resize(size_t N)
Definition: matrix_adaptors.h:349
mrpt::math::CMatrixRowAccessor::iterator
detail::AccessorIterator< CMatrixRowAccessor< MAT >, value_type > iterator
Definition: matrix_adaptors.h:244
mrpt::math::CConstMatrixColumnAccessorExtended
A vector-like wrapper for a const Matrix for accessing the elements of a given column with a [] opera...
Definition: matrix_adaptors.h:690
mrpt::math::CMatrixRowAccessorExtended::m_elementsSpace
size_t m_elementsSpace
Definition: matrix_adaptors.h:298
mrpt::math::detail::ReverseAccessorIterator::operator!=
bool operator!=(const ReverseAccessorIterator< A, T > &it) const
Definition: matrix_adaptors.h:205
mrpt::math::CConstMatrixColumnAccessor::operator[]
value_type operator[](size_t i) const
Definition: matrix_adaptors.h:649
mrpt::math::CConstMatrixColumnAccessorExtended::operator[]
value_type operator[](size_t i) const
Definition: matrix_adaptors.h:713
mrpt::math::getColumnAccessor
CMatrixColumnAccessor< MAT > getColumnAccessor(MAT &m, size_t colIdx)
Definition: matrix_adaptors.h:547
mrpt::math::detail::AccessorIterator::operator++
AccessorIterator< A, T > operator++(int)
Definition: matrix_adaptors.h:78
mrpt::math::detail::ReverseAccessorIterator::operator-
AccessorIterator< A, T > operator-(int off) const
Definition: matrix_adaptors.h:190
mrpt::math::detail::AccessorIterator::reference
T & reference
Definition: matrix_adaptors.h:69
mrpt::math::CMatrixRowAccessor::m_mat
MAT * m_mat
Definition: matrix_adaptors.h:223
mrpt::math::CMatrixColumnAccessorExtended::operator[]
value_type & operator[](size_t i)
Definition: matrix_adaptors.h:581
mrpt::math::CConstMatrixColumnAccessor::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:666
mrpt::math::detail::ReverseAccessorIterator::operator--
ReverseAccessorIterator< A, T > operator--(int)
Definition: matrix_adaptors.h:168
mrpt
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
Definition: BaseAppDataSource.h:15
mrpt::math::CConstMatrixRowAccessor::value_type
typename MAT::Scalar value_type
Definition: matrix_adaptors.h:377
mrpt::math::CMatrixColumnAccessorExtended::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:610
mrpt::math::CConstMatrixColumnAccessorExtended::CConstMatrixColumnAccessorExtended
CConstMatrixColumnAccessorExtended()
Definition: matrix_adaptors.h:712
mrpt::math::CConstMatrixRowAccessorExtended::end
const_iterator end() const
Definition: matrix_adaptors.h:459
mrpt::math::CConstMatrixRowAccessor::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:402
mrpt::math::CMatrixRowAccessorExtended::const_iterator
detail::AccessorIterator< const CMatrixRowAccessorExtended< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:326
mrpt::math::CMatrixColumnAccessor::reverse_iterator
detail::ReverseAccessorIterator< CMatrixColumnAccessor< MAT >, value_type > reverse_iterator
Definition: matrix_adaptors.h:516
mrpt::math::CMatrixRowAccessor::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:267
ASSERT_
#define ASSERT_(f)
Defines an assertion mechanism.
Definition: exceptions.h:120
mrpt::math::CMatrixRowAccessor
A vector-like wrapper for a Matrix for accessing the elements of a given row with a [] operator.
Definition: matrix_adaptors.h:220
mrpt::math::detail::AccessorIterator::operator+
AccessorIterator< A, T > operator+(int off) const
Definition: matrix_adaptors.h:100
mrpt::math::CMatrixColumnAccessorExtended
A vector-like wrapper for a Matrix for accessing the elements of a given column with a [] operator,...
Definition: matrix_adaptors.h:558
mrpt::math::CMatrixRowAccessor::CMatrixRowAccessor
CMatrixRowAccessor()
Definition: matrix_adaptors.h:234
mrpt::math::CMatrixRowAccessor::const_reverse_iterator
detail::ReverseAccessorIterator< const CMatrixRowAccessor< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:250
mrpt::math::CMatrixRowAccessor::m_rowInd
size_t m_rowInd
Definition: matrix_adaptors.h:224
mrpt::math::CMatrixColumnAccessor::m_colInd
size_t m_colInd
Definition: matrix_adaptors.h:492
mrpt::math::CMatrixRowAccessor::const_iterator
detail::AccessorIterator< const CMatrixRowAccessor< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:246
mrpt::math::CConstMatrixRowAccessor::m_rowInd
size_t m_rowInd
Definition: matrix_adaptors.h:374
mrpt::math::CMatrixRowAccessorExtended::begin
iterator begin()
Definition: matrix_adaptors.h:331
Scalar
double Scalar
Definition: KmUtils.h:43
mrpt::math::CConstMatrixRowAccessor::CConstMatrixRowAccessor
CConstMatrixRowAccessor()
Definition: matrix_adaptors.h:384
mrpt::math::CMatrixColumnAccessorExtended::end
iterator end()
Definition: matrix_adaptors.h:599
mrpt::math::CMatrixColumnAccessorExtended::m_elementsSpace
size_t m_elementsSpace
Definition: matrix_adaptors.h:564
mrpt::math::CConstMatrixRowAccessor::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:398
mrpt::math::CConstMatrixRowAccessorExtended::resize
void resize(size_t N)
Definition: matrix_adaptors.h:469
mrpt::math::CConstMatrixColumnAccessorExtended::m_rowOffset
size_t m_rowOffset
Definition: matrix_adaptors.h:695
mrpt::math::detail::ReverseAccessorIterator::difference_type
int difference_type
Definition: matrix_adaptors.h:146
mrpt::math::detail::AccessorIterator::operator-
int operator-(const AccessorIterator< A, T > &it) const
Definition: matrix_adaptors.h:117
mrpt::math::CMatrixRowAccessorExtended::howMany
size_t howMany
Definition: matrix_adaptors.h:299
mrpt::math::detail::ReverseAccessorIterator::operator-=
AccessorIterator< A, T > & operator-=(int off)
Definition: matrix_adaptors.h:185
mrpt::math::detail::ReverseAccessorIterator::value_type
T value_type
Definition: matrix_adaptors.h:145
mrpt::math::CConstMatrixColumnAccessorExtended::end
const_iterator end() const
Definition: matrix_adaptors.h:722
mrpt::math::CConstMatrixColumnAccessor::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:662
mrpt::math::detail::AccessorIterator::value_type
T value_type
Definition: matrix_adaptors.h:66
mrpt::math::detail::ReverseAccessorIterator::operator--
ReverseAccessorIterator< A, T > & operator--()
Definition: matrix_adaptors.h:163
mrpt::math::CMatrixColumnAccessor::rend
reverse_iterator rend()
Definition: matrix_adaptors.h:534
mrpt::math::CMatrixColumnAccessorExtended::value_type
typename MAT::Scalar value_type
Definition: matrix_adaptors.h:568
mrpt::math::detail::AccessorIterator::AccessorIterator
AccessorIterator(A &obj, size_t N)
Definition: matrix_adaptors.h:71
mrpt::math::CConstMatrixColumnAccessor::size
size_t size() const
Definition: matrix_adaptors.h:670
mrpt::math::CMatrixRowAccessorExtended::const_reverse_iterator
detail::ReverseAccessorIterator< const CMatrixRowAccessorExtended< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:330
mrpt::math::CConstMatrixColumnAccessor::CConstMatrixColumnAccessor
CConstMatrixColumnAccessor()
Definition: matrix_adaptors.h:648
mrpt::math::CMatrixColumnAccessor::const_iterator
detail::AccessorIterator< const CMatrixColumnAccessor< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:514
mrpt::math::detail::ReverseAccessorIterator::reference
T & reference
Definition: matrix_adaptors.h:148
mrpt::math::CConstMatrixRowAccessor::const_iterator
detail::AccessorIterator< const CConstMatrixRowAccessor< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:390
mrpt::math::CMatrixColumnAccessorExtended::reverse_iterator
detail::ReverseAccessorIterator< CMatrixColumnAccessorExtended< MAT >, value_type > reverse_iterator
Definition: matrix_adaptors.h:594
mrpt::math::CMatrixColumnAccessor::CMatrixColumnAccessor
CMatrixColumnAccessor(MAT &mat, size_t colIdx)
Definition: matrix_adaptors.h:497
mrpt::math::CMatrixRowAccessorExtended::m_rowInd
size_t m_rowInd
Definition: matrix_adaptors.h:296
mrpt::math::CConstMatrixRowAccessor::m_mat
const MAT * m_mat
Definition: matrix_adaptors.h:373
mrpt::math::CMatrixRowAccessorExtended::rend
reverse_iterator rend()
Definition: matrix_adaptors.h:343
mrpt::math::CMatrixColumnAccessor::begin
const_iterator begin() const
Definition: matrix_adaptors.h:520
mrpt::math::CMatrixRowAccessorExtended
A vector-like wrapper for a Matrix for accessing the elements of a given row with a [] operator,...
Definition: matrix_adaptors.h:292
mrpt::math::CConstMatrixRowAccessorExtended::m_rowInd
size_t m_rowInd
Definition: matrix_adaptors.h:431
mrpt::math::CMatrixColumnAccessorExtended::m_rowOffset
size_t m_rowOffset
Definition: matrix_adaptors.h:563
mrpt::math::CMatrixRowAccessor::end
const_iterator end() const
Definition: matrix_adaptors.h:254
mrpt::math::CConstMatrixRowAccessorExtended::size
size_t size() const
Definition: matrix_adaptors.h:468
mrpt::math::detail::ReverseAccessorIterator::operator+
ReverseAccessorIterator< A, T > operator+(int off) const
Definition: matrix_adaptors.h:179
mrpt::math::CMatrixColumnAccessor::end
iterator end()
Definition: matrix_adaptors.h:521
mrpt::math::CMatrixColumnAccessor::operator[]
value_type & operator[](const size_t i)
Definition: matrix_adaptors.h:503
mrpt::math::CMatrixRowAccessorExtended::CMatrixRowAccessorExtended
CMatrixRowAccessorExtended(MAT &mat, size_t row, size_t offset, size_t space)
Definition: matrix_adaptors.h:304
mrpt::math::CConstMatrixColumnAccessor::resize
void resize(size_t N)
Definition: matrix_adaptors.h:671
mrpt::math::CMatrixRowAccessor::resize
void resize(size_t N)
Definition: matrix_adaptors.h:272
mrpt::math::CConstMatrixRowAccessorExtended::m_elementsSpace
size_t m_elementsSpace
Definition: matrix_adaptors.h:433
mrpt::math::detail::MatrixWrapper
This template is a trick to switch the type of a variable using a boolean variable in the template.
Definition: matrix_adaptors.h:29
mrpt::math::CMatrixColumnAccessorExtended::m_colInd
size_t m_colInd
Definition: matrix_adaptors.h:562
mrpt::math::CConstMatrixColumnAccessorExtended::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:727
mrpt::math::detail::ReverseAccessorIterator::ReverseAccessorIterator
ReverseAccessorIterator(A &obj, size_t N)
Definition: matrix_adaptors.h:150
mrpt::math::CMatrixColumnAccessor::iterator
detail::AccessorIterator< CMatrixColumnAccessor< MAT >, value_type > iterator
Definition: matrix_adaptors.h:512
mrpt::math::CMatrixRowAccessor::end
iterator end()
Definition: matrix_adaptors.h:253
math_frwds.h
mrpt::math::CMatrixRowAccessor::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:262
mrpt::math::detail::AccessorIterator::operator[]
T & operator[](int off) const
Definition: matrix_adaptors.h:121
mrpt::math::detail::ReverseAccessorIterator::operator[]
T & operator[](int off) const
Definition: matrix_adaptors.h:200
mrpt::math::CConstMatrixColumnAccessor::value_type
typename MAT::Scalar value_type
Definition: matrix_adaptors.h:641
mrpt::math::CMatrixColumnAccessorExtended::const_reverse_iterator
detail::ReverseAccessorIterator< const CMatrixColumnAccessorExtended< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:596
A
Definition: is_defined_unittest.cpp:13
mrpt::math::CMatrixRowAccessor::size
size_t size() const
Definition: matrix_adaptors.h:271
mrpt::math::CMatrixColumnAccessor::size
size_t size() const
Definition: matrix_adaptors.h:539
mrpt::math::detail::ReverseAccessorIterator::operator-
int operator-(const ReverseAccessorIterator< A, T > &it) const
Definition: matrix_adaptors.h:196
mrpt::math::CMatrixColumnAccessor
A vector-like wrapper for a Matrix for accessing the elements of a given column with a [] operator.
Definition: matrix_adaptors.h:488
mrpt::math::CMatrixColumnAccessor::resize
void resize(size_t N)
Definition: matrix_adaptors.h:540
mrpt::math::CConstMatrixColumnAccessorExtended::value_type
typename MAT::Scalar value_type
Definition: matrix_adaptors.h:700
mrpt::math::detail::ReverseAccessorIterator::operator+=
ReverseAccessorIterator< A, T > & operator+=(int off)
Definition: matrix_adaptors.h:174
mrpt::math::CConstMatrixColumnAccessorExtended::m_elementsSpace
size_t m_elementsSpace
Definition: matrix_adaptors.h:696
mrpt::math::CMatrixColumnAccessor::value_type
typename MAT::Scalar value_type
Definition: matrix_adaptors.h:495
mrpt::math::CConstMatrixColumnAccessorExtended::const_reverse_iterator
detail::ReverseAccessorIterator< const CConstMatrixColumnAccessorExtended< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:720
mrpt::math::CMatrixColumnAccessor::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:535
mrpt::math::CConstMatrixColumnAccessorExtended::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:723
mrpt::math::CConstMatrixRowAccessor
A vector-like wrapper for a const Matrix for accessing the elements of a given row with a [] operator...
Definition: matrix_adaptors.h:370
mrpt::math::detail::MatrixWrapper< U, true >::MatrixType
CMatrixTemplateObjects< U > MatrixType
Definition: matrix_adaptors.h:36
mrpt::math::CMatrixRowAccessorExtended::begin
const_iterator begin() const
Definition: matrix_adaptors.h:332
mrpt::math::CConstMatrixRowAccessor::operator[]
value_type operator[](size_t i) const
Definition: matrix_adaptors.h:385
mrpt::math::CConstMatrixColumnAccessor::m_colInd
size_t m_colInd
Definition: matrix_adaptors.h:638
mrpt::math::CMatrixColumnAccessor::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:530
mrpt::math::CConstMatrixRowAccessorExtended
A vector-like wrapper for a const Matrix for accessing the elements of a given row with a [] operator...
Definition: matrix_adaptors.h:427
mrpt::math::CMatrixColumnAccessorExtended::begin
const_iterator begin() const
Definition: matrix_adaptors.h:598
mrpt::math::CMatrixColumnAccessor::end
const_iterator end() const
Definition: matrix_adaptors.h:522
mrpt::math::CMatrixRowAccessor::reverse_iterator
detail::ReverseAccessorIterator< CMatrixRowAccessor< MAT >, value_type > reverse_iterator
Definition: matrix_adaptors.h:248
mrpt::math::CConstMatrixRowAccessorExtended::howMany
size_t howMany
Definition: matrix_adaptors.h:434
mrpt::math::CConstMatrixColumnAccessorExtended::begin
const_iterator begin() const
Definition: matrix_adaptors.h:721
mrpt::math::detail::ReverseAccessorIterator::operator++
ReverseAccessorIterator< A, T > operator++(int)
Definition: matrix_adaptors.h:157
mrpt::math::CConstMatrixRowAccessor::size
size_t size() const
Definition: matrix_adaptors.h:406
mrpt::math::CConstMatrixColumnAccessor::CConstMatrixColumnAccessor
CConstMatrixColumnAccessor(const MAT &mat, size_t colIdx)
Definition: matrix_adaptors.h:643
mrpt::math::CMatrixColumnAccessorExtended::rbegin
reverse_iterator rbegin()
Definition: matrix_adaptors.h:601
mrpt::math::CMatrixRowAccessorExtended::CMatrixRowAccessorExtended
CMatrixRowAccessorExtended()
Definition: matrix_adaptors.h:314
mrpt::math::CConstMatrixColumnAccessor::end
const_iterator end() const
Definition: matrix_adaptors.h:658
mrpt::math::CConstMatrixRowAccessorExtended::CConstMatrixRowAccessorExtended
CConstMatrixRowAccessorExtended(const MAT &mat, size_t row, size_t offset, size_t space)
Definition: matrix_adaptors.h:439
mrpt::math::detail::AccessorIterator::pointer
T * pointer
Definition: matrix_adaptors.h:68
mrpt::math::CMatrixColumnAccessorExtended::begin
iterator begin()
Definition: matrix_adaptors.h:597
mrpt::math::CMatrixColumnAccessorExtended::m_mat
MAT * m_mat
Definition: matrix_adaptors.h:561
mrpt::math::CConstMatrixRowAccessor::CConstMatrixRowAccessor
CConstMatrixRowAccessor(const MAT &mat, size_t row)
Definition: matrix_adaptors.h:379
mrpt::math::CConstMatrixRowAccessorExtended::const_reverse_iterator
detail::ReverseAccessorIterator< const CConstMatrixRowAccessorExtended< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:457
mrpt::math::CMatrixRowAccessorExtended::end
iterator end()
Definition: matrix_adaptors.h:333
mrpt::math::CMatrixRowAccessor::CMatrixRowAccessor
CMatrixRowAccessor(MAT &mat, size_t rowIdx)
Definition: matrix_adaptors.h:229
mrpt::math::CConstMatrixRowAccessorExtended::m_mat
const MAT * m_mat
Definition: matrix_adaptors.h:430
mrpt::math::CConstMatrixRowAccessorExtended::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:460
mrpt::math::CMatrixRowAccessorExtended::operator[]
value_type operator[](size_t i) const
Definition: matrix_adaptors.h:319
mrpt::math::CConstMatrixColumnAccessor
A vector-like wrapper for a const Matrix for accessing the elements of a given column with a [] opera...
Definition: matrix_adaptors.h:634
mrpt::math::CConstMatrixColumnAccessorExtended::const_iterator
detail::AccessorIterator< const CConstMatrixColumnAccessorExtended< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:718
mrpt::math::CConstMatrixColumnAccessor::const_reverse_iterator
detail::ReverseAccessorIterator< const CConstMatrixColumnAccessor< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:656
mrpt::math::detail::ReverseAccessorIterator::operator++
ReverseAccessorIterator< A, T > & operator++()
Definition: matrix_adaptors.h:152
mrpt::math::CMatrixColumnAccessorExtended::operator[]
value_type operator[](size_t i) const
Definition: matrix_adaptors.h:585
mrpt::math::detail::AccessorIterator::operator++
AccessorIterator< A, T > & operator++()
Definition: matrix_adaptors.h:73
mrpt::math::CMatrixRowAccessor::begin
iterator begin()
Definition: matrix_adaptors.h:251
mrpt::math::CMatrixRowAccessorExtended::operator[]
value_type & operator[](size_t i)
Definition: matrix_adaptors.h:315
mrpt::math::CConstMatrixRowAccessor::begin
const_iterator begin() const
Definition: matrix_adaptors.h:393
mrpt::math::CMatrixRowAccessor::rend
reverse_iterator rend()
Definition: matrix_adaptors.h:266
mrpt::math::CMatrixRowAccessor::rbegin
reverse_iterator rbegin()
Definition: matrix_adaptors.h:258
mrpt::math::CMatrixColumnAccessorExtended::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:605
mrpt::math::getRowAccessor
CMatrixRowAccessor< MAT > getRowAccessor(MAT &m, size_t rowIdx)
Definition: matrix_adaptors.h:279
mrpt::math::detail::AccessorIterator::pos
int pos
Definition: matrix_adaptors.h:61
mrpt::math::CMatrixRowAccessor::operator[]
value_type operator[](const size_t i) const
Definition: matrix_adaptors.h:239
mrpt::math::CMatrixColumnAccessorExtended::resize
void resize(size_t N)
Definition: matrix_adaptors.h:615
mrpt::math::detail::AccessorIterator::operator--
AccessorIterator< A, T > operator--(int)
Definition: matrix_adaptors.h:89
mrpt::math::CConstMatrixRowAccessorExtended::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:464
mrpt::math::CMatrixColumnAccessorExtended::const_iterator
detail::AccessorIterator< const CMatrixColumnAccessorExtended< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:592
mrpt::math::CMatrixColumnAccessor::const_reverse_iterator
detail::ReverseAccessorIterator< const CMatrixColumnAccessor< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:518
mrpt::math::detail::AccessorIterator::iterator_category
std::random_access_iterator_tag iterator_category
Definition: matrix_adaptors.h:65
mrpt::math::CMatrixDynamic
This template class provides the basic functionality for a general 2D any-size, resizable container o...
Definition: CMatrixDynamic.h:39
mrpt::math::detail::ReverseAccessorIterator::base
A * base
Definition: matrix_adaptors.h:139
mrpt::math::CMatrixRowAccessor::begin
const_iterator begin() const
Definition: matrix_adaptors.h:252
mrpt::math::CMatrixRowAccessorExtended::m_colOffset
size_t m_colOffset
Definition: matrix_adaptors.h:297
mrpt::math::detail::AccessorIterator::operator-
AccessorIterator< A, T > operator-(int off) const
Definition: matrix_adaptors.h:111
mrpt::math::CMatrixColumnAccessor::m_mat
MAT * m_mat
Definition: matrix_adaptors.h:491
mrpt::math::detail::ReverseAccessorIterator::pointer
T * pointer
Definition: matrix_adaptors.h:147
mrpt::math::CMatrixRowAccessorExtended::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:344
mrpt::math::CMatrixColumnAccessorExtended::end
const_iterator end() const
Definition: matrix_adaptors.h:600
mrpt::math::CConstMatrixColumnAccessorExtended::CConstMatrixColumnAccessorExtended
CConstMatrixColumnAccessorExtended(const MAT &mat, size_t col, size_t offset, size_t space)
Definition: matrix_adaptors.h:702



Page generated by Doxygen 1.8.17 for MRPT 2.0.4 at Sun Jul 19 15:15:43 UTC 2020