Main MRPT website > C++ reference for MRPT 1.4.0
matrix_adaptors.h
Go to the documentation of this file.
1 /* +---------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2016, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +---------------------------------------------------------------------------+ */
9 #ifndef mrpt_matrix_adaptors_H
10 #define mrpt_matrix_adaptors_H
11 
12 #include <mrpt/utils/utils_defs.h>
13 #include <mrpt/math/math_frwds.h> // forward declarations
14 
15 namespace mrpt
16 {
17  namespace math
18  {
19 
20  /** Internal classes not to be directly used by the user. */
21  // Forward declarations:
22  template<typename T,typename U,bool UIsObject> class CBinaryRelation;
23  namespace detail
24  {
25  /**
26  * This template is a trick to switch the type of a variable using a boolean variable in the template. It's easy to extend its functionality to several
27  * types, using a unsigned char instead of a bool.
28  */
29  template<typename U,bool B> class MatrixWrapper;
30 
31  // partial specializations:
32  template<typename U> class MatrixWrapper<U,true> {
33  public:
35  };
36  template<typename U> class MatrixWrapper<U,false> {
37  public:
39  };
40 
41  template<typename T,typename U,bool UIsObject,typename FunctionType> inline void applyFunction(CBinaryRelation<T,U,UIsObject> &o, FunctionType fun,size_t e1,size_t e2,const T &T1,const T &T2);
42  }
43 
44 
45  namespace detail {
46  /** Template class for matrix accessor's iterators.
47  * \sa CMatrixRowAccessor,CMatrixColumnAccessor
48  */
49  template<typename A,typename T> class AccessorIterator {
50  protected:
51  A *base;
52  int pos;
53  public:
54  //typedefs for iterator_traits:
55  typedef std::random_access_iterator_tag iterator_category;
56  typedef T value_type;
57  typedef int difference_type;
58  typedef T *pointer;
59  typedef T &reference;
60 
61  inline AccessorIterator(A &obj,size_t N):base(&obj),pos(N) {}
62  inline T &operator*() const {
63  return (*base)[pos];
64  }
66  ++pos;
67  return *this;
68  }
70  AccessorIterator<A,T> it=*this;
71  ++*this;
72  return it;
73  }
75  --pos;
76  return *this;
77  }
79  AccessorIterator<A,T> it=*this;
80  --*this;
81  return it;
82  }
83  inline AccessorIterator<A,T> &operator+=(int off) {
84  pos+=off;
85  return *this;
86  }
87  inline AccessorIterator<A,T> operator+(int off) const {
88  AccessorIterator<A,T> it=*this;
89  it+=off;
90  return it;
91  }
92  inline AccessorIterator<A,T> &operator-=(int off) {
93  pos-=off;
94  return *this;
95  }
96  inline AccessorIterator<A,T> operator-(int off) const {
97  AccessorIterator<A,T> it=*this;
98  it-=off;
99  return it;
100  }
101  inline int operator-(const AccessorIterator<A,T> &it) const {
102  return pos-it.pos;
103  }
104  inline T &operator[](int off) const {
105  return (*base)[pos+off];
106  }
107  inline bool operator==(const AccessorIterator<A,T> &it) const {
108  return (pos==it.pos)&&(base==it.base);
109  }
110  inline bool operator!=(const AccessorIterator<A,T> &it) const {
111  return !(operator==(it));
112  }
113  };
114 
115  /** Template class for matrix accessor's iterators.
116  * \sa CMatrixRowAccessor,CMatrixColumnAccessor
117  */
118  template<typename A,typename T> class ReverseAccessorIterator {
119  protected:
120  A *base;
121  int pos;
122  public:
123  //typedefs for iterator_traits:
124  typedef std::random_access_iterator_tag iterator_category;
125  typedef T value_type;
126  typedef int difference_type;
127  typedef T *pointer;
128  typedef T &reference;
129 
130  inline ReverseAccessorIterator(A &obj,size_t N):base(&obj),pos(N) {}
131  inline T &operator*() const {
132  return (*base)[pos];
133  }
135  --pos;
136  return *this;
137  }
140  ++*this; //Yes, that's right.
141  return it;
142  }
144  ++pos;
145  return *this;
146  }
149  --*this; //Yes, that's right.
150  return it;
151  }
153  pos-=off;
154  return *this;
155  }
156  inline ReverseAccessorIterator<A,T> operator+(int off) const {
158  it+=off; //Yes, that's right.
159  return it;
160  }
162  pos+=off;
163  return *this;
164  }
165  inline AccessorIterator<A,T> operator-(int off) const {
167  it-=off; //Yes, that's right
168  return it;
169  }
170  inline int operator-(const ReverseAccessorIterator<A,T> &it) const {
171  return it.pos-pos;
172  }
173  inline T &operator[](int off) const {
174  return (*base)[pos-off];
175  }
176  inline bool operator==(const ReverseAccessorIterator<A,T> &it) const {
177  return (pos==it.pos)&&(&base==&it.base);
178  }
179  inline bool operator!=(const ReverseAccessorIterator<A,T> &it) const {
180  return !(operator==(it));
181  }
182  };
183  } //End of detail namespace
184 
185 
186  /** A vector-like wrapper for a Matrix for accessing the elements of a given row with a [] operator.
187  * For usage with MRPT's CMatrixTemplate only (for MRPT numeric matrices, use Eigen methods)
188  * \sa CMatrixColumnAccessor,CMatrixRowAccessorExtended,CConstMatrixRowAccessor,CConstMatrixRowAccessorExtended
189  */
190  template <typename MAT>
192  {
193  protected:
194  MAT *m_mat;
195  size_t m_rowInd;
196  public:
197  typedef typename MAT::Scalar value_type;
199  inline CMatrixRowAccessor(MAT &mat, size_t rowIdx) : m_mat(&mat), m_rowInd(rowIdx) { ASSERT_(rowIdx<mat.getRowCount()) }
200  inline CMatrixRowAccessor() {}
201  inline value_type &operator[](const size_t i) { return (*m_mat)(m_rowInd,i); }
202  inline value_type operator[](const size_t i) const { return (*m_mat)(m_rowInd,i); }
207  inline iterator begin() {
208  return iterator(*this,0);
209  }
210  inline const_iterator begin() const {
211  return const_iterator(*this,0);
212  }
213  inline iterator end() {
214  return iterator(*this,m_mat->getColCount());
215  }
216  inline const_iterator end() const {
217  return const_iterator(*this,m_mat->getColCount());
218  }
220  return reverse_iterator(*this,m_mat->getColCount()-1);
221  }
223  return const_reverse_iterator(*this,m_mat->getColCount()-1);
224  }
226  return reverse_iterator(*this,-1);
227  }
228  inline const_reverse_iterator rend() const {
229  return const_reverse_iterator(*this,-1);
230  }
231  inline size_t size() const {
232  return m_mat->getColCount();
233  }
234  inline void resize(size_t N) {
235  if (N!=size()) throw std::logic_error("Tried to resize a fixed-size vector");
236  }
237  };
238  template<typename MAT> inline CMatrixRowAccessor<MAT> getRowAccessor(MAT &m,size_t rowIdx) {
239  return CMatrixRowAccessor<MAT>(m,rowIdx);
240  }
241 
242  /** A vector-like wrapper for a Matrix for accessing the elements of a given row with a [] operator, with offset and custom spacing.
243  * For usage with MRPT's CMatrixTemplate only (for MRPT numeric matrices, use Eigen methods)
244  * \sa CMatrixColumnAccessorExtended,CMatrixRowAccessor,CConstMatrixRowAccessor,CConstMatrixRowAccessorExtended
245  */
246  template<class MAT>
248  protected:
249  MAT *m_mat;
250  size_t m_rowInd;
251  size_t m_colOffset;
253  size_t howMany;
254  public:
255  typedef typename MAT::Scalar value_type;
257  inline CMatrixRowAccessorExtended(MAT &mat,size_t row,size_t offset,size_t space):m_mat(&mat),m_rowInd(row),m_colOffset(offset),m_elementsSpace(space) {
258  ASSERT_(row<mat.getRowCount());
259  howMany=(mat.getColCount()-m_colOffset)/m_elementsSpace;
260  }
262  inline value_type &operator[](size_t i) {
263  return (*m_mat)(m_rowInd,m_colOffset+(i*m_elementsSpace));
264  }
265  inline value_type operator[](size_t i) const {
266  return (*m_mat)(m_rowInd,m_colOffset+(i*m_elementsSpace));
267  }
272  inline iterator begin() {
273  return iterator(*this,0);
274  }
275  inline const_iterator begin() const {
276  return const_iterator(*this,0);
277  }
278  inline iterator end() {
279  return iterator(*this,howMany);
280  }
281  inline const_iterator end() const {
282  return const_iterator(*this,howMany);
283  }
285  return reverse_iterator(*this,howMany-1);
286  }
288  return const_reverse_iterator(*this,howMany-1);
289  }
291  return reverse_iterator(*this,-1);
292  }
293  inline const_reverse_iterator rend() const {
294  return const_reverse_iterator(*this,-1);
295  }
296  inline size_t size() const {
297  return howMany;
298  }
299  inline void resize(size_t N) {
300  if (N!=size()) throw std::logic_error("Tried to resize a fixed-size vector");
301  }
302  };
303  template<typename MAT> inline CMatrixRowAccessorExtended<MAT> getRowAccessor(MAT &m,size_t rowIdx,size_t offset,size_t space=1) {
304  return CMatrixRowAccessor<MAT>(m,rowIdx,offset,space);
305  }
306 
307  /** A vector-like wrapper for a const Matrix for accessing the elements of a given row with a [] operator.
308  * For usage with MRPT's CMatrixTemplate only (for MRPT numeric matrices, use Eigen methods)
309  * \sa CConstMatrixColumnAccessor,CMatrixRowAccessorExtended,CMatrixRowAccessor,CConstMatrixRowAccessorExtended
310  */
311  template<class MAT>
313  protected:
314  const MAT *m_mat;
315  size_t m_rowInd;
316  public:
317  typedef typename MAT::Scalar value_type;
319  inline CConstMatrixRowAccessor(const MAT &mat,size_t row):m_mat(&mat),m_rowInd(row) {
320  ASSERT_(row<mat.getRowCount());
321  }
323  inline value_type operator[](size_t i) const {
324  return (*m_mat)(m_rowInd,i);
325  }
328  inline const_iterator begin() const {
329  return const_iterator(*this,0);
330  }
331  inline const_iterator end() const {
332  return const_iterator(*this,m_mat->getColCount());
333  }
335  return const_reverse_iterator(*this,m_mat->getColCount()-1);
336  }
337  inline const_reverse_iterator rend() const {
338  return const_reverse_iterator(*this,-1);
339  }
340  inline size_t size() const {
341  return m_mat->getColCount();
342  }
343  inline void resize(size_t N) {
344  if (N!=size()) throw std::logic_error("Tried to resize a fixed-size vector");
345  }
346  };
347  template<typename MAT> inline CConstMatrixRowAccessor<MAT> getRowAccessor(const MAT &m,size_t rowIdx) {
348  return CMatrixRowAccessor<MAT>(m,rowIdx);
349  }
350 
351  /** A vector-like wrapper for a const Matrix for accessing the elements of a given row with a [] operator, with offset and custom spacing.
352  * For usage with MRPT's CMatrixTemplate only (for MRPT numeric matrices, use Eigen methods)
353  * \sa CConstMatrixColumnAccessorExtended,CMatrixRowAccessor,CConstMatrixRowAccessor,CMatrixRowAccessorExtended
354  */
355  template<class MAT>
357  protected:
358  const MAT *m_mat;
359  size_t m_rowInd;
360  size_t m_colOffset;
362  size_t howMany;
363  public:
364  typedef typename MAT::Scalar value_type;
366  inline CConstMatrixRowAccessorExtended(const MAT &mat,size_t row,size_t offset,size_t space):m_mat(&mat),m_rowInd(row),m_colOffset(offset),m_elementsSpace(space) {
367  ASSERT_(row<mat.getRowCount());
368  howMany=(mat.getColCount()-m_colOffset)/m_elementsSpace;
369  }
371  inline value_type operator[](size_t i) const {
372  return (*m_mat)(m_rowInd,m_colOffset+(i*m_elementsSpace));
373  }
376  inline const_iterator begin() const {
377  return const_iterator(*this,0);
378  }
379  inline const_iterator end() const {
380  return const_iterator(*this,howMany);
381  }
383  return const_reverse_iterator(*this,howMany-1);
384  }
385  inline const_reverse_iterator rend() const {
386  return const_reverse_iterator(*this,-1);
387  }
388  inline size_t size() const {
389  return howMany;
390  }
391  inline void resize(size_t N) {
392  if (N!=size()) throw std::logic_error("Tried to resize a fixed-size vector");
393  }
394  };
395  template<typename MAT> inline CConstMatrixRowAccessorExtended<MAT> getRowAccessor(const MAT &m,size_t rowIdx,size_t offset,size_t space=1) {
396  return CConstMatrixRowAccessorExtended<MAT>(m,rowIdx,offset,space);
397  }
398 
399 
400  /** A vector-like wrapper for a Matrix for accessing the elements of a given column with a [] operator.
401  * \sa CMatrixRowAccessor,CMatrixColumnAccessorExtended,CConstMatrixColumnAccessor,CConstMatrixColumnAccessorExtended
402  */
403  template <typename MAT> class CMatrixColumnAccessor {
404  protected:
405  MAT *m_mat;
406  size_t m_colInd;
407  public:
408  typedef typename MAT::Scalar value_type;
410  inline CMatrixColumnAccessor(MAT &mat, size_t colIdx) : m_mat(&mat), m_colInd(colIdx) { ASSERT_(colIdx<mat.getColCount()) }
412  inline value_type &operator[](const size_t i) { return (*m_mat)(i,m_colInd); }
413  inline value_type operator[](const size_t i) const { return (*m_mat)(i,m_colInd); }
418  inline iterator begin() {
419  return iterator(*this,0);
420  }
421  inline const_iterator begin() const {
422  return const_iterator(*this,0);
423  }
424  inline iterator end() {
425  return iterator(*this,m_mat->getRowCount());
426  }
427  inline const_iterator end() const {
428  return const_iterator(*this,m_mat->getRowCount());
429  }
431  return reverse_iterator(*this,m_mat->getRowCount()-1);
432  }
434  return const_reverse_iterator(*this,m_mat->getRowCount()-1);
435  }
437  return reverse_iterator(*this,-1);
438  }
439  inline const_reverse_iterator rend() const {
440  return const_reverse_iterator(*this,-1);
441  }
442  inline size_t size() const {
443  return m_mat->getRowCount();
444  }
445  inline void resize(size_t N) {
446  if (N!=size()) throw std::logic_error("Tried to resize a fixed-size vector");
447  }
448  };
449  template<typename MAT> inline CMatrixColumnAccessor<MAT> getColumnAccessor(MAT &m,size_t colIdx) {
450  return CMatrixColumnAccessor<MAT>(m,colIdx);
451  }
452 
453  /** A vector-like wrapper for a Matrix for accessing the elements of a given column with a [] operator, with offset and custom spacing.
454  * \sa CMatrixRowAccessorExtended,CMatrixColumnAccessor,CConstMatrixColumnAccessor,CConstMatrixColumnAccessorExtended
455  */
456  template<typename MAT>
458  protected:
459  MAT *m_mat;
460  size_t m_colInd;
461  size_t m_rowOffset;
463  size_t howMany;
464  public:
465  typedef typename MAT::Scalar value_type;
467  inline CMatrixColumnAccessorExtended(MAT &mat,size_t col,size_t offset,size_t space):m_mat(&mat),m_colInd(col),m_rowOffset(offset),m_elementsSpace(space) {
468  ASSERT_(col<mat.getColCount());
469  howMany=(mat.getRowCount()-m_rowOffset)/m_elementsSpace;
470  }
472  inline value_type &operator[](size_t i) {
473  return (*m_mat)(m_rowOffset+(i*m_elementsSpace),m_colInd);
474  }
475  inline value_type operator[](size_t i) const {
476  return (*m_mat)(m_rowOffset+(i*m_elementsSpace),m_colInd);
477  }
482  inline iterator begin() {
483  return iterator(*this,0);
484  }
485  inline const_iterator begin() const {
486  return const_iterator(*this,0);
487  }
488  inline iterator end() {
489  return iterator(*this,howMany);
490  }
491  inline const_iterator end() const {
492  return const_iterator(*this,howMany);
493  }
495  return reverse_iterator(*this,howMany-1);
496  }
498  return const_reverse_iterator(*this,howMany-1);
499  }
501  return reverse_iterator(*this,-1);
502  }
503  inline const_reverse_iterator rend() const {
504  return const_reverse_iterator(*this,-1);
505  }
506  inline size_t size() const {
507  return howMany;
508  }
509  inline void resize(size_t N) {
510  if (N!=size()) throw std::logic_error("Tried to resize a fixed-size vector");
511  }
512  };
513  template<typename MAT> inline CMatrixColumnAccessorExtended<MAT> getColumnAccessor(MAT &m,size_t colIdx,size_t offset,size_t space=1) {
514  return CMatrixColumnAccessorExtended<MAT>(m,colIdx,offset,space);
515  }
516 
517  /** A vector-like wrapper for a const Matrix for accessing the elements of a given column with a [] operator.
518  * \sa CConstMatrixRowAccessor,CMatrixColumnAccessorExtended,CMatrixColumnAccessor,CConstMatrixColumnAccessorExtended
519  */
520  template<class MAT>
522  protected:
523  const MAT *m_mat;
524  size_t m_colInd;
525  public:
526  typedef typename MAT::Scalar value_type;
528  inline CConstMatrixColumnAccessor(const MAT &mat,size_t colIdx):m_mat(&mat),m_colInd(colIdx) {
529  ASSERT_(colIdx<mat.getColCount());
530  }
532  inline value_type operator[](size_t i) const {
533  return (*m_mat)(i,m_colInd);
534  }
537  inline const_iterator begin() const {
538  return const_iterator(*this,0);
539  }
540  inline const_iterator end() const {
541  return const_iterator(*this,m_mat->getRowCount());
542  }
544  return const_reverse_iterator(*this,m_mat->getRowCount()-1);
545  }
546  inline const_reverse_iterator rend() const {
547  return const_reverse_iterator(*this,-1);
548  }
549  inline size_t size() const {
550  return m_mat->getRowCount();
551  }
552  inline void resize(size_t N) {
553  if (N!=size()) throw std::logic_error("Tried to resize a fixed-size vector");
554  }
555  };
556  template<typename MAT> inline CConstMatrixColumnAccessor<MAT> getColumnAccessor(const MAT &m,size_t colIdx) {
557  return CConstMatrixColumnAccessor<MAT>(m,colIdx);
558  }
559 
560  /** A vector-like wrapper for a const Matrix for accessing the elements of a given column with a [] operator, with offset and custom spacing.
561  * \sa CConstMatrixRowAccessorExtended,CMatrixColumnAccessor,CConstMatrixColumnAccessor,CMatrixColumnAccessorExtended
562  */
563  template<typename MAT>
565  protected:
566  const MAT *m_mat;
567  size_t m_colInd;
568  size_t m_rowOffset;
570  size_t howMany;
571  public:
572  typedef typename MAT::Scalar value_type;
574  inline CConstMatrixColumnAccessorExtended(const MAT &mat,size_t col,size_t offset,size_t space):m_mat(&mat),m_colInd(col),m_rowOffset(offset),m_elementsSpace(space) {
575  ASSERT_(col<mat.getColCount());
576  howMany=(mat.getRowCount()-m_rowOffset)/m_elementsSpace;
577  }
579  inline value_type operator[](size_t i) const {
580  return (*m_mat)(m_rowOffset+(i*m_elementsSpace),m_colInd);
581  }
584  inline const_iterator begin() const {
585  return const_iterator(*this,0);
586  }
587  inline const_iterator end() const {
588  return const_iterator(*this,howMany);
589  }
591  return const_reverse_iterator(*this,howMany-1);
592  }
593  inline const_reverse_iterator rend() const {
594  return const_reverse_iterator(*this,-1);
595  }
596  inline size_t size() const {
597  return howMany;
598  }
599  inline void resize(size_t N) {
600  if (N!=size()) throw std::logic_error("Tried to resize a fixed-size vector");
601  }
602  };
603  template<typename MAT> inline CConstMatrixColumnAccessorExtended<MAT> getColumnAccessor(const MAT &m,size_t colIdx,size_t offset,size_t space=1) {
604  return CConstMatrixColumnAccessorExtended<MAT>(m,colIdx,offset,space);
605  }
606 
607 
608  } // End of namespace
609 } // End of namespace
610 
611 
612 #endif
mrpt::math::CConstMatrixRowAccessorExtended::operator[]
value_type operator[](size_t i) const
Definition: matrix_adaptors.h:371
mrpt::math::detail::AccessorIterator::value_type
T value_type
Definition: matrix_adaptors.h:56
mrpt::math::CMatrixRowAccessorExtended::m_mat
MAT * m_mat
Definition: matrix_adaptors.h:249
mrpt::math::CMatrixColumnAccessor::rbegin
reverse_iterator rbegin()
Definition: matrix_adaptors.h:430
mrpt::math::CConstMatrixColumnAccessorExtended::m_colInd
size_t m_colInd
Definition: matrix_adaptors.h:567
mrpt::math::CMatrixRowAccessorExtended::rbegin
reverse_iterator rbegin()
Definition: matrix_adaptors.h:284
mrpt::math::CConstMatrixRowAccessor::end
const_iterator end() const
Definition: matrix_adaptors.h:331
mrpt::math::detail::AccessorIterator::operator++
AccessorIterator< A, T > operator++(int)
Definition: matrix_adaptors.h:69
mrpt::math::CMatrixRowAccessorExtended::end
const_iterator end() const
Definition: matrix_adaptors.h:281
mrpt::math::CConstMatrixColumnAccessorExtended::resize
void resize(size_t N)
Definition: matrix_adaptors.h:599
mrpt::math::CConstMatrixRowAccessorExtended::CConstMatrixRowAccessorExtended
CConstMatrixRowAccessorExtended()
Definition: matrix_adaptors.h:370
mrpt::math::CConstMatrixColumnAccessorExtended::m_mat
const MAT * m_mat
Definition: matrix_adaptors.h:566
mrpt::math::detail::ReverseAccessorIterator::pos
int pos
Definition: matrix_adaptors.h:121
mrpt::math::CConstMatrixRowAccessorExtended::const_iterator
detail::AccessorIterator< const CConstMatrixRowAccessorExtended< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:374
mrpt::math::CConstMatrixRowAccessor::value_type
MAT::Scalar value_type
Definition: matrix_adaptors.h:317
mrpt::math::CMatrixRowAccessor::operator[]
value_type & operator[](const size_t i)
Definition: matrix_adaptors.h:201
mrpt::math::CMatrixColumnAccessor::operator[]
value_type operator[](const size_t i) const
Definition: matrix_adaptors.h:413
mrpt::math::detail::AccessorIterator::operator*
T & operator*() const
Definition: matrix_adaptors.h:62
mrpt::math::detail::ReverseAccessorIterator::difference_type
int difference_type
Definition: matrix_adaptors.h:126
mrpt::math::CMatrixRowAccessorExtended::const_reverse_iterator
detail::ReverseAccessorIterator< const CMatrixRowAccessorExtended< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:271
mrpt::math::CMatrixColumnAccessorExtended::value_type
MAT::Scalar value_type
Definition: matrix_adaptors.h:465
mrpt::math::detail::AccessorIterator::operator--
AccessorIterator< A, T > & operator--()
Definition: matrix_adaptors.h:74
mrpt::math::CMatrixRowAccessorExtended::const_iterator
detail::AccessorIterator< const CMatrixRowAccessorExtended< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:269
mrpt::math::CMatrixColumnAccessorExtended::howMany
size_t howMany
Definition: matrix_adaptors.h:463
mrpt::math::detail::AccessorIterator::base
A * base
Definition: matrix_adaptors.h:51
mrpt::math::CMatrixColumnAccessor::begin
iterator begin()
Definition: matrix_adaptors.h:418
mrpt::math::CConstMatrixColumnAccessor::begin
const_iterator begin() const
Definition: matrix_adaptors.h:537
mrpt::math::CConstMatrixColumnAccessor::value_type
MAT::Scalar value_type
Definition: matrix_adaptors.h:526
mrpt::math::detail::ReverseAccessorIterator::operator+
ReverseAccessorIterator< A, T > operator+(int off) const
Definition: matrix_adaptors.h:156
mrpt::math::detail::AccessorIterator
Template class for matrix accessor's iterators.
Definition: matrix_adaptors.h:49
mrpt::math::CConstMatrixColumnAccessor::const_reverse_iterator
detail::ReverseAccessorIterator< const CConstMatrixColumnAccessor< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:536
mrpt::math::CConstMatrixColumnAccessorExtended::howMany
size_t howMany
Definition: matrix_adaptors.h:570
mrpt::math::CConstMatrixRowAccessor::resize
void resize(size_t N)
Definition: matrix_adaptors.h:343
mrpt::math::CMatrixColumnAccessor::CMatrixColumnAccessor
CMatrixColumnAccessor()
Definition: matrix_adaptors.h:411
mrpt::math::CBinaryRelation
This class models a binary relation through the elements of any given set.
Definition: CBinaryRelation.h:31
mrpt::math::CConstMatrixColumnAccessor::m_mat
const MAT * m_mat
Definition: matrix_adaptors.h:523
mrpt::math::CMatrixColumnAccessorExtended::CMatrixColumnAccessorExtended
CMatrixColumnAccessorExtended(MAT &mat, size_t col, size_t offset, size_t space)
Definition: matrix_adaptors.h:467
mrpt::math::CConstMatrixColumnAccessor::mrpt_autotype
CConstMatrixColumnAccessor< MAT > mrpt_autotype
Definition: matrix_adaptors.h:527
mrpt::math::CConstMatrixColumnAccessorExtended::size
size_t size() const
Definition: matrix_adaptors.h:596
mrpt::math::CConstMatrixRowAccessorExtended::m_colOffset
size_t m_colOffset
Definition: matrix_adaptors.h:360
mrpt::math::CMatrixRowAccessorExtended::size
size_t size() const
Definition: matrix_adaptors.h:296
mrpt::math::detail::ReverseAccessorIterator::operator==
bool operator==(const ReverseAccessorIterator< A, T > &it) const
Definition: matrix_adaptors.h:176
mrpt::math::CMatrixColumnAccessorExtended::CMatrixColumnAccessorExtended
CMatrixColumnAccessorExtended()
Definition: matrix_adaptors.h:471
mrpt::math::detail::ReverseAccessorIterator::operator-=
AccessorIterator< A, T > & operator-=(int off)
Definition: matrix_adaptors.h:161
mrpt::math::CMatrixRowAccessorExtended::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:287
mrpt::math::detail::ReverseAccessorIterator::operator*
T & operator*() const
Definition: matrix_adaptors.h:131
mrpt::math::CMatrixTemplate
This template class provides the basic functionality for a general 2D any-size, resizable container o...
Definition: CMatrixTemplate.h:39
mrpt::math::detail::ReverseAccessorIterator
Template class for matrix accessor's iterators.
Definition: matrix_adaptors.h:118
mrpt::math::detail::AccessorIterator::operator==
bool operator==(const AccessorIterator< A, T > &it) const
Definition: matrix_adaptors.h:107
mrpt::math::detail::AccessorIterator::operator!=
bool operator!=(const AccessorIterator< A, T > &it) const
Definition: matrix_adaptors.h:110
mrpt::math::CMatrixColumnAccessorExtended::size
size_t size() const
Definition: matrix_adaptors.h:506
utils_defs.h
mrpt::math::CMatrixColumnAccessorExtended::rend
reverse_iterator rend()
Definition: matrix_adaptors.h:500
mrpt::math::CConstMatrixRowAccessorExtended::begin
const_iterator begin() const
Definition: matrix_adaptors.h:376
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:411
mrpt::math::CMatrixRowAccessorExtended::resize
void resize(size_t N)
Definition: matrix_adaptors.h:299
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:564
mrpt::math::CMatrixRowAccessorExtended::m_elementsSpace
size_t m_elementsSpace
Definition: matrix_adaptors.h:252
mrpt::math::detail::ReverseAccessorIterator::operator!=
bool operator!=(const ReverseAccessorIterator< A, T > &it) const
Definition: matrix_adaptors.h:179
mrpt::math::detail::AccessorIterator::operator+
AccessorIterator< A, T > operator+(int off) const
Definition: matrix_adaptors.h:87
mrpt::math::CConstMatrixColumnAccessor::operator[]
value_type operator[](size_t i) const
Definition: matrix_adaptors.h:532
mrpt::math::CConstMatrixColumnAccessorExtended::operator[]
value_type operator[](size_t i) const
Definition: matrix_adaptors.h:579
mrpt::math::CMatrixRowAccessorExtended::mrpt_autotype
CMatrixRowAccessorExtended< MAT > mrpt_autotype
Definition: matrix_adaptors.h:256
mrpt::math::getColumnAccessor
CMatrixColumnAccessor< MAT > getColumnAccessor(MAT &m, size_t colIdx)
Definition: matrix_adaptors.h:449
mrpt::math::detail::ReverseAccessorIterator::reference
T & reference
Definition: matrix_adaptors.h:128
mrpt::math::detail::AccessorIterator::operator--
AccessorIterator< A, T > operator--(int)
Definition: matrix_adaptors.h:78
mrpt::math::CMatrixRowAccessor::mrpt_autotype
CMatrixRowAccessor< MAT > mrpt_autotype
Definition: matrix_adaptors.h:198
mrpt::math::CMatrixColumnAccessor::const_iterator
detail::AccessorIterator< const CMatrixColumnAccessor< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:415
mrpt::math::CMatrixRowAccessor::m_mat
MAT * m_mat
Definition: matrix_adaptors.h:194
mrpt::math::CMatrixColumnAccessorExtended::operator[]
value_type & operator[](size_t i)
Definition: matrix_adaptors.h:472
mrpt::math::CConstMatrixRowAccessorExtended::const_reverse_iterator
detail::ReverseAccessorIterator< const CConstMatrixRowAccessorExtended< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:375
mrpt::math::CConstMatrixColumnAccessor::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:546
mrpt::math::CMatrixRowAccessor::reverse_iterator
detail::ReverseAccessorIterator< CMatrixRowAccessor< MAT >, value_type > reverse_iterator
Definition: matrix_adaptors.h:205
mrpt
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
Definition: CParticleFilter.h:16
mrpt::math::CMatrixColumnAccessorExtended::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:503
mrpt::math::CConstMatrixColumnAccessorExtended::CConstMatrixColumnAccessorExtended
CConstMatrixColumnAccessorExtended()
Definition: matrix_adaptors.h:578
mrpt::math::CConstMatrixRowAccessorExtended::end
const_iterator end() const
Definition: matrix_adaptors.h:379
mrpt::math::detail::ReverseAccessorIterator::operator+=
ReverseAccessorIterator< A, T > & operator+=(int off)
Definition: matrix_adaptors.h:152
mrpt::math::CConstMatrixRowAccessor::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:337
mrpt::math::CMatrixRowAccessor::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:228
mrpt::math::CMatrixColumnAccessorExtended::mrpt_autotype
CMatrixColumnAccessorExtended< MAT > mrpt_autotype
Definition: matrix_adaptors.h:466
mrpt::math::CMatrixRowAccessor::const_iterator
detail::AccessorIterator< const CMatrixRowAccessor< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:204
mrpt::math::CMatrixColumnAccessor::iterator
detail::AccessorIterator< CMatrixColumnAccessor< MAT >, value_type > iterator
Definition: matrix_adaptors.h:414
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:191
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:457
mrpt::math::CMatrixRowAccessor::CMatrixRowAccessor
CMatrixRowAccessor()
Definition: matrix_adaptors.h:200
mrpt::math::detail::ReverseAccessorIterator::operator-
AccessorIterator< A, T > operator-(int off) const
Definition: matrix_adaptors.h:165
mrpt::math::CMatrixRowAccessor::m_rowInd
size_t m_rowInd
Definition: matrix_adaptors.h:195
mrpt::math::CMatrixColumnAccessor::m_colInd
size_t m_colInd
Definition: matrix_adaptors.h:406
mrpt::math::CConstMatrixRowAccessor::m_rowInd
size_t m_rowInd
Definition: matrix_adaptors.h:315
mrpt::math::CMatrixRowAccessorExtended::begin
iterator begin()
Definition: matrix_adaptors.h:272
mrpt::math::CConstMatrixRowAccessor::CConstMatrixRowAccessor
CConstMatrixRowAccessor()
Definition: matrix_adaptors.h:322
mrpt::math::CMatrixColumnAccessorExtended::end
iterator end()
Definition: matrix_adaptors.h:488
mrpt::math::CMatrixColumnAccessorExtended::m_elementsSpace
size_t m_elementsSpace
Definition: matrix_adaptors.h:462
mrpt::math::CConstMatrixRowAccessor::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:334
mrpt::math::CConstMatrixRowAccessorExtended::resize
void resize(size_t N)
Definition: matrix_adaptors.h:391
mrpt::math::CConstMatrixColumnAccessorExtended::m_rowOffset
size_t m_rowOffset
Definition: matrix_adaptors.h:568
mrpt::math::detail::AccessorIterator::operator-
int operator-(const AccessorIterator< A, T > &it) const
Definition: matrix_adaptors.h:101
mrpt::math::CMatrixRowAccessorExtended::howMany
size_t howMany
Definition: matrix_adaptors.h:253
mrpt::math::CConstMatrixColumnAccessorExtended::mrpt_autotype
CMatrixColumnAccessorExtended< MAT > mrpt_autotype
Definition: matrix_adaptors.h:573
mrpt::math::CConstMatrixColumnAccessorExtended::end
const_iterator end() const
Definition: matrix_adaptors.h:587
mrpt::math::CMatrixColumnAccessor::value_type
MAT::Scalar value_type
Definition: matrix_adaptors.h:408
mrpt::math::CConstMatrixColumnAccessor::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:543
mrpt::math::CMatrixColumnAccessor::rend
reverse_iterator rend()
Definition: matrix_adaptors.h:436
mrpt::math::detail::AccessorIterator::AccessorIterator
AccessorIterator(A &obj, size_t N)
Definition: matrix_adaptors.h:61
mrpt::math::CConstMatrixColumnAccessorExtended::const_iterator
detail::AccessorIterator< const CConstMatrixColumnAccessorExtended< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:582
mrpt::math::CConstMatrixColumnAccessor::size
size_t size() const
Definition: matrix_adaptors.h:549
mrpt::math::CConstMatrixColumnAccessor::CConstMatrixColumnAccessor
CConstMatrixColumnAccessor()
Definition: matrix_adaptors.h:531
mrpt::math::detail::AccessorIterator::operator++
AccessorIterator< A, T > & operator++()
Definition: matrix_adaptors.h:65
mrpt::math::CMatrixColumnAccessor::CMatrixColumnAccessor
CMatrixColumnAccessor(MAT &mat, size_t colIdx)
Definition: matrix_adaptors.h:410
mrpt::math::CMatrixRowAccessorExtended::m_rowInd
size_t m_rowInd
Definition: matrix_adaptors.h:250
mrpt::math::detail::MatrixWrapper< U, true >::MatrixType
CMatrixTemplateObjects< U > MatrixType
Definition: matrix_adaptors.h:34
mrpt::math::CConstMatrixRowAccessor::m_mat
const MAT * m_mat
Definition: matrix_adaptors.h:314
mrpt::math::CMatrixRowAccessorExtended::rend
reverse_iterator rend()
Definition: matrix_adaptors.h:290
mrpt::math::CMatrixColumnAccessor::begin
const_iterator begin() const
Definition: matrix_adaptors.h:421
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:247
mrpt::math::CConstMatrixRowAccessorExtended::m_rowInd
size_t m_rowInd
Definition: matrix_adaptors.h:359
mrpt::math::CMatrixColumnAccessorExtended::m_rowOffset
size_t m_rowOffset
Definition: matrix_adaptors.h:461
mrpt::math::CMatrixRowAccessor::end
const_iterator end() const
Definition: matrix_adaptors.h:216
mrpt::math::detail::ReverseAccessorIterator::operator++
ReverseAccessorIterator< A, T > & operator++()
Definition: matrix_adaptors.h:134
mrpt::math::CConstMatrixRowAccessorExtended::size
size_t size() const
Definition: matrix_adaptors.h:388
mrpt::math::detail::MatrixWrapper< U, false >::MatrixType
CMatrixTemplate< U > MatrixType
Definition: matrix_adaptors.h:38
mrpt::math::CMatrixRowAccessor::const_reverse_iterator
detail::ReverseAccessorIterator< const CMatrixRowAccessor< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:206
mrpt::math::CMatrixRowAccessorExtended::iterator
detail::AccessorIterator< CMatrixRowAccessorExtended< MAT >, value_type > iterator
Definition: matrix_adaptors.h:268
mrpt::math::detail::ReverseAccessorIterator::pointer
T * pointer
Definition: matrix_adaptors.h:127
mrpt::math::CMatrixColumnAccessor::end
iterator end()
Definition: matrix_adaptors.h:424
mrpt::math::CMatrixColumnAccessor::operator[]
value_type & operator[](const size_t i)
Definition: matrix_adaptors.h:412
mrpt::math::detail::ReverseAccessorIterator::value_type
T value_type
Definition: matrix_adaptors.h:125
mrpt::math::CMatrixRowAccessorExtended::CMatrixRowAccessorExtended
CMatrixRowAccessorExtended(MAT &mat, size_t row, size_t offset, size_t space)
Definition: matrix_adaptors.h:257
mrpt::math::CMatrixRowAccessorExtended::value_type
MAT::Scalar value_type
Definition: matrix_adaptors.h:255
mrpt::math::CMatrixColumnAccessorExtended::const_iterator
detail::AccessorIterator< const CMatrixColumnAccessorExtended< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:479
mrpt::math::CConstMatrixColumnAccessor::resize
void resize(size_t N)
Definition: matrix_adaptors.h:552
mrpt::math::CMatrixRowAccessor::resize
void resize(size_t N)
Definition: matrix_adaptors.h:234
mrpt::math::CMatrixColumnAccessor::mrpt_autotype
CMatrixColumnAccessor< MAT > mrpt_autotype
Definition: matrix_adaptors.h:409
mrpt::math::CConstMatrixRowAccessorExtended::m_elementsSpace
size_t m_elementsSpace
Definition: matrix_adaptors.h:361
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:460
mrpt::math::CConstMatrixColumnAccessorExtended::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:593
mrpt::math::detail::ReverseAccessorIterator::ReverseAccessorIterator
ReverseAccessorIterator(A &obj, size_t N)
Definition: matrix_adaptors.h:130
mrpt::math::CMatrixRowAccessor::end
iterator end()
Definition: matrix_adaptors.h:213
math_frwds.h
mrpt::math::CMatrixRowAccessor::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:222
mrpt::math::detail::AccessorIterator::operator[]
T & operator[](int off) const
Definition: matrix_adaptors.h:104
mrpt::math::detail::ReverseAccessorIterator::operator[]
T & operator[](int off) const
Definition: matrix_adaptors.h:173
mrpt::math::detail::ReverseAccessorIterator::operator++
ReverseAccessorIterator< A, T > operator++(int)
Definition: matrix_adaptors.h:138
mrpt::math::CMatrixRowAccessor::size
size_t size() const
Definition: matrix_adaptors.h:231
mrpt::math::CConstMatrixRowAccessor::const_iterator
detail::AccessorIterator< const CConstMatrixRowAccessor< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:326
mrpt::math::CMatrixRowAccessor::iterator
detail::AccessorIterator< CMatrixRowAccessor< MAT >, value_type > iterator
Definition: matrix_adaptors.h:203
mrpt::math::CMatrixColumnAccessor::size
size_t size() const
Definition: matrix_adaptors.h:442
mrpt::math::CMatrixTemplateObjects
This template class extends the class "CMatrixTemplate" for storing "objects" at each matrix entry.
Definition: CMatrixTemplateObjects.h:32
mrpt::math::detail::ReverseAccessorIterator::operator-
int operator-(const ReverseAccessorIterator< A, T > &it) const
Definition: matrix_adaptors.h:170
mrpt::math::CMatrixColumnAccessor::reverse_iterator
detail::ReverseAccessorIterator< CMatrixColumnAccessor< MAT >, value_type > reverse_iterator
Definition: matrix_adaptors.h:416
mrpt::math::CConstMatrixRowAccessor::const_reverse_iterator
detail::ReverseAccessorIterator< const CConstMatrixRowAccessor< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:327
mrpt::math::detail::AccessorIterator::iterator_category
std::random_access_iterator_tag iterator_category
Definition: matrix_adaptors.h:55
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:403
mrpt::math::CMatrixColumnAccessor::resize
void resize(size_t N)
Definition: matrix_adaptors.h:445
mrpt::math::detail::AccessorIterator::difference_type
int difference_type
Definition: matrix_adaptors.h:57
mrpt::math::CMatrixColumnAccessorExtended::const_reverse_iterator
detail::ReverseAccessorIterator< const CMatrixColumnAccessorExtended< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:481
mrpt::math::CConstMatrixColumnAccessorExtended::m_elementsSpace
size_t m_elementsSpace
Definition: matrix_adaptors.h:569
mrpt::math::CMatrixColumnAccessorExtended::iterator
detail::AccessorIterator< CMatrixColumnAccessorExtended< MAT >, value_type > iterator
Definition: matrix_adaptors.h:478
mrpt::math::detail::ReverseAccessorIterator::iterator_category
std::random_access_iterator_tag iterator_category
Definition: matrix_adaptors.h:124
mrpt::math::CMatrixColumnAccessor::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:439
mrpt::math::CConstMatrixColumnAccessorExtended::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:590
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:312
mrpt::math::CMatrixRowAccessorExtended::begin
const_iterator begin() const
Definition: matrix_adaptors.h:275
mrpt::math::CConstMatrixRowAccessor::operator[]
value_type operator[](size_t i) const
Definition: matrix_adaptors.h:323
mrpt::math::CConstMatrixColumnAccessor::m_colInd
size_t m_colInd
Definition: matrix_adaptors.h:524
mrpt::math::CMatrixColumnAccessor::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:433
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:356
mrpt::math::CMatrixColumnAccessorExtended::begin
const_iterator begin() const
Definition: matrix_adaptors.h:485
mrpt::math::detail::AccessorIterator::reference
T & reference
Definition: matrix_adaptors.h:59
mrpt::math::CMatrixColumnAccessor::end
const_iterator end() const
Definition: matrix_adaptors.h:427
mrpt::math::CConstMatrixRowAccessorExtended::howMany
size_t howMany
Definition: matrix_adaptors.h:362
mrpt::math::CConstMatrixColumnAccessorExtended::begin
const_iterator begin() const
Definition: matrix_adaptors.h:584
mrpt::math::CConstMatrixRowAccessor::size
size_t size() const
Definition: matrix_adaptors.h:340
mrpt::math::CConstMatrixColumnAccessor::CConstMatrixColumnAccessor
CConstMatrixColumnAccessor(const MAT &mat, size_t colIdx)
Definition: matrix_adaptors.h:528
mrpt::math::CMatrixColumnAccessorExtended::rbegin
reverse_iterator rbegin()
Definition: matrix_adaptors.h:494
mrpt::math::CMatrixRowAccessorExtended::CMatrixRowAccessorExtended
CMatrixRowAccessorExtended()
Definition: matrix_adaptors.h:261
mrpt::math::CConstMatrixColumnAccessor::end
const_iterator end() const
Definition: matrix_adaptors.h:540
mrpt::math::CConstMatrixRowAccessorExtended::CConstMatrixRowAccessorExtended
CConstMatrixRowAccessorExtended(const MAT &mat, size_t row, size_t offset, size_t space)
Definition: matrix_adaptors.h:366
mrpt::math::CConstMatrixRowAccessorExtended::mrpt_autotype
CConstMatrixRowAccessorExtended< MAT > mrpt_autotype
Definition: matrix_adaptors.h:365
mrpt::math::CMatrixRowAccessorExtended::reverse_iterator
detail::ReverseAccessorIterator< CMatrixRowAccessorExtended< MAT >, value_type > reverse_iterator
Definition: matrix_adaptors.h:270
mrpt::math::CConstMatrixColumnAccessor::const_iterator
detail::AccessorIterator< const CConstMatrixColumnAccessor< MAT >, const value_type > const_iterator
Definition: matrix_adaptors.h:535
mrpt::math::CConstMatrixRowAccessorExtended::value_type
MAT::Scalar value_type
Definition: matrix_adaptors.h:364
mrpt::math::CMatrixRowAccessor::value_type
MAT::Scalar value_type
Definition: matrix_adaptors.h:197
mrpt::math::CMatrixColumnAccessorExtended::begin
iterator begin()
Definition: matrix_adaptors.h:482
mrpt::math::CConstMatrixColumnAccessorExtended::const_reverse_iterator
detail::ReverseAccessorIterator< const CConstMatrixColumnAccessorExtended< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:583
mrpt::math::CMatrixColumnAccessorExtended::m_mat
MAT * m_mat
Definition: matrix_adaptors.h:459
mrpt::math::CConstMatrixRowAccessor::CConstMatrixRowAccessor
CConstMatrixRowAccessor(const MAT &mat, size_t row)
Definition: matrix_adaptors.h:319
mrpt::math::CMatrixRowAccessorExtended::end
iterator end()
Definition: matrix_adaptors.h:278
mrpt::math::CMatrixRowAccessor::CMatrixRowAccessor
CMatrixRowAccessor(MAT &mat, size_t rowIdx)
Definition: matrix_adaptors.h:199
mrpt::math::CConstMatrixRowAccessorExtended::m_mat
const MAT * m_mat
Definition: matrix_adaptors.h:358
mrpt::math::CConstMatrixRowAccessorExtended::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:382
ASSERT_
#define ASSERT_(f)
Definition: mrpt_macros.h:261
mrpt::math::CMatrixRowAccessorExtended::operator[]
value_type operator[](size_t i) const
Definition: matrix_adaptors.h:265
mrpt::math::detail::AccessorIterator::pointer
T * pointer
Definition: matrix_adaptors.h:58
mrpt::math::CConstMatrixColumnAccessorExtended::value_type
MAT::Scalar value_type
Definition: matrix_adaptors.h:572
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:521
mrpt::math::CConstMatrixRowAccessor::mrpt_autotype
CConstMatrixRowAccessor< MAT > mrpt_autotype
Definition: matrix_adaptors.h:318
mrpt::math::CMatrixColumnAccessor::const_reverse_iterator
detail::ReverseAccessorIterator< const CMatrixColumnAccessor< MAT >, const value_type > const_reverse_iterator
Definition: matrix_adaptors.h:417
mrpt::math::CMatrixColumnAccessorExtended::operator[]
value_type operator[](size_t i) const
Definition: matrix_adaptors.h:475
mrpt::math::CMatrixRowAccessor::begin
iterator begin()
Definition: matrix_adaptors.h:207
mrpt::math::CMatrixRowAccessorExtended::operator[]
value_type & operator[](size_t i)
Definition: matrix_adaptors.h:262
mrpt::math::CConstMatrixRowAccessor::begin
const_iterator begin() const
Definition: matrix_adaptors.h:328
mrpt::math::detail::ReverseAccessorIterator::operator--
ReverseAccessorIterator< A, T > & operator--()
Definition: matrix_adaptors.h:143
mrpt::math::CMatrixRowAccessor::rend
reverse_iterator rend()
Definition: matrix_adaptors.h:225
mrpt::math::detail::AccessorIterator::operator-
AccessorIterator< A, T > operator-(int off) const
Definition: matrix_adaptors.h:96
mrpt::math::CMatrixRowAccessor::rbegin
reverse_iterator rbegin()
Definition: matrix_adaptors.h:219
mrpt::math::CMatrixColumnAccessorExtended::rbegin
const_reverse_iterator rbegin() const
Definition: matrix_adaptors.h:497
mrpt::math::getRowAccessor
CMatrixRowAccessor< MAT > getRowAccessor(MAT &m, size_t rowIdx)
Definition: matrix_adaptors.h:238
mrpt::math::detail::AccessorIterator::pos
int pos
Definition: matrix_adaptors.h:52
mrpt::math::CMatrixRowAccessor::operator[]
value_type operator[](const size_t i) const
Definition: matrix_adaptors.h:202
mrpt::math::CMatrixColumnAccessorExtended::resize
void resize(size_t N)
Definition: matrix_adaptors.h:509
mrpt::math::CConstMatrixRowAccessorExtended::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:385
mrpt::math::detail::ReverseAccessorIterator::base
A * base
Definition: matrix_adaptors.h:120
mrpt::math::CMatrixRowAccessor::begin
const_iterator begin() const
Definition: matrix_adaptors.h:210
mrpt::math::CMatrixRowAccessorExtended::m_colOffset
size_t m_colOffset
Definition: matrix_adaptors.h:251
mrpt::math::detail::ReverseAccessorIterator::operator--
ReverseAccessorIterator< A, T > operator--(int)
Definition: matrix_adaptors.h:147
mrpt::math::detail::AccessorIterator::operator-=
AccessorIterator< A, T > & operator-=(int off)
Definition: matrix_adaptors.h:92
mrpt::math::CMatrixColumnAccessor::m_mat
MAT * m_mat
Definition: matrix_adaptors.h:405
mrpt::math::CMatrixRowAccessorExtended::rend
const_reverse_iterator rend() const
Definition: matrix_adaptors.h:293
mrpt::math::CMatrixColumnAccessorExtended::end
const_iterator end() const
Definition: matrix_adaptors.h:491
mrpt::math::CConstMatrixColumnAccessorExtended::CConstMatrixColumnAccessorExtended
CConstMatrixColumnAccessorExtended(const MAT &mat, size_t col, size_t offset, size_t space)
Definition: matrix_adaptors.h:574
mrpt::math::CMatrixColumnAccessorExtended::reverse_iterator
detail::ReverseAccessorIterator< CMatrixColumnAccessorExtended< MAT >, value_type > reverse_iterator
Definition: matrix_adaptors.h:480
mrpt::math::detail::AccessorIterator::operator+=
AccessorIterator< A, T > & operator+=(int off)
Definition: matrix_adaptors.h:83



Page generated by Doxygen 1.8.16 for MRPT 1.4.0 SVN: at Mon Oct 14 23:08:25 UTC 2019